Skip to content

Self-evolving second brain with 35 AI skills, 10 agents, and people CRM. Closed-loop harness: a V-model verification lifecycle where the worker never grades its own homework. Plus paired anti-slop design skills for marketing and product UI. Works with Claude Code, Cursor, Kiro, Gemini CLI, Codex.

Add PM workflow skills and auto-research (v3.4.0)

Huy Tieu39ccbee54404
diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
index 93ea519..bdd2f49 100644
--- a/.claude-plugin/plugin.json
+++ b/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
{
"name": "cog-second-brain",
- "version": "3.3.0",
+ "version": "3.4.0",
"description": "A self-evolving second brain system using Claude Code, Obsidian markdown files, and Git version control. Features specialized AI agents for knowledge management, daily intelligence briefings, and strategic insights extraction.",
"author": {
"name": "Huy Tieu",
@@ -68,6 +68,41 @@
"name": "update-cog",
"path": ".claude/skills/update-cog/SKILL.md",
"description": "Check for and apply upstream COG framework updates without touching personal content"
+ },
+ {
+ "name": "auto-research",
+ "path": ".claude/skills/auto-research/SKILL.md",
+ "description": "Deep strategic research engine with parallel research threads and actionable analysis"
+ },
+ {
+ "name": "create-user-story",
+ "path": ".claude/skills/create-user-story/SKILL.md",
+ "description": "Create user stories with duplicate checking across Linear, GitHub Issues, or Jira"
+ },
+ {
+ "name": "generate-prd",
+ "path": ".claude/skills/generate-prd/SKILL.md",
+ "description": "Draft PRDs with approval gate before publishing to Confluence or Notion"
+ },
+ {
+ "name": "generate-release-notes",
+ "path": ".claude/skills/generate-release-notes/SKILL.md",
+ "description": "Generate release notes from GitHub milestones, Linear cycles, or manual input"
+ },
+ {
+ "name": "export-open-issues",
+ "path": ".claude/skills/export-open-issues/SKILL.md",
+ "description": "Audit and export open issues from any project tracker"
+ },
+ {
+ "name": "publish-to-confluence",
+ "path": ".claude/skills/publish-to-confluence/SKILL.md",
+ "description": "Publish vault markdown files to Confluence"
+ },
+ {
+ "name": "update-knowledge-base",
+ "path": ".claude/skills/update-knowledge-base/SKILL.md",
+ "description": "Maintain product knowledge base from releases and feature updates"
}
],
"metadata": {
@@ -105,7 +140,7 @@
},
"skillArchitecture": {
"type": "agent-skills",
- "skills": 10,
+ "skills": 17,
"rolePacks": 7,
"invocation": "model-invoked",
"progressiveDisclosure": true,
diff --git a/.claude/skills/auto-research/SKILL.md b/.claude/skills/auto-research/SKILL.md
new file mode 100644
index 0000000..978af3e
--- /dev/null
+++ b/.claude/skills/auto-research/SKILL.md
@@ -0,0 +1,234 @@
+---
+name: auto-research
+description: Deep strategic research engine — decomposes questions into parallel research threads, spawns multiple agents, and synthesizes into actionable strategic analysis
+roles: [product-manager, engineering-lead, founder, all]
+integrations: []
+---
+
+# COG Auto Research Skill
+
+## When to Invoke
+- User asks a strategic question requiring deep research
+- User says "research", "auto-research", "investigate", "strategic analysis", "deep dive into [topic]"
+- User wants to understand market forces, competitive dynamics, technology trajectories, or strategic options
+- User needs evidence-based analysis with real sources to support decision-making
+
+Inspired by Karpathy's autoresearch — but for strategic thinking instead of ML training.
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use the full parallel agent execution strategy (5-7 agents). This skill benefits massively from team mode.
+- If `agent_mode: solo` — run 2-3 sequential research passes with WebSearch/WebFetch, produce a lighter analysis without the full multi-thread structure.
+
+## Command: `/auto-research`
+
+## Input
+The user provides a strategic question or topic as the command argument. Examples:
+- "If foundation models commoditize, what happens to LLM wrapper companies like Katalon/Scout?"
+- "Future of the testing industry as AI capabilities expand"
+- "Should we build vs buy vs partner for our AI layer?"
+- "What are the strategic options for Scout if OpenAI launches a testing product?"
+
+---
+
+## Execution Strategy
+
+### Phase 1: Question Decomposition (Orchestrator — 2 minutes)
+
+Break the user's strategic question into 5-7 **research threads** that together will provide a comprehensive answer. Each thread should be:
+- **Independent** — can be researched in parallel
+- **Specific** — has a clear research objective
+- **Complementary** — together they cover the full strategic landscape
+
+**Decomposition framework:**
+1. **Market forces** — what macro trends drive this question?
+2. **Historical precedent** — has this pattern played out before in other industries?
+3. **Player analysis** — who are the key players and what are they doing?
+4. **Technology trajectory** — where is the underlying tech heading?
+5. **Customer behavior** — what do end-users actually want/do?
+6. **Economic model** — what are the unit economics and value capture dynamics?
+7. **Emerging tech & architectures** — what concepts, projects, or frameworks are still in development/discussion (pre-mainstream) that could be foundational? Research open-source projects, research papers, GitHub repos, Discord/forum discussions, conference talks, and early-stage tools that are relevant. Examples: novel agent architectures, new testing paradigms, experimental frameworks. These may not have polished docs — dig into READMEs, GitHub issues, Twitter/X threads, blog posts from builders, and academic preprints.
+8. **Contrarian view** — what's the strongest argument against the consensus?
+
+Not all threads apply to every question. Pick the 5-7 most relevant. **Thread 7 (Emerging tech) should ALWAYS be included** — the user specifically wants to stay ahead of concepts that aren't mainstream yet.
+
+**Before spawning agents:**
+1. Read relevant files from the vault for existing context:
+ - `05-knowledge/` for existing frameworks and mental models
+ - `04-projects/` for project-specific context if relevant
+ - Recent braindumps for the user's existing thinking on this topic
+2. State the decomposition to the user so they can course-correct before agents launch
+
+### Phase 2: Parallel Deep Research (Spawn 5-7 Agents Simultaneously)
+
+**CRITICAL: Launch ALL agents in a single message.** Use `run_in_background: true` for all agents.
+
+Each agent gets a detailed prompt following this template:
+
+```
+You are a strategic research analyst investigating a specific thread of a larger strategic question.
+
+MAIN QUESTION: [user's original question]
+YOUR THREAD: [specific research thread]
+EXISTING CONTEXT: [any relevant vault context]
+
+RESEARCH METHODOLOGY:
+1. WebSearch for 8-12 high-quality sources (prioritize: research reports, expert analyses, company filings, academic papers, industry publications — NOT listicles or superficial blog posts)
+2. For each source found, WebFetch to read the full content and extract key arguments, data points, and frameworks
+3. Look for CONFLICTING viewpoints — don't just confirm one narrative
+4. Identify specific data points, statistics, and concrete examples
+5. Note the credibility and potential bias of each source
+6. FOR EMERGING TECH THREADS: Go beyond polished sources. Search GitHub repos (README, issues, discussions), Twitter/X threads from builders, Discord/forum discussions, conference talk summaries, arXiv preprints, and early blog posts. The goal is to surface concepts that are pre-mainstream but technically promising. For each concept found, assess: maturity level, technical approach, relevance to the user's use case, and what it would take to adopt/integrate.
+
+OUTPUT FORMAT (return ALL of this):
+
+## Thread: [thread name]
+
+### Key Findings (3-5 bullet points)
+- Finding with source attribution
+
+### Evidence & Data Points
+- Specific statistics, market data, examples with sources
+
+### Expert/Notable Perspectives
+- Named perspectives from credible voices
+
+### Implications for [user's context]
+- What this means specifically for the user's situation
+
+### Confidence Level
+- HIGH / MEDIUM / LOW with reasoning
+
+### Sources
+- Numbered list of actual URLs consulted
+```
+
+**Agent naming convention:** `research-[thread-slug]` (e.g., `research-market-forces`, `research-historical-precedent`)
+
+### Phase 3: Synthesis (Orchestrator — after all agents complete)
+
+Once all agents return, synthesize into a single strategic analysis document:
+
+#### Document Structure:
+
+```markdown
+---
+type: strategic-research
+domain: [auto-detect from question]
+date: YYYY-MM-DD
+question: "[original question]"
+threads: [list of research threads]
+confidence: [overall confidence HIGH/MEDIUM/LOW]
+tags:
+ - auto-research
+ - strategy
+ - [topic tags]
+status: complete
+---
+
+# [Strategic Question as Title]
+
+## Executive Summary
+3-5 sentences capturing the core insight. Lead with the answer, not the process.
+
+## The Strategic Landscape
+Synthesized view across all research threads. Not a thread-by-thread dump — weave findings together into a coherent narrative.
+
+## Key Forces at Play
+The 3-4 most important dynamics shaping this question, with evidence from multiple threads.
+
+## Scenarios
+### Scenario A: [Most Likely] — X% confidence
+What happens, timeline, implications
+
+### Scenario B: [Optimistic/Alternative]
+What happens, timeline, implications
+
+### Scenario C: [Worst Case/Disruption]
+What happens, timeline, implications
+
+## Emerging Tech & Architectures to Watch
+Concepts, projects, and frameworks that are still in development/discussion but could be foundational. For each:
+- **What it is:** One-paragraph explanation
+- **Maturity:** Pre-alpha / Alpha / Early adoption / Growing community
+- **Technical approach:** How it works architecturally
+- **Relevance to our use case:** Why it matters for us specifically
+- **Adoption path:** What it would take to integrate/adopt — effort, risks, dependencies
+- **Key links:** GitHub repo, paper, discussion thread
+
+## Strategic Options
+For each option:
+- **Description:** What this means concretely
+- **Pros:** With evidence
+- **Cons:** With evidence
+- **Prerequisites:** What needs to be true
+- **Timeline:** When to decide/act
+- **Emerging tech leverage:** Which emerging concepts from above could strengthen this option
+
+## Recommended Actions
+Prioritized, concrete, time-bound action items. Not vague "consider X" — specific "do X by Y because Z."
+Include a separate "Tech Bets" subsection: which emerging projects to start experimenting with now, even if they're not production-ready.
+
+## Contrarian View
+The strongest argument against the consensus/recommended path. What could make all of this wrong?
+
+## Confidence & Gaps
+- What we're confident about and why
+- What we couldn't determine and what additional research would help
+- Key assumptions that should be monitored
+
+## Sources
+Consolidated, deduplicated list of all sources across threads.
+```
+
+### Phase 4: Save & Deliver
+
+1. Save the full analysis to `05-knowledge/research/YYYY-MM-DD-[slug].md`
+2. If the analysis is long (>3000 words), also create a brief 1-page summary at `05-knowledge/research/YYYY-MM-DD-[slug]-summary.md`
+3. Present the Executive Summary + Recommended Actions to the user directly in chat
+
+---
+
+## Quality Standards
+
+- **No hallucinated sources.** Every claim must trace to a real WebSearch/WebFetch result.
+- **Recency matters.** Prioritize sources from the last 6 months. Flag anything older.
+- **Bias awareness.** Note when sources have obvious commercial incentives.
+- **Specificity over generality.** "The testing tools market is $XX.XB and growing at YY% CAGR" beats "the market is growing."
+- **Actionability.** The output should help the user make a decision, not just understand a topic.
+- **Intellectual honesty.** If the research is inconclusive, say so. Don't manufacture false confidence.
+
+## Example Decomposition
+
+**Question:** "If generic LLM models get better over time, what's the future for LLM wrapper companies like Katalon or Scout?"
+
+**Threads:**
+1. **Foundation model trajectory** — How fast are GPT/Claude/Gemini improving at code understanding, test generation, bug detection? What's the capability curve?
+2. **Historical precedent: platform commoditization** — What happened to companies built on top of AWS, iOS, Salesforce, etc. when the platform absorbed their features? Who survived and why?
+3. **Testing industry structure** — Current market map, value chain, where margin lives, what buyers actually pay for
+4. **Wrapper company strategies** — How are current AI wrapper companies (Jasper, Copy.ai, Cursor, etc.) adapting? What's working?
+5. **Enterprise buying behavior** — Do enterprises buy "AI" or do they buy "solutions"? What's the procurement reality?
+6. **Emerging tech & architectures** — What pre-mainstream concepts could reshape the landscape? (e.g., novel agent frameworks, new testing paradigms, computer-use agents, browser automation architectures). Search GitHub repos, arXiv, Twitter/X builder threads, Discord communities, conference talks.
+7. **Defensibility analysis** — What moats exist for testing-specific AI companies? Data, workflow, integration, brand, switching costs?
+8. **Contrarian: wrappers win** — Arguments for why vertical AI companies might actually INCREASE in value as models commoditize
+
+## Runtime Expectations
+- Phase 1: ~2 minutes (decomposition + user confirmation)
+- Phase 2: ~5-10 minutes (parallel research, longest agent determines total time)
+- Phase 3: ~3-5 minutes (synthesis)
+- Total: ~10-15 minutes for a comprehensive strategic analysis
+
+## Error Handling
+
+- If a research thread returns low-quality results, note this in the synthesis rather than fabricating depth
+- If WebSearch/WebFetch fails for a thread, retry once with alternative search terms, then document the gap
+- The user may interrupt during Phase 2 to redirect or add threads
+- The skill can be run multiple times on related questions — reference previous research files from `05-knowledge/research/`
+
+## Fallback Behavior
+
+This skill requires WebSearch and WebFetch tools. If these are unavailable:
+- Fall back to vault-only analysis using existing `05-knowledge/` content
+- Clearly state that no live web research was performed
+- Recommend the user run the skill again when web tools are available
diff --git a/.claude/skills/create-user-story/SKILL.md b/.claude/skills/create-user-story/SKILL.md
new file mode 100644
index 0000000..e22a66f
--- /dev/null
+++ b/.claude/skills/create-user-story/SKILL.md
@@ -0,0 +1,238 @@
+---
+name: create-user-story
+description: Create user stories with duplicate checking across any project tracker (Linear, GitHub Issues, Jira)
+roles: [product-manager, engineering-lead, founder]
+integrations: [linear, github, jira]
+---
+
+# COG Create User Story Skill
+
+## When to Invoke
+- User wants to create a new user story, feature request, or issue
+- User says "create story", "new story", "add issue", "write user story", "create ticket"
+- User describes a feature or requirement that should be tracked
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use parallel agents to check for duplicates across all active trackers simultaneously, then create the story
+- If `agent_mode: solo` — check duplicates and create the story sequentially in the main conversation
+
+## Command: `/create-user-story`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** to determine which project trackers are active:
+ - **Linear** — use Linear MCP tools
+ - **GitHub** — use `gh` CLI
+ - **Jira** — use `jira` CLI or Jira API via WebFetch
+ - If NO tracker is active, save the story as a markdown file in `04-projects/[project]/stories/` and inform the user
+
+2. **Read `00-inbox/MY-PROFILE.md`** to get:
+ - Active projects (to determine which project/repo/board to target)
+ - User's name (for story author attribution)
+
+3. **Ask the user** (if not already provided):
+ - What is the feature or requirement? (free-form description)
+ - Which project does this belong to? (if multiple active projects)
+ - Priority level? (optional — default to medium)
+
+---
+
+## Execution Strategy
+
+### Phase 1: Understand the Request
+
+Parse the user's input to extract:
+- **Feature description** — what the user wants built
+- **Target users** — who benefits from this
+- **Problem statement** — what problem this solves
+- **Project context** — which project this belongs to
+
+If the user provides a brief description, ask clarifying questions before proceeding:
+- Who is the target user for this feature?
+- What problem does this solve?
+- Are there any specific acceptance criteria you have in mind?
+
+### Phase 2: Duplicate Check
+
+**CRITICAL: Always check for duplicates before creating.**
+
+#### Team Mode (parallel agents)
+
+Launch duplicate-check agents in parallel using the Task tool with `run_in_background: true`:
+
+**Agent: "duplicate-checker-linear"** (if Linear is active)
+```
+Search Linear for potential duplicate issues.
+1. Use ToolSearch to load Linear tools
+2. Use mcp__claude_ai_Linear_2__list_issues to search for issues with similar keywords
+3. Search across all active projects/teams
+4. Return any issues that match by title similarity or description overlap
+
+Search terms: [extracted keywords from user's description]
+Return: list of potential duplicates with title, status, URL, and similarity assessment
+```
+
+**Agent: "duplicate-checker-github"** (if GitHub is active)
+```
+Search GitHub Issues for potential duplicates.
+Repository: [CUSTOMIZE: your-org/your-repo]
+
+1. gh search issues "[keywords]" --repo [CUSTOMIZE: your-org/your-repo] --json number,title,state,url,body --limit 20
+2. Also search closed issues to check if this was already done:
+ gh search issues "[keywords]" --repo [CUSTOMIZE: your-org/your-repo] --state closed --json number,title,state,url --limit 10
+
+Return: list of potential duplicates with title, status, URL, and similarity assessment
+```
+
+**Agent: "duplicate-checker-jira"** (if Jira is active)
+```
+Search Jira for potential duplicate issues.
+Project: [CUSTOMIZE: YOUR-PROJECT-KEY]
+
+1. Use WebFetch or jira CLI to search:
+ JQL: project = "[CUSTOMIZE: YOUR-PROJECT-KEY]" AND text ~ "[keywords]" ORDER BY created DESC
+2. Check both open and recently resolved issues
+
+Return: list of potential duplicates with key, title, status, URL, and similarity assessment
+```
+
+#### Solo Mode (sequential)
+Run the same duplicate checks sequentially for whichever tracker is active.
+
+### Phase 3: Report Duplicates (if found)
+
+If potential duplicates are found, present them to the user:
+
+```
+I found [N] potential duplicate(s):
+
+1. **[TITLE]** ([STATUS]) — [URL]
+ Similarity: [High/Medium/Low] — [reason]
+
+2. **[TITLE]** ([STATUS]) — [URL]
+ Similarity: [High/Medium/Low] — [reason]
+
+Options:
+a) These are different — proceed with creating the new story
+b) This is a duplicate of #[N] — skip creation
+c) This is related to #[N] — create and link them
+```
+
+**Wait for user confirmation before proceeding.**
+
+### Phase 4: Format the User Story
+
+Generate the story in standard user story format:
+
+```markdown
+## Title
+[Concise, descriptive title]
+
+## User Story
+**As a** [type of user],
+**I want** [goal/desire],
+**So that** [benefit/value].
+
+## Description
+[Expanded description of the feature, including context and background]
+
+## Acceptance Criteria
+
+### Scenario 1: [Happy path scenario name]
+- **Given** [precondition]
+- **When** [action]
+- **Then** [expected outcome]
+
+### Scenario 2: [Alternative scenario name]
+- **Given** [precondition]
+- **When** [action]
+- **Then** [expected outcome]
+
+### Scenario 3: [Edge case or error scenario name]
+- **Given** [precondition]
+- **When** [action]
+- **Then** [expected outcome]
+
+## Technical Notes
+[Any implementation hints, constraints, or dependencies — if applicable]
+
+## Out of Scope
+[What this story explicitly does NOT cover — helps prevent scope creep]
+```
+
+**Present the formatted story to the user for review before creating it.**
+
+### Phase 5: Create in Tracker
+
+After user approves the story content:
+
+#### Linear
+```
+1. Use ToolSearch to load Linear tools
+2. Use mcp__claude_ai_Linear_2__get_team to find the target team
+3. Use mcp__claude_ai_Linear_2__list_issue_labels to find appropriate labels
+4. Use mcp__claude_ai_Linear_2__save_issue to create the issue with:
+ - title: [story title]
+ - description: [full story in markdown]
+ - team: [target team]
+ - priority: [user-specified or default medium]
+ - labels: [appropriate labels]
+```
+
+#### GitHub Issues
+```
+gh issue create \
+ --repo [CUSTOMIZE: your-org/your-repo] \
+ --title "[story title]" \
+ --body "[full story in markdown]" \
+ --label "[appropriate labels]"
+```
+
+#### Jira
+```
+Use WebFetch to POST to Jira REST API or use jira CLI:
+- Project: [CUSTOMIZE: YOUR-PROJECT-KEY]
+- Issue Type: Story
+- Summary: [story title]
+- Description: [full story in markdown/Jira wiki format]
+- Priority: [user-specified or default Medium]
+- Labels: [appropriate labels]
+```
+
+#### Vault Fallback (no tracker active)
+Save to `04-projects/[project]/stories/story-YYYY-MM-DD-[slug].md`
+
+### Phase 6: Confirm and Link
+
+1. Confirm creation with the user:
+ ```
+ Story created: **[TITLE]**
+ [URL or file path]
+ Priority: [priority]
+ Labels: [labels]
+ ```
+
+2. If the user indicated this is related to another issue (Phase 3, option c), create a link/relation between them.
+
+3. Also save a local copy to `04-projects/[project]/stories/` for vault reference.
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| No tracker active | Save as markdown in `04-projects/[project]/stories/` |
+| Tracker API fails | Save locally, warn user, suggest manual creation with the formatted content |
+| Duplicate check fails | Warn user that duplicate check was skipped, proceed with creation after confirmation |
+| User doesn't specify project | List active projects from MY-PROFILE.md and ask which one |
+| User provides minimal input | Ask clarifying questions to build a complete story |
+
+## Error Handling
+
+- **API rate limits**: Wait and retry once, then fall back to local save
+- **Authentication failures**: Inform user their integration may need re-authentication
+- **Large search results**: Limit duplicate check to top 10 most relevant matches
+- **Context overflow**: Summarize duplicate results rather than showing full descriptions
diff --git a/.claude/skills/export-open-issues/SKILL.md b/.claude/skills/export-open-issues/SKILL.md
new file mode 100644
index 0000000..5705ad7
--- /dev/null
+++ b/.claude/skills/export-open-issues/SKILL.md
@@ -0,0 +1,307 @@
+---
+name: export-open-issues
+description: Audit and export open issues from any project tracker with summary analysis and vault archival
+roles: [product-manager, engineering-lead, founder]
+integrations: [github, linear, jira]
+---
+
+# COG Export Open Issues Skill
+
+## When to Invoke
+- User wants to audit open issues or backlog health
+- User says "export issues", "open issues", "backlog audit", "issue report", "what's open"
+- Sprint/cycle planning prep — need a clear picture of what's in flight
+- Stakeholder reporting — need a snapshot of current work status
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use parallel agents to collect from all active trackers simultaneously and produce a unified report
+- If `agent_mode: solo` — collect from the primary tracker sequentially
+
+## Command: `/export-open-issues`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** to determine which trackers are active
+2. **Read `00-inbox/MY-PROFILE.md`** for active projects
+3. **Get current timestamp:** Run `date '+%Y-%m-%d %H:%M'` using Bash
+
+4. **Ask the user** (if not already provided):
+ - Which project? (if multiple active)
+ - Scope: all open issues, or filtered by label/milestone/assignee?
+ - Include additional analysis? (aging, priority distribution, assignee load)
+
+---
+
+## Execution Strategy
+
+### Phase 1: Collect Open Issues
+
+#### Team Mode (parallel agents)
+
+Launch collection agents using the Task tool with `run_in_background: true`:
+
+**Agent: "github-issues-collector"** (if GitHub is active)
+```
+Export all open issues from GitHub.
+Repository: [CUSTOMIZE: your-org/your-repo]
+
+1. Get all open issues:
+ gh issue list --repo [CUSTOMIZE: your-org/your-repo] --state open --json number,title,author,assignees,labels,createdAt,updatedAt,milestone,url --limit 500
+
+2. Get all open PRs (separate from issues):
+ gh pr list --repo [CUSTOMIZE: your-org/your-repo] --state open --json number,title,author,labels,createdAt,updatedAt,reviewDecision,url --limit 200
+
+For each issue, calculate:
+- Age in days (today - createdAt)
+- Days since last update (today - updatedAt)
+- Staleness flag: >30 days since last update = stale
+
+Return: full issue list with calculated fields
+```
+
+**Agent: "linear-issues-collector"** (if Linear is active)
+```
+Export all open issues from Linear.
+
+1. Use ToolSearch to load Linear tools
+2. List all teams: mcp__claude_ai_Linear_2__list_teams
+3. For each relevant team, list open issues: mcp__claude_ai_Linear_2__list_issues
+4. Get current cycles: mcp__claude_ai_Linear_2__list_cycles
+5. Get milestones: mcp__claude_ai_Linear_2__list_milestones
+
+For each issue, collect:
+- ID, title, status, priority, assignee, labels, project
+- Created date, updated date
+- Cycle membership
+- Blocked status
+
+Return: full issue list with metadata
+```
+
+**Agent: "jira-issues-collector"** (if Jira is active)
+```
+Export all open issues from Jira.
+Project: [CUSTOMIZE: YOUR-PROJECT-KEY]
+
+1. Search open issues:
+ JQL: project = "[CUSTOMIZE: YOUR-PROJECT-KEY]" AND status NOT IN (Done, Closed, Resolved) ORDER BY priority DESC, created ASC
+
+2. For each issue, collect:
+ key, summary, issuetype, status, priority, assignee, reporter, labels, components, fixVersion, created, updated, duedate
+
+Return: full issue list with metadata
+```
+
+#### Solo Mode
+Run collection sequentially for the primary tracker.
+
+### Phase 2: Analyze and Categorize
+
+Process the collected data to produce:
+
+#### 2.1 Summary Statistics
+```
+Total Open Issues: [N]
+ - By Priority: Critical [N], High [N], Medium [N], Low [N], None [N]
+ - By Type: Feature [N], Bug [N], Task [N], Other [N]
+ - By Status: To Do [N], In Progress [N], In Review [N], Blocked [N]
+ - By Assignee: [Name] ([N]), [Name] ([N]), Unassigned ([N])
+```
+
+#### 2.2 Health Indicators
+- **Stale issues** (no update in >30 days): list with age
+- **Unassigned issues**: list with priority
+- **Blocked issues**: list with blocker details
+- **Overdue issues** (past due date): list with days overdue
+- **Oldest open issues**: top 10 by age
+- **In-progress bottleneck**: issues in "In Progress" for >7 days
+
+#### 2.3 Distribution Charts (text-based)
+```
+Priority Distribution:
+ Critical ████░░░░░░ 12%
+ High ████████░░ 38%
+ Medium ██████░░░░ 28%
+ Low ████░░░░░░ 22%
+
+Age Distribution:
+ <7 days ██████████ 45%
+ 7-30 days ██████░░░░ 30%
+ 30-90 d ███░░░░░░░ 15%
+ >90 days ██░░░░░░░░ 10%
+```
+
+### Phase 3: Generate Report
+
+```markdown
+---
+type: open-issues-audit
+project: [project-name]
+date: [YYYY-MM-DD]
+created: [YYYY-MM-DD HH:MM]
+source: [github/linear/jira/multi]
+tags: ["#issues-audit", "#[project-name]", "#backlog"]
+summary:
+ total_open: [N]
+ critical: [N]
+ high: [N]
+ stale: [N]
+ unassigned: [N]
+ blocked: [N]
+ oldest_days: [N]
+---
+
+# Open Issues Audit — [Project Name]
+
+**Date:** [YYYY-MM-DD]
+**Source:** [Tracker(s) used]
+**Total Open Issues:** [N]
+
+---
+
+## Executive Summary
+
+[2-3 sentences: overall backlog health, biggest concerns, and recommended actions]
+
+---
+
+## Summary Statistics
+
+| Category | Count | % of Total |
+|----------|-------|-----------|
+| **By Priority** | | |
+| Critical | [N] | [%] |
+| High | [N] | [%] |
+| Medium | [N] | [%] |
+| Low | [N] | [%] |
+| No Priority | [N] | [%] |
+| **By Status** | | |
+| To Do | [N] | [%] |
+| In Progress | [N] | [%] |
+| In Review | [N] | [%] |
+| Blocked | [N] | [%] |
+| **By Type** | | |
+| Feature/Story | [N] | [%] |
+| Bug | [N] | [%] |
+| Task | [N] | [%] |
+| Other | [N] | [%] |
+
+---
+
+## Assignee Load
+
+| Assignee | Open Issues | Critical/High | In Progress | Oldest Issue (days) |
+|----------|-------------|---------------|-------------|-------------------|
+| [Name] | [N] | [N] | [N] | [N] |
+| [Name] | [N] | [N] | [N] | [N] |
+| Unassigned | [N] | [N] | — | [N] |
+
+---
+
+## Health Alerts
+
+### Stale Issues (>30 days without update)
+| # | Title | Assignee | Priority | Age (days) | Last Updated |
+|---|-------|----------|----------|-----------|-------------|
+| [#] | [Title] | [Name] | [Priority] | [N] | [Date] |
+
+### Blocked Issues
+| # | Title | Assignee | Blocked By | Days Blocked |
+|---|-------|----------|-----------|-------------|
+| [#] | [Title] | [Name] | [Reason] | [N] |
+
+### Unassigned High-Priority Issues
+| # | Title | Priority | Age (days) | Labels |
+|---|-------|----------|-----------|--------|
+| [#] | [Title] | [Priority] | [N] | [Labels] |
+
+### Overdue Issues
+| # | Title | Assignee | Due Date | Days Overdue |
+|---|-------|----------|----------|-------------|
+| [#] | [Title] | [Name] | [Date] | [N] |
+
+---
+
+## Full Issue List
+
+### Critical Priority
+| # | Title | Status | Assignee | Age | Labels | URL |
+|---|-------|--------|----------|-----|--------|-----|
+| [#] | [Title] | [Status] | [Name] | [N]d | [Labels] | [URL] |
+
+### High Priority
+[Same table format]
+
+### Medium Priority
+[Same table format]
+
+### Low Priority
+[Same table format]
+
+---
+
+## Recommendations
+
+1. **[Recommendation 1]** — [Specific action with rationale]
+2. **[Recommendation 2]** — [Specific action with rationale]
+3. **[Recommendation 3]** — [Specific action with rationale]
+
+---
+
+*Generated by COG Open Issues Audit | [Date]*
+```
+
+### Phase 4: Save to Vault
+
+Save to: `04-projects/[project]/audits/open-issues-YYYY-MM-DD.md`
+
+```bash
+mkdir -p "04-projects/[project]/audits"
+```
+
+### Phase 5: Present Results
+
+Show the user:
+1. Executive summary
+2. Key health alerts (stale, blocked, unassigned)
+3. Top recommendations
+4. File location
+
+Ask if they want:
+- Full detailed view
+- Export as CSV (generate a simple CSV file alongside the markdown)
+- Share to a specific channel or wiki
+
+---
+
+## CSV Export (Optional)
+
+If user requests CSV, generate alongside the markdown:
+
+```
+#,Title,Type,Status,Priority,Assignee,Labels,Created,Updated,Age(days),URL
+[data rows]
+```
+
+Save to: `04-projects/[project]/audits/open-issues-YYYY-MM-DD.csv`
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| No tracker active | Inform user that a project tracker integration is needed; offer to set one up |
+| Tracker API fails | Retry once, then report partial results with error note |
+| Too many issues (>500) | Paginate collection, warn user, offer to filter by label/milestone/assignee |
+| Multiple trackers active | Collect from all and produce a unified report, noting the source for each item |
+| No open issues found | Report clean backlog status (this is good news!) |
+
+## Error Handling
+
+- **Rate limits**: Paginate requests and add delays if needed
+- **Large payloads**: Summarize rather than list all items if >200 issues
+- **Missing fields**: Mark as "N/A" rather than failing
+- **Context overflow**: Process in batches, summarize per batch
diff --git a/.claude/skills/generate-prd/SKILL.md b/.claude/skills/generate-prd/SKILL.md
new file mode 100644
index 0000000..f804248
--- /dev/null
+++ b/.claude/skills/generate-prd/SKILL.md
@@ -0,0 +1,364 @@
+---
+name: generate-prd
+description: Generate product requirements documents with optional publishing to Confluence or other wiki platforms
+roles: [product-manager, engineering-lead, founder]
+integrations: [confluence, notion, hackmd]
+---
+
+# COG Generate PRD Skill
+
+## When to Invoke
+- User wants to create a PRD, product spec, or requirements document
+- User says "generate PRD", "write PRD", "product requirements", "spec doc", "feature spec"
+- User has a feature or project that needs formal documentation before development
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use parallel agents to gather context from multiple sources (existing PRDs, related issues, competitive research) while drafting
+- If `agent_mode: solo` — gather context and draft sequentially in the main conversation
+
+## Command: `/generate-prd`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** to determine publishing options:
+ - **Confluence** — can publish PRD to team wiki
+ - **Notion** — can publish PRD to Notion workspace
+ - **HackMD** — can publish PRD as shared markdown doc
+ - If none active, PRD stays in the vault only (still fully useful)
+
+2. **Read `00-inbox/MY-PROFILE.md`** for:
+ - Active projects
+ - User's name and role (for PRD author field)
+
+3. **Get current timestamp:**
+ Run `date '+%Y-%m-%d %H:%M'` using Bash for the `created:` frontmatter field
+
+---
+
+## Execution Strategy
+
+### Phase 1: Gather Requirements
+
+Ask the user for the following (skip what they've already provided):
+
+**Required:**
+- Feature/product name
+- Problem statement — what problem are we solving?
+- Target users — who is this for?
+- High-level solution — what are we building?
+
+**Optional (will generate reasonable defaults if not provided):**
+- Success metrics — how do we measure success?
+- Constraints — technical, time, budget, or regulatory constraints
+- Dependencies — what does this depend on?
+- Related documents — links to designs, research, prior art
+- Target timeline — when does this need to ship?
+
+### Phase 2: Context Gathering
+
+#### Team Mode (parallel agents)
+
+Launch context-gathering agents using the Task tool with `run_in_background: true`:
+
+**Agent: "existing-prd-scanner"**
+```
+Scan the vault for existing PRDs and related documents.
+
+1. Glob for PRDs: 04-projects/*/PRDs/*.md
+2. Glob for related project files: 04-projects/[project]/**/*.md
+3. Read recent PRDs to understand the user's preferred format and level of detail
+4. Look for any existing docs related to the feature being specified
+
+Return: relevant existing content, user's PRD style preferences, and any related docs
+```
+
+**Agent: "issue-context-gatherer"**
+```
+Gather related issues and feature requests from active trackers.
+
+Check 00-inbox/MY-INTEGRATIONS.md for active trackers, then:
+
+If Linear is active:
+1. Use ToolSearch to load Linear tools
+2. Search for issues related to [feature keywords]
+3. Check current initiatives and projects for context
+
+If GitHub is active:
+1. gh search issues "[feature keywords]" --repo [CUSTOMIZE: your-org/your-repo] --json number,title,body,labels --limit 15
+2. Check for related discussions or feature requests
+
+Return: related issues, existing feature requests, and any prior discussion context
+```
+
+#### Solo Mode
+Run the same context gathering sequentially.
+
+### Phase 3: Generate PRD
+
+Create the PRD using this template:
+
+```markdown
+---
+type: prd
+project: [project-name]
+feature: [feature-name]
+status: draft
+author: [user name]
+created: [YYYY-MM-DD HH:MM]
+last_updated: [YYYY-MM-DD]
+version: "1.0"
+approvers: [CUSTOMIZE: list of approvers]
+tags: ["#prd", "#product", "#[project-name]"]
+---
+
+# PRD: [Feature Name]
+
+## Overview
+
+| Field | Value |
+|-------|-------|
+| **Author** | [Name] |
+| **Status** | Draft |
+| **Created** | [Date] |
+| **Target Release** | [Timeline or TBD] |
+| **Priority** | [High/Medium/Low] |
+
+---
+
+## 1. Problem Statement
+
+[Clear description of the problem being solved. Include data or evidence where available.]
+
+### Who is affected?
+[Target users and how they're impacted]
+
+### What is the current experience?
+[How users currently deal with this problem]
+
+### Why now?
+[Why this is important to solve at this time]
+
+---
+
+## 2. Goals & Success Metrics
+
+### Goals
+1. [Primary goal]
+2. [Secondary goal]
+3. [Tertiary goal]
+
+### Success Metrics
+| Metric | Current Baseline | Target | Measurement Method |
+|--------|-----------------|--------|-------------------|
+| [Metric 1] | [Current] | [Target] | [How to measure] |
+| [Metric 2] | [Current] | [Target] | [How to measure] |
+
+### Non-Goals
+- [What this project explicitly does NOT aim to solve]
+- [Scope boundaries]
+
+---
+
+## 3. User Stories
+
+### Primary User: [User Type]
+
+**Story 1:** As a [user type], I want [goal] so that [benefit].
+
+**Story 2:** As a [user type], I want [goal] so that [benefit].
+
+### Secondary User: [User Type] (if applicable)
+
+**Story 3:** As a [user type], I want [goal] so that [benefit].
+
+---
+
+## 4. Proposed Solution
+
+### 4.1 Solution Overview
+[High-level description of the proposed solution]
+
+### 4.2 Key Features
+1. **[Feature 1]** — [Description]
+2. **[Feature 2]** — [Description]
+3. **[Feature 3]** — [Description]
+
+### 4.3 User Flow
+[Step-by-step description of the primary user flow]
+
+1. User [action]
+2. System [response]
+3. User [action]
+4. System [response]
+
+### 4.4 Edge Cases & Error Handling
+| Scenario | Expected Behavior |
+|----------|------------------|
+| [Edge case 1] | [How the system handles it] |
+| [Edge case 2] | [How the system handles it] |
+
+---
+
+## 5. Technical Considerations
+
+### Architecture Impact
+[How this fits into the existing system architecture]
+
+### Dependencies
+- [Dependency 1] — [Status: available/needs work]
+- [Dependency 2] — [Status: available/needs work]
+
+### Technical Risks
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| [Risk 1] | [H/M/L] | [H/M/L] | [Mitigation plan] |
+
+### Performance Requirements
+- [Performance requirement 1]
+- [Performance requirement 2]
+
+---
+
+## 6. Design & UX
+
+[Link to designs or describe UX requirements]
+
+### Key UX Principles
+- [Principle 1]
+- [Principle 2]
+
+### Accessibility Requirements
+- [Requirement 1]
+- [Requirement 2]
+
+---
+
+## 7. Release Strategy
+
+### Rollout Plan
+- **Phase 1:** [Description] — [Timeline]
+- **Phase 2:** [Description] — [Timeline]
+
+### Feature Flags
+- [Feature flag 1] — [Purpose]
+
+### Rollback Plan
+[How to roll back if issues arise]
+
+---
+
+## 8. Open Questions
+
+- [ ] [Question 1] — Owner: [Name]
+- [ ] [Question 2] — Owner: [Name]
+- [ ] [Question 3] — Owner: [Name]
+
+---
+
+## 9. References
+
+- [Link to related PRDs]
+- [Link to designs]
+- [Link to research]
+- [Link to related issues/tickets]
+
+---
+
+## Changelog
+
+| Version | Date | Author | Changes |
+|---------|------|--------|---------|
+| 1.0 | [Date] | [Author] | Initial draft |
+```
+
+### Phase 4: Review Gate
+
+**Present the generated PRD to the user:**
+
+```
+PRD draft is ready for review.
+
+Sections generated:
+1. Problem Statement
+2. Goals & Success Metrics
+3. User Stories
+4. Proposed Solution
+5. Technical Considerations
+6. Design & UX
+7. Release Strategy
+8. Open Questions
+9. References
+
+Would you like to:
+a) Review the full PRD (I'll display it)
+b) Save as-is to the vault
+c) Make changes to specific sections
+d) Publish to [active wiki platform] (requires your approval)
+```
+
+**NEVER auto-publish. Always wait for explicit user approval.**
+
+### Phase 5: Save to Vault
+
+Save the PRD to: `04-projects/[project]/PRDs/prd-[feature-slug]-YYYY-MM-DD.md`
+
+Create the directory structure if it doesn't exist:
+```bash
+mkdir -p "04-projects/[project]/PRDs"
+```
+
+### Phase 6: Publish (Optional, requires approval)
+
+**Only proceed if the user explicitly approves publishing.**
+
+#### Confluence
+```
+Use WebFetch to publish via Confluence REST API:
+- POST /wiki/rest/api/content
+- Space: [CUSTOMIZE: YOUR-SPACE-KEY]
+- Parent page: [CUSTOMIZE: PRDs-parent-page-id]
+- Title: "PRD: [Feature Name]"
+- Body: [converted to Confluence storage format]
+
+Note: Convert markdown to Confluence XHTML storage format before publishing.
+```
+
+#### Notion
+```
+1. Use ToolSearch to load Notion tools
+2. Use mcp__claude_ai_Notion__notion-create-pages to create the PRD page
+3. Place under [CUSTOMIZE: PRDs database or parent page]
+```
+
+#### HackMD
+```
+Use WebFetch to publish via HackMD API:
+- POST to create a new note
+- Set permissions as configured
+```
+
+After publishing, update the vault copy with the published URL:
+```markdown
+published_url: [URL]
+published_at: [timestamp]
+```
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| No wiki platform active | Save to vault only — PRD is still fully useful as a local document |
+| Publishing API fails | Save to vault, provide the formatted content for manual publishing |
+| User doesn't specify project | List active projects from MY-PROFILE.md and ask |
+| Minimal input provided | Generate a skeleton PRD with [TODO] markers for the user to fill in |
+| Existing PRD found for same feature | Ask if this is an update/revision or a new PRD |
+
+## Error Handling
+
+- **Context overflow**: If gathering too much context from existing docs, summarize rather than include full text
+- **API failures**: Always save to vault first, then attempt publishing as a separate step
+- **Large PRDs**: If the PRD exceeds typical wiki page limits, suggest splitting into sub-pages
diff --git a/.claude/skills/generate-release-notes/SKILL.md b/.claude/skills/generate-release-notes/SKILL.md
new file mode 100644
index 0000000..5ed4f3b
--- /dev/null
+++ b/.claude/skills/generate-release-notes/SKILL.md
@@ -0,0 +1,348 @@
+---
+name: generate-release-notes
+description: Generate categorized release notes from any source (GitHub, Linear, Jira, or manual input) with optional publishing
+roles: [product-manager, engineering-lead, founder]
+integrations: [github, linear, jira, confluence, notion, hackmd]
+---
+
+# COG Generate Release Notes Skill
+
+## When to Invoke
+- User wants to create release notes for a version, sprint, or cycle
+- User says "release notes", "changelog", "what shipped", "write release notes"
+- A new version or milestone has been completed
+- End of sprint/cycle documentation
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use parallel agents to collect data from all active sources simultaneously
+- If `agent_mode: solo` — collect data sequentially from the primary tracker
+
+## Command: `/generate-release-notes`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** to determine data sources and publishing options
+2. **Read `00-inbox/MY-PROFILE.md`** for active projects
+3. **Get current timestamp:** Run `date '+%Y-%m-%d %H:%M'` using Bash
+
+4. **Ask the user** (if not already provided):
+ - What version/release/cycle is this for?
+ - What is the date range? (or: which milestone/cycle/sprint?)
+ - Which project? (if multiple active)
+ - Audience: internal team, customers, or both?
+
+---
+
+## Execution Strategy
+
+### Phase 1: Collect Release Data
+
+#### Team Mode (parallel agents)
+
+Launch data collection agents using the Task tool with `run_in_background: true`:
+
+**Agent: "github-release-collector"** (if GitHub is active)
+```
+Collect all merged PRs and release data for the specified version/period.
+Repository: [CUSTOMIZE: your-org/your-repo]
+Period: [START_DATE] to [END_DATE]
+
+1. Get merged PRs in the period:
+ gh pr list --repo [CUSTOMIZE: your-org/your-repo] --state merged --search "merged:[START_DATE]..[END_DATE]" --json number,title,author,labels,body,mergedAt --limit 200
+
+2. Check for existing GitHub release (if version tag exists):
+ gh release view [VERSION_TAG] --repo [CUSTOMIZE: your-org/your-repo] --json name,body,tagName,createdAt 2>/dev/null
+
+3. Get commits between tags (if applicable):
+ gh api repos/[CUSTOMIZE: your-org/your-repo]/compare/[PREV_TAG]...[CURRENT_TAG] --jq '.commits[] | {sha: .sha[:7], message: .commit.message, author: .author.login}'
+
+Categorize each PR by its labels or title prefix:
+- "feat"/"feature"/"enhancement" labels → Enhancements
+- "fix"/"bug"/"bugfix" labels → Bug Fixes
+- "tech"/"refactor"/"chore"/"infrastructure" labels → Technical Improvements
+- "docs"/"documentation" labels → Documentation
+- "security" labels → Security
+- "breaking"/"breaking-change" labels → Breaking Changes
+- "deprecation" labels → Deprecations
+
+Return: categorized list of changes with PR numbers, titles, authors, and descriptions
+```
+
+**Agent: "linear-release-collector"** (if Linear is active)
+```
+Collect completed issues for the specified cycle/period.
+
+1. Use ToolSearch to load Linear tools
+2. List cycles: mcp__claude_ai_Linear_2__list_cycles
+3. Find the target cycle or filter by date range
+4. List all completed issues in the cycle/period: mcp__claude_ai_Linear_2__list_issues
+5. For each issue, get details including labels and project
+
+Categorize by label or issue type:
+- Feature/Enhancement labels → Enhancements
+- Bug labels → Bug Fixes
+- Technical/Infrastructure labels → Technical Improvements
+- Documentation labels → Documentation
+
+Return: categorized list of changes with issue IDs, titles, assignees, and descriptions
+```
+
+**Agent: "jira-release-collector"** (if Jira is active)
+```
+Collect issues for the specified version/sprint.
+Project: [CUSTOMIZE: YOUR-PROJECT-KEY]
+
+1. Search by fixVersion:
+ JQL: project = "[CUSTOMIZE: YOUR-PROJECT-KEY]" AND fixVersion = "[VERSION]" AND status = Done ORDER BY issuetype, priority DESC
+
+ OR search by sprint:
+ JQL: project = "[CUSTOMIZE: YOUR-PROJECT-KEY]" AND sprint = "[SPRINT_NAME]" AND status = Done ORDER BY issuetype, priority DESC
+
+2. For each issue, collect: key, summary, issuetype, priority, assignee, labels, description
+
+Categorize by issue type:
+- Story/Feature → Enhancements
+- Bug → Bug Fixes
+- Task/Technical Task → Technical Improvements
+- Documentation → Documentation
+
+Return: categorized list with issue keys, titles, assignees, types, and descriptions
+```
+
+#### Solo Mode
+Run the primary tracker collection sequentially.
+
+#### Manual Input Fallback
+If no tracker is active or the user prefers manual input:
+```
+No project tracker detected. You can provide release items manually.
+
+Please list the changes in this release. I'll categorize them for you.
+Format: one change per line, optionally prefix with [feature], [fix], [tech], [docs], [security], [breaking]
+```
+
+### Phase 2: Categorize and Organize
+
+Organize collected items into standard categories:
+
+1. **Breaking Changes** (always first if present)
+2. **New Features & Enhancements**
+3. **Bug Fixes**
+4. **Technical Improvements**
+5. **Security Updates**
+6. **Documentation**
+7. **Deprecations**
+8. **Known Issues** (if any remain)
+
+Within each category, order by:
+1. Priority (highest first)
+2. User impact (most impactful first)
+
+### Phase 3: Generate Release Notes
+
+#### For Customer/External Audience:
+
+```markdown
+---
+type: release-notes
+project: [project-name]
+version: [version]
+date: [YYYY-MM-DD]
+created: [YYYY-MM-DD HH:MM]
+audience: external
+tags: ["#release-notes", "#[project-name]", "#v[version]"]
+items_count: [total count]
+categories:
+ enhancements: [count]
+ bug_fixes: [count]
+ technical: [count]
+ security: [count]
+ breaking_changes: [count]
+---
+
+# Release Notes — [Project Name] [Version]
+
+**Release Date:** [Date]
+
+## What's New
+
+[2-3 sentence executive summary of the most important changes in this release]
+
+---
+
+### Breaking Changes
+
+> **Action Required:** The following changes may require updates to your workflow.
+
+- **[Change title]** — [User-friendly description of what changed and what to do]
+
+---
+
+### New Features & Enhancements
+
+- **[Feature title]** — [User-friendly description focused on the benefit to users]
+- **[Feature title]** — [User-friendly description]
+
+### Bug Fixes
+
+- **[Fix title]** — [What was broken and how it's fixed, in user terms]
+- **[Fix title]** — [Description]
+
+### Security Updates
+
+- **[Update title]** — [Description without exposing vulnerability details]
+
+### Deprecations
+
+- **[Deprecated feature]** — [What's being deprecated, timeline, and migration path]
+
+---
+
+### Known Issues
+
+- [Known issue description] — [Workaround if available]
+
+---
+
+*For questions or feedback, [CUSTOMIZE: contact info or link]*
+```
+
+#### For Internal/Team Audience:
+
+```markdown
+---
+type: release-notes
+project: [project-name]
+version: [version]
+date: [YYYY-MM-DD]
+created: [YYYY-MM-DD HH:MM]
+audience: internal
+tags: ["#release-notes", "#[project-name]", "#v[version]"]
+source_tracker: [github/linear/jira/manual]
+---
+
+# Release Notes — [Project Name] [Version] (Internal)
+
+**Release Date:** [Date]
+**Cycle/Sprint:** [Name if applicable]
+
+## Summary
+[Executive summary with key stats: N features, N fixes, N tech improvements]
+
+---
+
+### Breaking Changes
+- **[Title]** ([PR/Issue #link]) — [Technical description] — @[author]
+
+### New Features & Enhancements
+- **[Title]** ([PR/Issue #link]) — [Description] — @[author]
+
+### Bug Fixes
+- **[Title]** ([PR/Issue #link]) — [Description] — @[author]
+
+### Technical Improvements
+- **[Title]** ([PR/Issue #link]) — [Description] — @[author]
+
+### Documentation
+- **[Title]** ([PR/Issue #link]) — [Description] — @[author]
+
+---
+
+### Stats
+- **Total items:** [N]
+- **Contributors:** [list of contributors]
+- **PRs merged:** [N]
+- **Issues resolved:** [N]
+
+---
+
+### Known Issues & Follow-ups
+- [ ] [Issue description] — Owner: [name]
+```
+
+### Phase 4: Review Gate
+
+Present the generated release notes to the user:
+
+```
+Release notes draft is ready for [Project] [Version].
+
+Summary:
+- [N] New Features & Enhancements
+- [N] Bug Fixes
+- [N] Technical Improvements
+- [N] other items
+
+Audience: [external/internal]
+
+Would you like to:
+a) Review the full release notes
+b) Save as-is to the vault
+c) Make changes
+d) Publish to [active platform] (requires your approval)
+```
+
+**NEVER auto-publish. Always wait for explicit user approval.**
+
+### Phase 5: Save to Vault
+
+Save to: `04-projects/[project]/release-notes/release-[version]-YYYY-MM-DD.md`
+
+```bash
+mkdir -p "04-projects/[project]/release-notes"
+```
+
+### Phase 6: Publish (Optional, requires approval)
+
+**Only proceed if the user explicitly approves.**
+
+#### GitHub Release
+```
+gh release create [VERSION_TAG] \
+ --repo [CUSTOMIZE: your-org/your-repo] \
+ --title "[Project] [Version]" \
+ --notes-file [path-to-release-notes]
+```
+
+#### Confluence
+```
+Use WebFetch to publish via Confluence REST API:
+- Space: [CUSTOMIZE: YOUR-SPACE-KEY]
+- Parent page: [CUSTOMIZE: Release-Notes-parent-page-id]
+- Title: "Release Notes — [Project] [Version]"
+```
+
+#### Notion
+```
+1. Use ToolSearch to load Notion tools
+2. Use mcp__claude_ai_Notion__notion-create-pages
+```
+
+#### HackMD
+```
+Use WebFetch to publish via HackMD API
+```
+
+After publishing, update the vault copy with the published URL.
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| No tracker active | Accept manual input, or scan git log for commits in the date range |
+| Tracker API fails | Fall back to git log analysis: `git log --oneline [PREV_TAG]..[CURRENT_TAG]` |
+| No version tag specified | Use date range instead, or list recent completed work |
+| Mixed sources | Merge and deduplicate items from multiple trackers |
+| No publishing platform | Save to vault only |
+| Very large release | Split into "Highlights" section + full changelog |
+
+## Error Handling
+
+- **Too many items**: If >100 items, auto-summarize minor changes and list only significant ones in detail
+- **Missing PR descriptions**: Use PR title and commit messages as fallback
+- **Duplicate items across trackers**: Deduplicate by matching titles/descriptions
+- **Context overflow**: Paginate data collection, summarize per-batch
diff --git a/.claude/skills/publish-to-confluence/SKILL.md b/.claude/skills/publish-to-confluence/SKILL.md
new file mode 100644
index 0000000..b2bd6c2
--- /dev/null
+++ b/.claude/skills/publish-to-confluence/SKILL.md
@@ -0,0 +1,261 @@
+---
+name: publish-to-confluence
+description: Publish any markdown file from the vault to Confluence with format conversion and approval gate
+roles: [product-manager, engineering-lead, founder]
+integrations: [confluence]
+---
+
+# COG Publish to Confluence Skill
+
+## When to Invoke
+- User wants to publish a document to Confluence
+- User says "publish to Confluence", "push to wiki", "send to Confluence", "confluence publish"
+- User has a markdown file they want to share with the team on Confluence
+- After generating a PRD, release notes, or other document that should go to the wiki
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — no significant benefit for this skill (single sequential operation)
+- If `agent_mode: solo` — standard execution
+
+## Command: `/publish-to-confluence`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** — Confluence MUST be listed under Active Integrations
+ - If Confluence is **not active**: Inform the user and stop.
+ ```
+ Confluence is not in your active integrations.
+
+ Would you like to:
+ a) Set up Confluence integration (I'll add it to MY-INTEGRATIONS.md)
+ b) Export the document in a Confluence-compatible format for manual upload
+ ```
+ - If Confluence is **disabled**: Skip silently per COG conventions. Suggest alternative publishing (HackMD, Notion) if active.
+
+2. **Get current timestamp:** Run `date '+%Y-%m-%d %H:%M'` using Bash
+
+---
+
+## Execution Strategy
+
+### Phase 1: Identify the Source Document
+
+Determine what to publish:
+
+**Option A: User specifies a file path**
+```
+Read the specified file from the vault.
+```
+
+**Option B: User describes the document**
+```
+Search for matching files:
+1. Glob for likely matches in 04-projects/, 05-knowledge/, 01-daily/
+2. Present candidates and let user choose
+```
+
+**Option C: Just-generated document**
+If this skill is invoked right after generating a PRD, release notes, or other document, use that document.
+
+### Phase 2: Configure Publishing Target
+
+Ask the user (if not already provided):
+
+```
+Where should this be published in Confluence?
+
+Required:
+- Space key: [CUSTOMIZE: YOUR-SPACE-KEY] (or let me search for spaces)
+- Parent page: [Page title or ID under which to nest this page]
+
+Optional:
+- Page title: [defaults to the document's H1 heading]
+- Labels: [Confluence labels to add]
+- Publish mode: "create new" or "update existing"
+```
+
+**If the user doesn't know the space or parent page:**
+```
+Use WebFetch to search Confluence:
+GET /wiki/rest/api/space?limit=50
+- List available spaces for the user to choose
+
+GET /wiki/rest/api/content?spaceKey=[SPACE]&type=page&limit=25
+- List pages in the space for parent page selection
+```
+
+### Phase 3: Convert Markdown to Confluence Format
+
+Convert the markdown document to Confluence storage format (XHTML):
+
+**Conversion rules:**
+| Markdown | Confluence Storage Format |
+|----------|--------------------------|
+| `# Heading` | `<h1>Heading</h1>` |
+| `## Heading` | `<h2>Heading</h2>` |
+| `**bold**` | `<strong>bold</strong>` |
+| `*italic*` | `<em>italic</em>` |
+| `- list item` | `<ul><li>list item</li></ul>` |
+| `1. list item` | `<ol><li>list item</li></ol>` |
+| `[text](url)` | `<a href="url">text</a>` |
+| `` `code` `` | `<code>code</code>` |
+| Code blocks | `<ac:structured-macro ac:name="code"><ac:plain-text-body><![CDATA[...]]></ac:plain-text-body></ac:structured-macro>` |
+| Tables | `<table><tbody><tr><th>...</th></tr><tr><td>...</td></tr></tbody></table>` |
+| `> blockquote` | `<blockquote><p>quote</p></blockquote>` |
+| `---` | `<hr />` |
+| `- [ ] task` | `<ac:task-list><ac:task><ac:task-status>incomplete</ac:task-status><ac:task-body>task</ac:task-body></ac:task></ac:task-list>` |
+| `- [x] task` | Same with `complete` status |
+| YAML frontmatter | Strip entirely (not displayed in Confluence) |
+
+**Important conversion notes:**
+- Strip YAML frontmatter — it should not appear in the Confluence page
+- Preserve table structure carefully
+- Convert relative vault links to plain text (they won't work in Confluence)
+- Handle nested lists properly
+- Preserve emoji characters as-is
+
+### Phase 4: Preview and Approval Gate
+
+**CRITICAL: NEVER publish without explicit user approval.**
+
+Present a summary to the user:
+
+```
+Ready to publish to Confluence:
+
+Document: [filename]
+Title: [page title]
+Space: [space key]
+Parent Page: [parent page title]
+Mode: [create new / update existing]
+Labels: [labels]
+
+Content preview (first 500 chars):
+[preview text]
+
+Estimated page size: [approximate word count]
+
+Proceed with publishing? (yes/no)
+```
+
+**Wait for explicit "yes" before proceeding.**
+
+### Phase 5: Publish
+
+#### Create New Page
+```
+Use WebFetch to POST to Confluence REST API:
+
+POST [CUSTOMIZE: your-confluence-url]/wiki/rest/api/content
+
+Headers:
+ Content-Type: application/json
+ Authorization: [from configured credentials]
+
+Body:
+{
+ "type": "page",
+ "title": "[page title]",
+ "space": { "key": "[SPACE_KEY]" },
+ "ancestors": [{ "id": "[PARENT_PAGE_ID]" }],
+ "body": {
+ "storage": {
+ "value": "[converted XHTML content]",
+ "representation": "storage"
+ }
+ },
+ "metadata": {
+ "labels": [
+ { "prefix": "global", "name": "[label]" }
+ ]
+ }
+}
+```
+
+#### Update Existing Page
+```
+First, get the current page to obtain the version number:
+GET [CUSTOMIZE: your-confluence-url]/wiki/rest/api/content/[PAGE_ID]?expand=version
+
+Then update:
+PUT [CUSTOMIZE: your-confluence-url]/wiki/rest/api/content/[PAGE_ID]
+
+Body:
+{
+ "type": "page",
+ "title": "[page title]",
+ "version": { "number": [current_version + 1] },
+ "body": {
+ "storage": {
+ "value": "[converted XHTML content]",
+ "representation": "storage"
+ }
+ }
+}
+```
+
+### Phase 6: Confirm and Update Vault
+
+After successful publishing:
+
+1. **Confirm to the user:**
+ ```
+ Published successfully!
+
+ Page: [Title]
+ URL: [Confluence page URL]
+ Space: [Space Key]
+ Version: [version number]
+ ```
+
+2. **Update the source vault file** (add published metadata to frontmatter):
+ ```yaml
+ confluence_url: "[page URL]"
+ confluence_page_id: "[page ID]"
+ confluence_space: "[space key]"
+ published_at: "[timestamp]"
+ confluence_version: [version number]
+ ```
+
+3. **Log the publication** for future reference.
+
+---
+
+## Re-Publishing (Update Flow)
+
+If the vault file already has `confluence_page_id` in its frontmatter:
+
+```
+This document was previously published to Confluence:
+ URL: [confluence_url]
+ Last published: [published_at]
+
+Would you like to:
+a) Update the existing Confluence page (increment version)
+b) Create a new page (separate copy)
+c) Cancel
+```
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| Confluence not active | Stop and inform user; suggest alternative platforms |
+| Confluence API fails | Save the converted XHTML to a file so user can manually paste it |
+| Authentication failure | Inform user their Confluence credentials may need refreshing |
+| Page already exists (same title) | Ask user: update existing, create with different title, or cancel |
+| Very large document | Warn user about page size; suggest splitting into child pages |
+| Complex markdown (unsupported elements) | Convert best-effort, warn about any elements that couldn't be converted |
+
+## Error Handling
+
+- **API 403 (Forbidden)**: User may lack write permissions to the target space
+- **API 404 (Not Found)**: Space key or parent page ID may be incorrect
+- **API 409 (Conflict)**: Page was modified by someone else; fetch latest version and retry
+- **Conversion failures**: Fall back to plain text for elements that can't be converted
+- **Rate limits**: Retry with backoff
+- **Network errors**: Save converted content locally so no work is lost
diff --git a/.claude/skills/update-knowledge-base/SKILL.md b/.claude/skills/update-knowledge-base/SKILL.md
new file mode 100644
index 0000000..3353de3
--- /dev/null
+++ b/.claude/skills/update-knowledge-base/SKILL.md
@@ -0,0 +1,361 @@
+---
+name: update-knowledge-base
+description: Maintain and update product knowledge base from releases, features, and project changes with optional wiki sync
+roles: [product-manager, engineering-lead, founder]
+integrations: [github, linear, jira, confluence, notion]
+---
+
+# COG Update Knowledge Base Skill
+
+## When to Invoke
+- After a release — update product knowledge with new features and changes
+- User says "update knowledge base", "update KB", "sync knowledge", "update product docs"
+- Periodic maintenance — ensure knowledge base reflects current product state
+- After major feature launches, architecture changes, or deprecations
+
+## Agent Mode Awareness
+
+**Check `agent_mode` in `00-inbox/MY-PROFILE.md` frontmatter:**
+- If `agent_mode: team` — use parallel agents to scan multiple sources and update multiple knowledge files simultaneously
+- If `agent_mode: solo` — process updates sequentially, one knowledge file at a time
+
+## Command: `/update-knowledge-base`
+
+## Pre-Flight Check
+
+1. **Read `00-inbox/MY-INTEGRATIONS.md`** for active data sources and publishing targets
+2. **Read `00-inbox/MY-PROFILE.md`** for active projects
+3. **Get current timestamp:** Run `date '+%Y-%m-%d %H:%M'` using Bash
+4. **Scan existing knowledge base:** Glob `05-knowledge/**/*.md` to understand current state
+
+---
+
+## Execution Strategy
+
+### Phase 1: Determine Update Scope
+
+Ask the user (or infer from context):
+
+```
+What triggered this knowledge base update?
+
+a) New release shipped (I'll pull changes from release notes and tracker)
+b) Feature launched or updated (I'll document the feature)
+c) Architecture or technical change (I'll update technical knowledge)
+d) Periodic review (I'll scan for anything that's changed since last update)
+e) Custom — describe what needs updating
+```
+
+### Phase 2: Gather Update Data
+
+#### Team Mode (parallel agents)
+
+Launch data-gathering agents using the Task tool with `run_in_background: true`:
+
+**Agent: "release-scanner"** (for release-triggered updates)
+```
+Scan recent releases and release notes for knowledge base updates.
+
+1. Check vault for recent release notes:
+ Glob: 04-projects/*/release-notes/*.md
+ Read the most recent release notes for each active project
+
+2. If GitHub is active:
+ gh release list --repo [CUSTOMIZE: your-org/your-repo] --limit 5 --json tagName,name,body,publishedAt
+ Get the latest release details
+
+3. If Linear is active:
+ Use ToolSearch to load Linear tools
+ Check recently completed cycles and milestones for shipped features
+
+Extract from each source:
+- New features added (name, description, user impact)
+- Features modified (what changed)
+- Features deprecated or removed
+- Technical changes (architecture, API, infrastructure)
+- Bug fixes that affect documented behavior
+
+Return: structured list of knowledge updates needed
+```
+
+**Agent: "existing-kb-auditor"**
+```
+Audit the current knowledge base for staleness and gaps.
+
+1. Read all files in 05-knowledge/:
+ Glob: 05-knowledge/**/*.md
+
+2. For each file, extract:
+ - Last updated date (from frontmatter or file modification)
+ - Topics covered
+ - Products/features documented
+ - Any [TODO] or [OUTDATED] markers
+
+3. Cross-reference with active projects from MY-PROFILE.md:
+ - Are all active projects represented in the KB?
+ - Are there KB entries for discontinued/inactive projects?
+
+4. Check for:
+ - Files not updated in >90 days (potentially stale)
+ - Topics mentioned in recent release notes but missing from KB
+ - Contradictions between KB entries and recent changes
+
+Return: staleness report, gap analysis, and recommended updates
+```
+
+**Agent: "tracker-feature-collector"** (for feature-triggered updates)
+```
+Collect current feature/product state from project trackers.
+
+If Linear is active:
+1. Use ToolSearch to load Linear tools
+2. List all projects and their current status: mcp__claude_ai_Linear_2__list_projects
+3. List all initiatives: mcp__claude_ai_Linear_2__list_initiatives
+4. For key initiatives, get details: mcp__claude_ai_Linear_2__get_initiative
+
+If GitHub is active:
+1. Check repo README and docs for current feature descriptions
+2. Review recent PRs that touch documentation:
+ gh pr list --repo [CUSTOMIZE: your-org/your-repo] --state merged --search "label:docs merged:>=[30_DAYS_AGO]" --json number,title,body --limit 20
+
+Return: current product/feature state for knowledge base comparison
+```
+
+#### Solo Mode
+Run the most relevant agent sequentially based on the update trigger.
+
+### Phase 3: Identify Knowledge Updates
+
+Compare gathered data against existing knowledge base to determine:
+
+1. **New entries needed** — features, products, or topics not yet documented
+2. **Updates needed** — existing entries that need modification
+3. **Deprecation/removal** — entries for features that no longer exist
+4. **Gap filling** — missing context, examples, or cross-references
+
+Present the update plan to the user:
+
+```
+Knowledge Base Update Plan:
+
+NEW entries to create:
+1. [Topic] — [reason: new feature in v[X]]
+2. [Topic] — [reason: gap identified]
+
+UPDATES to existing entries:
+1. 05-knowledge/[file].md — [what needs changing]
+2. 05-knowledge/[file].md — [what needs changing]
+
+DEPRECATION candidates:
+1. 05-knowledge/[file].md — [reason: feature removed in v[X]]
+
+STALE entries (>90 days, may need review):
+1. 05-knowledge/[file].md — last updated [date]
+
+Proceed with these updates? (yes / modify plan / skip specific items)
+```
+
+**Wait for user approval before making changes.**
+
+### Phase 4: Execute Updates
+
+#### 4.1 Create New Knowledge Entries
+
+For each new entry, use this template:
+
+```markdown
+---
+type: knowledge
+domain: [product/technical/process/architecture]
+project: [project-name]
+topic: [topic name]
+created: [YYYY-MM-DD HH:MM]
+last_updated: [YYYY-MM-DD]
+source: [release-notes/feature-launch/manual/periodic-review]
+version: "1.0"
+tags: ["#knowledge", "#[project]", "#[topic-area]"]
+related:
+ - [path to related KB entry]
+ - [path to related project file]
+---
+
+# [Topic Title]
+
+## Overview
+[Clear, concise description of the topic — what it is, why it matters]
+
+## Current State
+[How this feature/system/process works as of the last update]
+
+### Key Details
+- **[Detail 1]:** [Value/description]
+- **[Detail 2]:** [Value/description]
+- **[Detail 3]:** [Value/description]
+
+## History
+| Date | Version | Change | Source |
+|------|---------|--------|--------|
+| [Date] | [Version] | [What changed] | [Release notes / PR / manual] |
+
+## Related
+- [Link to related KB entries]
+- [Link to PRDs if applicable]
+- [Link to project files]
+
+## Notes
+[Additional context, caveats, or open questions]
+
+---
+
+*Last updated: [YYYY-MM-DD] | Source: [what triggered this update]*
+```
+
+Save to: `05-knowledge/[domain]/[topic-slug].md`
+
+```bash
+mkdir -p "05-knowledge/[domain]"
+```
+
+#### 4.2 Update Existing Entries
+
+For each update:
+1. Read the existing file
+2. Update the relevant sections
+3. Add a row to the History table
+4. Update `last_updated` in frontmatter
+5. Update `version` (increment minor version)
+
+#### 4.3 Mark Deprecations
+
+For deprecated entries:
+1. Add `status: deprecated` to frontmatter
+2. Add a deprecation notice at the top of the file:
+ ```markdown
+ > **DEPRECATED:** This feature was removed/replaced in [version/date]. See [replacement link] for the current approach.
+ ```
+3. Do NOT delete the file — historical context is valuable
+
+### Phase 5: Generate Update Summary
+
+Create an update log:
+
+```markdown
+---
+type: kb-update-log
+date: [YYYY-MM-DD]
+created: [YYYY-MM-DD HH:MM]
+trigger: [release/feature/periodic/manual]
+tags: ["#knowledge", "#update-log"]
+---
+
+# Knowledge Base Update — [YYYY-MM-DD]
+
+## Trigger
+[What caused this update: release X.Y.Z / feature launch / periodic review]
+
+## Changes Made
+
+### New Entries
+| File | Topic | Domain | Source |
+|------|-------|--------|--------|
+| [path] | [topic] | [domain] | [source] |
+
+### Updated Entries
+| File | Changes | Previous Version | New Version |
+|------|---------|-----------------|-------------|
+| [path] | [summary of changes] | [old ver] | [new ver] |
+
+### Deprecated Entries
+| File | Reason | Replacement |
+|------|--------|-------------|
+| [path] | [reason] | [link to replacement or N/A] |
+
+## Knowledge Base Health
+- **Total entries:** [N]
+- **Updated this session:** [N]
+- **Created this session:** [N]
+- **Deprecated this session:** [N]
+- **Stale entries remaining (>90 days):** [N]
+- **Coverage:** [assessment of how well the KB covers active projects]
+
+---
+
+*Generated by COG Knowledge Base Updater*
+```
+
+Save to: `05-knowledge/_logs/kb-update-YYYY-MM-DD.md`
+
+```bash
+mkdir -p "05-knowledge/_logs"
+```
+
+### Phase 6: Optional Wiki Sync (requires approval)
+
+If Confluence or Notion is active, offer to sync updated entries:
+
+```
+Knowledge base updated locally. Would you like to sync to your wiki?
+
+Active wiki platforms:
+- [Confluence / Notion — whichever is active]
+
+Options:
+a) Sync all changed entries to [platform]
+b) Sync specific entries only
+c) Skip wiki sync (vault-only)
+```
+
+**NEVER auto-publish. Wait for explicit approval.**
+
+#### Confluence Sync
+Use the `/publish-to-confluence` skill pattern for each entry being synced.
+
+#### Notion Sync
+```
+1. Use ToolSearch to load Notion tools
+2. Search for existing pages matching the KB entry: mcp__claude_ai_Notion__notion-search
+3. If exists: update with mcp__claude_ai_Notion__notion-update-page
+4. If new: create with mcp__claude_ai_Notion__notion-create-pages
+```
+
+---
+
+## Knowledge Base Organization
+
+Recommended `05-knowledge/` structure:
+
+```
+05-knowledge/
+ _logs/ # Update logs
+ kb-update-YYYY-MM-DD.md
+ product/ # Product features, capabilities, roadmap
+ [feature-name].md
+ technical/ # Architecture, APIs, infrastructure
+ [system-name].md
+ process/ # Team processes, workflows, conventions
+ [process-name].md
+ domain/ # Domain knowledge, industry context
+ [topic-name].md
+ integrations/ # Integration docs, API references
+ [integration-name].md
+```
+
+---
+
+## Fallback Behavior
+
+| Scenario | Behavior |
+|----------|----------|
+| No trackers active | Work from vault data only (release notes, PRDs, project files) |
+| No existing KB entries | Create the initial knowledge base structure and first entries |
+| Wiki sync fails | All changes are already saved locally; inform user to sync manually |
+| Very large KB (>50 files) | Process in batches, prioritize most recently changed entries |
+| No recent changes found | Report that KB is up to date; suggest periodic review topics |
+| Conflicting information | Flag conflicts for user resolution rather than auto-resolving |
+
+## Error Handling
+
+- **File conflicts**: If an update would contradict a recent manual edit, present both versions to the user
+- **Context overflow**: Process knowledge files in batches of 10
+- **Stale data sources**: Warn if tracker data seems outdated (API issues)
+- **Missing project context**: Ask user to clarify which project the knowledge relates to
diff --git a/AGENTS.md b/AGENTS.md
index bd49c77..5b39be5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -244,6 +244,182 @@ This document defines the available commands/skills for AI agents interacting wi
---
+### /auto-research
+
+**Description:** Deep strategic research engine — decomposes questions into parallel research threads, spawns multiple agents, and synthesizes into actionable strategic analysis.
+
+**Triggers:**
+- `/auto-research`
+- "research [topic]"
+- "investigate [question]"
+- "strategic analysis"
+- "deep dive into [topic]"
+
+**Purpose:** Take a high-level strategic question, decompose it into 5-7 parallel research threads, investigate each with real web sources, and synthesize findings into an actionable strategic analysis with scenarios and recommendations.
+
+**What it does:**
+1. Decomposes the question into independent research threads (market forces, historical precedent, player analysis, technology trajectory, emerging tech, contrarian view, etc.)
+2. Presents decomposition for user approval before launching research
+3. Spawns parallel research agents (team mode) or runs sequential research passes (solo mode)
+4. Each thread searches 8-12 high-quality sources via web search
+5. Synthesizes all threads into a unified strategic analysis with scenarios, options, and recommendations
+6. Saves to vault with executive summary
+
+**Output location:** `05-knowledge/research/YYYY-MM-DD-[slug].md`
+
+**Key features:**
+- No hallucinated sources — every claim traces to real web search results
+- Emerging tech thread always included — surfaces pre-mainstream concepts
+- Contrarian view section challenges consensus
+- Confidence levels and gaps explicitly stated
+
+---
+
+### PM Workflow Skills
+
+The following 6 skills form a complete product management lifecycle:
+**Research** → **PRD** → **Stories** → Development → **Release Notes** → **Knowledge Base**
+
+### /create-user-story
+
+**Description:** Create user stories with duplicate checking across Linear, GitHub Issues, or Jira.
+
+**Triggers:**
+- `/create-user-story`
+- "create a user story"
+- "create a story for"
+- "new user story"
+
+**Purpose:** Create well-structured user stories in your project tracker with automatic duplicate detection, standard As a/I want/So that format, and Given/When/Then acceptance criteria.
+
+**What it does:**
+1. Accepts problem statement and solution from user
+2. Checks active integrations (Linear, GitHub, Jira) in `00-inbox/MY-INTEGRATIONS.md`
+3. Searches for potential duplicate issues in the active tracker
+4. If duplicates found, stops and shows candidates
+5. If no duplicates, creates story with user story format and acceptance criteria
+6. Saves a copy to `04-projects/[project]/stories/`
+
+**Output:** Issue created in active tracker + local copy in vault
+
+---
+
+### /generate-prd
+
+**Description:** Draft product requirement documents with an approval gate before publishing.
+
+**Triggers:**
+- `/generate-prd`
+- "generate a PRD"
+- "draft PRD"
+- "product requirements"
+
+**Purpose:** Generate structured PRDs from problem context, save to vault, and optionally publish to Confluence/Notion with explicit human approval.
+
+**What it does:**
+1. Collects problem statement, goals, user context from user
+2. Reads existing project context from `04-projects/` and `05-knowledge/`
+3. Drafts PRD with standard sections (Problem, Goals, Non-goals, User workflows, Functional requirements, Iterations, Dependencies, Risks, Success metrics)
+4. Saves to `04-projects/[project]/PRDs/PRD-[slug].md`
+5. Presents summary and asks for explicit approval before any publishing
+6. Only publishes to Confluence/Notion if user explicitly approves
+
+**Output location:** `04-projects/[project]/PRDs/PRD-[slug].md`
+
+---
+
+### /generate-release-notes
+
+**Description:** Generate release notes from GitHub milestones, Linear cycles, or manual input.
+
+**Triggers:**
+- `/generate-release-notes`
+- "generate release notes"
+- "release notes for"
+- "what shipped in"
+
+**Purpose:** Compile release notes by pulling completed issues/PRs from your tracker, categorizing into enhancements, improvements, and bug fixes.
+
+**What it does:**
+1. Identifies release scope (GitHub milestone, Linear cycle, or manual list)
+2. Fetches all completed issues/PRs in the release
+3. Categorizes into Enhancements, Technical Improvements, Bug Fixes
+4. Generates formatted release notes markdown
+5. Saves to `04-projects/[project]/releases/`
+6. Optionally publishes to Confluence with approval
+
+**Output location:** `04-projects/[project]/releases/release-notes-[version]-YYYY-MM-DD.md`
+
+---
+
+### /export-open-issues
+
+**Description:** Audit and export open issues from any project tracker.
+
+**Triggers:**
+- `/export-open-issues`
+- "export open issues"
+- "issue audit"
+- "open issues report"
+
+**Purpose:** Generate a structured audit of all open issues from your active tracker for review, grooming, or stakeholder reporting.
+
+**What it does:**
+1. Checks active integrations for available trackers
+2. Fetches all open issues with metadata (assignee, priority, labels, dates)
+3. Generates summary statistics and categorized breakdown
+4. Identifies stale issues, unassigned work, and priority imbalances
+5. Saves structured report to vault
+
+**Output location:** `04-projects/[project]/audits/open-issues-YYYY-MM-DD.md`
+
+---
+
+### /publish-to-confluence
+
+**Description:** Publish any vault markdown file to Confluence.
+
+**Triggers:**
+- `/publish-to-confluence`
+- "publish to Confluence"
+- "push to Confluence"
+
+**Purpose:** Publish a local markdown file from the vault to a Confluence page (create or update), with explicit approval before publishing.
+
+**What it does:**
+1. Accepts path to local markdown file
+2. Requires Confluence integration to be active
+3. Converts markdown to Confluence-compatible format
+4. Creates new page or updates existing page
+5. Returns published page URL
+
+**Requires:** Confluence integration active in `00-inbox/MY-INTEGRATIONS.md`
+
+---
+
+### /update-knowledge-base
+
+**Description:** Maintain product knowledge base from releases, features, and project changes.
+
+**Triggers:**
+- `/update-knowledge-base`
+- "update knowledge base"
+- "update KB"
+- "sync knowledge base"
+
+**Purpose:** Keep your product knowledge base in `05-knowledge/` current by incorporating release data, feature updates, and project changes.
+
+**What it does:**
+1. Reads current knowledge base files from `05-knowledge/`
+2. Accepts feature updates and/or release version as input
+3. Cross-references with project PRDs and release notes in `04-projects/`
+4. Updates knowledge base with factual, thorough changes
+5. Optionally syncs to external wiki (Confluence/Notion) with approval
+
+**Output location:** `05-knowledge/consolidated/product-knowledge-base.md`
+
+---
+
## Vault Structure
```
@@ -285,6 +461,10 @@ COG-second-brain/
4. **End of week?** Use `/weekly-checkin` to reflect
5. **Save a link?** Use `/url-dump` with the URL
6. **Build knowledge?** Run `/knowledge-consolidation` periodically
+7. **Create user stories?** Use `/create-user-story` with a problem/solution
+8. **Draft a PRD?** Use `/generate-prd` with your problem context
+9. **Release notes?** Use `/generate-release-notes` with a version
+10. **Strategic research?** Use `/auto-research` with your question
---
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1744950..4eb540d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,77 @@
All notable changes to COG (Cognition + Obsidian + Git) will be documented in this file.
+## [3.4.0] - 2026-03-12
+
+### PM Workflow Skills & Auto-Research
+
+COG now includes a complete product management workflow (6 skills) and a deep strategic research engine. PM skills cover the full lifecycle from PRD to release notes to knowledge base maintenance, with multi-tracker support (Linear, GitHub Issues, Jira) and optional Confluence/Notion publishing.
+
+### Added
+
+#### Auto-Research Skill
+- **`auto-research`** — Deep strategic research engine inspired by Karpathy's autoresearch
+ - Decomposes strategic questions into 5-7 parallel research threads
+ - Spawns parallel agents (team mode) for simultaneous web research
+ - Synthesizes into actionable analysis with scenarios, options, and recommendations
+ - Always includes emerging tech thread for pre-mainstream concepts
+ - Saves to `05-knowledge/research/`
+
+#### PM Workflow Skills (6 new skills)
+- **`create-user-story`** — Create user stories with duplicate checking
+ - Multi-tracker: Linear (MCP), GitHub Issues (`gh` CLI), Jira (API)
+ - Standard As a/I want/So that format with Given/When/Then acceptance criteria
+ - Automatic duplicate detection before creation
+- **`generate-prd`** — Draft product requirement documents
+ - Standard sections: Problem, Goals, Non-goals, User workflows, Requirements, Risks, Metrics
+ - Approval gate before any external publishing
+ - Saves to `04-projects/[project]/PRDs/`
+- **`generate-release-notes`** — Generate release notes from any source
+ - GitHub milestones, Linear cycles, or manual input
+ - Auto-categorizes: Enhancements, Technical Improvements, Bug Fixes
+ - Saves to `04-projects/[project]/releases/`
+- **`export-open-issues`** — Audit and export open issues
+ - Multi-tracker support with stale issue detection
+ - Priority distribution and assignee load analysis
+ - Saves structured report to `04-projects/[project]/audits/`
+- **`publish-to-confluence`** — Publish vault markdown to Confluence
+ - Create or update pages with approval gate
+ - Requires Confluence integration active
+- **`update-knowledge-base`** — Maintain product knowledge base
+ - Accepts feature updates, release data, or both
+ - Cross-references PRDs and release notes
+ - Optional Confluence/Notion sync with approval
+
+#### Skill Metadata
+- All 7 new skills have `roles` and `integrations` fields in YAML frontmatter
+- PM skills: `roles: [product-manager, engineering-lead, founder]`
+- Auto-research: `roles: [product-manager, engineering-lead, founder, all]`
+
+### Changed
+
+#### Documentation
+- **`README.md`** — Added PM Workflow Skills section, Strategic Research section, updated mermaid diagrams, vault structure (17 skills), roadmap
+- **`AGENTS.md`** — Added 7 new skill commands with full documentation, PM Workflow lifecycle description
+- **`SETUP.md`** — Updated skill counts (10 → 17), updated directory structure
+- **`GEMINI.md`** — Updated available skills list
+- **`CLAUDE.md`** — Updated skill count to 17
+- **`CONTRIBUTING.md`** — No structural changes needed (existing conventions apply)
+- **`CHANGELOG.md`** — This entry
+
+#### Version & Metadata
+- **`COG-VERSION`** — Bumped 3.3.0 → 3.4.0
+- **`.claude-plugin/plugin.json`** — Bumped version, updated skill count to 17, added 7 new skills
+- **`marketplace-entry.json`** — Bumped version to 3.4.0
+- **`cog-update.sh`** — Added 7 new skills to FRAMEWORK_FILES array
+
+### Design Decisions
+- **Multi-tracker architecture**: PM skills check `MY-INTEGRATIONS.md` and work with Linear, GitHub, or Jira — graceful degradation when trackers are unavailable
+- **Approval gates**: Publishing to external services (Confluence, Notion) always requires explicit user confirmation
+- **Vault-first output**: All PM artifacts save to vault (`04-projects/`, `05-knowledge/`) before any external publishing
+- **PM lifecycle flow**: Skills designed as a pipeline: Research → PRD → Stories → Development → Release Notes → KB Update
+
+---
+
## [3.3.0] - 2026-02-25
### Role Packs & Integration Discovery
diff --git a/CLAUDE.md b/CLAUDE.md
index 8059e46..2f41c45 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -36,7 +36,7 @@ Role packs live in `.claude/roles/`. New roles can be added by dropping a file f
- `COMPETITIVE-WATCHLIST.md` — Companies/people being tracked
### Framework files (updated via `cog-update.sh` or `/update-cog`)
-- `.claude/skills/` — Claude Code skills (10 skills)
+- `.claude/skills/` — Claude Code skills (17 skills)
- `.claude/roles/` — Role packs for personalized recommendations
- `.kiro/powers/` — Kiro powers
- `.gemini/commands/` — Gemini CLI commands
diff --git a/COG-VERSION b/COG-VERSION
index 15a2799..1809198 100644
--- a/COG-VERSION
+++ b/COG-VERSION
@@ -1 +1 @@
-3.3.0
+3.4.0
diff --git a/GEMINI.md b/GEMINI.md
index 3a74e18..a720b33 100644
--- a/GEMINI.md
+++ b/GEMINI.md
@@ -27,7 +27,7 @@ Read `03-professional/COMPETITIVE-WATCHLIST.md` for companies to track.
## Available Skills
-Use `/onboarding`, `/braindump`, `/daily-brief`, `/weekly-checkin`, `/knowledge-consolidation`, `/url-dump`, or `/update-cog` to invoke COG skills. Each has a detailed playbook in `.gemini/skills/`.
+Use `/onboarding`, `/braindump`, `/daily-brief`, `/weekly-checkin`, `/knowledge-consolidation`, `/url-dump`, `/update-cog`, `/auto-research`, `/create-user-story`, `/generate-prd`, `/generate-release-notes`, `/export-open-issues`, `/publish-to-confluence`, or `/update-knowledge-base` to invoke COG skills. Each has a detailed playbook in `.gemini/skills/`.
## Rules
diff --git a/README.md b/README.md
index 92275fc..db551b2 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
```mermaid
graph LR
A[You] -- natural language --> B[AI Agent]
- B -- runs --> C[10 Skills]
+ B -- runs --> C[17 Skills]
C -- reads & writes --> D[.md Files]
C -- syncs with --> G[GitHub / Linear / Slack / PostHog]
D --> E[Git]
@@ -60,6 +60,25 @@ Done — COG is personalized and ready in ~2 minutes. See [SETUP.md](SETUP.md) f
| **meeting-transcript** | Process meeting recordings into structured decisions, action items, and team dynamics | "Process this meeting" |
| **comprehensive-analysis** | Deep 7-day analysis for weekly reviews, board prep, or strategic planning (~8-12 min) | "Weekly analysis" / "Board prep" |
+### PM Workflow Skills (for Product Managers)
+
+| Skill | What it does | Try saying... |
+|---|---|---|
+| **create-user-story** | Create user stories with duplicate checking across Linear, GitHub Issues, or Jira | "Create a user story for..." |
+| **generate-prd** | Draft PRDs with approval gate before publishing to Confluence/Notion | "Generate a PRD for..." |
+| **generate-release-notes** | Generate release notes from GitHub milestones, Linear cycles, or manual input | "Generate release notes for v2.1" |
+| **export-open-issues** | Audit and export open issues from any tracker into a structured vault summary | "Export open issues" |
+| **publish-to-confluence** | Publish any vault markdown file to Confluence | "Publish this to Confluence" |
+| **update-knowledge-base** | Maintain product knowledge base from releases, features, and project changes | "Update the knowledge base with v2.1 changes" |
+
+> **PM Workflow:** These skills form a complete product management lifecycle: **Research** (`/auto-research`) → **PRD** (`/generate-prd`) → **Stories** (`/create-user-story`) → Development → **Release Notes** (`/generate-release-notes`) → **Knowledge Base** (`/update-knowledge-base`). Use `/export-open-issues` for audits and `/publish-to-confluence` to share externally.
+
+### Strategic Research
+
+| Skill | What it does | Try saying... |
+|---|---|---|
+| **auto-research** | Deep strategic research engine — decomposes questions into parallel research threads with multiple agents | "Research the future of AI testing tools" |
+
### Role Packs (Personalized Recommendations)
COG matches your role during onboarding to a **role pack** that prioritizes the most relevant skills and integrations for you. Available role packs: Product Manager, Engineering Lead, Engineer, Designer, Founder, Marketer — or create your own from the template.
@@ -79,6 +98,10 @@ graph TD
C --> D[Monthly: Knowledge consolidation]
CA --> D
D -- COG learns your patterns --> A
+ R[Strategic: Auto-research] --> P[PM: Generate PRD]
+ P --> S[PM: Create user stories]
+ S -- after development --> RN[PM: Release notes]
+ RN --> KB[PM: Update knowledge base]
```
- **Daily capture** — braindump raw thoughts; COG classifies by domain and extracts action items
@@ -88,6 +111,8 @@ graph TD
- **Weekly reflection** — pattern analysis across all domains surfaces insights you'd miss
- **Weekly deep dive** — comprehensive analysis for board prep, retros, and strategic planning
- **Monthly synthesis** — scattered notes become consolidated frameworks and a knowledge base
+- **Strategic research** — deep multi-agent investigation of strategic questions with real sources
+- **PM workflow** — full product lifecycle from PRD to release notes to knowledge base updates
## Features at a Glance
@@ -100,7 +125,7 @@ graph TD
```
COG-second-brain/
-├── .claude/skills/ # Claude Code skills (10)
+├── .claude/skills/ # Claude Code skills (17)
├── .claude/roles/ # Role packs (7) — personalized recommendations
├── .kiro/powers/ # Kiro powers
├── .gemini/commands/ # Gemini CLI commands
@@ -165,6 +190,7 @@ Git is optional but recommended for version history. COG works fine with just iC
- [x] ~~Gemini CLI + OpenAI Codex support~~ (shipped in v3.1)
- [x] ~~Upstream update system~~ (shipped in v3.2)
- [x] ~~Role packs & integration discovery~~ (shipped in v3.3)
+- [x] ~~PM workflow skills & auto-research~~ (shipped in v3.4)
- [ ] Web interface for knowledge graph visualization
- [ ] Mobile-first commands (optimized for Obsidian mobile)
- [ ] Team collaboration features (with privacy preservation)
diff --git a/SETUP.md b/SETUP.md
index 68c6d95..c5b0ad4 100644
--- a/SETUP.md
+++ b/SETUP.md
@@ -42,7 +42,7 @@ That's it! You now have a working second brain.
**What just happened?**
- The cloned `COG-second-brain` folder IS your second brain
-- 10 AI skills are available in multiple formats:
+- 17 AI skills are available in multiple formats:
- `.claude/skills/` - For Claude Code
- `.kiro/powers/` - For Kiro
- `agents.md` - For any agent
@@ -127,13 +127,20 @@ COG-second-brain/ # This is your second brain folder
├── agents.md # Universal agent documentation
├── .claude/
│ ├── roles/ # 7 role packs for personalized recommendations
-│ └── skills/ # 10 Claude Code skills
+│ └── skills/ # 17 Claude Code skills
│ ├── onboarding/
│ ├── braindump/
│ ├── daily-brief/
│ ├── weekly-checkin/
│ ├── knowledge-consolidation/
-│ └── url-dump/
+│ ├── url-dump/
+│ ├── auto-research/
+│ ├── create-user-story/
+│ ├── generate-prd/
+│ ├── generate-release-notes/
+│ ├── export-open-issues/
+│ ├── publish-to-confluence/
+│ └── update-knowledge-base/
├── .kiro/
│ └── powers/ # 6 Kiro powers
│ ├── cog-onboarding/
diff --git a/cog-update.sh b/cog-update.sh
index 4a2e4e2..a9df6a8 100755
--- a/cog-update.sh
+++ b/cog-update.sh
@@ -41,6 +41,13 @@ FRAMEWORK_FILES=(
".claude/skills/team-brief/SKILL.md"
".claude/skills/comprehensive-analysis/SKILL.md"
".claude/skills/meeting-transcript/SKILL.md"
+ ".claude/skills/auto-research/SKILL.md"
+ ".claude/skills/create-user-story/SKILL.md"
+ ".claude/skills/generate-prd/SKILL.md"
+ ".claude/skills/generate-release-notes/SKILL.md"
+ ".claude/skills/export-open-issues/SKILL.md"
+ ".claude/skills/publish-to-confluence/SKILL.md"
+ ".claude/skills/update-knowledge-base/SKILL.md"
# Role packs
".claude/roles/_template.md"
diff --git a/marketplace-entry.json b/marketplace-entry.json
index 8510a1c..eb0eae3 100644
--- a/marketplace-entry.json
+++ b/marketplace-entry.json
@@ -7,5 +7,5 @@
"url": "https://github.com/huytieu"
},
"description": "Self-evolving second brain with AI agents for knowledge management",
- "version": "3.3.0"
+ "version": "3.4.0"
}