@synergenius/flow-weaver-pack-weaver 0.8.1

package/src/node-types/approval-gate.ts

@@ -0,0 +1,95 @@
+import * as readline from 'node:readline';
+import type { WeaverContext } from '../bot/types.js';
+import { auditEmit } from '../bot/audit-logger.js';
+
+/**
+ * Presents the plan to the user for approval. Branching:
+ * onSuccess = approved, onFailure = rejected.
+ * Supports autoApprove mode from config.
+ *
+ * @flowWeaver nodeType
+ * @label Approval Gate
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with rejectionReason (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+export async function weaverApprovalGate(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+
+  // Studio sandbox: use agent channel instead of readline
+  const channel = (globalThis as any).__fw_agent_channel__;
+  if (channel) {
+    const plan = JSON.parse(context.planJson!) as { steps: Array<{ id: string; operation: string; description: string }>; summary: string };
+    const result = await channel.request({
+      agentId: 'weaver-approval',
+      context: { plan: { steps: plan.steps || [] }, summary: plan.summary || '' },
+      prompt: `Review and approve/reject this plan with ${(plan.steps || []).length} steps.`,
+    });
+    const approved = (result as Record<string, unknown>).approved !== false;
+    if (approved) {
+      context.rejectionReason = '';
+      return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+    } else {
+      const reason = ((result as Record<string, unknown>).reason as string) || 'rejected by agent';
+      context.rejectionReason = reason;
+      return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+    }
+  }
+
+  if (!execute) {
+    context.rejectionReason = '';
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { config } = env;
+  const approvalMode = typeof config.approval === 'string' ? config.approval : config.approval?.mode ?? 'prompt';
+
+  // Check for autoApprove in task options
+  const task = JSON.parse(context.taskJson!) as { options?: { autoApprove?: boolean } };
+  if (task.options?.autoApprove || approvalMode === 'auto') {
+    console.log('\x1b[36m→ Auto-approved\x1b[0m');
+    auditEmit('approval-decision', { approved: true, mode: 'auto' });
+    context.rejectionReason = '';
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  // Display the plan
+  const plan = JSON.parse(context.planJson!) as { steps: Array<{ id: string; operation: string; description: string }>; summary: string };
+  console.log('\n\x1b[1m┌─ Bot Plan ─────────────────────────────┐\x1b[0m');
+  console.log(`\x1b[1m│\x1b[0m Summary: ${plan.summary}`);
+  console.log(`\x1b[1m│\x1b[0m Steps: ${plan.steps.length}`);
+  for (const step of plan.steps) {
+    console.log(`\x1b[1m│\x1b[0m  ${step.id}: [${step.operation}] ${step.description}`);
+  }
+  console.log('\x1b[1m└────────────────────────────────────────┘\x1b[0m\n');
+
+  // Prompt for approval
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>(resolve => {
+    rl.question('Approve this plan? [Y/n] ', resolve);
+  });
+  rl.close();
+
+  const approved = !answer || answer.toLowerCase().startsWith('y');
+
+  if (approved) {
+    console.log('\x1b[32m→ Plan approved\x1b[0m');
+    auditEmit('approval-decision', { approved: true, mode: 'prompt' });
+    context.rejectionReason = '';
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const reason = answer || 'rejected by user';
+  console.log(`\x1b[33m→ Plan rejected: ${reason}\x1b[0m`);
+  auditEmit('approval-decision', { approved: false, reason });
+  context.rejectionReason = reason;
+  return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+}

package/src/node-types/bot-report.ts

@@ -0,0 +1,82 @@
+import type { WeaverContext } from '../bot/types.js';
+
+/**
+ * Generates the final bot session report. Receives context from any
+ * of the three paths: read-only, main execution, or abort.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Bot Report
+ * @executeWhen DISJUNCTION
+ * @input [mainCtx] [order:0] - Context from main path (JSON, optional)
+ * @input [readCtx] [order:1] - Context from read-only path (JSON, optional)
+ * @input [abortCtx] [order:2] - Context from abort path (JSON, optional)
+ * @output summary [order:0] - Summary text
+ * @output reportJson [order:1] [hidden] - Full report (JSON)
+ * @output onFailure [hidden]
+ */
+export function weaverBotReport(
+  mainCtx?: string,
+  readCtx?: string,
+  abortCtx?: string,
+): { summary: string; reportJson: string } {
+  const ctxStr = mainCtx ?? readCtx ?? abortCtx;
+
+  if (!ctxStr) {
+    const report = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
+    return { summary: '', reportJson: JSON.stringify(report) };
+  }
+
+  const context = JSON.parse(ctxStr) as WeaverContext;
+  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string; mode?: string } : {};
+  const files: string[] = context.filesModified ? JSON.parse(context.filesModified) : [];
+  const gitResult = context.gitResultJson ? JSON.parse(context.gitResultJson) : null;
+
+  let result: { success?: boolean; summary?: string; outcome?: string; results?: unknown[] } | null = null;
+  let pathName = 'unknown';
+
+  if (readCtx) {
+    result = context.resultJson ? JSON.parse(context.resultJson) : null;
+    pathName = 'read';
+  } else if (mainCtx) {
+    result = context.resultJson ? JSON.parse(context.resultJson) : null;
+    pathName = 'main';
+  } else if (abortCtx) {
+    result = context.resultJson ? JSON.parse(context.resultJson) : null;
+    pathName = 'abort';
+  }
+
+  const parts: string[] = [];
+
+  if (task.instruction) {
+    parts.push(`Task: ${task.instruction}`);
+  }
+
+  if (result) {
+    parts.push(`Outcome: ${result.outcome ?? (result.success ? 'completed' : 'failed')}`);
+    if (result.summary) parts.push(`Summary: ${result.summary}`);
+  }
+
+  if (files.length > 0) {
+    parts.push(`Files: ${files.length} modified`);
+  }
+
+  if (gitResult && !gitResult.skipped) {
+    parts.push('Git: committed');
+  }
+
+  const summary = parts.join(' | ');
+
+  const report = {
+    task,
+    path: pathName,
+    result,
+    filesModified: files,
+    gitResult,
+    timestamp: Date.now(),
+  };
+
+  console.log(`\n\x1b[1m${result?.success !== false ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
+
+  return { summary, reportJson: JSON.stringify(report) };
+}

package/src/node-types/build-context.ts

@@ -0,0 +1,65 @@
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { WeaverContext } from '../bot/types.js';
+
+/**
+ * Builds the knowledge bundle the AI needs for planning. Calls
+ * flow-weaver context authoring for the base knowledge, and
+ * appends target file sources for modify tasks.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Build Context
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with contextBundle (JSON)
+ * @output onFailure [hidden]
+ */
+export function weaverBuildContext(ctx: string): { ctx: string } {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { projectDir } = context.env;
+  const task = JSON.parse(context.taskJson!) as { mode?: string; targets?: string[] };
+  const sections: string[] = [];
+
+  try {
+    const ctxOutput = execFileSync('flow-weaver', ['context', 'authoring', '--profile', 'assistant'], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 30_000,
+      cwd: projectDir,
+    }).trim();
+    if (ctxOutput) sections.push(ctxOutput);
+  } catch {
+    sections.push('(flow-weaver context not available)');
+  }
+
+  if (task.mode === 'modify' && task.targets) {
+    for (const target of task.targets) {
+      const filePath = path.isAbsolute(target) ? target : path.resolve(projectDir, target);
+      try {
+        if (fs.existsSync(filePath)) {
+          const source = fs.readFileSync(filePath, 'utf-8');
+          sections.push(`## Current Source: ${target}\n\n\`\`\`typescript\n${source}\n\`\`\``);
+        }
+      } catch { /* skip unreadable files */ }
+    }
+  }
+
+  if (task.mode === 'create') {
+    try {
+      const templates = execFileSync('flow-weaver', ['list', 'templates'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10_000,
+        cwd: projectDir,
+      }).trim();
+      if (templates) sections.push(`## Available Templates\n\n${templates}`);
+    } catch { /* templates not available */ }
+  }
+
+  const bundle = sections.join('\n\n---\n\n');
+  console.log(`\x1b[36m→ Context bundle: ${bundle.length} chars\x1b[0m`);
+
+  context.contextBundle = bundle;
+  return { ctx: JSON.stringify(context) };
+}

package/src/node-types/detect-provider.ts

@@ -0,0 +1,77 @@
+import { execFileSync } from 'node:child_process';
+import type { WeaverConfig, WeaverEnv, ProviderInfo } from '../bot/types.js';
+
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+
+function whichSafe(cmd: string, cwd: string): string {
+  try {
+    return execFileSync(WHICH_CMD, [cmd], { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Auto-detect or resolve the configured AI provider.
+ * Assembles the WeaverEnv bundle from projectDir, config, and detected provider.
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Detect Provider
+ * @input projectDir [order:0] - Project root directory
+ * @input config [order:1] - Weaver configuration
+ * @output env [order:0] - Weaver environment bundle
+ * @output onFailure [hidden]
+ */
+export function weaverDetectProvider(projectDir: string, config: WeaverConfig): {
+  env: WeaverEnv;
+} {
+  const providerSetting = config.provider ?? 'auto';
+
+  let type: string;
+  let model: string | undefined;
+  let maxTokens: number | undefined;
+
+  if (typeof providerSetting === 'object') {
+    type = providerSetting.name;
+    model = providerSetting.model;
+    maxTokens = providerSetting.maxTokens;
+  } else if (providerSetting !== 'auto') {
+    type = providerSetting;
+  } else {
+    if ((globalThis as any).__fw_llm_provider__) {
+      type = 'platform';
+    } else if (process.env.ANTHROPIC_API_KEY) {
+      type = 'anthropic';
+    } else if (whichSafe('claude', projectDir)) {
+      type = 'claude-cli';
+    } else if (whichSafe('copilot', projectDir)) {
+      type = 'copilot-cli';
+    } else {
+      throw new Error(
+        'No AI provider found. Options:\n' +
+        '  1. Set ANTHROPIC_API_KEY environment variable\n' +
+        '  2. Install Claude CLI: https://docs.anthropic.com/claude-code\n' +
+        '  3. Install GitHub Copilot CLI: https://github.com/features/copilot',
+      );
+    }
+  }
+
+  const providerInfo: ProviderInfo = {
+    type: type as ProviderInfo['type'],
+    model: model ?? (type === 'anthropic' ? 'claude-sonnet-4-6' : undefined),
+    maxTokens: maxTokens ?? (type === 'anthropic' ? 4096 : undefined),
+    apiKey: type === 'anthropic' ? process.env.ANTHROPIC_API_KEY : undefined,
+  };
+
+  if (type === 'anthropic' && !providerInfo.apiKey) {
+    throw new Error('Provider is "anthropic" but ANTHROPIC_API_KEY is not set');
+  }
+
+  const label = providerInfo.model ? `${type} (${providerInfo.model})` : type;
+  console.log(`\x1b[36m→ Provider: ${label}\x1b[0m`);
+
+  return {
+    env: { projectDir, config, providerType: type, providerInfo },
+  };
+}

package/src/node-types/exec-validate-retry.ts

@@ -0,0 +1,170 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { WeaverContext } from '../bot/types.js';
+import { callAI, parseJsonResponse } from '../bot/ai-client.js';
+import { executeStep } from '../bot/step-executor.js';
+import { validateFiles } from '../bot/file-validator.js';
+import { auditEmit } from '../bot/audit-logger.js';
+
+/**
+ * Execute-validate-fix retry loop. Runs the plan, validates results,
+ * and if validation fails, asks the AI for fixes. Up to 3 attempts.
+ *
+ * @flowWeaver nodeType
+ * @label Execute & Validate
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with results (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function weaverExecValidateRetry(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+
+  if (!execute) {
+    context.resultJson = JSON.stringify({ success: true, stepsCompleted: 0, stepsTotal: 0 });
+    context.validationResultJson = '[]';
+    context.filesModified = '[]';
+    context.allValid = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { providerInfo: pInfo, projectDir } = env;
+  const maxAttempts = 3;
+  let currentPlan = JSON.parse(context.planJson!);
+  let allFilesModified: string[] = [];
+  let lastExecResult: Record<string, unknown> = {};
+  let lastValidation: Array<{ file: string; valid: boolean; errors: string[] }> = [];
+  let allValid = false;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    console.log(`\x1b[36m→ Attempt ${attempt}/${maxAttempts}\x1b[0m`);
+    auditEmit('step-start', { attempt, stepCount: currentPlan.steps?.length });
+
+    const execResult = await executePlanSteps(currentPlan, projectDir);
+    lastExecResult = execResult;
+    allFilesModified = [...new Set([...allFilesModified, ...execResult.filesModified])];
+    auditEmit('step-complete', { attempt, filesModified: execResult.filesModified, errors: execResult.errors });
+
+    const validation = await validateFiles(execResult.filesModified, projectDir);
+    lastValidation = validation;
+    allValid = validation.every(v => v.valid);
+    const errorCount = validation.filter(v => !v.valid).length;
+    auditEmit('validation-run', { attempt, allValid, errorCount });
+
+    // Collect design warnings from valid files
+    const designWarnings = validation
+      .filter(v => v.valid && v.warnings.length > 0)
+      .map(v => `${v.file}:\n${v.warnings.map(w => `  - ${w}`).join('\n')}`)
+      .join('\n');
+
+    if (allValid && !designWarnings) {
+      console.log('\x1b[32m→ All files valid, no design issues\x1b[0m');
+      break;
+    }
+
+    if (allValid && designWarnings) {
+      console.log('\x1b[32m→ All files valid\x1b[0m');
+      console.log(`\x1b[33m→ Design warnings:\n${designWarnings}\x1b[0m`);
+      // Design warnings don't block, but include them for the AI on the next attempt
+      if (attempt < maxAttempts) {
+        // Only retry for design issues if there are warning/error severity checks
+        const hasActionable = validation.some(v =>
+          v.designReport?.checks.some(c => c.severity === 'warning' || c.severity === 'error'),
+        );
+        if (!hasActionable) break;
+      } else {
+        break;
+      }
+    }
+
+    if (attempt < maxAttempts) {
+      console.log(`\x1b[33m→ Validation errors found, requesting fix plan...\x1b[0m`);
+      const validationErrors = validation.filter(v => !v.valid).map(v => `${v.file}: ${v.errors.join(', ')}`).join('\n');
+      const errors = [validationErrors, designWarnings].filter(Boolean).join('\n\nDesign issues:\n');
+
+      try {
+        auditEmit('fix-attempt', { attempt });
+
+        let systemPrompt: string;
+        try {
+          const mod = await import('../bot/system-prompt.js');
+          systemPrompt = await mod.buildSystemPrompt();
+        } catch {
+          systemPrompt = 'You are Weaver. Return ONLY valid JSON.';
+        }
+
+        const fixPrompt = `The following validation errors occurred:\n${errors}\n\nProvide a fix plan as JSON with steps and summary.`;
+
+        const text = await callAI(pInfo, systemPrompt, fixPrompt, 8192);
+
+        currentPlan = parseJsonResponse(text);
+        console.log(`\x1b[36m→ Fix plan: ${(currentPlan as { summary?: string }).summary ?? 'generated'}\x1b[0m`);
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\x1b[31m→ Fix planning failed: ${msg}\x1b[0m`);
+        break;
+      }
+    }
+  }
+
+  context.resultJson = JSON.stringify(lastExecResult);
+  context.validationResultJson = JSON.stringify(lastValidation);
+  context.filesModified = JSON.stringify(allFilesModified);
+  context.allValid = allValid;
+
+  return { onSuccess: allValid, onFailure: !allValid, ctx: JSON.stringify(context) };
+}
+
+async function executePlanSteps(
+  plan: { steps: Array<{ id: string; operation: string; description: string; args: Record<string, unknown> }> },
+  projectDir: string,
+): Promise<{ success: boolean; filesModified: string[]; errors: string[]; stepsCompleted: number; stepsTotal: number }> {
+  const filesModified: string[] = [];
+  const errors: string[] = [];
+  let completed = 0;
+  const steps = plan.steps ?? [];
+
+  for (const step of steps) {
+    const steering = checkSteeringSignal();
+    if (steering === 'cancel') {
+      errors.push(`Cancelled at step ${step.id}`);
+      break;
+    }
+
+    try {
+      const result = await executeStep(step, projectDir);
+      if (result.file) filesModified.push(result.file);
+      if (result.files) filesModified.push(...result.files);
+      completed++;
+      console.log(`\x1b[32m  + ${step.id}: ${step.description}\x1b[0m`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`${step.id}: ${msg}`);
+      console.error(`\x1b[31m  x ${step.id}: ${msg}\x1b[0m`);
+    }
+  }
+
+  return { success: errors.length === 0, filesModified: [...new Set(filesModified)], errors, stepsCompleted: completed, stepsTotal: steps.length };
+}
+
+function checkSteeringSignal(): 'cancel' | null {
+  try {
+    const controlPath = path.join(os.homedir(), '.weaver', 'control.json');
+    if (!fs.existsSync(controlPath)) return null;
+    const raw = fs.readFileSync(controlPath, 'utf-8');
+    fs.unlinkSync(controlPath);
+    const cmd = JSON.parse(raw) as { command: string };
+    if (cmd.command === 'cancel') return 'cancel';
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/node-types/execute-plan.ts

@@ -0,0 +1,130 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import type { WeaverEnv } from '../bot/types.js';
+import { executeStep } from '../bot/step-executor.js';
+
+/**
+ * Executes plan steps via the flow-weaver CLI. Checks steering
+ * between steps.
+ *
+ * @flowWeaver nodeType
+ * @label Execute Plan
+ * @input env [order:0] - Weaver environment bundle
+ * @input planJson [order:1] - Plan (JSON)
+ * @input taskJson [order:2] - Task (JSON)
+ * @output env [order:0] - Weaver environment bundle (pass-through)
+ * @output executionResultJson [order:1] - Execution result (JSON)
+ * @output taskJson [order:2] - Task (pass-through)
+ * @output filesModified [order:3] - Files modified (JSON array)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] - On Failure
+ */
+export async function weaverExecutePlan(
+  execute: boolean,
+  env: WeaverEnv,
+  planJson: string,
+  taskJson: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  env: WeaverEnv;
+  executionResultJson: string; taskJson: string; filesModified: string;
+}> {
+  if (!execute) {
+    return {
+      onSuccess: true, onFailure: false, env, taskJson,
+      executionResultJson: JSON.stringify({ success: true, stepsCompleted: 0, stepsTotal: 0, filesModified: [], filesCreated: [], errors: [], output: 'dry run' }),
+      filesModified: '[]',
+    };
+  }
+
+  const { projectDir } = env;
+  const plan = JSON.parse(planJson) as { steps: Array<{ id: string; operation: string; description: string; args: Record<string, unknown> }> };
+  const filesModified: string[] = [];
+  const filesCreated: string[] = [];
+  const errors: string[] = [];
+  const output: string[] = [];
+  let completed = 0;
+
+  const steeringCheck = checkSteering();
+  if (steeringCheck === 'cancel') {
+    return {
+      onSuccess: false, onFailure: true, env, taskJson,
+      executionResultJson: JSON.stringify({ success: false, stepsCompleted: 0, stepsTotal: plan.steps.length, filesModified: [], filesCreated: [], errors: ['Cancelled via steering'], output: '' }),
+      filesModified: '[]',
+    };
+  }
+
+  for (const step of plan.steps) {
+    const steering = checkSteering();
+    if (steering === 'cancel') {
+      output.push(`Cancelled at step ${step.id}`);
+      break;
+    }
+    if (steering === 'pause') {
+      console.log('\x1b[33m→ Paused. Waiting for resume...\x1b[0m');
+      await waitForResume();
+    }
+
+    try {
+      const result = await executeStep(step, projectDir);
+      if (result.file) {
+        if (result.created) filesCreated.push(result.file);
+        else filesModified.push(result.file);
+      }
+      completed++;
+      output.push(`${step.id}: ${step.description} - done`);
+      console.log(`\x1b[32m  + ${step.id}: ${step.description}\x1b[0m`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`${step.id}: ${msg}`);
+      output.push(`${step.id}: FAILED - ${msg}`);
+      console.error(`\x1b[31m  x ${step.id}: ${msg}\x1b[0m`);
+    }
+  }
+
+  const allFiles = [...new Set([...filesModified, ...filesCreated])];
+  const success = errors.length === 0;
+
+  return {
+    onSuccess: success, onFailure: !success, env, taskJson,
+    executionResultJson: JSON.stringify({
+      success, stepsCompleted: completed, stepsTotal: plan.steps.length,
+      filesModified, filesCreated, errors, output: output.join('\n'),
+    }),
+    filesModified: JSON.stringify(allFiles),
+  };
+}
+
+function checkSteering(): 'cancel' | 'pause' | null {
+  try {
+    const controlPath = path.join(os.homedir(), '.weaver', 'control.json');
+    if (!fs.existsSync(controlPath)) return null;
+    const raw = fs.readFileSync(controlPath, 'utf-8');
+    fs.unlinkSync(controlPath);
+    const cmd = JSON.parse(raw) as { command: string };
+    if (cmd.command === 'cancel') return 'cancel';
+    if (cmd.command === 'pause') return 'pause';
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function waitForResume(): Promise<void> {
+  const controlPath = path.join(os.homedir(), '.weaver', 'control.json');
+  while (true) {
+    await new Promise(r => setTimeout(r, 1000));
+    try {
+      if (fs.existsSync(controlPath)) {
+        const raw = fs.readFileSync(controlPath, 'utf-8');
+        fs.unlinkSync(controlPath);
+        const cmd = JSON.parse(raw) as { command: string };
+        if (cmd.command === 'resume' || cmd.command === 'cancel') {
+          console.log(`\x1b[36m→ ${cmd.command === 'resume' ? 'Resumed' : 'Cancelled'}\x1b[0m`);
+          return;
+        }
+      }
+    } catch { /* retry */ }
+  }
+}