@synergenius/flow-weaver-pack-weaver 0.9.199 → 0.9.201

package/src/bot/capability-registry.ts

@@ -23,7 +23,7 @@ const CAP_CORE: CapabilityDefinition = {
   prompt: `You are Weaver. Execute tasks by calling tools — do not describe what you would do.
 
 ## System Constraints
-- All file paths are relative to the workspace root. "../" is blocked.
+- All file paths MUST be relative to the workspace root (e.g. "src/index.ts", not "/home/user/project/src/index.ts"). NEVER use absolute paths. "../" is blocked.
 - Writes that shrink a file >50% or write empty content are BLOCKED by the system.
 - Blocked shell commands: rm -rf, git push, npm publish, sudo, curl|sh.`,
 };
@@ -36,46 +36,69 @@ const CAP_ROLE_ORCHESTRATOR: CapabilityDefinition = {
   name: 'role-orchestrator',
   description: 'Orchestrator role: decomposes objectives into subtask DAGs.',
   tools: [OP_TASK_CREATE, OP_LIST_FILES, OP_READ_FILE],
+  acceptance: [
+    { name: 'subtasks-created', command: 'python3 -c "import json; tasks=json.load(open(\'.weaver/tasks.json\')); exit(0 if len(tasks)>=3 else 1)"' },
+    { name: 'deps-defined', command: 'python3 -c "import json; tasks=json.load(open(\'.weaver/tasks.json\')); exit(0 if any(t.get(\'dependsOn\') for t in tasks) else 1)"' },
+  ],
   prompt: `## YOUR ROLE: Orchestrator
 You decompose objectives into subtasks. You never write code or create files directly.
 Your only output is task_create calls + done.
 
-1. Analyze the objective and list_files to understand the workspace.
-2. Create subtasks via task_create with parentId: "@self".
-3. Assign profiles: developer (code), reviewer (review), ops (infra/setup).
-4. Set dependsOn using task titles (resolved to IDs automatically).
-5. Add acceptance.checks — shell commands that exit 0 on success. The system runs them after each run.
-6. Maximize parallelism: tasks with no shared files should not depend on each other.
-7. Your LAST subtask: "Review & Steer" assigned to orchestrator, dependsOn all others.
-
-### Design First
-For multi-file projects, your FIRST subtask should create a .design.md with:
-- Module map: which files, what each exports (function signatures with types)
-- Conventions: naming, error handling, patterns (e.g., factory functions for servers)
-All subsequent developer tasks must read .design.md before writing code.
+### Execution Planning Protocol
+Before creating subtasks, you MUST:
+1. Use list_files and read_file to read every source file. Map the dependency graph (which files import which).
+2. IDENTIFY the critical path — the longest sequential chain. This is your bottleneck.
+3. GROUP tasks to match worker count (shown in context as maxConcurrent=N).
+   - Each dependency level should have at most N parallel tasks.
+   - Combine small independent files into single tasks to reduce overhead.
+   - Separate high-risk files (many bugs/complexity) from clean ones.
+   - Never create more sequential levels than necessary.
+4. SHOW YOUR REASONING in the first task_create description:
+   - Dependency graph you found
+   - Critical path identified
+   - Why you grouped tasks this way
+
+### Task Creation Rules
+- Create subtasks via task_create with parentId: "@self".
+- Assign profiles: developer (code), reviewer (review), ops (infra/setup).
+- Set dependsOn using task titles (resolved to IDs automatically).
+- Fewer tasks with more work each > many tiny serial tasks.
+- A file and its only dependent CAN be in the same task.
+- Tests can be combined with the last implementation task.
+- Your LAST subtask: "Review & Steer" assigned to orchestrator, dependsOn all others.
 
 ### Acceptance Criteria
 Every subtask MUST have acceptance.checks — shell commands that verify "done" (exit 0 = pass).
+Checks must test BEHAVIOR (run the code, import the module), not string patterns (grep for text).
 The system runs them automatically after each run. If any fail, the task stays open.
 Examples:
-- File exists: test -f url-shortener/src/store.ts
-- Compiles: cd url-shortener && npx tsc --noEmit
-- Tests pass: cd url-shortener && npx vitest run
-- Export exists: grep -q "export.*startServer" url-shortener/src/server.ts
+- Compiles: npx tsc --noEmit
+- Tests pass: npx vitest run
+- Module works: node -e "import('./src/db.js').then(m => process.exit(m.getById ? 0 : 1))"
+- File exists: test -f src/types.ts
+
+### Design First
+For multi-file projects, your FIRST subtask should create a .design.md with:
+- Module map: which files, what each exports (function signatures with types)
+- Conventions: naming, error handling, patterns
+All subsequent developer tasks must read .design.md before writing code.
 
 ### Steering Mode (when running a Review & Steer task)
 Read the sibling task list in your context — it shows status, run count, and check failures with error details.
 - All checks pass → done.
 - Tasks with 0 runs still open → they will be picked up, do not recreate them.
-- Checks failing → read the specific error in the check detail, then create a targeted fix task addressing that exact error. Do not create broad "fix everything" tasks.
+- Checks failing → read the specific error in the check detail, then create a targeted fix task addressing that exact error.
 - Task stagnant (3+ failed runs) → redefine with smaller scope or reassign to different profile.
-- Before creating ANY task, check if an existing open sibling already covers the same work. If yes, do not create a duplicate — the existing task will be retried.
+- Before creating ANY task, check if an existing open sibling already covers the same work.
 - After creating fix tasks, create one more Review & Steer depending on them, then done.`,
 };
 
 const CAP_ROLE_DEVELOPER: CapabilityDefinition = {
   name: 'role-developer',
   description: 'Developer role: writes code, creates files, runs commands.',
+  acceptance: [
+    { name: 'file-changes-produced', command: 'test $(find src tests -name "*.ts" -newer .weaver/swarm.json 2>/dev/null | wc -l) -gt 0 || test $(find src tests -name "*.js" -newer .weaver/swarm.json 2>/dev/null | wc -l) -gt 0', condition: 'src' },
+  ],
   prompt: `## YOUR ROLE: Developer
 You write code and produce files. Execute the task directly — do not delegate.
 
@@ -128,8 +151,8 @@ const CAP_SHELL: CapabilityDefinition = {
 
 const CAP_TASK_MGMT: CapabilityDefinition = {
   name: 'task-mgmt',
-  description: 'Create swarm subtasks.',
-  tools: [OP_TASK_CREATE],
+  description: 'Create and inspect swarm subtasks.',
+  tools: [OP_TASK_CREATE, 'task_list', 'task_get', 'task_update'],
   prompt: `## Task Management
 - task_create(title, description?, assignedProfile?, parentId?, dependsOn?, complexity?, acceptance?):
   Creates a subtask in the swarm task pool. Returns task ID.
@@ -138,6 +161,9 @@ const CAP_TASK_MGMT: CapabilityDefinition = {
   - assignedProfile: "developer" | "reviewer" | "ops" | "orchestrator". Omit for auto-routing.
   - parentId: "@self" to nest under current task. Omit for top-level.
   - dependsOn: Array of task titles. Resolved to IDs automatically.
+- task_list(status?): List tasks in the swarm. Optionally filter by status (pending, in-progress, done, failed).
+- task_get(id): Get full details of a specific task.
+- task_update(id, notes?, files?, description?): Update a task's notes, files list, or description.
   - complexity: "trivial" | "simple" | "moderate" | "complex".
   - acceptance: { checks: [{ name: string, command: string }] } — shell commands that exit 0 on success.`,
 };
@@ -254,9 +280,13 @@ const CAP_VERIFICATION: CapabilityDefinition = {
   name: 'verification',
   description: 'TypeScript compilation and test runner verification.',
   tools: [OP_RUN_SHELL],
+  acceptance: [
+    { name: 'tsc-compiles', command: 'npx tsc --noEmit', condition: "find src -name '*.ts' | head -1 | grep -q ." },
+  ],
   prompt: `## Verification
-- tsc_check: npx tsc --noEmit — returns TypeScript compilation errors or empty on success.
-- test_run: npx vitest run — returns test results with pass/fail counts.`,
+Use run_shell for compilation and test verification:
+- npx tsc --noEmit — returns TypeScript compilation errors or empty on success.
+- npx vitest run — returns test results with pass/fail counts.`,
 };
 
 const CAP_CROSS_FILE_CHECK: CapabilityDefinition = {
@@ -264,8 +294,9 @@ const CAP_CROSS_FILE_CHECK: CapabilityDefinition = {
   description: 'Cross-file dependency verification.',
   tools: [OP_READ_FILE, OP_LIST_FILES, OP_RUN_SHELL],
   prompt: `## Cross-File Checks
-Use grep (via run_shell) to find all import/export references across files.
-Use read_file to verify import paths resolve to actual exports.`,
+Use list_files to find relevant files, read_file to inspect them,
+and run_shell with grep to find all import/export references across files.
+Verify import paths resolve to actual exports.`,
 };
 
 const CAP_PROJECT_SETUP: CapabilityDefinition = {
@@ -282,7 +313,7 @@ const CAP_SECURITY: CapabilityDefinition = {
   description: 'Security audit tools.',
   tools: [OP_READ_FILE, OP_LIST_FILES, OP_RUN_SHELL],
   prompt: `## Security
-Use grep (via run_shell) to scan for hardcoded secrets, eval(), shell injection patterns.
+Use list_files to discover files, read_file to inspect them, and run_shell with grep to scan for hardcoded secrets, eval(), shell injection patterns.
 Use npm audit (via run_shell) for dependency vulnerabilities.
 Finding format: FILE:LINE | SEVERITY (critical/high/medium/low) | ISSUE.`,
 };
@@ -358,7 +389,7 @@ export const BUILT_IN_CAPABILITIES: readonly CapabilityDefinition[] = [
 
 /** Capability pools per profile role. Triage selects from these per task. */
 export const PROFILE_CAPABILITIES: Record<string, string[]> = {
-  orchestrator: ['core', 'role-orchestrator', 'decomposition', 'routing', 'task-mgmt', 'context'],
+  orchestrator: ['core', 'role-orchestrator', 'decomposition', 'routing', 'task-mgmt', 'shell', 'context'],
   developer: ['core', 'role-developer', 'file-ops', 'shell', 'verification', 'cross-file-check', 'context'],
   'fw-developer': ['core', 'role-developer', 'file-ops', 'shell', 'verification', 'cross-file-check', 'fw-grammar', 'fw-validate', 'fw-cli', 'context'],
   reviewer: ['core', 'role-reviewer', 'code-review', 'security', 'context'],
@@ -374,6 +405,31 @@ export function getCapability(name: string): CapabilityDefinition | undefined {
   return capabilityMap.get(name);
 }
 
+/**
+ * Collect all acceptance checks from a profile's capabilities.
+ * Deduplicates by check name — first occurrence wins.
+ */
+export function getCapabilityAcceptanceChecks(profileId: string): Array<{ name: string; command: string; condition?: string }> {
+  const capNames = PROFILE_CAPABILITIES[profileId];
+  if (!capNames) return [];
+
+  const seen = new Set<string>();
+  const checks: Array<{ name: string; command: string; condition?: string }> = [];
+
+  for (const capName of capNames) {
+    const cap = capabilityMap.get(capName);
+    if (!cap?.acceptance) continue;
+    for (const check of cap.acceptance) {
+      if (!seen.has(check.name)) {
+        seen.add(check.name);
+        checks.push(check);
+      }
+    }
+  }
+
+  return checks;
+}
+
 /** List all available capabilities. */
 export function listCapabilities(): CapabilityDefinition[] {
   return [...BUILT_IN_CAPABILITIES];

package/src/bot/capability-types.ts

@@ -11,6 +11,15 @@
  * Built-in capabilities ship with the pack. Custom capabilities can be
  * added per-workspace via .weaver/capabilities/.
  */
+export interface CapabilityAcceptanceCheck {
+  /** Human-readable check name (e.g. 'compiles', 'tests-pass'). */
+  name: string;
+  /** Shell command that exits 0 on success. */
+  command: string;
+  /** Only run if this file exists in the workspace (e.g. 'tsconfig.json'). */
+  condition?: string;
+}
+
 export interface CapabilityDefinition {
   /** Unique identifier (e.g. 'typescript', 'fw-grammar'). */
   name: string;
@@ -20,4 +29,6 @@ export interface CapabilityDefinition {
   prompt: string;
   /** Tool operation names this capability grants (e.g. ['write_file', 'patch_file']). */
   tools?: string[];
+  /** Deterministic acceptance checks auto-merged into every task using this capability. */
+  acceptance?: CapabilityAcceptanceCheck[];
 }

package/src/bot/cli-provider.ts

@@ -88,13 +88,14 @@ export class CliAgentProvider implements BotAgentProvider {
   }
 
   private async *streamRaw(userPrompt: string, systemPrompt?: string): AsyncGenerator<StreamChunk> {
-    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
-    if (this.model) {
-      args.push('--model', this.model);
-    }
-    if (systemPrompt) {
-      args.push('--system-prompt', systemPrompt);
-    }
+    // Use centralized CLI config — enforces --tools "" and --strict-mcp-config
+    const { getCliBaseArgs } = await import('@synergenius/flow-weaver/agent');
+    const args = getCliBaseArgs({
+      model: this.model,
+      systemPrompt,
+      outputFormat: 'stream-json',
+      includePartialMessages: true,
+    });
 
     const child = spawn('claude', args, {
       stdio: ['pipe', 'pipe', 'pipe'],

package/src/bot/preflight.ts

@@ -0,0 +1,285 @@
+/**
+ * Pre-flight validator — runs before the swarm starts to catch config bugs.
+ *
+ * Validates that the tool pipeline is intact:
+ * 1. Every BOT_TOOLS entry has a TOOL_SCHEMAS entry (schema completeness)
+ * 2. Every schema'd tool has an execution handler (handler completeness)
+ * 3. Every mode's resolveToolsForTask produces only schema'd tools
+ * 4. Capability-granted tools are all schema'd
+ * 5. MCP bridge round-trip (create bridge, call tool via socket, verify result)
+ *
+ * Fails fast with clear error messages before any AI calls are made.
+ */
+
+import * as net from 'node:net';
+import * as fs from 'node:fs';
+import { ALL_TOOLS, BOT_TOOLS, resolveToolsForTask } from './tool-registry.js';
+import { TOOL_SCHEMAS } from '../node-types/plan-task.js';
+
+// Known execution handlers — tools handled by weaver-tools.ts (bot context)
+// and assistant-tools.ts (assistant context). Maintained manually because
+// the handlers are switch/case statements, not a registry.
+const WEAVER_TOOL_HANDLERS = new Set([
+  'read_file', 'write_file', 'patch_file', 'list_files', 'run_shell',
+  'validate', 'tsc_check', 'run_tests', 'learn', 'recall', 'remember',
+  'web_fetch', 'task_create', 'task_list', 'task_get', 'task_update',
+  'ask_user', 'done', 'complete', 'respond',
+]);
+
+export interface PreflightError {
+  check: string;
+  tool: string;
+  message: string;
+}
+
+export interface PreflightResult {
+  passed: boolean;
+  errors: PreflightError[];
+  warnings: PreflightError[];
+  checks: { name: string; passed: boolean; count: number }[];
+}
+
+/**
+ * Run all pre-flight checks. Returns a result with errors and warnings.
+ * Call this before starting the swarm — if errors exist, abort.
+ */
+export function runPreflight(options?: {
+  capabilities?: string[];
+  mode?: string;
+}): PreflightResult {
+  const errors: PreflightError[] = [];
+  const warnings: PreflightError[] = [];
+  const checks: { name: string; passed: boolean; count: number }[] = [];
+
+  // 1. Schema completeness — every BOT_TOOLS entry has a TOOL_SCHEMAS entry
+  {
+    const missing = BOT_TOOLS
+      .map(t => t.name)
+      .filter(name => !TOOL_SCHEMAS[name]);
+    checks.push({
+      name: 'schema-completeness',
+      passed: missing.length === 0,
+      count: BOT_TOOLS.length - missing.length,
+    });
+    for (const name of missing) {
+      errors.push({
+        check: 'schema-completeness',
+        tool: name,
+        message: `Tool '${name}' is in BOT_TOOLS (described in system prompt) but has no TOOL_SCHEMAS entry. The model will see it but cannot call it.`,
+      });
+    }
+  }
+
+  // 2. Handler completeness — every TOOL_SCHEMAS entry has an execution handler
+  {
+    const schemaNames = Object.keys(TOOL_SCHEMAS);
+    const missing = schemaNames.filter(name => !WEAVER_TOOL_HANDLERS.has(name));
+    checks.push({
+      name: 'handler-completeness',
+      passed: missing.length === 0,
+      count: schemaNames.length - missing.length,
+    });
+    for (const name of missing) {
+      errors.push({
+        check: 'handler-completeness',
+        tool: name,
+        message: `Tool '${name}' has a TOOL_SCHEMAS entry but no execution handler in weaver-tools.ts or assistant-tools.ts. Calls will return "Unknown tool".`,
+      });
+    }
+  }
+
+  // 3. Mode consistency — every mode produces only schema'd tools
+  {
+    let modeErrors = 0;
+    for (const mode of ['create', 'modify', 'read', 'batch']) {
+      const modeTools = resolveToolsForTask({ mode });
+      for (const name of modeTools) {
+        if (!TOOL_SCHEMAS[name]) {
+          modeErrors++;
+          errors.push({
+            check: 'mode-consistency',
+            tool: name,
+            message: `Mode '${mode}' grants tool '${name}' via resolveToolsForTask but it has no TOOL_SCHEMAS entry.`,
+          });
+        }
+      }
+    }
+    checks.push({
+      name: 'mode-consistency',
+      passed: modeErrors === 0,
+      count: 4 - (modeErrors > 0 ? 1 : 0),
+    });
+  }
+
+  // 4. Registry-schema alignment — every ALL_TOOLS entry should have a schema
+  {
+    const allNames = ALL_TOOLS.map(t => t.name);
+    const missing = allNames.filter(name => !TOOL_SCHEMAS[name]);
+    checks.push({
+      name: 'registry-schema-alignment',
+      passed: true, // warnings only — not a blocker
+      count: allNames.length - missing.length,
+    });
+    for (const name of missing) {
+      warnings.push({
+        check: 'registry-schema-alignment',
+        tool: name,
+        message: `Tool '${name}' is in ALL_TOOLS but has no TOOL_SCHEMAS entry. If it's a bot-only or assistant-only tool, this may be intentional.`,
+      });
+    }
+  }
+
+  return {
+    passed: errors.length === 0,
+    errors,
+    warnings,
+    checks,
+  };
+}
+
+/**
+ * Runtime check: create a real MCP bridge, send a test tool call through the
+ * Unix socket, verify the round-trip. Catches MCP tool server startup failures,
+ * socket connectivity issues, and executor wiring bugs.
+ *
+ * Returns a PreflightResult that can be merged with the static checks.
+ */
+export async function runBridgePreflight(): Promise<PreflightResult> {
+  const errors: PreflightError[] = [];
+  const checks: { name: string; passed: boolean; count: number }[] = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let bridge: any = null;
+
+  try {
+    const { createMcpBridge } = await import('@synergenius/flow-weaver/agent');
+    const { WEAVER_TOOLS } = await import('./weaver-tools.js');
+
+    // Create a bridge with a test executor
+    let testCallReceived = false;
+    bridge = await createMcpBridge(
+      WEAVER_TOOLS.slice(0, 1), // one tool is enough
+      async (name: string) => {
+        testCallReceived = true;
+        return { result: `preflight-ok:${name}`, isError: false };
+      },
+    );
+
+    // 5a. Config file exists and is valid JSON
+    const configExists = fs.existsSync(bridge!.configPath);
+    if (!configExists) {
+      errors.push({ check: 'bridge-config', tool: '', message: 'MCP bridge config file not created' });
+      checks.push({ name: 'bridge-config', passed: false, count: 0 });
+      return { passed: false, errors, warnings: [], checks };
+    }
+
+    const config = JSON.parse(fs.readFileSync(bridge!.configPath, 'utf-8'));
+    const serverConfig = config?.mcpServers?.['fw-agent'];
+    if (!serverConfig) {
+      errors.push({ check: 'bridge-config', tool: '', message: 'MCP config missing fw-agent server entry' });
+      checks.push({ name: 'bridge-config', passed: false, count: 0 });
+      return { passed: false, errors, warnings: [], checks };
+    }
+    checks.push({ name: 'bridge-config', passed: true, count: 1 });
+
+    // 5b. Socket is listening and accepts connections
+    const socketPath = serverConfig.env?.FW_TOOL_SOCKET;
+    if (!socketPath || !fs.existsSync(socketPath)) {
+      errors.push({ check: 'bridge-socket', tool: '', message: `Bridge socket not found: ${socketPath}` });
+      checks.push({ name: 'bridge-socket', passed: false, count: 0 });
+      return { passed: false, errors, warnings: [], checks };
+    }
+    checks.push({ name: 'bridge-socket', passed: true, count: 1 });
+
+    // 5c. Round-trip: send a tool call, get a result
+    const toolName = WEAVER_TOOLS[0]?.name ?? 'test';
+    const roundTripResult = await new Promise<{ result: string; isError: boolean }>((resolve, reject) => {
+      const client = net.createConnection(socketPath, () => {
+        client.write(JSON.stringify({ name: toolName, args: {} }) + '\n');
+      });
+      let buf = '';
+      client.on('data', (chunk) => { buf += chunk.toString(); });
+      client.on('end', () => {
+        try { resolve(JSON.parse(buf.trim())); }
+        catch { reject(new Error(`Invalid bridge response: ${buf.slice(0, 200)}`)); }
+      });
+      client.on('error', (err) => reject(err));
+      setTimeout(() => { client.destroy(); reject(new Error('Bridge socket round-trip timed out (5s)')); }, 5000);
+    });
+
+    const roundTripOk = roundTripResult.result.startsWith('preflight-ok:') && testCallReceived;
+    if (!roundTripOk) {
+      errors.push({
+        check: 'bridge-roundtrip',
+        tool: toolName,
+        message: `Bridge round-trip failed: received=${JSON.stringify(roundTripResult).slice(0, 200)}, callReceived=${testCallReceived}`,
+      });
+    }
+    checks.push({ name: 'bridge-roundtrip', passed: roundTripOk, count: roundTripOk ? 1 : 0 });
+
+    // 5d. Tool server script exists
+    const scriptArgs: string[] = serverConfig.args ?? [];
+    const scriptPath = scriptArgs[scriptArgs.length - 1];
+    const scriptExists = scriptPath && (
+      fs.existsSync(scriptPath) ||
+      fs.existsSync(scriptPath.replace(/\.ts$/, '.js')) ||
+      fs.existsSync(scriptPath.replace(/\.js$/, '.ts'))
+    );
+    if (!scriptExists) {
+      errors.push({ check: 'bridge-script', tool: '', message: `MCP tool server script not found: ${scriptPath}` });
+    }
+    checks.push({ name: 'bridge-script', passed: !!scriptExists, count: scriptExists ? 1 : 0 });
+
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push({ check: 'bridge-runtime', tool: '', message: `MCP bridge preflight failed: ${msg}` });
+    checks.push({ name: 'bridge-runtime', passed: false, count: 0 });
+  } finally {
+    bridge?.cleanup();
+  }
+
+  return {
+    passed: errors.length === 0,
+    errors,
+    warnings: [],
+    checks,
+  };
+}
+
+/**
+ * Format preflight result for console output.
+ */
+export function formatPreflightResult(result: PreflightResult): string {
+  const lines: string[] = ['[swarm-preflight] Validating tool pipeline...'];
+
+  for (const check of result.checks) {
+    const icon = check.passed ? '✓' : '✗';
+    lines.push(`  ${icon} ${check.name} (${check.count} passed)`);
+  }
+
+  if (result.errors.length > 0) {
+    lines.push('');
+    lines.push(`Errors (${result.errors.length}):`);
+    for (const err of result.errors) {
+      lines.push(`  ✗ [${err.check}] ${err.tool}: ${err.message}`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    lines.push('');
+    lines.push(`Warnings (${result.warnings.length}):`);
+    for (const warn of result.warnings) {
+      lines.push(`  ⚠ [${warn.check}] ${warn.tool}: ${warn.message}`);
+    }
+  }
+
+  if (result.passed) {
+    lines.push('');
+    lines.push('Preflight passed. Tool pipeline is intact.');
+  } else {
+    lines.push('');
+    lines.push(`Preflight FAILED: ${result.errors.length} error(s). Fix before starting swarm.`);
+  }
+
+  return lines.join('\n');
+}