Add heavy-task dual completion status

packages/headless/src/__tests__/heavy-task-finalization.test.ts

@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+import { evaluateHeavyTaskCompletionStatus } from '../heavy-task-finalization.js';
+import type {
+  HeavyTaskModeFacts,
+  HeavyTaskSemanticSelfCheckState,
+  HeavyTaskSelfCheckStatus,
+  HeavyTaskTodoItem,
+  HeavyTaskTodoState,
+  TaskRunStatus,
+} from '../task-contracts.js';
+
+const heavyTaskMode: HeavyTaskModeFacts = {
+  schemaVersion: 1,
+  enabled: true,
+  triggerSource: 'config',
+  triggerReason: 'long public task',
+  policyVersion: 'maka-heavy-task-policy.v1',
+};
+
+describe('heavy-task finalization status', () => {
+  test('marks semantic complete with accepted pass self-check and completed todos', () => {
+    const status = evaluateHeavyTaskCompletionStatus({
+      status: 'budget_exhausted',
+      taxonomy: 'budget_exhausted',
+      heavyTaskMode,
+      latestHeavyTaskSelfCheck: selfCheck('pass'),
+      latestHeavyTaskTodos: todos([{ id: 'edit', status: 'completed' }]),
+    });
+
+    assert.equal(status.runtime.capLike, true);
+    assert.equal(status.runtime.capKind, 'budget_exhausted');
+    assert.equal(status.semantic.status, 'complete');
+    assert.equal(status.semantic.advisory, true);
+    assert.deepEqual(status.semantic.unresolvedTodoIds, []);
+    assert.equal(status.finalization.eligible, true);
+    assert.equal(status.finalization.boundedTurnImplemented, false);
+  });
+
+  test('treats cancelled todos with evidence as nonblocking', () => {
+    const status = evaluateHeavyTaskCompletionStatus({
+      status: 'incomplete',
+      taxonomy: 'agent_incomplete',
+      heavyTaskMode,
+      latestHeavyTaskSelfCheck: selfCheck('pass'),
+      latestHeavyTaskTodos: todos([
+        { id: 'implemented', status: 'completed' },
+        { id: 'optional-polish', status: 'cancelled', evidence: 'Out of scope after public README review.' },
+      ]),
+    });
+
+    assert.equal(status.semantic.status, 'complete');
+    assert.deepEqual(status.semantic.nonblockingTodoIds, ['optional-polish']);
+    assert.deepEqual(status.semantic.unresolvedTodoIds, []);
+    assert.equal(status.finalization.eligible, true);
+  });
+
+  test('requires accepted public pass self-check evidence', () => {
+    const cases = [
+      { name: 'missing self-check', selfCheck: undefined },
+      {
+        name: 'rejected self-check',
+        selfCheck: selfCheck('pass', { guardStatus: 'rejected' }) as unknown as HeavyTaskSemanticSelfCheckState,
+      },
+      { name: 'private payload replay', selfCheck: selfCheck('pass', { publicReason: 'hidden/tests/private_case.py passed.' }) },
+      { name: 'failed self-check', selfCheck: selfCheck('fail') },
+      { name: 'inconclusive self-check', selfCheck: selfCheck('inconclusive') },
+    ];
+
+    for (const item of cases) {
+      const status = evaluateHeavyTaskCompletionStatus({
+        status: 'budget_exhausted',
+        taxonomy: 'budget_exhausted',
+        heavyTaskMode,
+        latestHeavyTaskSelfCheck: item.selfCheck,
+        latestHeavyTaskTodos: todos([{ id: 'edit', status: 'completed' }]),
+      });
+
+      assert.equal(status.semantic.status, 'incomplete', item.name);
+      assert.equal(status.finalization.eligible, false, item.name);
+    }
+  });
+
+  test('requires non-empty latest todos with no unresolved work', () => {
+    const cases = [
+      { name: 'missing todos', todos: undefined, unresolved: [] },
+      { name: 'empty todos', todos: todos([]), unresolved: [] },
+      { name: 'pending todo', todos: todos([{ id: 'inspect', status: 'pending' }]), unresolved: ['inspect'] },
+      { name: 'in-progress todo', todos: todos([{ id: 'edit', status: 'in_progress' }]), unresolved: ['edit'] },
+      { name: 'cancelled without evidence', todos: todos([{ id: 'optional', status: 'cancelled' }]), unresolved: ['optional'] },
+      {
+        name: 'unknown future status',
+        todos: todos([{ id: 'future', status: 'blocked' as HeavyTaskTodoItem['status'] }]),
+        unresolved: ['future'],
+      },
+    ];
+
+    for (const item of cases) {
+      const status = evaluateHeavyTaskCompletionStatus({
+        status: 'budget_exhausted',
+        taxonomy: 'budget_exhausted',
+        heavyTaskMode,
+        latestHeavyTaskSelfCheck: selfCheck('pass'),
+        latestHeavyTaskTodos: item.todos,
+      });
+
+      assert.equal(status.semantic.status, 'incomplete', item.name);
+      assert.deepEqual(status.semantic.unresolvedTodoIds, item.unresolved, item.name);
+      assert.equal(status.finalization.eligible, false, item.name);
+    }
+  });
+
+  test('classifies cap-like runtime outcomes without treating verifier failures as caps', () => {
+    const capCases: Array<{
+      name: string;
+      status: TaskRunStatus;
+      taxonomy?: string;
+      errorClass?: string;
+      message?: string;
+      reason?: string;
+      capKind: string;
+    }> = [
+      { name: 'budget exhausted', status: 'budget_exhausted', taxonomy: 'budget_exhausted', capKind: 'budget_exhausted' },
+      { name: 'runtime step cap', status: 'failed', errorClass: 'max_steps', message: 'runtime step cap reached', capKind: 'runtime_step_cap' },
+      { name: 'wall time cap', status: 'failed', message: 'wall time cap reached', capKind: 'wall_time_cap' },
+      { name: 'max attempts', status: 'failed', reason: 'max attempts exhausted', capKind: 'max_attempts' },
+      { name: 'tool calls', status: 'incomplete', errorClass: 'incomplete_tool_calls', capKind: 'tool_call_step_cap' },
+      { name: 'max tokens', status: 'incomplete', errorClass: 'max_tokens', capKind: 'token_cap' },
+      { name: 'timeout', status: 'failed', errorClass: 'timeout', capKind: 'timeout' },
+    ];
+
+    for (const item of capCases) {
+      const status = evaluateHeavyTaskCompletionStatus({
+        status: item.status,
+        taxonomy: item.taxonomy,
+        error: item.errorClass || item.message ? { class: item.errorClass, message: item.message ?? item.errorClass ?? '' } : undefined,
+        decisions: item.reason ? [{ id: `decision-${item.name}`, taskRunId: 'run-1', ts: 1, decision: 'stop', reason: item.reason }] : undefined,
+        heavyTaskMode,
+        latestHeavyTaskSelfCheck: selfCheck('pass'),
+        latestHeavyTaskTodos: todos([{ id: 'edit', status: 'completed' }]),
+      });
+
+      assert.equal(status.runtime.capLike, true, item.name);
+      assert.equal(status.runtime.capKind, item.capKind, item.name);
+      assert.equal(status.finalization.eligible, true, item.name);
+    }
+
+    const verifierFailure = evaluateHeavyTaskCompletionStatus({
+      status: 'completed',
+      taxonomy: 'verification_failed',
+      heavyTaskMode,
+      latestHeavyTaskSelfCheck: selfCheck('pass'),
+      latestHeavyTaskTodos: todos([{ id: 'edit', status: 'completed' }]),
+    });
+    assert.equal(verifierFailure.runtime.capLike, false);
+    assert.equal(verifierFailure.runtime.capKind, 'none');
+    assert.equal(verifierFailure.semantic.status, 'complete');
+    assert.equal(verifierFailure.finalization.eligible, false);
+  });
+});
+
+function selfCheck(
+  status: HeavyTaskSelfCheckStatus,
+  options: { guardStatus?: 'accepted' | 'rejected'; publicReason?: string } = {},
+): HeavyTaskSemanticSelfCheckState {
+  return {
+    schemaVersion: 1,
+    selfCheckId: `self-check-${status}-${options.guardStatus ?? 'accepted'}`,
+    taskRunId: 'run-1',
+    ts: 2,
+    status,
+    publicReason: options.publicReason ?? 'npm test passed against public files.',
+    commandEvidence: [{ command: 'npm test', exitCode: 0, outputExcerpt: 'public tests passed' }],
+    artifactEvidence: [{ path: 'build-output.log', kind: 'log', exists: true }],
+    guard: {
+      status: options.guardStatus ?? 'accepted',
+      checkedAt: 2,
+      categories: options.guardStatus === 'rejected' ? ['official_verifier_artifacts'] : [],
+      publicReason: options.guardStatus === 'rejected'
+        ? 'Rejected because submitted evidence referenced private, hidden, or evaluator-only material.'
+        : 'Accepted as public, task-derived advisory self-check evidence.',
+    } as unknown as HeavyTaskSemanticSelfCheckState['guard'],
+    source: { kind: 'model_tool', toolCallId: 'tool-self-check' },
+  };
+}
+
+function todos(items: Array<{ id: string; status: HeavyTaskTodoItem['status']; evidence?: string }>): HeavyTaskTodoState {
+  return {
+    schemaVersion: 1,
+    todoSetId: 'todos-1',
+    taskRunId: 'run-1',
+    ts: 3,
+    items: items.map((item) => ({
+      id: item.id,
+      content: `Work item ${item.id}`,
+      status: item.status,
+      priority: 'high',
+      ...(item.evidence ? { evidence: item.evidence } : {}),
+    })),
+    source: { kind: 'model_tool', toolCallId: 'tool-todos' },
+  };
+}

packages/headless/src/__tests__/result-export.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { describe, test } from 'node:test';
 import { renderTaskRunMarkdown, taskRunExportFromProjection, writeTaskRunExport } from '../result-export.js';
-import type { TaskEvent } from '../task-contracts.js';
+import type { HeavyTaskTodoItem, TaskEvent } from '../task-contracts.js';
 import { projectTaskRun } from '../task-run-store.js';
 
 describe('task run export', () => {
@@ -283,6 +283,55 @@ describe('task run export', () => {
     }
   });
 
+  test('exports heavy-task dual runtime and semantic completion status in full and compact views', async () => {
+    const projection = projectTaskRun(heavyTaskCompletionEvents(), 'run-heavy-complete');
+    const exported = taskRunExportFromProjection(projection, { exportedAt: '2026-06-19T00:00:00.000Z' });
+
+    assert.equal(exported.taskRun.status, 'budget_exhausted');
+    assert.equal(exported.taxonomy.value, 'verification_failed');
+    assert.equal(exported.taxonomy.passed, false);
+    assert.equal(exported.legacyResultRecord.passed, false);
+    assert.equal(exported.heavyTask?.mode?.enabled, true);
+    assert.equal(exported.heavyTask?.completion.runtime.taskRunStatus, 'budget_exhausted');
+    assert.equal(exported.heavyTask?.completion.runtime.taxonomy, 'verification_failed');
+    assert.equal(exported.heavyTask?.completion.runtime.capLike, true);
+    assert.equal(exported.heavyTask?.completion.semantic.status, 'complete');
+    assert.equal(exported.heavyTask?.completion.semantic.advisory, true);
+    assert.deepEqual(exported.heavyTask?.completion.semantic.unresolvedTodoIds, []);
+    assert.deepEqual(exported.heavyTask?.completion.semantic.nonblockingTodoIds, ['optional-polish']);
+    assert.equal(exported.heavyTask?.completion.finalization.eligible, true);
+    assert.equal(exported.score?.taxonomy, 'verification_failed');
+    assert.equal(exported.verifier?.passed, false);
+
+    const outDir = await mkdtemp(join(tmpdir(), 'maka-heavy-task-export-'));
+    try {
+      const written = await writeTaskRunExport(outDir, projection, {
+        exportedAt: '2026-06-19T00:00:00.000Z',
+      });
+      const compact = JSON.parse(await readFile(written.files.resultJson, 'utf8'));
+      assert.deepEqual(compact.heavyTask, exported.heavyTask);
+      assert.equal(compact.taxonomy.value, 'verification_failed');
+      assert.equal(compact.legacyResultRecord.passed, false);
+    } finally {
+      await rm(outDir, { recursive: true, force: true });
+    }
+  });
+
+  test('exports semantic incomplete and finalization ineligible when todos are unresolved', () => {
+    const events = heavyTaskCompletionEvents([
+      { id: 'edit', content: 'Patch implementation', status: 'completed', priority: 'high' },
+      { id: 'verify', content: 'Run public checks', status: 'pending', priority: 'high' },
+    ]);
+    const exported = taskRunExportFromProjection(projectTaskRun(events, 'run-heavy-complete'));
+
+    assert.equal(exported.heavyTask?.completion.runtime.capLike, true);
+    assert.equal(exported.heavyTask?.completion.semantic.status, 'incomplete');
+    assert.deepEqual(exported.heavyTask?.completion.semantic.unresolvedTodoIds, ['verify']);
+    assert.equal(exported.heavyTask?.completion.finalization.eligible, false);
+    assert.equal(exported.taxonomy.value, 'verification_failed');
+    assert.equal(exported.legacyResultRecord.passed, false);
+  });
+
   test('exports official verifier truth over a non-authoritative placeholder result', async () => {
     const events: TaskEvent[] = [
       { type: 'task_run_created', id: 'e1', taskRunId: 'run-official', ts: 1, taskId: 'task-1', configId: 'cfg-1' },
@@ -551,3 +600,109 @@ describe('task run export', () => {
     }
   });
 });
+
+function heavyTaskCompletionEvents(todos: HeavyTaskTodoItem[] = [
+  { id: 'edit', content: 'Patch implementation', status: 'completed', priority: 'high' },
+  {
+    id: 'optional-polish',
+    content: 'Optional polish',
+    status: 'cancelled',
+    priority: 'low',
+    evidence: 'Not required by public task.',
+  },
+]): TaskEvent[] {
+  const taskRunId = 'run-heavy-complete';
+  return [
+    { type: 'task_run_created', id: 'hc1', taskRunId, ts: 1, taskId: 'task-1', configId: 'cfg-1' },
+    {
+      type: 'heavy_task_mode_recorded',
+      id: 'hc2',
+      taskRunId,
+      ts: 2,
+      facts: {
+        schemaVersion: 1,
+        enabled: true,
+        triggerSource: 'config',
+        triggerReason: 'long public task',
+        policyVersion: 'maka-heavy-task-policy.v1',
+      },
+    },
+    {
+      type: 'heavy_task_todos_recorded',
+      id: 'hc3',
+      taskRunId,
+      ts: 3,
+      todos: {
+        schemaVersion: 1,
+        todoSetId: 'todos-2',
+        taskRunId,
+        ts: 3,
+        items: todos,
+        source: { kind: 'model_tool', toolCallId: 'tool-todos' },
+      },
+    },
+    {
+      type: 'heavy_task_self_check_recorded',
+      id: 'hc4',
+      taskRunId,
+      ts: 4,
+      selfCheck: {
+        schemaVersion: 1,
+        selfCheckId: 'self-check-1',
+        taskRunId,
+        ts: 4,
+        status: 'pass',
+        publicReason: 'npm test passed against public files.',
+        commandEvidence: [{ command: 'npm test', exitCode: 0, outputExcerpt: 'public tests passed' }],
+        artifactEvidence: [{ path: 'build-output.log', kind: 'log', exists: true }],
+        guard: {
+          status: 'accepted',
+          checkedAt: 4,
+          categories: [],
+          publicReason: 'Accepted as public, task-derived advisory self-check evidence.',
+        },
+        source: { kind: 'model_tool', toolCallId: 'tool-self-check' },
+      },
+    },
+    {
+      type: 'verifier_result_recorded',
+      id: 'hc5',
+      taskRunId,
+      ts: 5,
+      result: {
+        id: 'verifier-1',
+        taskRunId,
+        ts: 5,
+        kind: 'terminal_bench',
+        passed: false,
+        exitCode: 1,
+        errorClass: 'verification_failed',
+        authority: { source: 'official_harbor_verifier', authoritative: true },
+      },
+    },
+    {
+      type: 'score_result_recorded',
+      id: 'hc6',
+      taskRunId,
+      ts: 6,
+      result: {
+        id: 'score-1',
+        taskRunId,
+        ts: 6,
+        passed: false,
+        scored: true,
+        eligible: true,
+        taxonomy: 'verification_failed',
+        errorClass: 'verification_failed',
+        authority: { source: 'official_harbor_verifier', authoritative: true },
+      },
+    },
+    {
+      type: 'task_run_budget_exhausted',
+      id: 'hc7',
+      taskRunId,
+      ts: 7,
+      error: { message: 'runtime step cap reached', class: 'max_steps' },
+    },
+  ];
+}