vibeman 0.0.9 → 0.0.11

package/dist/scripts/lib/test-fixtures.mjs

@@ -0,0 +1,901 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(moduleDir, '..', '..');
+
+const DEFAULT_CODEX_MODEL = 'gpt-5.3-codex';
+const LOW_COST_GEMINI_MODEL = 'gemini-3-flash-preview';
+const LOW_COST_CLAUDE_MODEL = 'claude-haiku';
+
+const EXECUTOR_IDS = {
+  CODEX_PING: 'executor_fixture_codex_mini_ping',
+  CODEX_FIX: 'executor_fixture_codex_mini_fix',
+  CODEX_FORCED_FAIL: 'executor_fixture_codex_mini_forced_fail',
+  CLAUDE_PING: 'executor_fixture_claude_haiku_ping',
+  GEMINI_PING: 'executor_fixture_gemini_flash_lite_ping',
+  SHELL_SUCCESS: 'executor_fixture_shell_success',
+  SHELL_LONG_RUNNING: 'executor_fixture_shell_long_running',
+  SHELL_FAIL_ALWAYS: 'executor_fixture_shell_fail_always',
+  SHELL_FAIL_ONCE: 'executor_fixture_shell_fail_once',
+  SHELL_RESTART_GATE: 'executor_fixture_shell_restart_gate',
+  SHELL_RANDOM_REVIEW: 'executor_fixture_shell_random_review',
+  SHELL_NOISY_LOGS: 'executor_fixture_shell_noisy_logs',
+  HUMAN_GATE: 'executor_fixture_human_gate',
+};
+
+const WORKFLOW_IDS = {
+  T00_CONN_CODEX_BASIC: 'workflow_test_t00_conn_codex_basic',
+  T01_CONN_CLAUDE_BASIC: 'workflow_test_t01_conn_claude_basic',
+  T02_CONN_GEMINI_BASIC: 'workflow_test_t02_conn_gemini_basic',
+  T03_CROSS_AGENT_HANDOFF: 'workflow_test_t03_cross_agent_handoff',
+  T04_CROSS_AGENT_REVIEW_HANDOFF: 'workflow_test_t04_cross_agent_review_handoff',
+  T10_LONG_RUNNING_CANCEL: 'workflow_test_t10_t11_t14_long_running_cancel',
+  T12_PAUSE_RESUME_GATE: 'workflow_test_t12_t15_pause_resume_gate',
+  T13_RESTART_MARKER: 'workflow_test_t13_restart_marker',
+  T17_RETRY_EXHAUSTED: 'workflow_test_t17_retry_exhausted',
+  T19_THREAD_REUSE: 'workflow_test_t19_thread_reuse',
+  T30_LIFECYCLE_HAPPY_MERGED: 'workflow_test_t30_lifecycle_happy_merged',
+  T31_FAILURE_RECOVERY_MERGED: 'workflow_test_t31_failure_recovery_merged',
+  T32_REVIEW_RANDOMNESS_MERGED: 'workflow_test_t32_review_randomness_merged',
+  T33_OBSERVABILITY_MERGED: 'workflow_test_t33_observability_merged',
+};
+
+function makeAgentExecutor({ id, name, provider, model, prompt, tags }) {
+  return {
+    id,
+    name,
+    type: 'coding_agent',
+    config: {
+      provider,
+      model,
+      permissionMode: 'full-auto',
+      systemPrompt:
+        'You are running a vibeman workflow fixture. Keep responses short and deterministic.',
+      prompt,
+      includeTaskFile: false,
+      includeRawContextJson: false,
+      includeFailureContract: false,
+      promptMode: 'full',
+      ...(provider === 'codex-cli' ? { agentThreadOptions: { modelReasoningEffort: 'low' } } : {}),
+    },
+    tags: ['fixture', 'test', ...tags],
+  };
+}
+
+function makeShellExecutor({ id, name, commands, tags }) {
+  return {
+    id,
+    name,
+    type: 'shell',
+    config: { commands },
+    tags: ['fixture', 'test', ...tags],
+  };
+}
+
+export const TEST_FIXTURE_EXECUTORS = [
+  makeAgentExecutor({
+    id: EXECUTOR_IDS.CODEX_PING,
+    name: 'Fixture Codex Ping',
+    provider: 'codex-cli',
+    model: DEFAULT_CODEX_MODEL,
+    prompt: 'Output exactly one line: FIXTURE_OK_CODEX',
+    tags: ['codex', 'connectivity'],
+  }),
+  makeAgentExecutor({
+    id: EXECUTOR_IDS.CODEX_FIX,
+    name: 'Fixture Codex Fix',
+    provider: 'codex-cli',
+    model: DEFAULT_CODEX_MODEL,
+    prompt: 'Output exactly one line: FIXTURE_FIX_APPLIED',
+    tags: ['codex'],
+  }),
+  makeAgentExecutor({
+    id: EXECUTOR_IDS.CODEX_FORCED_FAIL,
+    name: 'Fixture Codex Forced Fail',
+    provider: 'codex-cli',
+    model: DEFAULT_CODEX_MODEL,
+    prompt:
+      'Respond exactly with this JSON and nothing else: {"vibeman_task_result": {"success": false, "reason": "Intentional failure for retry exhaustion fixture"}}',
+    tags: ['codex', 'failure'],
+  }),
+  makeAgentExecutor({
+    id: EXECUTOR_IDS.CLAUDE_PING,
+    name: 'Fixture Claude Haiku Ping',
+    provider: 'claude-code',
+    model: LOW_COST_CLAUDE_MODEL,
+    prompt: 'Output exactly one line: FIXTURE_OK_CLAUDE',
+    tags: ['claude', 'connectivity'],
+  }),
+  makeAgentExecutor({
+    id: EXECUTOR_IDS.GEMINI_PING,
+    name: 'Fixture Gemini Flash-Lite Ping',
+    provider: 'gemini-cli',
+    model: LOW_COST_GEMINI_MODEL,
+    prompt: 'Output exactly one line: FIXTURE_OK_GEMINI',
+    tags: ['gemini', 'connectivity'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_SUCCESS,
+    name: 'Fixture Shell Success',
+    commands: [
+      'echo "fixture shell success"',
+      'test -n "$VIBEMAN_TASK_PATH"',
+      'test -f "$VIBEMAN_TASK_PATH"',
+      'echo "task file verified: $VIBEMAN_TASK_PATH"',
+    ],
+    tags: ['shell', 'success'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_LONG_RUNNING,
+    name: 'Fixture Shell Long Running',
+    commands: ['node -e "setTimeout(() => console.log(\'fixture long-running done\'), 30000)"'],
+    tags: ['shell', 'cancel'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_FAIL_ALWAYS,
+    name: 'Fixture Shell Fail Always',
+    commands: ['node -e "console.error(\'fixture forced failure\'); process.exit(1)"'],
+    tags: ['shell', 'failure'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_FAIL_ONCE,
+    name: 'Fixture Shell Fail Once',
+    commands: [
+      "node -e \"const fs=require('node:fs'); const d='.vibeman/.fixtures'; const p=d+'/retry-once.marker'; fs.mkdirSync(d,{recursive:true}); if (fs.existsSync(p)) { console.log('retry-once-pass'); process.exit(0); } fs.writeFileSync(p,'1'); console.error('retry-once-fail'); process.exit(1);\"",
+    ],
+    tags: ['shell', 'retry'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_RESTART_GATE,
+    name: 'Fixture Shell Restart Gate',
+    commands: [
+      "node -e \"const fs=require('node:fs'); const d='.vibeman/.fixtures'; const p=d+'/restart-gate.marker'; fs.mkdirSync(d,{recursive:true}); if (fs.existsSync(p)) { console.log('restart-gate-pass'); process.exit(0); } fs.writeFileSync(p,'1'); console.error('restart-gate-first-run-fail'); process.exit(1);\"",
+    ],
+    tags: ['shell', 'restart'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_RANDOM_REVIEW,
+    name: 'Fixture Shell Random Review',
+    commands: [
+      "node -e \"const ok=Math.random()>=0.5; if (ok) { console.log('review-approve'); process.exit(0); } console.error('review-reject'); process.exit(1);\"",
+    ],
+    tags: ['shell', 'review', 'random'],
+  }),
+  makeShellExecutor({
+    id: EXECUTOR_IDS.SHELL_NOISY_LOGS,
+    name: 'Fixture Shell Noisy Logs',
+    commands: [
+      "node -e \"console.log('stdout-line-1'); console.error('stderr-line-1'); console.log('stdout-line-2'); console.error('stderr-line-2')\"",
+    ],
+    tags: ['shell', 'logs'],
+  }),
+  {
+    id: EXECUTOR_IDS.HUMAN_GATE,
+    name: 'Fixture Human Gate',
+    type: 'human_input',
+    config: {
+      message: 'Fixture human checkpoint: provide approval to continue.',
+    },
+    tags: ['fixture', 'test', 'human'],
+  },
+];
+
+function node(
+  nodeKey,
+  executorId,
+  {
+    next = null,
+    onFailure = null,
+    maxRetry = 0,
+    timeoutMs = 120000,
+    nodeConfig = {},
+    routes = undefined,
+  } = {},
+) {
+  return {
+    nodeKey,
+    executorId,
+    nodeConfig,
+    transitionMap: {
+      next,
+      onFailure,
+      ...(routes ? { routes } : {}),
+    },
+    maxRetry,
+    timeoutMs,
+  };
+}
+
+function workflow({ id, name, description, startNodeKey, nodes }) {
+  return {
+    id,
+    name,
+    type: 'test',
+    tag: 'test-fixture',
+    description,
+    startNodeKey,
+    nodes,
+  };
+}
+
+export const TEST_FIXTURE_WORKFLOWS = [
+  workflow({
+    id: WORKFLOW_IDS.T00_CONN_CODEX_BASIC,
+    name: 'T00 Connectivity: Codex Basic',
+    description: 'Basic codex-cli connectivity using low-cost codex mini model.',
+    startNodeKey: 'connect_codex',
+    nodes: [node('connect_codex', EXECUTOR_IDS.CODEX_PING)],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T01_CONN_CLAUDE_BASIC,
+    name: 'T01 Connectivity: Claude Basic',
+    description: 'Basic claude-code connectivity using low-cost haiku model.',
+    startNodeKey: 'connect_claude',
+    nodes: [node('connect_claude', EXECUTOR_IDS.CLAUDE_PING)],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T02_CONN_GEMINI_BASIC,
+    name: 'T02 Connectivity: Gemini Basic',
+    description: 'Basic gemini-cli connectivity using low-cost flash-lite model.',
+    startNodeKey: 'connect_gemini',
+    nodes: [node('connect_gemini', EXECUTOR_IDS.GEMINI_PING)],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T03_CROSS_AGENT_HANDOFF,
+    name: 'T03 Cross Agent Handoff',
+    description: 'Codex step followed by Claude step to validate cross-provider handoff.',
+    startNodeKey: 'codex_step',
+    nodes: [
+      node('codex_step', EXECUTOR_IDS.CODEX_PING, { next: 'claude_step' }),
+      node('claude_step', EXECUTOR_IDS.CLAUDE_PING),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T04_CROSS_AGENT_REVIEW_HANDOFF,
+    name: 'T04 Cross Agent Review Handoff',
+    description:
+      'Codex step followed by Gemini review step to validate handoff and provider change.',
+    startNodeKey: 'codex_step',
+    nodes: [
+      node('codex_step', EXECUTOR_IDS.CODEX_PING, { next: 'gemini_review' }),
+      node('gemini_review', EXECUTOR_IDS.GEMINI_PING),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T10_LONG_RUNNING_CANCEL,
+    name: 'T10/T11/T14 Long Running Cancel Fixture',
+    description: 'Long-running shell node for run/node cancel behavior validation.',
+    startNodeKey: 'long_running',
+    nodes: [node('long_running', EXECUTOR_IDS.SHELL_LONG_RUNNING, { timeoutMs: 90000 })],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T12_PAUSE_RESUME_GATE,
+    name: 'T12/T15 Pause Resume Gate',
+    description: 'Pause on human input then continue to completion.',
+    startNodeKey: 'prepare',
+    nodes: [
+      node('prepare', EXECUTOR_IDS.CODEX_PING, { next: 'await_input' }),
+      node('await_input', EXECUTOR_IDS.HUMAN_GATE, {
+        next: 'finalize',
+        onFailure: 'finalize',
+      }),
+      node('finalize', EXECUTOR_IDS.SHELL_SUCCESS),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T13_RESTART_MARKER,
+    name: 'T13 Restart Marker',
+    description: 'First run fails, restart succeeds due marker file.',
+    startNodeKey: 'restart_gate',
+    nodes: [node('restart_gate', EXECUTOR_IDS.SHELL_RESTART_GATE)],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T17_RETRY_EXHAUSTED,
+    name: 'T17 Retry Exhausted',
+    description: 'Codex node intentionally reports failure to test retry exhaustion behavior.',
+    startNodeKey: 'failing_codex',
+    nodes: [
+      node('failing_codex', EXECUTOR_IDS.CODEX_FORCED_FAIL, {
+        next: null,
+        onFailure: 'fallback_if_retry_allowed',
+        maxRetry: 1,
+      }),
+      node('fallback_if_retry_allowed', EXECUTOR_IDS.CODEX_PING),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T19_THREAD_REUSE,
+    name: 'T19 Thread Reuse',
+    description: 'Codex -> human pause -> codex to validate resume and thread reuse behavior.',
+    startNodeKey: 'codex_first',
+    nodes: [
+      node('codex_first', EXECUTOR_IDS.CODEX_PING, { next: 'await_input' }),
+      node('await_input', EXECUTOR_IDS.HUMAN_GATE, {
+        next: 'codex_second',
+        onFailure: 'codex_second',
+      }),
+      node('codex_second', EXECUTOR_IDS.CODEX_FIX),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T30_LIFECYCLE_HAPPY_MERGED,
+    name: 'T30 Lifecycle Happy Merged',
+    description: 'Merged happy-path fixture for pause/resume, retry-once, and final completion.',
+    startNodeKey: 'kickoff',
+    nodes: [
+      node('kickoff', EXECUTOR_IDS.CODEX_PING, { next: 'await_input' }),
+      node('await_input', EXECUTOR_IDS.HUMAN_GATE, {
+        next: 'retry_once',
+        onFailure: 'retry_once',
+      }),
+      node('retry_once', EXECUTOR_IDS.SHELL_FAIL_ONCE, {
+        next: 'emit_logs',
+        onFailure: 'retry_once',
+        maxRetry: 2,
+      }),
+      node('emit_logs', EXECUTOR_IDS.SHELL_NOISY_LOGS, { next: 'done' }),
+      node('done', EXECUTOR_IDS.SHELL_SUCCESS),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T31_FAILURE_RECOVERY_MERGED,
+    name: 'T31 Failure Recovery Merged',
+    description:
+      'Merged failure-recovery fixture for transient failure, fallback, and codex finalize.',
+    startNodeKey: 'transient_retry',
+    nodes: [
+      node('transient_retry', EXECUTOR_IDS.SHELL_FAIL_ONCE, {
+        next: 'fail_to_fallback',
+        onFailure: 'transient_retry',
+        maxRetry: 2,
+      }),
+      node('fail_to_fallback', EXECUTOR_IDS.SHELL_FAIL_ALWAYS, {
+        next: 'done',
+        onFailure: 'fallback_success',
+        maxRetry: 2,
+      }),
+      node('fallback_success', EXECUTOR_IDS.SHELL_SUCCESS, { next: 'codex_finalize' }),
+      node('codex_finalize', EXECUTOR_IDS.CODEX_FIX),
+      node('done', EXECUTOR_IDS.SHELL_SUCCESS),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T32_REVIEW_RANDOMNESS_MERGED,
+    name: 'T32 Review Randomness Merged',
+    description: 'Random review outcomes with codex fix loop to validate branch behavior.',
+    startNodeKey: 'implement',
+    nodes: [
+      node('implement', EXECUTOR_IDS.CODEX_PING, { next: 'review_random' }),
+      node('review_random', EXECUTOR_IDS.SHELL_RANDOM_REVIEW, {
+        next: 'finalize',
+        onFailure: 'fix',
+        maxRetry: 2,
+      }),
+      node('fix', EXECUTOR_IDS.CODEX_FIX, { next: 'review_random' }),
+      node('finalize', EXECUTOR_IDS.SHELL_SUCCESS),
+    ],
+  }),
+  workflow({
+    id: WORKFLOW_IDS.T33_OBSERVABILITY_MERGED,
+    name: 'T33 Observability Merged',
+    description: 'Codex + noisy shell logs for usage/log validation in one run.',
+    startNodeKey: 'codex_start',
+    nodes: [
+      node('codex_start', EXECUTOR_IDS.CODEX_PING, { next: 'noisy_logs' }),
+      node('noisy_logs', EXECUTOR_IDS.SHELL_NOISY_LOGS, { next: 'done' }),
+      node('done', EXECUTOR_IDS.SHELL_SUCCESS),
+    ],
+  }),
+];
+
+function makeTask({
+  id,
+  title,
+  workflowId,
+  tags,
+  goal,
+  context,
+  requirements,
+  notes,
+  steps,
+  acceptance,
+}) {
+  return {
+    id,
+    title,
+    workflowId,
+    type: 'test',
+    status: 'backlog',
+    priority: 'low',
+    tags,
+    goal,
+    context,
+    requirements,
+    notes,
+    steps,
+    acceptance,
+  };
+}
+
+export const TEST_FIXTURE_TASKS = [
+  makeTask({
+    id: 'test-t00-conn-codex-basic',
+    title: 'T00 Connectivity Codex Basic',
+    workflowId: WORKFLOW_IDS.T00_CONN_CODEX_BASIC,
+    tags: ['fixture', 'workflow', 'codex', 'connectivity'],
+    goal: 'Validate codex-cli can run a minimal workflow step with default codex model settings.',
+    context: 'Use this as the first sanity check before any other fixture execution.',
+    requirements: [
+      'Start the workflow successfully.',
+      'Node output indicates codex connectivity passed.',
+    ],
+    notes: [
+      'No repository edits are required.',
+      'Expected to finish quickly and deterministically.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t00_conn_codex_basic` for this task.',
+      'Confirm run status becomes `completed`.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Terminal logs contain `FIXTURE_OK_CODEX`.'],
+  }),
+  makeTask({
+    id: 'test-t01-conn-claude-basic',
+    title: 'T01 Connectivity Claude Basic',
+    workflowId: WORKFLOW_IDS.T01_CONN_CLAUDE_BASIC,
+    tags: ['fixture', 'workflow', 'claude', 'connectivity'],
+    goal: 'Validate claude-code can run a minimal workflow step.',
+    context: 'Nightly connectivity coverage for non-codex provider.',
+    requirements: [
+      'Start the workflow successfully.',
+      'Node output indicates claude connectivity passed.',
+    ],
+    notes: ['Keep this as a minimal one-step smoke check.', 'Use low-cost Claude model.'],
+    steps: [
+      'Start workflow `workflow_test_t01_conn_claude_basic`.',
+      'Confirm run completes and output is present.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Terminal logs contain `FIXTURE_OK_CLAUDE`.'],
+  }),
+  makeTask({
+    id: 'test-t02-conn-gemini-basic',
+    title: 'T02 Connectivity Gemini Basic',
+    workflowId: WORKFLOW_IDS.T02_CONN_GEMINI_BASIC,
+    tags: ['fixture', 'workflow', 'gemini', 'connectivity'],
+    goal: 'Validate gemini-cli can run a minimal workflow step.',
+    context: 'Nightly connectivity coverage for non-codex provider.',
+    requirements: [
+      'Start the workflow successfully.',
+      'Node output indicates gemini connectivity passed.',
+    ],
+    notes: ['Keep this as a minimal one-step smoke check.', 'Use low-cost Gemini model.'],
+    steps: [
+      'Start workflow `workflow_test_t02_conn_gemini_basic`.',
+      'Confirm run completes and output is present.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Terminal logs contain `FIXTURE_OK_GEMINI`.'],
+  }),
+  makeTask({
+    id: 'test-t03-cross-agent-handoff',
+    title: 'T03 Cross Agent Handoff',
+    workflowId: WORKFLOW_IDS.T03_CROSS_AGENT_HANDOFF,
+    tags: ['fixture', 'workflow', 'cross-agent'],
+    goal: 'Validate codex-to-claude handoff works in one workflow.',
+    context: 'Covers provider switch in sequential nodes.',
+    requirements: ['Both nodes execute in order.', 'Run completes without manual intervention.'],
+    notes: ['No code edits required.', 'Focus on provider transition stability.'],
+    steps: [
+      'Start workflow `workflow_test_t03_cross_agent_handoff`.',
+      'Verify both node logs are present.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Logs include both codex and claude outputs.'],
+  }),
+  makeTask({
+    id: 'test-t04-cross-agent-review-handoff',
+    title: 'T04 Cross Agent Review Handoff',
+    workflowId: WORKFLOW_IDS.T04_CROSS_AGENT_REVIEW_HANDOFF,
+    tags: ['fixture', 'workflow', 'cross-agent', 'review'],
+    goal: 'Validate codex-to-gemini handoff in a review-like sequence.',
+    context: 'Covers second cross-agent path used for review routing checks.',
+    requirements: ['Codex node runs first.', 'Gemini node runs after codex node.'],
+    notes: ['Keep output short and deterministic.', 'This is a handoff verification fixture.'],
+    steps: [
+      'Start workflow `workflow_test_t04_cross_agent_review_handoff`.',
+      'Confirm node execution order in timeline.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Timeline shows codex then gemini.'],
+  }),
+  makeTask({
+    id: 'test-t10-run-cancel-pending',
+    title: 'T10 Run Cancel Pending',
+    workflowId: WORKFLOW_IDS.T10_LONG_RUNNING_CANCEL,
+    tags: ['fixture', 'workflow', 'cancel', 'run'],
+    goal: 'Validate run-level cancel works when cancel is triggered immediately after start.',
+    context: 'Use long-running shell node so cancel window is easy to hit.',
+    requirements: [
+      'Run starts and enters active state.',
+      'Cancel action moves run to terminal cancelled state.',
+    ],
+    notes: [
+      'Trigger cancel quickly after start.',
+      'Same workflow is reused for running/node cancel tests.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t10_t11_t14_long_running_cancel`.',
+      'Immediately click run cancel.',
+    ],
+    acceptance: ['Run status becomes `cancelled`.', 'No extra downstream nodes run.'],
+  }),
+  makeTask({
+    id: 'test-t11-run-cancel-running',
+    title: 'T11 Run Cancel Running',
+    workflowId: WORKFLOW_IDS.T10_LONG_RUNNING_CANCEL,
+    tags: ['fixture', 'workflow', 'cancel', 'run'],
+    goal: 'Validate run-level cancel during active execution.',
+    context: 'Cancel after node is clearly in running state.',
+    requirements: ['Node starts running.', 'Cancel stops run and marks it terminal.'],
+    notes: ['Wait until running state is visible.', 'Cancel should stop the active node.'],
+    steps: [
+      'Start workflow `workflow_test_t10_t11_t14_long_running_cancel`.',
+      'Cancel when node state is `running`.',
+    ],
+    acceptance: [
+      'Run status becomes `cancelled`.',
+      'Node does not continue to natural completion.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t12-run-resume-paused',
+    title: 'T12 Run Resume Paused',
+    workflowId: WORKFLOW_IDS.T12_PAUSE_RESUME_GATE,
+    tags: ['fixture', 'workflow', 'resume', 'run'],
+    goal: 'Validate run-level resume from paused human gate.',
+    context: 'Workflow intentionally pauses at `await_input` node.',
+    requirements: ['Run pauses waiting for input.', 'Resume continues and completes workflow.'],
+    notes: ['Provide a positive approval payload.', 'Observe paused -> running transition.'],
+    steps: [
+      'Start workflow `workflow_test_t12_t15_pause_resume_gate`.',
+      'Submit human input and resume run.',
+    ],
+    acceptance: [
+      'Run transitions from `paused` to `completed`.',
+      'Final shell node executes successfully.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t13-run-restart-from-initial',
+    title: 'T13 Run Restart From Initial',
+    workflowId: WORKFLOW_IDS.T13_RESTART_MARKER,
+    tags: ['fixture', 'workflow', 'restart', 'run'],
+    goal: 'Validate run-level restart from initial payload/state.',
+    context: 'First run fails by design; restart should pass because marker file now exists.',
+    requirements: ['First run ends in failure.', 'Restarted run reaches completion.'],
+    notes: [
+      'Do not delete marker between first run and restart.',
+      'Use restart action on the same run context.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t13_restart_marker` and wait for fail.',
+      'Use run restart action and observe second run.',
+    ],
+    acceptance: ['First run is `failed`.', 'Restarted run is `completed`.'],
+  }),
+  makeTask({
+    id: 'test-t14-node-cancel-running',
+    title: 'T14 Node Cancel Running',
+    workflowId: WORKFLOW_IDS.T10_LONG_RUNNING_CANCEL,
+    tags: ['fixture', 'workflow', 'cancel', 'node'],
+    goal: 'Validate node-level cancel while current node is running.',
+    context: 'Long-running node provides enough time for node cancel action.',
+    requirements: ['Node enters running state.', 'Node cancel action interrupts execution.'],
+    notes: [
+      'Use node-level action instead of run-level action.',
+      'Observe node status transition in timeline.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t10_t11_t14_long_running_cancel`.',
+      'Click cancel on the active node execution.',
+    ],
+    acceptance: [
+      'Node is terminally cancelled/failed-as-cancelled per UI behavior.',
+      'Run reflects interrupted execution state.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t15-node-resume-paused',
+    title: 'T15 Node Resume Paused',
+    workflowId: WORKFLOW_IDS.T12_PAUSE_RESUME_GATE,
+    tags: ['fixture', 'workflow', 'resume', 'node'],
+    goal: 'Validate node-level resume from paused human input node.',
+    context: 'Pause is deterministic at `await_input` node.',
+    requirements: ['Node pauses awaiting response.', 'Node resume continues to final node.'],
+    notes: ['Provide decision payload in human input.', 'Verify node-level state transitions.'],
+    steps: [
+      'Start workflow `workflow_test_t12_t15_pause_resume_gate`.',
+      'Resume paused `await_input` node with input payload.',
+    ],
+    acceptance: ['Paused node resumes and completes.', 'Workflow run reaches `completed`.'],
+  }),
+  makeTask({
+    id: 'test-t16-node-restart',
+    title: 'T16 Node Restart',
+    workflowId: WORKFLOW_IDS.T30_LIFECYCLE_HAPPY_MERGED,
+    tags: ['fixture', 'workflow', 'restart', 'node'],
+    goal: 'Validate node-level restart in a multi-node workflow.',
+    context: 'Use merged lifecycle workflow to inspect downstream reset behavior.',
+    requirements: [
+      'Restart from a selected node is accepted.',
+      'Downstream nodes re-run after restart.',
+    ],
+    notes: [
+      'Prefer restarting from `retry_once` or `emit_logs` node.',
+      'Watch timeline reset scope carefully.',
+    ],
+    steps: [
+      'Run `workflow_test_t30_lifecycle_happy_merged` once to completion.',
+      'Trigger node restart and observe second execution path.',
+    ],
+    acceptance: [
+      'Selected node and downstream nodes execute again.',
+      'Workflow reaches `completed` after restart.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t17-node-retry-exhausted',
+    title: 'T17 Node Retry Exhausted',
+    workflowId: WORKFLOW_IDS.T17_RETRY_EXHAUSTED,
+    tags: ['fixture', 'workflow', 'retry', 'node'],
+    goal: 'Validate failure behavior when maxRetry cap is reached.',
+    context: 'Codex node intentionally reports failure on every attempt.',
+    requirements: ['Node fails on first attempt.', 'Run fails with retry exhaustion message.'],
+    notes: ['Max retry is intentionally low.', 'Fallback node should not run once cap is reached.'],
+    steps: [
+      'Start workflow `workflow_test_t17_retry_exhausted`.',
+      'Check run/node failure messages after terminal fail.',
+    ],
+    acceptance: ['Run status is `failed`.', 'Failure message references retry cap/attempt.'],
+  }),
+  makeTask({
+    id: 'test-t18-state-guard-rules',
+    title: 'T18 State Guard Rules',
+    workflowId: WORKFLOW_IDS.T12_PAUSE_RESUME_GATE,
+    tags: ['fixture', 'workflow', 'guards', 'lifecycle'],
+    goal: 'Validate invalid lifecycle actions are rejected in guarded states.',
+    context: 'Use paused and active states from existing fixtures to test guard behavior.',
+    requirements: [
+      'Invalid resume/retry/restart actions are blocked.',
+      'Error messages are explicit and stable.',
+    ],
+    notes: [
+      'Try operations on active, paused, and terminal runs.',
+      'Reuse paused gate and long-running fixtures as needed.',
+    ],
+    steps: [
+      'Create paused run from `workflow_test_t12_t15_pause_resume_gate`.',
+      'Attempt invalid lifecycle actions and capture responses.',
+    ],
+    acceptance: [
+      'Guarded actions are rejected consistently.',
+      'No invalid transition mutates run state.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t19-thread-reuse-resume-retry',
+    title: 'T19 Thread Reuse Resume Retry',
+    workflowId: WORKFLOW_IDS.T19_THREAD_REUSE,
+    tags: ['fixture', 'workflow', 'thread', 'resume', 'retry'],
+    goal: 'Validate thread continuity across pause/resume and subsequent codex node execution.',
+    context: 'Workflow has codex node before and after human pause.',
+    requirements: [
+      'First codex node stores thread/session context.',
+      'Second codex node reuses resumable context where applicable.',
+    ],
+    notes: [
+      'Inspect prompt state metadata in run payload/logs.',
+      'Use node retry once to observe thread behavior.',
+    ],
+    steps: [
+      'Run `workflow_test_t19_thread_reuse` until paused, then resume.',
+      'Inspect second codex node logs for resume context.',
+    ],
+    acceptance: [
+      'Workflow completes successfully.',
+      'Thread reuse behavior matches configured resume rules.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t30-lifecycle-happy-merged',
+    title: 'T30 Lifecycle Happy Merged',
+    workflowId: WORKFLOW_IDS.T30_LIFECYCLE_HAPPY_MERGED,
+    tags: ['fixture', 'workflow', 'merged', 'happy-path'],
+    goal: 'Run one merged flow covering pause/resume, retry-once, and final completion.',
+    context: 'This is the primary low-cost lifecycle happy-path regression fixture.',
+    requirements: [
+      'Human pause/resume succeeds.',
+      'Retry-once node eventually succeeds and flow completes.',
+    ],
+    notes: [
+      'This fixture intentionally emits logs near the end.',
+      'Use this as default manual regression path.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t30_lifecycle_happy_merged`.',
+      'Approve human gate and let workflow finish.',
+    ],
+    acceptance: [
+      'Run status becomes `completed`.',
+      'Timeline shows pause/resume and retry behavior.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t31-failure-recovery-merged',
+    title: 'T31 Failure Recovery Merged',
+    workflowId: WORKFLOW_IDS.T31_FAILURE_RECOVERY_MERGED,
+    tags: ['fixture', 'workflow', 'merged', 'failure-recovery'],
+    goal: 'Run one merged flow covering transient retry and onFailure fallback recovery.',
+    context: 'Combines multiple failure recovery paths to reduce total fixture count.',
+    requirements: [
+      'Transient failure path recovers via retry.',
+      'Hard failure path recovers via fallback node.',
+    ],
+    notes: [
+      'Observe node attempts and transitions closely.',
+      'Codex final node confirms post-recovery continuation.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t31_failure_recovery_merged`.',
+      'Verify retry and fallback transitions in timeline.',
+    ],
+    acceptance: [
+      'Run reaches terminal completion.',
+      'Timeline contains both retry and fallback events.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t32-review-randomness-merged',
+    title: 'T32 Review Randomness Merged',
+    workflowId: WORKFLOW_IDS.T32_REVIEW_RANDOMNESS_MERGED,
+    tags: ['fixture', 'workflow', 'merged', 'review', 'random'],
+    goal: 'Validate stochastic review branch behavior with bounded retries.',
+    context: 'Random review node may approve or reject; rejection routes to codex fix.',
+    requirements: [
+      'Both approve/reject branches can be observed over multiple runs.',
+      'Retry cap prevents unbounded loops.',
+    ],
+    notes: [
+      'Run this fixture multiple times for branch coverage.',
+      'Keep focus on route behavior, not model output quality.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t32_review_randomness_merged` repeatedly.',
+      'Record branch outcomes from review node.',
+    ],
+    acceptance: [
+      'At least one run shows fix loop path.',
+      'At least one run shows direct approval path.',
+    ],
+  }),
+  makeTask({
+    id: 'test-t33-observability-merged',
+    title: 'T33 Observability Merged',
+    workflowId: WORKFLOW_IDS.T33_OBSERVABILITY_MERGED,
+    tags: ['fixture', 'workflow', 'merged', 'observability'],
+    goal: 'Validate token/log observability in a single low-cost merged run.',
+    context: 'Combines codex token usage with mixed stdout/stderr logging.',
+    requirements: [
+      'Codex node usage metadata is recorded.',
+      'Shell node stdout/stderr entries are persisted and readable.',
+    ],
+    notes: [
+      'Use log pagination views after completion.',
+      'This fixture is intended for observability checks only.',
+    ],
+    steps: [
+      'Start workflow `workflow_test_t33_observability_merged`.',
+      'Inspect run logs and usage data after completion.',
+    ],
+    acceptance: ['Run reaches `completed`.', 'Expected logs and usage metadata are present.'],
+  }),
+];
+
+export const PRIMARY_TEST_TASK_ID = TEST_FIXTURE_TASKS[0].id;
+export const PRIMARY_TEST_WORKFLOW_ID = TEST_FIXTURE_TASKS[0].workflowId;
+
+export function taskFilename(taskId) {
+  return `${taskId}.md`;
+}
+
+export function taskRelativePath(taskId) {
+  return `.vibeman/tasks/${taskFilename(taskId)}`;
+}
+
+export function readTaskTemplate() {
+  return readFileSync(resolve(repoRoot, 'apps/api/resources/templates/task.md'), 'utf8');
+}
+
+function replaceOnce(input, from, to) {
+  return input.replace(from, to);
+}
+
+function ensureTwo(items, fallbackA, fallbackB) {
+  const first = typeof items?.[0] === 'string' && items[0].trim() ? items[0].trim() : fallbackA;
+  const second = typeof items?.[1] === 'string' && items[1].trim() ? items[1].trim() : fallbackB;
+  return [first, second];
+}
+
+export function buildTaskMarkdown(taskDef, nowIso = new Date().toISOString()) {
+  const template = readTaskTemplate();
+  const [requirementA, requirementB] = ensureTwo(
+    taskDef.requirements,
+    'Execute the target workflow successfully.',
+    'Verify expected run and node states.',
+  );
+  const [stepA, stepB] = ensureTwo(
+    taskDef.steps,
+    `Start workflow \`${taskDef.workflowId}\` for this task.`,
+    'Confirm the final state matches expectation.',
+  );
+  const [acceptanceA, acceptanceB] = ensureTwo(
+    taskDef.acceptance,
+    'Workflow completes with expected status.',
+    'Observed behavior matches fixture intent.',
+  );
+
+  const notes =
+    Array.isArray(taskDef.notes) && taskDef.notes.length > 0
+      ? taskDef.notes.map((note) => `- ${note}`).join('\n')
+      : '- Keep the run focused and deterministic.';
+
+  const tags =
+    Array.isArray(taskDef.tags) && taskDef.tags.length > 0
+      ? taskDef.tags.join(', ')
+      : 'fixture, workflow';
+
+  let task = template;
+
+  task = replaceOnce(task, /id:\s*\[type\]-\[short-id\]/, `id: ${taskDef.id}`);
+  task = replaceOnce(task, /title:\s*\[Short, descriptive title\]/, `title: ${taskDef.title}`);
+  task = replaceOnce(task, /type:\s*feature\b/, `type: ${taskDef.type ?? 'test'}`);
+  task = replaceOnce(task, /status:\s*backlog\b/, `status: ${taskDef.status ?? 'backlog'}`);
+  task = replaceOnce(task, /tags:\s*\[tag1, tag2\]/, `tags: [${tags}]`);
+  task = replaceOnce(task, /priority:\s*medium\b/, `priority: ${taskDef.priority ?? 'low'}`);
+  task = replaceOnce(
+    task,
+    /---\n\n## Goal/,
+    `created_at: '${nowIso}'\nupdated_at: '${nowIso}'\n---\n\n## Goal`,
+  );
+
+  task = replaceOnce(
+    task,
+    '[What outcome should exist when this is done? Keep it concrete and short.]',
+    taskDef.goal,
+  );
+  task = replaceOnce(
+    task,
+    '[Key background, links, or constraints that matter to implementation.]',
+    `${taskDef.context}\n\nTarget workflow: \`${taskDef.workflowId}\`.`,
+  );
+
+  task = replaceOnce(task, '- [ ] Primary requirement #1', `- [ ] ${requirementA}`);
+  task = replaceOnce(task, '- [ ] Primary requirement #2', `- [ ] ${requirementB}`);
+
+  task = replaceOnce(
+    task,
+    `[Notes for AI or human. Include only what matters:\n\n- target files or directories\n- desired approach or patterns to follow\n- tests/commands to run\n- any do-not-change or out-of-scope items]`,
+    notes,
+  );
+
+  task = replaceOnce(task, '- [ ] Actionable TODO', `- [ ] ${stepA}`);
+  task = replaceOnce(task, '- [ ] Actionable TODO', `- [ ] ${stepB}`);
+
+  task = replaceOnce(task, '- [ ] Verifiable outcome #1', `- [ ] ${acceptanceA}`);
+  task = replaceOnce(task, '- [ ] Verifiable outcome #2', `- [ ] ${acceptanceB}`);
+
+  return task;
+}
+
+export function getRepoRoot() {
+  return repoRoot;
+}