knowledge-ops

Classify and route knowledge across local files, MCP memory, vector stores, Git repositories, and project trackers.

Updated Mar 26, 2026
One-click install
npx skills add https://github.com/luongldptit/move-ticket --skill knowledge-ops-luongldptit
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: knowledge-ops
Source: https://github.com/luongldptit/move-ticket/tree/main/.agent/skills/knowledge-ops
Command: npx skills add https://github.com/luongldptit/move-ticket --skill knowledge-ops-luongldptit

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the frustration of fragmented, duplicated knowledge scattered across local files, project trackers like GitHub and Linear, memory systems, and Git repositories, which makes it difficult to find accurate, up-to-date information and maintain consistent context across workstreams.

Core Features & Use Cases

  • Multi-layer knowledge ingestion: Automatically classify new information (project decisions, conversations, reference documents, personal preferences) and route it to the appropriate storage layer (Claude Code memory, MCP knowledge graph, GitHub/Linear, knowledge base repo) based on content type.
  • Cross-system sync and deduplication: Sync knowledge between all connected systems, automatically detecting and merging duplicate entries to avoid conflicting or outdated context.
  • Use case: For example, after a project planning call, use this Skill to save key decisions to your Linear project, add action items to your project memory file, and sync the full conversation notes to your durable knowledge base repo for long-term access.

Quick Start

Use the knowledge-ops skill to save the key decisions from today's project sync call to your Linear project and update your team's knowledge base repo with the full meeting notes.

Frequently Asked Questions about knowledge-ops

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I sync knowledge across GitHub, Linear, and local files?

To sync knowledge across GitHub, Linear, and local files, the skill automatically detects and merges duplicate entries across connected systems, maintaining consistent cross-system context. It routes content to appropriate storage layers based on content type to avoid conflicting or outdated information.

What is the best way to deduplicate fragmented context across project trackers and memory stores?

Deduplicating fragmented context across project trackers and memory stores involves automatically classifying new information and routing it to appropriate storage layers. The skill detects and merges duplicate entries across local files, MCP memory, vector stores, and Git repositories to maintain consistent context.

How does knowledge ingestion and classification work for engineering teams?

Knowledge ingestion for engineering teams automatically classifies new information like project decisions, conversations, and reference documents. It then routes this content to appropriate storage layers such as Claude Code memory, MCP knowledge graph, GitHub, Linear, or a durable knowledge base repo based on content type.

Can I redact sensitive data before committing knowledge to Git repositories?

Yes, you can redact sensitive data before committing knowledge to version-controlled repositories. The skill satisfies requirements for redacting sensitive data before committing to Git repositories, ensuring secure knowledge management across storage layers.

Does this approach support syncing meeting notes and action items to multiple work systems?

Yes, syncing meeting notes and action items to multiple work systems is supported. After a project planning call, you can save key decisions to Linear, add action items to project memory files, and sync full conversation notes to a durable knowledge base repo for long-term access.

When should I use cross-system knowledge sync instead of manual context updates?

Cross-system knowledge sync should be used when managing fragmented knowledge across multiple storage layers becomes difficult. It is ideal when you need to classify knowledge by type, route content to durable or quick-access storage, and maintain consistent context across GitHub, Linear, and personal knowledge bases.