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.
Python agent-loopagent-pluginsagent-skillsagenticai-agentsclaude-codeclosed-loopcursorgarry-tangbraingstackknowledge-managementloop-engineeringobsidianpeople-crmproductivitysecond-brainself-evolvingverification-harnessworker-agents
Add PM workflow skills and auto-research (v3.4.0)
Huy Tieu39ccbee54404
diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.jsonindex 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.mdnew file mode 100644index 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 availablediff --git a/.claude/skills/create-user-story/SKILL.md b/.claude/skills/create-user-story/SKILL.mdnew file mode 100644index 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 descriptionsdiff --git a/.claude/skills/export-open-issues/SKILL.md b/.claude/skills/export-open-issues/SKILL.mdnew file mode 100644index 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 batchdiff --git a/.claude/skills/generate-prd/SKILL.md b/.claude/skills/generate-prd/SKILL.mdnew file mode 100644index 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-pagesdiff --git a/.claude/skills/generate-release-notes/SKILL.md b/.claude/skills/generate-release-notes/SKILL.mdnew file mode 100644index 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-batchdiff --git a/.claude/skills/publish-to-confluence/SKILL.md b/.claude/skills/publish-to-confluence/SKILL.mdnew file mode 100644index 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 lostdiff --git a/.claude/skills/update-knowledge-base/SKILL.md b/.claude/skills/update-knowledge-base/SKILL.mdnew file mode 100644index 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 todiff --git a/AGENTS.md b/AGENTS.mdindex 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 reflect5. **Save a link?** Use `/url-dump` with the URL6. **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.mdindex 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 Discoverydiff --git a/CLAUDE.md b/CLAUDE.mdindex 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 commandsdiff --git a/COG-VERSION b/COG-VERSIONindex 15a2799..1809198 100644--- a/COG-VERSION+++ b/COG-VERSION@@ -1 +1 @@-3.3.0+3.4.0diff --git a/GEMINI.md b/GEMINI.mdindex 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/`.## Rulesdiff --git a/README.md b/README.mdindex 92275fc..db551b2 100644--- a/README.md+++ b/README.md@@ -9,7 +9,7 @@```mermaidgraph LRA[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 TDC --> D[Monthly: Knowledge consolidation]CA --> DD -- 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.mdindex 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.shindex 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.jsonindex 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"}