@colin4k1024/tsp 2.5.0 → 2.5.2

package/scripts/lib/wave-cost-advisor.js

@@ -0,0 +1,155 @@
+'use strict';
+
+/**
+ * wave-cost-advisor.js
+ *
+ * Budget-aware wave scheduling for Loop Engineering.
+ * Calculates optimal parallelism based on remaining budget, estimated costs,
+ * and worker availability before launching a wave.
+ *
+ * Integrates with wave-execution skill and the workflow executor.
+ */
+
+const DEFAULT_COST_PER_WORKER = 0.50; // USD per worker iteration (conservative estimate)
+const DEFAULT_MAX_PARALLEL = 4;
+const DEFAULT_BUDGET = 10.0; // USD
+
+function createCostAdvisor(options = {}) {
+  const totalBudget = options.totalBudget || DEFAULT_BUDGET;
+  let spent = options.spent || 0;
+  const maxParallel = options.maxParallel || DEFAULT_MAX_PARALLEL;
+  const costPerWorker = options.costPerWorker || DEFAULT_COST_PER_WORKER;
+
+  return {
+    get remaining() { return totalBudget - spent; },
+    get spent() { return spent; },
+    get totalBudget() { return totalBudget; },
+
+    recordSpend(amount) {
+      spent += amount;
+    },
+
+    adviseBatchSize(taskCount, options = {}) {
+      const estimatedIterations = options.estimatedIterations || 1;
+      const taskCost = options.costPerTask || costPerWorker;
+      const maxWorkers = Math.min(taskCount, maxParallel);
+
+      if (spent >= totalBudget) {
+        return {
+          recommended: 0,
+          reason: 'budget_exhausted',
+          remaining: 0,
+          canAfford: 0,
+        };
+      }
+
+      const remaining = totalBudget - spent;
+      const costPerBatch = maxWorkers * taskCost * estimatedIterations;
+
+      if (costPerBatch <= remaining) {
+        return {
+          recommended: maxWorkers,
+          reason: 'within_budget',
+          remaining,
+          estimatedCost: costPerBatch,
+          canAfford: maxWorkers,
+        };
+      }
+
+      // Reduce parallelism to fit budget
+      const affordableWorkers = Math.max(1, Math.floor(remaining / (taskCost * estimatedIterations)));
+      const actualWorkers = Math.min(affordableWorkers, taskCount);
+
+      return {
+        recommended: actualWorkers,
+        reason: 'budget_constrained',
+        remaining,
+        estimatedCost: actualWorkers * taskCost * estimatedIterations,
+        canAfford: affordableWorkers,
+        requestedButDenied: maxWorkers - actualWorkers,
+      };
+    },
+
+    adviseWavePlan(waves, options = {}) {
+      const taskCost = options.costPerTask || costPerWorker;
+      const plan = [];
+      let projectedSpend = spent;
+
+      for (let i = 0; i < waves.length; i++) {
+        const wave = waves[i];
+        const taskCount = Array.isArray(wave) ? wave.length : wave.taskCount || 1;
+        const remaining = totalBudget - projectedSpend;
+
+        if (remaining <= 0) {
+          plan.push({
+            waveIndex: i,
+            status: 'deferred',
+            reason: 'budget_exhausted',
+            tasks: taskCount,
+            parallelism: 0,
+          });
+          continue;
+        }
+
+        const maxForWave = Math.min(taskCount, maxParallel);
+        const waveCost = maxForWave * taskCost;
+
+        if (waveCost <= remaining) {
+          plan.push({
+            waveIndex: i,
+            status: 'full',
+            tasks: taskCount,
+            parallelism: maxForWave,
+            estimatedCost: waveCost,
+          });
+          projectedSpend += waveCost;
+        } else {
+          const affordable = Math.max(1, Math.floor(remaining / taskCost));
+          const actual = Math.min(affordable, taskCount);
+          plan.push({
+            waveIndex: i,
+            status: 'reduced',
+            tasks: taskCount,
+            parallelism: actual,
+            estimatedCost: actual * taskCost,
+            note: `Reduced from ${maxForWave} to ${actual} workers due to budget`,
+          });
+          projectedSpend += actual * taskCost;
+        }
+      }
+
+      return {
+        plan,
+        projectedTotalCost: projectedSpend,
+        remainingAfterPlan: totalBudget - projectedSpend,
+        budgetUtilization: projectedSpend / totalBudget,
+      };
+    },
+
+    shouldPause() {
+      return spent >= totalBudget;
+    },
+
+    formatSummary() {
+      const pct = ((spent / totalBudget) * 100).toFixed(1);
+      return `Budget: $${spent.toFixed(2)} / $${totalBudget.toFixed(2)} (${pct}% used), $${(totalBudget - spent).toFixed(2)} remaining`;
+    },
+  };
+}
+
+function estimateGoalCost(goal, averageCostPerIteration) {
+  const remainingIterations = (goal.budget?.maxIterations || 15) - (goal.currentIteration || 0);
+  const avgCost = averageCostPerIteration || DEFAULT_COST_PER_WORKER;
+  return {
+    bestCase: avgCost,
+    expectedCase: avgCost * Math.min(3, remainingIterations),
+    worstCase: avgCost * remainingIterations,
+  };
+}
+
+module.exports = {
+  DEFAULT_COST_PER_WORKER,
+  DEFAULT_MAX_PARALLEL,
+  createCostAdvisor,
+  estimateGoalCost,
+};

package/scripts/test-opencode-install.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const OPENCODE_HOME = path.join(os.homedir(), '.config', 'opencode');
+const PLUGIN_DIR = path.join(OPENCODE_HOME, 'plugins', 'team-skills-platform');
+
+console.log('=== OpenCode 安装验证 ===\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('OPENCODE_HOME 目录存在', fs.existsSync(OPENCODE_HOME));
+check('AGENTS.md 文件存在', fs.existsSync(path.join(OPENCODE_HOME, 'AGENTS.md')));
+check('opencode.json 文件存在', fs.existsSync(path.join(OPENCODE_HOME, 'opencode.json')));
+check('agents 目录存在', fs.existsSync(path.join(OPENCODE_HOME, 'agents')));
+check('command 目录存在', fs.existsSync(path.join(OPENCODE_HOME, 'command')));
+check('plugins 目录存在', fs.existsSync(path.join(OPENCODE_HOME, 'plugins')));
+check('team-skills-platform 插件存在', fs.existsSync(PLUGIN_DIR));
+check('tsp-hooks.js 插件存在', fs.existsSync(path.join(OPENCODE_HOME, 'plugins', 'tsp-hooks.js')));
+
+console.log('\n📄 文件内容检查:');
+
+// 检查 AGENTS.md
+const agentsMdPath = path.join(OPENCODE_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('## 核心团队命令'));
+  check('AGENTS.md 包含技能索引', content.includes('## 可用技能'));
+}
+
+// 检查 opencode.json
+const configPath = path.join(OPENCODE_HOME, 'opencode.json');
+if (fs.existsSync(configPath)) {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  check('opencode.json 包含 instructions', Array.isArray(config.instructions));
+  check('opencode.json 包含 plugin', Array.isArray(config.plugin));
+  check('opencode.json 包含 permission', typeof config.permission === 'object');
+}
+
+console.log('\n👥 Agents 检查:');
+const agentsDir = path.join(OPENCODE_HOME, 'agents');
+if (fs.existsSync(agentsDir)) {
+  const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+  check(`agents 目录包含文件 (${agentFiles.length})`, agentFiles.length > 0);
+
+  // 检查是否有角色 agents
+  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)));
+  }
+
+  // 检查是否有 specialist agents
+  const specialistAgents = agentFiles.filter(f => f.startsWith('specialist-'));
+  check(`specialist agents 存在 (${specialistAgents.length})`, specialistAgents.length > 0);
+
+  // 检查 agent 文件格式
+  if (agentFiles.length > 0) {
+    const sampleAgent = fs.readFileSync(path.join(agentsDir, agentFiles[0]), 'utf8');
+    check('agent 文件包含 YAML front matter', sampleAgent.startsWith('---'));
+  }
+}
+
+console.log('\n📝 Commands 检查:');
+const commandsDir = path.join(OPENCODE_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);
+
+  // 检查是否有 SKILL.md 文件
+  let skillsWithMd = 0;
+  for (const dir of skillDirs.slice(0, 10)) {
+    if (fs.existsSync(path.join(skillsDir, dir, 'SKILL.md'))) {
+      skillsWithMd++;
+    }
+  }
+  check(`skills 包含 SKILL.md 文件 (${skillsWithMd})`, skillsWithMd > 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')));
+  check('zh 规则目录存在', fs.existsSync(path.join(rulesDir, 'zh')));
+}
+
+console.log('\n⚡ Hooks 检查:');
+const hooksPath = path.join(OPENCODE_HOME, 'plugins', 'tsp-hooks.js');
+if (fs.existsSync(hooksPath)) {
+  const hooksContent = fs.readFileSync(hooksPath, 'utf8');
+  check('tsp-hooks.js 包含插件函数', hooksContent.includes('module.exports = function tspHooks'));
+  check('tsp-hooks.js 包含 tool.execute.before', hooksContent.includes("'tool.execute.before'"));
+  check('tsp-hooks.js 包含 tool.execute.after', hooksContent.includes("'tool.execute.after'"));
+}
+
+// 总结
+console.log('\n=== 测试总结 ===');
+console.log(`通过: ${passed}`);
+console.log(`失败: ${failed}`);
+console.log(`总计: ${passed + failed}`);
+
+if (failed === 0) {
+  console.log('\n🎉 所有测试通过！OpenCode 安装成功。');
+  console.log('\n下一步:');
+  console.log('1. 启动 OpenCode: opencode');
+  console.log('2. 查看可用角色: AGENTS.md 中包含所有角色索引');
+  console.log('3. 执行团队命令: /team-intake, /team-plan 等');
+  console.log('4. 加载技能: skill frontend-engineering');
+  console.log('5. 引用规则: @rules/common/coding-style.md');
+  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/goframe-v2/examples/practices/quick-demo/manifest/config/config.yaml

@@ -1,15 +1,15 @@
-# https://goframe.org/docs/web/server-config-file-template
-server:
-  address:     ":8000"
-  openapiPath: "/api.json"
-  swaggerPath: "/swagger"
-
-# https://goframe.org/docs/core/glog-config
-logger:
-  level : "all"
-  stdout: true
-
-# https://goframe.org/docs/core/gdb-config-file
-database:
-  default:
+# https://goframe.org/docs/web/server-config-file-template
+server:
+  address:     ":8000"
+  openapiPath: "/api.json"
+  swaggerPath: "/swagger"
+
+# https://goframe.org/docs/core/glog-config
+logger:
+  level : "all"
+  stdout: true
+
+# https://goframe.org/docs/core/gdb-config-file
+database:
+  default:
     link: "mysql:root:12345678@tcp(127.0.0.1:3306)/test"

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
+```