@colin4k1024/tsp 2.5.1 → 2.5.3

package/scripts/test-cangming-install.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CANGMING_HOME = path.join(os.homedir(), '.config', 'cangming');
+const PLUGIN_DIR = path.join(CANGMING_HOME, 'plugins', 'team-skills-platform');
+
+console.log('=== Cangming 安装验证 ===\n');
+
+let passed = 0;
+let failed = 0;
+
+function check(description, condition) {
+  if (condition) {
+    console.log(`✅ ${description}`);
+    passed++;
+  } else {
+    console.log(`❌ ${description}`);
+    failed++;
+  }
+}
+
+console.log('📁 目录结构检查:');
+check('CANGMING_HOME 目录存在', fs.existsSync(CANGMING_HOME));
+check('AGENTS.md 文件存在', fs.existsSync(path.join(CANGMING_HOME, 'AGENTS.md')));
+check('agents 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'agents')));
+check('command 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'command')));
+check('plugins 目录存在', fs.existsSync(path.join(CANGMING_HOME, 'plugins')));
+check('team-skills-platform 插件存在', fs.existsSync(PLUGIN_DIR));
+
+console.log('\n📄 文件内容检查:');
+
+const agentsMdPath = path.join(CANGMING_HOME, 'AGENTS.md');
+if (fs.existsSync(agentsMdPath)) {
+  const content = fs.readFileSync(agentsMdPath, 'utf8');
+  check('AGENTS.md 包含团队技能平台标记', content.includes('<!-- team-skills-platform -->'));
+  check('AGENTS.md 包含角色索引', content.includes('## 可用角色'));
+  check('AGENTS.md 包含命令索引', content.includes('## 核心团队命令'));
+  check('AGENTS.md 包含插件根路径', content.includes('## 插件根路径'));
+}
+
+console.log('\n👥 Agents 检查:');
+const agentsDir = path.join(CANGMING_HOME, 'agents');
+if (fs.existsSync(agentsDir)) {
+  const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+  check(`agents 目录包含文件 (${agentFiles.length})`, agentFiles.length > 0);
+
+  const roleAgents = ['tech-lead.md', 'product-manager.md', 'architect.md', 'frontend-engineer.md',
+                      'backend-engineer.md', 'qa-engineer.md', 'devops-engineer.md'];
+  for (const agent of roleAgents) {
+    check(`角色 agent ${agent} 存在`, fs.existsSync(path.join(agentsDir, agent)));
+  }
+
+  const specialistAgents = agentFiles.filter(f => f.startsWith('specialist-'));
+  check(`specialist agents 存在 (${specialistAgents.length})`, specialistAgents.length > 0);
+}
+
+console.log('\n📝 Commands 检查:');
+const commandsDir = path.join(CANGMING_HOME, 'command');
+if (fs.existsSync(commandsDir)) {
+  const commandFiles = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+  check(`commands 目录包含文件 (${commandFiles.length})`, commandFiles.length > 0);
+
+  const coreCommands = ['team-intake.md', 'team-plan.md', 'team-execute.md', 'team-review.md',
+                        'team-release.md', 'handoff.md'];
+  for (const cmd of coreCommands) {
+    check(`核心命令 ${cmd} 存在`, fs.existsSync(path.join(commandsDir, cmd)));
+  }
+}
+
+console.log('\n🎯 Skills 检查:');
+const skillsDir = path.join(PLUGIN_DIR, 'skills');
+if (fs.existsSync(skillsDir)) {
+  const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+  check(`skills 目录包含目录 (${skillDirs.length})`, skillDirs.length > 0);
+}
+
+console.log('\n📜 Rules 检查:');
+const rulesDir = path.join(PLUGIN_DIR, 'rules');
+if (fs.existsSync(rulesDir)) {
+  const ruleItems = fs.readdirSync(rulesDir);
+  check(`rules 目录包含内容 (${ruleItems.length})`, ruleItems.length > 0);
+  check('common 规则目录存在', fs.existsSync(path.join(rulesDir, 'common')));
+}
+
+// 总结
+console.log('\n=== 测试总结 ===');
+console.log(`通过: ${passed}`);
+console.log(`失败: ${failed}`);
+console.log(`总计: ${passed + failed}`);
+
+if (failed === 0) {
+  console.log('\n🎉 所有测试通过！Cangming 安装成功。');
+  console.log('\n下一步:');
+  console.log('1. 启动 Cangming: cangming');
+  console.log('2. 查看可用角色: AGENTS.md 中包含所有角色索引');
+  console.log('3. 执行团队命令: /team-intake, /team-plan 等');
+  process.exit(0);
+} else {
+  console.log('\n⚠️  部分测试失败，请检查安装。');
+  process.exit(1);
+}

package/skills/goal-convergence/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: goal-convergence
+description: "Goal-oriented autonomous loop with external completion oracle. Keeps iterating until verifiable stopping conditions are met, checked by a separate model."
+origin: ECC
+---
+
+# Goal Convergence
+
+Goal-oriented autonomous loop with external completion oracle.
+Based on Addy Osmani's Loop Engineering principle: "Keep going until a verifiable
+stopping condition holds, with a separate small model checking completion."
+
+## When to Activate
+
+- User invokes `/goal` command
+- Heartbeat auto-creates a goal from scan failures
+- Triage item is promoted to a goal via `/triage act <id> goal`
+- Session resumes with an active goal state file
+
+## Core Concept: Maker-Oracle Separation
+
+The model that wrote the code is too nice grading its own homework.
+A second model (the oracle) with different instructions and READ-ONLY tools
+catches what the first talked itself into.
+
+```
+Maker (primary model, full tools)
+  │
+  ▼ produces iteration output
+  │
+Oracle (different model, read-only)
+  │
+  ├─ ALL conditions pass → CONVERGE (goal done)
+  ├─ Some fail + budget remains → nextHint → LOOP (maker iterates)
+  └─ Budget exhausted → ESCALATE (triage inbox)
+```
+
+## Goal Lifecycle
+
+```
+CREATE → ACTIVE → [iterate] → CONVERGED
+                       │
+                       ├──── PAUSED (manual /goal pause)
+                       └──── ESCALATED (budget exhausted or repeated failure)
+```
+
+States:
+- `active`: Maker-oracle loop is running
+- `paused`: Manually paused, resumes with `/goal resume`
+- `converged`: All stopping conditions met, goal complete
+- `escalated`: Cannot converge within budget, needs human triage
+- `failed`: Explicitly abandoned
+
+## Stopping Conditions
+
+Each goal has one or more stopping conditions. ALL must pass for convergence.
+
+| Type | Command Pattern | Example |
+|------|----------------|---------|
+| `test_pass` | Test runner exits 0 | `npm test` |
+| `lint_clean` | Linter exits 0 | `npm run lint -- --quiet` |
+| `coverage_threshold` | Coverage >= N% | `npm test -- --coverage` |
+| `build_pass` | Build succeeds | `npm run build` |
+| `custom_command` | Any command exits 0 | `grep -r "TODO" src/ \| wc -l` |
+
+## Oracle Protocol
+
+The oracle receives:
+1. The goal objective (natural language)
+2. All stopping condition commands and their latest output
+3. The maker's iteration summary
+4. Previous iteration history (last 3)
+
+The oracle returns:
+```json
+{
+  "converged": false,
+  "conditionResults": [
+    {"type": "test_pass", "passed": false, "output": "2 tests failing"},
+    {"type": "lint_clean", "passed": true, "output": ""}
+  ],
+  "reasons": ["2 tests still failing in auth module"],
+  "nextHint": "Focus on src/auth/refresh.test.ts — the token expiry mock is stale",
+  "confidence": 0.85
+}
+```
+
+## Budget Management
+
+Three budget dimensions, any exhaustion triggers escalation:
+
+| Dimension | Default | Rationale |
+|-----------|---------|-----------|
+| Iterations | 15 | Prevents infinite loops |
+| Wall time | 2h | Bounds real-world duration |
+| Cost (USD) | $10 | Prevents runaway API spend |
+
+On escalation, the goal:
+1. Persists full state to `~/.claude/goals/{goalId}.json`
+2. Creates a triage inbox item with context
+3. Marks state as `escalated`
+4. Reports final status to user
+
+## Inter-Session Persistence
+
+Goals survive session restarts:
+1. `SessionEnd` hook serializes active goals
+2. `SessionStart` hook detects active goals and notifies user
+3. `/goal resume` re-enters the loop with oracle's last `nextHint`
+
+State file: `~/.claude/goals/{goalId}.json` (follows `schemas/goal.schema.json`)
+
+## Integration Points
+
+- **`/heartbeat`**: Auto-creates goals from scan failures
+- **`/triage`**: Escalated goals land in triage; triage items can become goals
+- **`/checkpoint`**: Each iteration implicitly checkpoints
+- **`/verify`**: Oracle internally uses verification patterns
+- **`wave-execution`**: Multiple goals can run in parallel waves
+- **`rework-loop`**: Failed iterations trigger blame-attributed rework
+
+## Hard Bans
+
+- Oracle MUST be a different model than maker (eliminates self-grading bias)
+- Oracle MUST NOT have write tools (prevents it from "helping" fix issues)
+- Goals MUST have at least one stopping condition (no open-ended loops)
+- Budget MUST have at least one limit set (no unbounded execution)
+- State MUST persist to disk (no goals lost on crash)
+
+## Example
+
+```
+User: /goal "make all tests pass"
+
+System infers:
+  objective: "make all tests pass"
+  stoppingConditions: [{type: "test_pass", command: "npm test"}]
+  budget: {maxIterations: 15, maxDuration: "2h", maxDollars: 10}
+  oracle: {model: "haiku"}
+
+Iteration 1:
+  Maker: reads test output, fixes obvious import error in auth.ts
+  Oracle: runs `npm test` → 1 test still failing → {converged: false, nextHint: "..."}
+
+Iteration 2:
+  Maker: fixes token refresh logic based on oracle hint
+  Oracle: runs `npm test` → all pass → {converged: true}
+
+Result: CONVERGED in 2 iterations, $0.45 spent
+```

package/skills/loop-heartbeat/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: loop-heartbeat
+description: "Scheduled discovery automation that runs scans on a heartbeat interval, classifies findings, and routes them to goals or triage inbox."
+origin: ECC
+---
+
+# Loop Heartbeat
+
+Scheduled discovery automation that runs scans, finds issues, and routes findings
+to goals or triage. The heartbeat is what makes a loop a loop — not a one-shot run.
+
+Based on Addy Osmani's Loop Engineering: "Automations are the thing that makes
+a loop an actual loop. Run prompts on a schedule. Findings go to a triage inbox;
+empty runs archive themselves."
+
+## When to Activate
+
+- User invokes `/heartbeat start` to begin scheduled scans
+- User invokes `/heartbeat run` for a one-shot scan
+- A goal converges and follow-up scanning is needed
+- Project onboarding includes quality monitoring setup
+
+## Core Concept
+
+The heartbeat is the "discovery layer" of a loop. It answers: "What's broken right
+now?" on a recurring basis without human prompting.
+
+```
+Every 30 minutes:
+  ┌─ Run test suite ─── PASS → skip
+  ├─ Run linter ─────── FAIL → create goal (auto-fix)
+  ├─ Audit deps ─────── FAIL → triage inbox (human decision)
+  └─ Type check ─────── PASS → skip
+```
+
+## Configuration
+
+Create `.claude/heartbeat.yaml` in the project root:
+
+```yaml
+heartbeat:
+  interval: "30m"
+  scans:
+    - name: "test-health"
+      command: "npm test 2>&1 | tail -10"
+      onFailure: "auto-goal"
+      description: "Test suite health"
+    - name: "lint-drift"
+      command: "npm run lint -- --quiet 2>&1 | wc -l"
+      threshold: 0
+      onFailure: "triage"
+      description: "Lint error count"
+    - name: "type-check"
+      command: "npx tsc --noEmit 2>&1; echo EXIT:$?"
+      onFailure: "auto-goal"
+      description: "TypeScript type errors"
+  budget:
+    maxDollarsPerHour: 2.0
+    pauseOnExhaust: true
+```
+
+## Scan Result Classification
+
+| onFailure | Behavior | Use When |
+|-----------|----------|----------|
+| `auto-goal` | Creates `/goal` automatically | Machine can fix it (tests, lint, types) |
+| `triage` | Adds to `/triage` inbox | Human judgment needed (deps, security) |
+| `notify` | Desktop notification only | Informational, no action required |
+| `ignore` | Log silently | Monitoring only, aggregate later |
+
+## Budget Controls
+
+- `maxDollarsPerHour`: Pause heartbeat if scanning costs exceed this
+- `pauseOnExhaust`: If true, pause (resumable); if false, stop entirely
+- Goal creation inherits the default goal budget from `/goal` settings
+
+## Empty Run Handling
+
+When all scans pass:
+- No goals or triage items are created
+- Run is logged to `~/.claude/heartbeat-last-run.json`
+- Next run proceeds on schedule
+- This is the "archive themselves silently" behavior
+
+## Integration Points
+
+- **`/goal`**: `auto-goal` failures create goals via completion-oracle.js
+- **`/triage`**: `triage` failures append to `~/.claude/triage/inbox.jsonl`
+- **CronCreate**: Scheduling uses the Claude Code CronCreate primitive
+- **ScheduleWakeup**: Alternative for dynamic-interval loops
+- **Hooks**: Runs as a scheduled task, not a synchronous hook
+
+## Hard Bans
+
+- Heartbeat MUST NOT modify code (it's discovery-only)
+- Heartbeat MUST NOT create goals without a stopping condition
+- Budget limits MUST be enforced (no unbounded scan spending)
+- Failed scans MUST be classified (no silent failures)
+- Empty runs MUST NOT create noise (pass = skip)
+
+## Example Session
+
+```
+User: /heartbeat start
+
+System:
+  Loaded .claude/heartbeat.yaml (3 scans configured)
+  Registered CronCreate: every 30m
+  Next run: 30m from now
+  Budget: $2.00/hour
+
+[30 minutes later, heartbeat fires]
+
+Scan results:
+  ✓ test-health: all tests pass
+  ✗ lint-drift: 4 lint errors found → created goal-a1b2c3d4
+  ✓ type-check: no type errors
+
+Summary: 2/3 scans passed, 1 goal created
+```

package/skills/mcp-connector-bridge/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: mcp-connector-bridge
+description: "Active MCP connector polling that integrates external tools (issue trackers, error monitoring, CI) into the heartbeat loop for cross-system discovery."
+origin: ECC
+---
+
+# MCP Connector Bridge
+
+Active MCP connector polling that integrates external tools into the heartbeat loop.
+The difference between an agent that says "here is the fix" vs a loop that opens
+the PR, links the ticket, and pings the channel — by itself.
+
+## When to Activate
+
+- User configures `.claude/connectors.yaml` with active MCP servers
+- Heartbeat scheduler includes connector-based scans
+- User invokes `/heartbeat start` with connector scans configured
+- External event triggers a connector poll
+
+## Core Concept
+
+MCP connectors let the loop touch real tools: issue trackers, error monitoring,
+databases, CI systems, chat platforms. Without connectors, the loop is isolated
+to the local repo. With connectors, it can discover issues from anywhere.
+
+```
+Heartbeat tick
+  │
+  ├─ Local scans (test, lint, type-check)
+  │
+  └─ Connector scans (MCP servers)
+       ├─ GitHub: "List open issues assigned to me"
+       ├─ Sentry: "List unresolved errors in last 24h"
+       └─ Linear: "List my in-progress tasks stale >7d"
+```
+
+## Configuration
+
+Create `.claude/connectors.yaml`:
+
+```yaml
+connectors:
+  - name: "github-issues"
+    server: "github"
+    heartbeatScan: "List open issues assigned to me with label:bug"
+    triageOnNew: true
+    priority: "medium"
+
+  - name: "sentry-errors"
+    server: "sentry"
+    heartbeatScan: "List unresolved errors from last 24 hours"
+    triageOnNew: true
+    priority: "high"
+
+  - name: "linear-tasks"
+    server: "linear"
+    heartbeatScan: "List my in-progress tasks not updated in 7 days"
+    autoGoalOnStale: "7d"
+    priority: "low"
+
+  - name: "slack-mentions"
+    server: "slack"
+    heartbeatScan: "Check unread mentions in engineering channel"
+    triageOnNew: true
+    priority: "low"
+```
+
+## Connector Scan Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Unique connector identifier |
+| `server` | Yes | MCP server name (must be configured in mcp-configs/) |
+| `heartbeatScan` | Yes | Prompt to send to the MCP server |
+| `triageOnNew` | No | Create triage items for new findings |
+| `autoGoalOnStale` | No | Auto-create goal if stale beyond duration |
+| `priority` | No | Default severity for triage items (high/medium/low) |
+| `enabled` | No | Disable without removing (default: true) |
+
+## Health Check
+
+Before polling, verify connector is reachable:
+
+1. Check MCP server is configured in project MCP settings
+2. Verify server responds to basic query
+3. If unreachable: skip this connector, log warning
+4. If reachable: execute heartbeatScan prompt
+
+Builds on existing `pre:mcp-health-check` hook.
+
+## Result Classification
+
+Connector scan results follow the same classification as local scans:
+
+| Finding | Action |
+|---------|--------|
+| New issue discovered | → Triage item (if `triageOnNew: true`) |
+| Stale task detected | → Auto-goal (if `autoGoalOnStale` configured) |
+| No new findings | → Skip silently |
+| Connection failed | → Log warning, skip |
+
+## Integration Points
+
+- **`/heartbeat`**: Connector scans run alongside local scans during each tick
+- **`/triage`**: New connector findings populate the triage inbox
+- **`/goal`**: Stale task connectors can auto-create goals
+- **`mcp-configs/`**: Connector references must match configured MCP servers
+- **MCP health hook**: Validates connectivity before scan
+
+## Hard Bans
+
+- Connectors MUST NOT write to external systems during discovery (read-only scans)
+- Failed connections MUST NOT block local heartbeat scans
+- Connector output MUST be size-limited (prevent token overflow from large responses)
+- Credentials MUST NOT be stored in connectors.yaml (use MCP server config)
+- Polling frequency MUST respect rate limits of external services
+
+## Example Flow
+
+```
+Heartbeat tick (every 30m):
+  Local scans: ✓ tests pass, ✓ lint clean
+  Connector scans:
+    github-issues: Found 2 new bugs → triage inbox
+    sentry-errors: No new errors → skip
+    linear-tasks: 1 task stale 10 days → auto-goal created
+
+Result:
+  2 triage items created from GitHub
+  1 goal created from Linear stale task
+  Total: 3 actions from this tick
+```

package/skills/rework-loop/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: rework-loop
+description: "Structured rework with git blame attribution for failed goal iterations. Maps failures to responsible changes and routes targeted fix briefs."
+origin: ECC
+---
+
+# Rework Loop
+
+Structured rework with blame attribution for failed goal iterations.
+When the oracle says "fail," don't blindly retry — identify what broke,
+map it to the responsible change, and route a targeted fix.
+
+## When to Activate
+
+- Oracle returns `fail` verdict during a goal iteration
+- Code reviewer identifies rework-worthy issues
+- Build/test failures after a maker iteration
+- Manual invocation for targeted re-implementation
+
+## Core Concept: Blame-Attributed Rework
+
+Blind retry is the #1 waste in autonomous loops. A rework loop instead:
+
+1. **Parses** failure output to extract specific failing locations
+2. **Blames** via `git diff` / `git blame` to find the responsible change
+3. **Constrains** the rework to only the affected scope
+4. **Routes** to the right specialist (TS issues → typescript-reviewer, etc.)
+5. **Tracks** rework attempts per location to detect persistent trouble spots
+
+```
+Oracle: FAIL
+  │
+  ▼
+Parse failure → "tests/auth.test.ts:45 — token refresh assertion fails"
+  │
+  ▼
+Blame → "src/auth/refresh.ts:23 changed in this iteration"
+  │
+  ▼
+Rework brief → {file: "src/auth/refresh.ts", constraint: "only fix refresh logic"}
+  │
+  ▼
+Route → backend-engineer or typescript-reviewer
+  │
+  ▼
+Track → attempts[src/auth/refresh.ts] += 1
+```
+
+## Rework Brief Format
+
+The rework brief is a structured context packet for the next iteration:
+
+```markdown
+## REWORK BRIEF
+
+**Goal:** {original objective}
+**Iteration:** {N} (rework attempt {M} for this location)
+
+**Failing evidence:**
+- Test: tests/auth.test.ts:45 — "should refresh expired tokens"
+- Error: Expected token.expiresAt to be > now, got 2024-01-01
+
+**Root cause (blame):**
+- File: src/auth/refresh.ts:23
+- Change: Added early return before expiry check
+- Commit: (this iteration, uncommitted)
+
+**Constraint:**
+- ONLY modify src/auth/refresh.ts
+- DO NOT touch test files (they define correct behavior)
+- The refresh logic must handle: valid token, expired token, missing token
+
+**Suggested fix:**
+- Remove the early return at line 23
+- Ensure expiry check runs before refresh attempt
+```
+
+## Escalation Triggers
+
+Rework escalates to triage when:
+
+| Condition | Action |
+|-----------|--------|
+| 3+ rework attempts on same location | Escalate: "persistent trouble spot" |
+| Rework introduces new failures | Escalate: "regression cascade" |
+| Blame maps to multiple unrelated files | Escalate: "scope too broad for targeted rework" |
+| No clear blame (flaky test, env issue) | Escalate: "non-deterministic failure" |
+
+## Blame Attribution Algorithm
+
+1. **Parse failure output** for file paths and line numbers
+2. **Get changed files** via `git diff --name-only` (this iteration vs last good)
+3. **Intersect** failing files with changed files
+4. **For each intersection:**
+   - `git diff <file>` to extract specific hunks
+   - Map test failure line to source change via call stack or import chain
+5. **If no intersection:** failure is pre-existing or environmental → escalate
+
+## Rework Tracking
+
+Track attempts per file/function to detect patterns:
+
+```json
+{
+  "src/auth/refresh.ts": {
+    "attempts": 3,
+    "lastAttempt": "2024-01-15T10:30:00Z",
+    "outcomes": ["fail", "fail", "pass"],
+    "totalCost": 1.20
+  }
+}
+```
+
+When `attempts >= 3` without convergence: this is a persistent trouble spot.
+The loop should escalate rather than keep burning budget.
+
+## Integration Points
+
+- **`/goal`**: Rework replaces blind retry in the maker-oracle loop
+- **`completion-oracle.js`**: Oracle's `failReasons` feed into blame parsing
+- **`/triage`**: Escalated rework items go to triage inbox
+- **Specialist agents**: Rework briefs route to appropriate specialists
+- **Cost advisor**: Rework attempts count toward goal budget
+
+## Hard Bans
+
+- DO NOT retry without blame analysis (blind retry wastes budget)
+- DO NOT modify test files during rework (tests define correct behavior)
+- DO NOT expand scope beyond blamed files (scope creep = new bugs)
+- DO NOT rework indefinitely (3 attempts max per location)
+- DO NOT skip tracking (rework history enables pattern detection)