let-them-talk 5.3.0 → 5.4.1

package/scripts/check-autonomy-v2-watchdog.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const SERVER_FILE = path.resolve(__dirname, '..', 'server.js');
+const {
+  classifyBlockedTaskPolicy,
+  classifyRetryPolicy,
+  classifyStalledWorkflowStepPolicy,
+  planWatchdogActions,
+} = require(path.resolve(__dirname, '..', 'autonomy', 'watchdog-policy.js'));
+const { resolveAgentDecisionContext } = require(path.resolve(__dirname, '..', 'autonomy', 'decision-v2.js'));
+const { resolveAgentContract } = require(path.resolve(__dirname, '..', 'agent-contracts.js'));
+
+function fail(lines, exitCode = 1) {
+  process.stderr.write(lines.join('\n') + '\n');
+  process.exit(exitCode);
+}
+
+function assert(condition, message, problems) {
+  if (!condition) problems.push(message);
+}
+
+function extractBlock(source, startAnchor, endAnchor) {
+  const startIndex = source.indexOf(startAnchor);
+  if (startIndex === -1) return '';
+  const endIndex = endAnchor ? source.indexOf(endAnchor, startIndex + startAnchor.length) : source.length;
+  if (endIndex === -1) return source.slice(startIndex);
+  return source.slice(startIndex, endIndex);
+}
+
+function isoFromMs(ms) {
+  return new Date(ms).toISOString();
+}
+
+function main() {
+  const problems = [];
+  const serverSource = fs.readFileSync(SERVER_FILE, 'utf8');
+  const watchdogBlock = extractBlock(serverSource, 'function watchdogCheck() {', '// --- Monitor Agent: system health check ---');
+  const updateTaskBlock = extractBlock(serverSource, 'function toolUpdateTask(taskId, status, notes = null, evidence = null) {', 'function toolListTasks(status = null, assignee = null) {');
+  const monitorBlock = extractBlock(serverSource, 'function monitorHealthCheck() {', '// --- Advisor Agent: strategic analysis ---');
+
+  assert(serverSource.includes("require('./autonomy/watchdog-policy')"), 'server.js must load the shared autonomy/watchdog policy helper.', problems);
+  assert(watchdogBlock.includes('const watchdogActions = planWatchdogActions({'), 'watchdogCheck() must derive actions from the shared watchdog policy planner.', problems);
+  assert(watchdogBlock.includes('canonicalState.setWorkflowStepPolicySignal({'), 'watchdogCheck() must persist workflow-step watchdog signals through canonical state helpers.', problems);
+  assert(watchdogBlock.includes("sourceTool: 'watchdog_policy'"), 'watchdogCheck() task transitions must identify the explicit watchdog policy source tool.', problems);
+  assert(!serverSource.includes('function reassignWorkFrom('), 'server.js must remove the old raw watchdog reassignment helper seam.', problems);
+  assert(!watchdogBlock.includes('step.assignee = replacement'), 'watchdogCheck() must no longer silently assign stalled workflow steps to a replacement agent.', problems);
+  assert(!watchdogBlock.includes('task.assignee = null; // Unassign so get_work can claim it'), 'watchdogCheck() must no longer mutate task claims through the old raw reassignment block.', problems);
+  assert(!monitorBlock.includes('task.assignee = freshAgents[0]'), 'monitorHealthCheck() must stop acting like a second scheduler by directly assigning fresh agents.', problems);
+  assert(updateTaskBlock.includes('const retryPolicy = status === \'pending\''), 'toolUpdateTask() must classify pending-task retry policy explicitly before mutating task state.', problems);
+  assert(updateTaskBlock.includes('classifyRetryPolicy({'), 'toolUpdateTask() must use the shared retry policy classifier.', problems);
+  assert(!updateTaskBlock.includes("task.status = 'blocked_permanent';"), 'toolUpdateTask() must not mutate blocked_permanent directly via the old raw circuit-breaker branch.', problems);
+
+  const interruptedReviewerContext = resolveAgentDecisionContext({
+    agentName: 'qa_agent',
+    branchId: 'main',
+    sessionSummary: { session_id: 'sess_qa', branch_id: 'main', state: 'interrupted', stale: true },
+    contract: resolveAgentContract({ role: 'quality', archetype: 'reviewer', skills: ['testing'] }),
+    agentRecord: { runtime_type: 'cli' },
+  });
+  const activeImageContext = resolveAgentDecisionContext({
+    agentName: 'media_bot',
+    branchId: 'main',
+    sessionSummary: { session_id: 'sess_media', branch_id: 'main', state: 'active', stale: false },
+    contract: resolveAgentContract({ archetype: 'implementer', skills: ['media'] }),
+    agentRecord: {
+      runtime_type: 'api',
+      provider_id: 'gemini',
+      model_id: 'gemini-image',
+      capabilities: ['image_generation'],
+    },
+  });
+
+  const retryPolicy = classifyRetryPolicy({
+    target: {
+      work_type: 'task',
+      title: 'Render launch poster',
+      description: 'Create the image asset for release day',
+      assigned: true,
+      required_capabilities: ['image_generation'],
+    },
+    context: interruptedReviewerContext,
+    attemptCount: 3,
+    ownerAlive: true,
+    idleMs: 0,
+  });
+  assert(retryPolicy.state === 'blocked_permanent', 'Retry policy must block permanently at the bounded attempt limit.', problems);
+  assert(retryPolicy.owner_state === 'session_interrupted', 'Retry policy must surface interrupted canonical session state explicitly.', problems);
+  assert(retryPolicy.capability_advisory && retryPolicy.capability_advisory.status === 'mismatch', 'Retry policy must keep provider/capability context visible instead of falling back to raw attempt counts only.', problems);
+
+  const blockedPolicy = classifyBlockedTaskPolicy({
+    target: {
+      work_type: 'task',
+      title: 'Recover blocked artifact pipeline',
+      description: 'Blocked build artifact repair task',
+      assigned: true,
+    },
+    context: interruptedReviewerContext,
+    attemptCount: 2,
+    ownerAlive: false,
+    idleMs: 0,
+    blockedAgeMs: 360000,
+  });
+  assert(blockedPolicy.signal === 'escalate', 'Blocked-task policy must produce an explicit escalation signal once the bounded window or retry threshold is crossed.', problems);
+  assert(blockedPolicy.classification === 'blocked_owner_unavailable', 'Blocked-task policy must classify unavailable owners explicitly from canonical session/aliveness context.', problems);
+
+  const checkinStepPolicy = classifyStalledWorkflowStepPolicy({
+    target: {
+      work_type: 'workflow_step',
+      title: 'Assemble release pack',
+      description: 'Launch workflow',
+      assigned: true,
+      required_capabilities: ['image_generation'],
+    },
+    context: activeImageContext,
+    ownerAlive: true,
+    idleMs: 0,
+    stepAgeMs: 960000,
+    resumeContext: {
+      dependency_evidence: [{ evidence: { evidence_ref: { evidence_id: 'ev_dep' } } }],
+      recent_evidence: [{ evidence: { evidence_ref: { evidence_id: 'ev_recent' } } }],
+    },
+  });
+  assert(checkinStepPolicy.signal === 'checkin', 'Stalled-step policy must request a bounded status check before a full escalation.', problems);
+  assert(checkinStepPolicy.dependency_evidence_count === 1 && checkinStepPolicy.recent_evidence_count === 1, 'Stalled-step policy must carry evidence context counts explicitly.', problems);
+
+  const unavailableStepPolicy = classifyStalledWorkflowStepPolicy({
+    target: {
+      work_type: 'workflow_step',
+      title: 'Finalize release',
+      description: 'Launch workflow',
+      assigned: true,
+    },
+    context: interruptedReviewerContext,
+    ownerAlive: false,
+    idleMs: 0,
+    stepAgeMs: 60000,
+  });
+  assert(unavailableStepPolicy.signal === 'escalate', 'Stalled-step policy must escalate immediately when the canonical owner is unavailable.', problems);
+  assert(unavailableStepPolicy.classification === 'step_owner_unavailable', 'Unavailable-step policy must be classified explicitly for follow-on 12C handling.', problems);
+
+  const nowMs = Date.UTC(2026, 3, 16, 12, 0, 0);
+  const watchdogActions = planWatchdogActions({
+    watchdogAgentName: 'alpha',
+    branchId: 'main',
+    nowMs,
+    agents: {
+      alpha: { branch: 'main', last_activity: isoFromMs(nowMs - 1000) },
+      bravo: { branch: 'main', last_activity: isoFromMs(nowMs - 360000), watchdog_nudged: nowMs - 240000 },
+      charlie: { branch: 'main', last_activity: isoFromMs(nowMs - 720000) },
+    },
+    tasks: [
+      {
+        id: 'task_blocked',
+        title: 'Blocked publish checklist',
+        description: 'Wait on blocked release dependency',
+        status: 'blocked',
+        assignee: 'bravo',
+        updated_at: isoFromMs(nowMs - 400000),
+        attempt_agents: ['alpha', 'bravo'],
+      },
+      {
+        id: 'task_claim',
+        title: 'Recover dead owner claim',
+        description: 'Resume from interrupted owner state',
+        status: 'in_progress',
+        assignee: 'charlie',
+        updated_at: isoFromMs(nowMs - 120000),
+        attempt_agents: ['charlie'],
+      },
+    ],
+    workflows: [{
+      id: 'wf_launch',
+      name: 'Launch workflow',
+      status: 'active',
+      steps: [{
+        id: 2,
+        description: 'Finalize release notes',
+        status: 'in_progress',
+        assignee: 'charlie',
+        started_at: isoFromMs(nowMs - 1900000),
+      }],
+    }],
+    resolveContext: (agentName) => {
+      if (agentName === 'bravo') return activeImageContext;
+      if (agentName === 'charlie') return interruptedReviewerContext;
+      return resolveAgentDecisionContext({
+        agentName,
+        branchId: 'main',
+        sessionSummary: { session_id: `sess_${agentName}`, branch_id: 'main', state: 'active', stale: false },
+        contract: resolveAgentContract({ archetype: 'generalist' }),
+        agentRecord: { runtime_type: 'cli' },
+      });
+    },
+    resolveStepResumeContext: () => ({
+      dependency_evidence: [{ evidence: { evidence_ref: { evidence_id: 'ev_dep' } } }],
+      recent_evidence: [],
+    }),
+    isAgentAlive: (agentName) => agentName !== 'charlie',
+  });
+
+  assert(watchdogActions.some((action) => action.kind === 'nudge_idle_hard' && action.agentName === 'bravo'), 'Watchdog planner must emit explicit hard-idle nudges deterministically.', problems);
+  assert(watchdogActions.some((action) => action.kind === 'escalate_blocked_task' && action.taskId === 'task_blocked'), 'Watchdog planner must escalate blocked tasks through explicit policy actions.', problems);
+  assert(watchdogActions.some((action) => action.kind === 'release_task_claim' && action.taskId === 'task_claim'), 'Watchdog planner must release interrupted/dead task claims without assigning a replacement.', problems);
+  assert(watchdogActions.some((action) => action.kind === 'signal_stalled_step' && action.workflowId === 'wf_launch' && action.signal === 'escalate'), 'Watchdog planner must surface stalled workflow steps as explicit escalation signals.', problems);
+  assert(!watchdogActions.some((action) => String(action.kind || '').includes('reassign')), 'Watchdog planner must not emit broad reassignment actions in the 12B policy-only slice.', problems);
+  assert(!watchdogActions.some((action) => String(action.kind || '').includes('assign')), 'Watchdog planner must not silently assign new owners in the 12B policy-only slice.', problems);
+
+  if (problems.length > 0) {
+    fail(['Autonomy-v2 watchdog policy validation failed.', ...problems.map((problem) => `- ${problem}`)]);
+  }
+
+  console.log([
+    'Autonomy-v2 watchdog policy validation passed.',
+    '- Watchdog and retry policy now flow through a shared classifier/planner instead of raw server-side mutation seams.',
+    '- Retry, blocked-task, and stalled-step decisions all carry explicit session, contract, capability, and evidence context.',
+    '- Dead/interrupted ownership now releases task claims or emits escalation signals without broad silent reassignment.',
+    '- Monitor health reporting consumes the same policy planner and no longer acts like a second scheduler.',
+  ].join('\n'));
+}
+
+main();

package/scripts/check-branch-fork-snapshot.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+const { createBranchPathResolvers } = require(path.resolve(__dirname, '..', 'state', 'canonical.js'));
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const SERVER_FILE = path.resolve(PACKAGE_ROOT, 'server.js');
+
+function fail(lines, exitCode = 1) {
+  fs.writeSync(2, lines.join('\n') + '\n');
+  process.exit(exitCode);
+}
+
+function stableSerialize(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableSerialize(entry)).join(',')}]`;
+  }
+
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(value[key])}`).join(',')}}`;
+  }
+
+  return JSON.stringify(value);
+}
+
+function deepEqual(actual, expected) {
+  return stableSerialize(actual) === stableSerialize(expected);
+}
+
+function toJsonl(rows) {
+  return rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : '');
+}
+
+function readJson(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const raw = fs.readFileSync(filePath, 'utf8').trim();
+  if (!raw) return [];
+  return raw.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+}
+
+async function callTool(client, name, args = {}) {
+  const result = await client.callTool({ name, arguments: args });
+  const text = Array.isArray(result.content)
+    ? result.content.map((entry) => (entry && entry.type === 'text' ? entry.text : '')).join('')
+    : '';
+
+  if (result.isError) {
+    throw new Error(`${name} failed: ${text || 'unknown error'}`);
+  }
+
+  return text ? JSON.parse(text) : {};
+}
+
+function createFixture() {
+  const evidenceRef = {
+    evidence_id: 'evidence-task4f-main',
+    branch_id: 'main',
+    recorded_at: '2026-04-16T00:00:05.000Z',
+    recorded_by_session: 'session-alpha-main',
+  };
+
+  return {
+    message: {
+      id: 'msg-task4f-main-1',
+      from: 'alpha',
+      to: 'beta',
+      content: 'Main branch snapshot seed',
+      timestamp: '2026-04-16T00:00:10.000Z',
+      reply_to: null,
+      system: false,
+    },
+    task: {
+      id: 'task-task4f-main',
+      title: 'Main branch fork snapshot task',
+      description: 'Task fixture that must copy into the forked branch snapshot.',
+      status: 'done',
+      assignee: 'alpha',
+      created_by: 'alpha',
+      created_at: '2026-04-16T00:00:00.000Z',
+      updated_at: '2026-04-16T00:00:05.000Z',
+      evidence_ref: evidenceRef,
+      notes: [],
+    },
+    workflow: {
+      id: 'wf-task4f-main',
+      name: 'Main branch fork snapshot workflow',
+      branch_id: 'main',
+      status: 'active',
+      autonomous: false,
+      parallel: false,
+      created_by: 'alpha',
+      created_at: '2026-04-16T00:00:00.000Z',
+      updated_at: '2026-04-16T00:00:05.000Z',
+      steps: [
+        {
+          id: 1,
+          description: 'Seeded workflow step',
+          assignee: 'alpha',
+          depends_on: [],
+          status: 'done',
+          started_at: '2026-04-16T00:00:00.000Z',
+          completed_at: '2026-04-16T00:00:05.000Z',
+          notes: '',
+          evidence_ref: evidenceRef,
+        },
+      ],
+    },
+    evidenceStore: {
+      schema_version: 1,
+      updated_at: '2026-04-16T00:00:05.000Z',
+      records: [
+        {
+          evidence_id: 'evidence-task4f-main',
+          subject_kind: 'completion',
+          branch_id: 'main',
+          task_id: 'task-task4f-main',
+          workflow_id: 'wf-task4f-main',
+          step_id: 1,
+          notes: 'Seeded branch-local evidence',
+          summary: 'Validated seeded fork snapshot state.',
+          verification: 'Manual temp-runtime inspection',
+          files_changed: ['agent-bridge/server.js'],
+          confidence: 95,
+          learnings: 'Fork snapshots should preserve task/workflow evidence context.',
+          flagged: false,
+          flag_reason: null,
+          recorded_at: '2026-04-16T00:00:05.000Z',
+          recorded_by: 'alpha',
+          recorded_by_session: 'session-alpha-main',
+          source_tool: 'check-branch-fork-snapshot',
+        },
+      ],
+    },
+    workspaces: {
+      alpha: {
+        draft: { content: 'Main branch workspace note' },
+        retry_history: [],
+      },
+    },
+  };
+}
+
+async function runValidation() {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'letthemtalk-fork-snapshot-'));
+  const dataDir = path.join(tempRoot, '.agent-bridge');
+  const branchPaths = createBranchPathResolvers(dataDir);
+  const fixture = createFixture();
+  const problems = [];
+  let transport = null;
+
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(branchPaths.getMessagesFile('main'), toJsonl([fixture.message]));
+    fs.writeFileSync(branchPaths.getHistoryFile('main'), toJsonl([fixture.message]));
+    fs.writeFileSync(branchPaths.getTasksFile('main'), JSON.stringify([fixture.task], null, 2));
+    fs.writeFileSync(branchPaths.getWorkflowsFile('main'), JSON.stringify([fixture.workflow], null, 2));
+    fs.writeFileSync(branchPaths.getEvidenceFile('main'), JSON.stringify(fixture.evidenceStore, null, 2));
+    fs.mkdirSync(branchPaths.getWorkspacesDir('main'), { recursive: true });
+    for (const [agentName, workspace] of Object.entries(fixture.workspaces)) {
+      fs.writeFileSync(branchPaths.getWorkspaceFile(agentName, 'main'), JSON.stringify(workspace, null, 2));
+    }
+
+    const client = new Client({ name: 'branch-fork-validator', version: '1.0.0' });
+    transport = new StdioClientTransport({
+      command: process.execPath,
+      args: [SERVER_FILE],
+      cwd: PACKAGE_ROOT,
+      env: {
+        AGENT_BRIDGE_DATA_DIR: dataDir,
+      },
+      stderr: 'pipe',
+    });
+
+    await client.connect(transport);
+    await client.listTools();
+
+    await callTool(client, 'register', { name: 'alpha', provider: 'Verifier' });
+    const forkResult = await callTool(client, 'fork_conversation', { branch_name: 'feature_task4f' });
+
+    if (!forkResult.success || forkResult.branch !== 'feature_task4f') {
+      problems.push('fork_conversation must create and switch into the target feature_task4f branch.');
+    }
+
+    const forkMessages = readJsonl(branchPaths.getMessagesFile('feature_task4f'));
+    const forkHistory = readJsonl(branchPaths.getHistoryFile('feature_task4f'));
+    const forkTasks = readJson(branchPaths.getTasksFile('feature_task4f'), []);
+    const forkWorkflows = readJson(branchPaths.getWorkflowsFile('feature_task4f'), []);
+    const forkEvidence = readJson(branchPaths.getEvidenceFile('feature_task4f'), null);
+    const forkWorkspace = readJson(branchPaths.getWorkspaceFile('alpha', 'feature_task4f'), {});
+
+    const expectedForkTask = {
+      ...fixture.task,
+      evidence_ref: {
+        ...fixture.task.evidence_ref,
+        branch_id: 'feature_task4f',
+      },
+    };
+
+    const expectedForkWorkflow = {
+      ...fixture.workflow,
+      branch_id: 'feature_task4f',
+      steps: fixture.workflow.steps.map((step) => ({
+        ...step,
+        evidence_ref: {
+          ...step.evidence_ref,
+          branch_id: 'feature_task4f',
+        },
+      })),
+    };
+
+    const expectedForkEvidence = {
+      ...fixture.evidenceStore,
+      records: fixture.evidenceStore.records.map((record) => ({
+        ...record,
+        branch_id: 'feature_task4f',
+      })),
+    };
+
+    if (forkMessages.length !== 0) {
+      problems.push('Forked branch messages projection must start empty after the snapshot copy.');
+    }
+
+    if (!deepEqual(forkHistory, [fixture.message])) {
+      problems.push('Forked branch history must preserve the visible main-branch conversation snapshot.');
+    }
+
+    if (!deepEqual(forkTasks, [expectedForkTask])) {
+      problems.push('Forked branch tasks must copy the source branch task snapshot and remap embedded branch references.');
+    }
+
+    if (!deepEqual(forkWorkflows, [expectedForkWorkflow])) {
+      problems.push('Forked branch workflows must copy the source branch workflow snapshot and remap branch_id fields to the fork.');
+    }
+
+    if (!deepEqual(forkEvidence, expectedForkEvidence)) {
+      problems.push('Forked branch evidence store must copy historical evidence context and remap branch_id fields to the fork.');
+    }
+
+    if (!deepEqual(forkWorkspace, fixture.workspaces.alpha)) {
+      problems.push('Forked branch workspaces must copy the source branch workspace snapshot.');
+    }
+
+    await callTool(client, 'create_task', {
+      title: 'Fork-only branch task',
+      description: 'Verifies post-fork task divergence stays branch-local.',
+    });
+    await callTool(client, 'create_workflow', {
+      name: 'Fork-only branch workflow',
+      steps: ['Fork-only step', 'Fork-only follow-up'],
+      autonomous: false,
+      parallel: false,
+    });
+    await callTool(client, 'workspace_write', {
+      key: 'fork_note',
+      content: 'Fork-only workspace note',
+    });
+
+    const mainTasksAfterForkWrites = readJson(branchPaths.getTasksFile('main'), []);
+    const mainWorkflowsAfterForkWrites = readJson(branchPaths.getWorkflowsFile('main'), []);
+    const forkTasksAfterWrites = readJson(branchPaths.getTasksFile('feature_task4f'), []);
+    const forkWorkflowsAfterWrites = readJson(branchPaths.getWorkflowsFile('feature_task4f'), []);
+    const mainWorkspaceAfterForkWrites = readJson(branchPaths.getWorkspaceFile('alpha', 'main'), {});
+    const forkWorkspaceAfterWrites = readJson(branchPaths.getWorkspaceFile('alpha', 'feature_task4f'), {});
+
+    if (!deepEqual(mainTasksAfterForkWrites, [fixture.task])) {
+      problems.push('Fork-local task writes must not mutate the source branch task snapshot.');
+    }
+
+    if (!deepEqual(mainWorkflowsAfterForkWrites, [fixture.workflow])) {
+      problems.push('Fork-local workflow writes must not mutate the source branch workflow snapshot.');
+    }
+
+    if (!(Array.isArray(forkTasksAfterWrites) && forkTasksAfterWrites.length === 2)) {
+      problems.push('Fork-local task writes must append only inside the forked branch task projection.');
+    }
+
+    if (!(Array.isArray(forkWorkflowsAfterWrites) && forkWorkflowsAfterWrites.length === 2)) {
+      problems.push('Fork-local workflow writes must append only inside the forked branch workflow projection.');
+    }
+
+    if (!deepEqual(mainWorkspaceAfterForkWrites, fixture.workspaces.alpha)) {
+      problems.push('Fork-local workspace writes must not mutate the source branch workspace snapshot.');
+    }
+
+    if (!(forkWorkspaceAfterWrites && forkWorkspaceAfterWrites.fork_note && forkWorkspaceAfterWrites.fork_note.content === 'Fork-only workspace note')) {
+      problems.push('Fork-local workspace writes must persist only inside the forked branch workspace projection.');
+    }
+  } finally {
+    if (transport) {
+      try {
+        await transport.close();
+      } catch {}
+    }
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+
+  return problems;
+}
+
+async function main() {
+  const problems = await runValidation();
+
+  if (problems.length > 0) {
+    fail([
+      'Branch fork snapshot validation failed.',
+      'Violations:',
+      ...problems.map((problem) => `- ${problem}`),
+    ], 1);
+  }
+
+  console.log([
+    'Branch fork snapshot validation passed.',
+    'Validated fork-time history/message reset plus branch-local task/workflow/evidence/workspace snapshot copying and post-fork divergence.',
+  ].join('\n'));
+}
+
+main().catch((error) => {
+  fail([
+    'Branch fork snapshot validation failed.',
+    `Unhandled error: ${error && error.message ? error.message : String(error)}`,
+  ], 1);
+});