natsufox/tapestry/synthesis

Tapestry Synthesis

Analyze a stored Tapestry artifact: $ARGUMENTS

When to use this skill

Use this skill when:

• A user wants interpretation or analysis of already-ingested content
• You need to consolidate multiple sources into research notes
• The user asks for synthesis, insights, or higher-level understanding
• You need to organize ingested content into the knowledge base hierarchy
• The deterministic ingest is complete and model-based reasoning is needed

Overview

This skill is the workflow layer for model-eligible reasoning.

Use it after deterministic ingest has already produced:

1. a capture JSON file
2. a normalized feed JSON file
3. a Markdown knowledge-base note
4. a structured handoff payload describing the recommended analysis

The package runtime does not call any model APIs directly. This skill owns the interpretation step.

This skill is also responsible for maintaining the book-like knowledge base under knowledge-base/.

Important: The synthesis mode configuration controls when this skill should be invoked:

• auto: Agent evaluates note accumulation and decides whether to merge (intelligent, load-based)
• manual: Only runs when explicitly requested by user
• batch: Runs after multiple ingests to process all at once
• deterministic: Runs automatically after every single ingest (high overhead)

See config/tapestry.config.json for current mode setting.

Workflow

1. Identify the target:

• if the user gave a stored note path, use it directly
• if the user gave a URL and it has not been ingested yet, run $tapestry-ingest first

1. IMPORTANT: Change to the project root directory before running the script:

cd /path/to/your/tapestry/project
python synthesis/_scripts/load_context.py \
  "$ARGUMENTS"

Or use the --project-root flag:

python synthesis/_scripts/load_context.py \
  --project-root /path/to/your/tapestry/project \
  "$ARGUMENTS"

1. Read the returned handoff payload carefully:

• digest is the deterministic baseline
• analysis.skill, analysis.instructions, and analysis.deliverable describe the intended workflow
• note_text, feed_payload, and capture_payload are the factual source materials
• Identify the language by reading the content naturally (title, body, comments)

1. Ensure the book hierarchy exists:

cd /path/to/your/tapestry/project
python synthesis/_scripts/bootstrap_kb.py

Or use the --project-root flag:

python synthesis/_scripts/bootstrap_kb.py \
  --project-root /path/to/your/tapestry/project

1. Read the knowledge-base governance files:

• synthesis/_kb_rules/_shared-governance.md
• synthesis/_kb_rules/topic-taxonomy.md
• synthesis/_kb_rules/chapter-decision-rules.md

1. CRITICAL: Read the existing knowledge base structure thoroughly:

• Explore knowledge-base/books/ to understand existing topics and chapters
• Read relevant index.md files to understand chapter scope and content
• Look for existing chapters where this content naturally fits

1. Default to integration - Decide in this priority order:
2. FIRST CHOICE: Extend an existing chapter - Integrate the new content into an existing chapter's narrative if it matches the chapter's central concept. Do NOT just append; weave it into the existing structure.
3. SECOND CHOICE: Create a new chapter - Only if the content introduces a distinct subdomain that doesn't fit existing chapters
4. LAST RESORT: Restructure the topic tree - Only if multiple chapters overlap heavily or the taxonomy has become incoherent
5. IMPORTANT: Identify the language of the source content by reading it, then write your synthesis in that same language. Do not translate unless explicitly requested.
6. When extending an existing chapter:

• Read the full chapter content first
• Identify where the new information fits thematically
• Integrate it into the existing narrative structure (don't append at the end)
• Update section headers if the new content shifts the conceptual balance
• Maintain consistent voice and formatting

1. When creating a new chapter:

• Ensure it represents a recurring domain, not a one-off article
• Update the parent index.md to register the new chapter
• Follow the chapter structure patterns from existing chapters

1. Return the synthesis clearly, grounded in the stored artifacts rather than vague recollection.

Synthesis Quality Standards

IMPORTANT: All synthesized content must go through this refinement process, regardless of the source crawler or content type. These standards ensure consistent, high-quality output across all ingested content.

Language Preservation

CRITICAL: The synthesis process MUST preserve the original language of the source content.

• Identify the language by reading the source content (title, body, comments) in the handoff payload
• Write synthesis in the same language as the source content
• Do NOT translate content from one language to another unless explicitly requested by the user
• If the source is in Chinese, write the synthesis in Chinese (including headers, descriptions, and analysis)
• If the source is in English, write the synthesis in English (including headers, descriptions, and analysis)
• Maintain language consistency throughout the entire knowledge base entry

How to identify language:

• Read the note_text, feed_payload.body, and feed_payload.title from the handoff
• Naturally determine the primary language based on the content
• Use that language for all synthesis output

1. Text Formatting and Cleanup

Add proper structure:

• Use clear hierarchical headers (H2 for main sections, H3 for subsections)
• Add paragraph breaks for readability (no walls of text)
• Separate distinct topics with appropriate headers
• Use proper spacing after punctuation

Apply markdown formatting:

• **bold** for key terms and emphasis
• *italic* for technical terms or foreign words
• ` code ` for technical terms, commands, or code snippets
• > quotes for important statements or definitions
• [links](url) for all references and resources
• Lists (bulleted or numbered) for enumerated items
• CRITICAL: Always add a blank line before lists (both ordered and unordered)
• Markdown requires a blank line before list items to render them as <ul> or <ol> elements
• Without the blank line, lists will render as plain text inside <p> tags
• Example:

```markdown Correct: Some text here.

• List item 1
• List item 2

Wrong: Some text here.

• List item 1
• List item 2

```

Remove noise and artifacts:

• Navigation text ("Home", "Next", "Previous", "Menu")
• Boilerplate ("Subscribe to our newsletter", "Cookie policy")
• Redundant disclaimers and legal text
• Advertisement content
• Broken formatting from HTML conversion
• Concatenated words or missing spaces

2. Content Organization

Identify and structure:

• What is the main topic or thesis?
• What are the key sections or concepts?
• What's the logical flow of information?

Create clear hierarchy:

• Start with a brief introduction or overview
• Group related concepts together
• Use descriptive section headers
• Maintain consistent heading levels

Preserve important elements:

• Technical details and specifications
• Code examples and commands
• Important links and references
• Author attributions and publication dates
• Key quotes and definitions

3. Factual Accuracy

Ground in source material:

• Only include information from the stored note, feed, or capture
• Maintain technical accuracy and proper terminology
• Preserve numerical data and statistics
• Keep important context and caveats

Do not:

• Add information not in the source
• Interpret or speculate beyond what's stated
• Simplify to the point of losing accuracy
• Change technical terms or jargon

4. Content-Specific Guidance

For articles and documentation:

• Preserve the main thesis and key arguments
• Highlight concrete claims and evidence
• Structure with clear sections
• Keep code examples and technical details

For discussions and Q&A:

• Preserve question-answer structure
• Highlight key insights from comments
• Note areas of consensus or disagreement
• Keep important context from the discussion

For reference material:

• Organize as a reference document
• Use clear section headers for easy lookup
• Preserve technical specifications
• Keep all links and resources

5. Knowledge Base Integration

CRITICAL: The knowledge base is a living reference book, not a flat collection of article summaries. Every new piece of content should enrich existing chapters rather than creating redundant standalone entries.

Integration-First Approach:

1. Explore existing structure first:

• Read knowledge-base/books/ to understand topics and chapters
• Examine relevant index.md files to understand chapter scope
• Look for chapters covering related concepts, technologies, or domains

1. Prefer integration over creation:

• Default behavior: Integrate new content into existing chapters
• Creating a new chapter should be the exception, not the rule
• Ask: "Does this add new information to an existing chapter?" before creating a new one

1. How to integrate effectively:

• Read the full existing chapter content
• Identify thematic connections and where new information fits
• Weave content into the narrative - don't just append at the end
• Add new sections or subsections if the content introduces new dimensions
• Update existing sections with complementary information
• Maintain consistent voice, formatting, and language

1. When to create a new chapter:

• The content introduces a distinct subdomain that will likely recur
• No existing chapter can absorb it without losing coherence
• The topic represents a stable, recurring domain (not a one-off article)
• Forcing it into existing chapters would reduce retrievability

1. Update hierarchy:

• Always update parent index.md when creating new chapters
• Update topic descriptions if content shifts the conceptual balance
• Maintain navigation structure
• Follow governance rules in synthesis/_kb_rules/

Anti-patterns to avoid:

• Creating a new chapter for every ingested article
• Appending raw content dumps to the end of chapters
• Creating near-duplicate chapters with slightly different wording
• Leaving the knowledge base as a glorified link collection

Rules