---
id: daily-knowledge-ops
name: "knowledge-ops"
url: https://skills.yangsir.net/skill/daily-knowledge-ops
author: affaan-m
domain: ai-agent-memory-knowledge
tags: ["knowledge-management", "documentation", "information-retrieval", "sync", "workspace-automation"]
install_count: 4300
rating: 4.40 (27 reviews)
github: https://github.com/affaan-m/everything-claude-code
---

# knowledge-ops

> 管理多层知识系统，跨多个存储进行知识摄取、组织、同步和检索，支持代码仓库、GitHub、Linear 等工作空间

**Stats**: 4,300 installs · 4.4/5 (27 reviews)

## Before / After 对比

### 知识同步

**Before**:

知识分散在多个平台和工具中，手动同步耗时且易出错，查找信息需要切换多个系统

**After**:

自动聚合代码、文档、工单等多源知识，统一索引和检索，一键定位相关信息

| Metric | Before | After | Change |
|---|---|---|---|
| 信息查找时间 | 10分钟 | 1分钟 | -90% |

## Readme

# knowledge-ops

# Knowledge Operations

Manage a multi-layered knowledge system for ingesting, organizing, syncing, and retrieving knowledge across multiple stores.

Prefer the live workspace model:

- code work lives in the real cloned repos

- active execution context lives in GitHub, Linear, and repo-local working-context files

- broader human-facing notes can live in a non-repo context/archive folder

- durable cross-machine memory belongs in the knowledge base, not in a shadow repo workspace

## When to Activate

- User wants to save information to their knowledge base

- Ingesting documents, conversations, or data into structured storage

- Syncing knowledge across systems (local files, MCP memory, Supabase, Git repos)

- Deduplicating or organizing existing knowledge

- User says "save this to KB", "sync knowledge", "what do I know about X", "ingest this", "update the knowledge base"

- Any knowledge management task beyond simple memory recall

## Knowledge Architecture

### Layer 1: Active execution truth

- **Sources:** GitHub issues, PRs, discussions, release notes, Linear issues/projects/docs

- **Use for:** the current operational state of the work

- **Rule:** if something affects an active engineering plan, roadmap, rollout, or release, prefer putting it here first

### Layer 2: Claude Code Memory (Quick Access)

- **Path:** `~/.claude/projects/*/memory/`

- **Format:** Markdown files with frontmatter

- **Types:** user preferences, feedback, project context, reference

- **Use for:** quick-access context that persists across conversations

- **Automatically loaded at session start**

### Layer 3: MCP Memory Server (Structured Knowledge Graph)

- **Access:** MCP memory tools (create_entities, create_relations, add_observations, search_nodes)

- **Use for:** Semantic search across all stored memories, relationship mapping

- **Cross-session persistence with queryable graph structure**

### Layer 4: Knowledge base repo / durable document store

- **Use for:** curated durable notes, session exports, synthesized research, operator memory, long-form docs

- **Rule:** this is the preferred durable store for cross-machine context when the content is not repo-owned code

### Layer 5: External Data Store (Supabase, PostgreSQL, etc.)

- **Use for:** Structured data, large document storage, full-text search

- **Good for:** Documents too large for memory files, data needing SQL queries

### Layer 6: Local context/archive folder

- **Use for:** human-facing notes, archived gameplans, local media organization, temporary non-code docs

- **Rule:** writable for information storage, but not a shadow code workspace

- **Do not use for:** active code changes or repo truth that should live upstream

## Ingestion Workflow

When new knowledge needs to be captured:

### 1. Classify

What type of knowledge is it?

- Business decision -> memory file (project type) + MCP memory

- Active roadmap / release / implementation state -> GitHub + Linear first

- Personal preference -> memory file (user/feedback type)

- Reference info -> memory file (reference type) + MCP memory

- Large document -> external data store + summary in memory

- Conversation/session -> knowledge base repo + short summary in memory

### 2. Deduplicate

Check if this knowledge already exists:

- Search memory files for existing entries

- Query MCP memory with relevant terms

- Check whether the information already exists in GitHub or Linear before creating another local note

- Do not create duplicates. Update existing entries instead.

### 3. Store

Write to appropriate layer(s):

- Always update Claude Code memory for quick access

- Use MCP memory for semantic searchability and relationship mapping

- Update GitHub / Linear first when the information changes live project truth

- Commit to the knowledge base repo for durable long-form additions

### 4. Index

Update any relevant indexes or summary files.

## Sync Operations

### Conversation Sync

Periodically sync conversation history into the knowledge base:

- Sources: Claude session files, Codex sessions, other agent sessions

- Destination: knowledge base repo

- Generate a session index for quick browsing

- Commit and push

### Workspace State Sync

Mirror important workspace configuration and scripts to the knowledge base:

- Generate directory maps

- Redact sensitive config before committing

- Track changes over time

- Do not treat the knowledge base or archive folder as the live code workspace

### GitHub / Linear Sync

When the information affects active execution:

- update the relevant GitHub issue, PR, discussion, release notes, or roadmap thread

- attach supporting docs to Linear when the work needs durable planning context

- only mirror a local note afterwards if it still adds value

### Cross-Source Knowledge Sync

Pull knowledge from multiple sources into one place:

- Claude/ChatGPT/Grok conversation exports

- Browser bookmarks

- GitHub activity events

- Write status summary, commit and push

## Memory Patterns

```
# Short-term: current session context
Use TodoWrite for in-session task tracking

# Medium-term: project memory files
Write to ~/.claude/projects/*/memory/ for cross-session recall

# Long-term: GitHub / Linear / KB
Put active execution truth in GitHub + Linear
Put durable synthesized context in the knowledge base repo

# Semantic layer: MCP knowledge graph
Use mcp__memory__create_entities for permanent structured data
Use mcp__memory__create_relations for relationship mapping
Use mcp__memory__add_observations for new facts about known entities
Use mcp__memory__search_nodes to find existing knowledge

```

## Best Practices

- Keep memory files concise. Archive old data rather than letting files grow unbounded.

- Use frontmatter (YAML) for metadata on all knowledge files.

- Deduplicate before storing. Search first, then create or update.

- Prefer one canonical home per fact set. Avoid parallel copies of the same plan across local notes, repo files, and tracker docs.

- Redact sensitive information (API keys, passwords) before committing to Git.

- Use consistent naming conventions for knowledge files (lowercase-kebab-case).

- Tag entries with topics/categories for easier retrieval.

## Quality Gate

Before completing any knowledge operation:

- no duplicate entries created

- sensitive data redacted from any Git-tracked files

- indexes and summaries updated

- appropriate storage layer chosen for the data type

- cross-references added where relevant

Weekly Installs536Repository[affaan-m/everyt…ude-code](https://github.com/affaan-m/everything-claude-code)GitHub Stars157.6KFirst Seen11 days agoSecurity Audits[Gen Agent Trust HubPass](/affaan-m/everything-claude-code/knowledge-ops/security/agent-trust-hub)[SocketPass](/affaan-m/everything-claude-code/knowledge-ops/security/socket)[SnykWarn](/affaan-m/everything-claude-code/knowledge-ops/security/snyk)Installed oncodex504opencode488gemini-cli485kimi-cli484antigravity484amp484

---
*Source: https://skills.yangsir.net/skill/daily-knowledge-ops*
*Markdown mirror: https://skills.yangsir.net/api/skill/daily-knowledge-ops/markdown*