sdd-agent-platform 0.4.2 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/status/project-status.test.ts

@@ -1,511 +1,288 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
-import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { setTimeout } from 'node:timers/promises';
-
-import { contextBuildTaskMarkdown, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
-import { getProjectStatus, getStatuslineProjection, resolveProjectStatusNextIntent } from './project-status.js';
-import { initProject } from '../config/init-project.js';
-import { readAgentRuntimeProjectConfig as readProjectConfig } from '../router/agent-runtime-config.js';
-import { buildContextBuildPackage } from '../context/build-package.js';
-import { decideCommandTeamRuntime } from '../registries/command-team-runtime.js';
-import { STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION } from '../contracts.js';
-import { recordStageRunProjection, recordWorkflowHandoffProjection, type StageRun, type WorkflowHandoff } from '../stage-runtime.js';
-import { decideContextOffload, evaluateContextLoadSignal, recordContextLoadSignalProjection, recordContextOffloadDecisionProjection } from '../context-offload.js';
-import { recordSubagentDispatchProjection, type SubagentDispatch } from '../subagents.js';
-import { workflowNextIntent } from '../workflow-state/resolve.js';
-import { createRun } from '../run-state/run-state.js';
-import { createRuntimeEvidenceSet, recordRuntimeArtifactPayload, recordRuntimeWorkflowGateDecision, runtimeScopedId, updateRuntimeSelectionPointer } from '../storage/runtime-store.js';
-import type { WorkflowGateDecision } from '../workflow-gate/types.js';
-import type { TruthReconciliationDecision } from '../truth-reconciliation.js';
-
-const execFileAsync = promisify(execFile);
-
-async function removeTempRoot(root: string): Promise<void> {
-  for (let attempt = 0; attempt < 5; attempt += 1) {
-    try {
-      await rm(root, { recursive: true, force: true });
-      return;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EBUSY' || attempt === 4) {
-        throw error;
-      }
-      await setTimeout(100);
-    }
-  }
-}
-
-test('project status reports closed full-stage chain as complete instead of rerunning ship close', () => {
-  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
-  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ship_ready' });
-
-  assert.equal(nextIntent.stage, 'ship');
-  assert.equal(nextIntent.intent, 'workflow_complete');
-  assert.equal(nextIntent.canonicalCommand, 'sdd status --branch master --json');
-  assert.equal(nextIntent.displayCommand, '/sdd status --branch master --json');
-  assert.equal(nextIntent.commandSemantics, 'inspection_navigation');
-  assert.equal(nextIntent.targetRuntimeStage, 'ship');
-
-  const readyIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ready_for_ship' });
-  assert.equal(readyIntent.stage, 'ship');
-  assert.equal(readyIntent.intent, 'ship_readiness');
-  assert.equal(readyIntent.canonicalCommand, 'sdd ship close --branch master --compact-json');
-});
-
-test('project status prioritizes truth reconciliation before closed full-stage chain routing', () => {
-  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
-  const reconcileIntent = workflowNextIntent('do', 'reconcile_truth', 'sdd do task <task_id> --branch master', 'Reconcile implementation truth drift.', 'truthAlignment requires reconciliation', {
-    targetRuntimeStage: 'do',
-    resumeMode: 'reconcile'
-  });
-  const reconciliation: TruthReconciliationDecision = {
-    contract: 'sdd-truth-reconciliation-v1',
-    branch: 'master',
-    ownerStage: 'do',
-    changedRef: { kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-hash' },
-    oldHash: 'old-hash',
-    newHash: 'new-hash',
-    changeKind: 'implementation_mismatch',
-    semanticImpact: 'material',
-    preservesEvidenceRefs: [],
-    supersedesEvidenceRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-hash' }],
-    invalidatesStages: ['do'],
-    minimalFrontier: ['do', 'test', 'goal-verify', 'ship'],
-    nextIntent: reconcileIntent,
-    reasons: ['implementation truth drift requires owner-manager reconciliation']
-  };
-
-  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ship_ready' }, undefined, reconciliation);
-
-  assert.equal(nextIntent, reconcileIntent);
-  assert.equal(nextIntent.intent, 'reconcile_truth');
-  assert.equal(nextIntent.targetRuntimeStage, 'do');
-  assert.equal(nextIntent.canonicalCommand, 'sdd do task <task_id> --branch master');
-  assert.equal(nextIntent.canonicalCommand.includes('sync-back'), false);
-});
-
-test('project status routes fresh intra-bundle handoff to the internal runtime stage', () => {
-  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
-  const goalVerifyIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
-    status: 'fresh',
-    latestHandoff: {
-      ...statusHandoff(),
-      id: 'handoff-status-test-goal-verify',
-      fromStage: 'test',
-      toStage: 'goal-verify',
-      fromAgent: 'test-manager',
-      toAgent: 'goal-verify-manager',
-      status: 'proposed'
-    }
-  });
-
-  assert.equal(goalVerifyIntent.bundle, 'test');
-  assert.equal(goalVerifyIntent.targetRuntimeStage, 'goal-verify');
-  assert.equal(goalVerifyIntent.intent, 'run_goal_verify');
-  assert.equal(goalVerifyIntent.canonicalCommand, 'sdd test close --branch master --target goal-verify --compact-json');
-
-  const verifiesIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
-    status: 'fresh',
-    latestHandoff: {
-      ...statusHandoff(),
-      id: 'handoff-status-tasks-verifies',
-      fromStage: 'tasks',
-      toStage: 'verifies',
-      fromAgent: 'tasks-manager',
-      toAgent: 'verifies-manager',
-      status: 'proposed'
-    }
-  });
-
-  assert.equal(verifiesIntent.bundle, 'tasks');
-  assert.equal(verifiesIntent.targetRuntimeStage, 'verifies');
-  assert.equal(verifiesIntent.intent, 'run_verifies');
-  assert.equal(verifiesIntent.canonicalCommand, 'sdd tasks close --branch master --target verifies --compact-json');
-});
-
-test('project status ignores fresh intra-bundle handoff when target runtime stage is already completed', () => {
-  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
-  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
-    status: 'fresh',
-    latestStageRun: {
-      ...statusStageRun(),
-      id: 'stage-status-goal-verify',
-      stage: 'goal-verify',
-      ownerAgent: 'goal-verify-manager',
-      coMainAgents: ['goal-reviewer'],
-      outputRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/goal-verify/goal-verification-v1.md' }]
-    },
-    latestHandoff: {
-      ...statusHandoff(),
-      id: 'handoff-status-test-goal-verify-completed',
-      fromStage: 'test',
-      toStage: 'goal-verify',
-      fromAgent: 'test-manager',
-      toAgent: 'goal-verify-manager',
-      status: 'proposed'
-    }
-  });
-
-  assert.equal(nextIntent, taskIntent);
-});
-
-test('getProjectStatus resolves configured default SDD branch without silent master fallback', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-resolver-'));
-  try {
-    await initProject(root, { branch: 'feature-x' });
-    const config = await readProjectConfig(root);
-    const defaultStatus = await getProjectStatus(root);
-    const explicitStatus = await getProjectStatus(root, { branch: 'feature-x' });
-
-    assert.equal(config.sdd.default_branch, 'feature-x');
-    assert.equal(defaultStatus.context.branch, 'feature-x');
-    assert.equal(defaultStatus.context.branchSource, 'project_config');
-    assert.equal(defaultStatus.context.specDir, 'specs/feature-x');
-    assert.equal(explicitStatus.context.branch, 'feature-x');
-    assert.equal(explicitStatus.context.branchSource, 'explicit_option');
-    assert.equal(explicitStatus.context.specDir, 'specs/feature-x');
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('getProjectStatus resolves concrete project config branch when no default branch is set', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-config-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'config-branch', '# Tasks\n');
-    const configPath = path.join(root, '.sdd', 'project.yml');
-    const config = await readFile(configPath, 'utf8');
-    await writeFile(configPath, config.replace(/  default_branch: master\n/, '').replace('spec_dir: specs/<branch>', 'spec_dir: specs/config-branch'), 'utf8');
-
-    const status = await getProjectStatus(root);
-
-    assert.equal(status.context.branch, 'config-branch');
-    assert.equal(status.context.branchSource, 'project_config');
-    assert.equal(status.context.specDir, 'specs/config-branch');
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('Phase 6.4 getProjectStatus resolves current Git branch before project config default', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-git-'));
-  try {
-    await execFileAsync('git', ['init'], { cwd: root });
-    await execFileAsync('git', ['checkout', '-b', 'git-branch'], { cwd: root });
-    await initProject(root);
-    await writeBranchDocs(root, 'git-branch', '# Tasks\n');
-
-    const status = await getProjectStatus(root);
-
-    assert.equal(status.context.rawBranch, 'git-branch');
-    assert.equal(status.context.branch, 'git-branch');
-    assert.equal(status.context.partition, 'git-branch');
-    assert.equal(status.context.branchSource, 'git_branch');
-    assert.equal(status.context.specDir, 'specs/git-branch');
-    assert.equal(status.workflowStatus, 'active');
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('Phase 6.4 maps slash Git branch names to stable safe partitions', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-git-slash-'));
-  const rawBranch = 'feature/login';
-  const partition = `feature-login-${createHash('sha256').update(rawBranch).digest('hex').slice(0, 8)}`;
-  try {
-    await execFileAsync('git', ['init'], { cwd: root });
-    await execFileAsync('git', ['checkout', '-b', rawBranch], { cwd: root });
-    await initProject(root);
-    await writeBranchDocs(root, partition, '# Tasks\n');
-
-    const status = await getProjectStatus(root);
-
-    assert.equal(status.context.rawBranch, rawBranch);
-    assert.equal(status.context.branch, partition);
-    assert.equal(status.context.partition, partition);
-    assert.equal(status.context.branchSource, 'git_branch');
-    assert.equal(status.context.specDir, `specs/${partition}`);
-    assert.equal(status.documents.tasksExists, true);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('Phase 9.31 ignores legacy based_on metadata for status stale decisions', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-legacy-based-on-ignored-'));
-  try {
-    await initProject(root);
-    const branchDir = path.join(root, 'specs', 'feature');
-    await mkdir(branchDir, { recursive: true });
-    await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nInitial requirement.\n', 'utf8');
-    await writeFile(path.join(branchDir, 'plan.md'), '# Plan\n\nbased_on_spec_hash: legacy\n\nInitial plan.\n', 'utf8');
-    await writeFile(path.join(branchDir, 'tasks.md'), `${validTaskMarkdown('T1', [])}\nbased_on_plan_hash: legacy\n`, 'utf8');
-
-    const fresh = await getProjectStatus(root, { branch: 'feature' });
-    await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nChanged requirement.\n', 'utf8');
-    const changed = await getProjectStatus(root, { branch: 'feature' });
-
-    assert.equal(fresh.documents.planStale, false);
-    assert.equal(fresh.documents.tasksStale, false);
-    assert.equal(changed.documents.planStale, false);
-    assert.equal(changed.documents.tasksStale, false);
-    assert.equal(changed.gaps.some((gap) => /stale/.test(gap.message)), false);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('getProjectStatus rejects unresolved branch instead of silently using specs master', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-no-fallback-'));
-  try {
-    await initProject(root);
-    const configPath = path.join(root, '.sdd', 'project.yml');
-    const config = await readFile(configPath, 'utf8');
-    await writeFile(configPath, config.replace(/  default_branch: master\n/, ''), 'utf8');
-
-    await assert.rejects(() => getProjectStatus(root), /Cannot resolve SDD branch/);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('statusline token health uses context and team runtime projections', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-token-health-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', contextBuildTaskMarkdown('T1'));
-    const unknown = await getStatuslineProjection(root, { branch: 'master' });
-    await buildContextBuildPackage(root, { taskId: 'T1', branch: 'master', mode: 'do', agent: 'implementer' });
-    const nominal = await getProjectStatus(root, { branch: 'master' });
-    await decideCommandTeamRuntime(root, { command: 'recover', activation: 'force', riskTags: ['blocked'] });
-    const pressure = await getStatuslineProjection(root, { branch: 'master' });
-
-    assert.equal(unknown.tokenHealth, 'unknown');
-    assert.notEqual(nominal.tokenProjection.health, 'unknown');
-    assert.equal(nominal.tokenProjection.contextPackages, 1);
-    assert.equal(pressure.tokenHealth, 'pressure');
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('getProjectStatus exposes observable workflow handoff projections', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-handoff-'));
-  try {
-    await initProject(root);
-    await recordStageRunProjection(root, statusStageRun());
-    await recordWorkflowHandoffProjection(root, statusHandoff());
-
-    const status = await getProjectStatus(root, { branch: 'master' });
-
-    assert.equal(status.workflowHandoff.status, 'fresh');
-    assert.equal(status.workflowHandoff.latestStageRun?.stage, 'do');
-    assert.equal(status.workflowHandoff.latestHandoff?.status, 'accepted');
-    assert.equal(status.workflowHandoff.projectionCounts.stageRuns, 1);
-    assert.equal(status.workflowHandoff.projectionCounts.handoffs, 1);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('statusline exposes context offload and subagent dispatch projections', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-context-subagent-'));
-  try {
-    await initProject(root);
-    const signal = evaluateContextLoadSignal({
-      scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
-      refs: [{ kind: 'document', ref: 'specs/master/tasks.md' }],
-      fileCount: 20,
-      artifactBytes: 200_000,
-      dependencyFanout: 12,
-      unknownImpact: true,
-      generatedAt: '2026-05-18T00:00:00.000Z'
-    });
-    await recordContextLoadSignalProjection(root, signal);
-    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal, { dispatchRefs: [{ kind: 'projection', ref: 'phase8_subagent_dispatch:master:T1:run-1:none:dispatch-1' }] }));
-    await recordSubagentDispatchProjection(root, statusSubagentDispatch());
-
-    const statusline = await getStatuslineProjection(root, { branch: 'master' });
-
-    assert.equal(statusline.contextLoad, 'high');
-    assert.equal(statusline.contextAction, 'dispatch-subagent');
-    assert.equal(statusline.subagentHealth, 'blocked');
-    assert.equal(statusline.counts.subagentDispatches, 1);
-    assert.equal(statusline.counts.blockingSubagents, 1);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-test('project status exposes workflow gate evidence selection and ignored evidence', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-evidence-selection-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
-    const run = await createRun(root, { runId: 'run-1', branch: 'master', taskId: 'T1' });
-    const selected = await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-selected', 'artifacts/validation-T1.md', 'active'));
-    await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-rejected', 'artifacts/old-validation-T1.md', 'rejected'));
-    await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-stale', 'artifacts/stale-validation-T1.md', 'stale'));
-    const evidenceSetId = runtimeScopedId('evidence-set', run.runId, selected.payloadId);
-    await createRuntimeEvidenceSet(root, {
-      evidenceSetId,
-      branchSlug: 'master',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      sourceRunId: run.runId,
-      documentContractHashes: {},
-      gateDecisionId: 'gate-status-selection',
-      status: 'accepted',
-      items: [{
-        evidenceSetId,
-        payloadId: selected.payloadId,
-        logicalRef: selected.logicalRef,
-        role: selected.artifactRole,
-        required: true,
-        digestAtSelection: selected.digest
-      }],
-      payload: { selectionReasons: ['selected current validation evidence'] }
-    });
-    await updateRuntimeSelectionPointer(root, {
-      branchSlug: 'master',
-      scopeKind: 'task',
-      scopeId: 'T1',
-      selectedEvidenceSetId: evidenceSetId,
-      selectedAt: '2026-05-31T00:00:00.000Z',
-      selectedByGateDecisionId: 'gate-status-selection',
-      reason: 'latest accepted gate evidence'
-    });
-    await recordRuntimeWorkflowGateDecision(root, statusGateDecision(run.runId, selected, evidenceSetId));
-
-    const status = await getProjectStatus(root, { branch: 'master' });
-
-    assert.equal(status.workflowGateHealth.evidenceSelection.source, 'selection_pointer');
-    assert.equal(status.workflowGateHealth.evidenceSelection.selectionPointerRef, 'selection:task:T1');
-    assert.equal(status.workflowGateHealth.evidenceSelection.acceptedEvidenceSetRef, evidenceSetId);
-    assert.deepEqual(status.workflowGateHealth.evidenceSelection.selectedRefs.map((ref) => ref.logicalRef), ['artifacts/validation-T1.md']);
-    assert.deepEqual(status.workflowGateHealth.evidenceSelection.selectionReasons, ['latest accepted gate evidence', 'selected current validation evidence']);
-    assert.equal(status.workflowGateHealth.evidenceSelection.ignoredCounts.rejected, 1);
-    assert.equal(status.workflowGateHealth.evidenceSelection.ignoredCounts.stale, 1);
-    assert.deepEqual(status.workflowGateHealth.evidenceSelection.ignoredRefs.map((ref) => ref.logicalRef).sort(), ['artifacts/old-validation-T1.md', 'artifacts/stale-validation-T1.md']);
-  } finally {
-    await removeTempRoot(root);
-  }
-});
-
-function statusPayload(runId: string, payloadId: string, logicalRef: string, status: 'active' | 'rejected' | 'stale') {
-  return {
-    payloadId,
-    runId,
-    sourceRunId: runId,
-    branchSlug: 'master',
-    taskId: 'T1',
-    logicalRef,
-    physicalPayloadPath: logicalRef,
-    artifactRole: 'validation',
-    digest: `digest-${payloadId}`,
-    status,
-    payload: {}
-  };
-}
-
-function statusGateDecision(runId: string, selected: Awaited<ReturnType<typeof recordRuntimeArtifactPayload>>, evidenceSetId: string): WorkflowGateDecision {
-  return {
-    decisionId: 'gate-status-selection',
-    inputHash: 'input-hash-status-selection',
-    generatedAt: '2026-05-31T00:01:00.000Z',
-    partition: 'master',
-    taskId: 'T1',
-    runId,
-    decisionKind: 'test',
-    status: 'PASS',
-    decidedBy: 'runtime_policy',
-    hardBlocks: [],
-    warnings: [],
-    advisorSummary: { status: 'none', highConcernCount: 0, mediumConcernCount: 0, invalidCount: 0, lowConfidenceCount: 0, summaries: [] },
-    allowedNextActions: ['continue'],
-    forbiddenNextActions: [],
-    humanRequired: false,
-    reasons: ['runtime_policy produced PASS'],
-    evidenceRefs: [selected.logicalRef],
-    payload: {
-      contract: 'sdd-workflow-gate-runtime-v1',
-      packetId: 'packet-status-selection',
-      workflowScope: { waveRunId: null, taskIds: ['T1'], runIds: [runId], evidenceRefs: [] },
-      evidenceBinding: {
-        contract: 'sdd-gate-evidence-binding-v1',
-        branch: 'master',
-        gate: 'test',
-        selectionPointerRef: 'selection:task:T1',
-        acceptedEvidenceSetRef: evidenceSetId,
-        source: 'selection_pointer',
-        selectedRefs: [{ payloadId: selected.payloadId, logicalRef: selected.logicalRef, digest: selected.digest, status: selected.status }],
-        blockedRefs: [],
-        selectionReasons: ['latest accepted gate evidence', 'selected current validation evidence'],
-        decision: 'pass',
-        reasons: []
-      }
-    }
-  };
-}
-
-function statusStageRun(): StageRun {
-  return {
-    contract: STAGE_RUN_CONTRACT_VERSION,
-    id: 'stage-status-do',
-    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
-    stage: 'do',
-    ownerAgent: 'implementer',
-    coMainAgents: ['reviewer'],
-    status: 'completed',
-    inputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    outputRefs: [{ kind: 'artifact', ref: 'artifacts/status-handoff.md' }],
-    decisionRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    blockingReasons: [],
-    createdAt: '2026-05-18T00:00:00.000Z',
-    updatedAt: '2026-05-18T00:01:00.000Z'
-  };
-}
-
-function statusHandoff(): WorkflowHandoff {
-  return {
-    contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
-    id: 'handoff-status-do-test',
-    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
-    fromStage: 'do',
-    toStage: 'test',
-    fromAgent: 'implementer',
-    toAgent: 'validator',
-    status: 'accepted',
-    outputRefs: [{ kind: 'artifact', ref: 'artifacts/status-handoff.md' }],
-    requiredInputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    riskDecisionRef: { kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' },
-    evidenceRefs: [{ kind: 'evidence', ref: 'artifacts/status-handoff-validation.md#AC-1' }],
-    openQuestions: [],
-    blockingGaps: [],
-    createdAt: '2026-05-18T00:02:00.000Z',
-    decidedAt: '2026-05-18T00:03:00.000Z'
-  };
-}
-
-function statusSubagentDispatch(): SubagentDispatch {
-  return {
-    contract: SUBAGENT_DISPATCH_CONTRACT_VERSION,
-    id: 'dispatch-1',
-    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
-    workUnitId: 'wu-subagent-1',
-    definitionName: 'test-writer',
-    mode: 'background',
-    status: 'queued',
-    blocking: true,
-    requiredBefore: 'handoff',
-    contextRef: { kind: 'projection', ref: 'sdd-scoped-context-handoff:T1' },
-    createdAt: '2026-05-18T00:00:00.000Z',
-    updatedAt: '2026-05-18T00:01:00.000Z'
-  };
-}
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { setTimeout } from 'node:timers/promises';
+
+import { contextBuildTaskMarkdown, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { getProjectStatus, getStatuslineProjection } from './project-status.js';
+import { initProject } from '../config/init-project.js';
+import { readAgentRuntimeProjectConfig as readProjectConfig } from '../router/agent-runtime-config.js';
+import { buildContextBuildPackage } from '../context/build-package.js';
+import { decideCommandTeamRuntime } from '../registries/command-team-runtime.js';
+import { STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION } from '../contracts.js';
+import { recordStageRunProjection, recordWorkflowHandoffProjection, type StageRun, type WorkflowHandoff } from '../stage-runtime.js';
+import { decideContextOffload, evaluateContextLoadSignal, recordContextLoadSignalProjection, recordContextOffloadDecisionProjection } from '../context-offload.js';
+import { recordSubagentDispatchProjection, type SubagentDispatch } from '../subagents.js';
+
+const execFileAsync = promisify(execFile);
+
+async function removeTempRoot(root: string): Promise<void> {
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await rm(root, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EBUSY' || attempt === 4) {
+        throw error;
+      }
+      await setTimeout(100);
+    }
+  }
+}
+
+
+test('getProjectStatus resolves configured default SDD branch without silent master fallback', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-resolver-'));
+  try {
+    await initProject(root, { branch: 'feature-x' });
+    const config = await readProjectConfig(root);
+    const defaultStatus = await getProjectStatus(root);
+    const explicitStatus = await getProjectStatus(root, { branch: 'feature-x' });
+
+    assert.equal(config.sdd.default_branch, 'feature-x');
+    assert.equal(defaultStatus.context.branch, 'feature-x');
+    assert.equal(defaultStatus.context.branchSource, 'project_config');
+    assert.equal(defaultStatus.context.specDir, 'specs/feature-x');
+    assert.equal(explicitStatus.context.branch, 'feature-x');
+    assert.equal(explicitStatus.context.branchSource, 'explicit_option');
+    assert.equal(explicitStatus.context.specDir, 'specs/feature-x');
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('getProjectStatus resolves concrete project config branch when no default branch is set', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-config-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'config-branch', '# Tasks\n');
+    const configPath = path.join(root, '.sdd', 'project.yml');
+    const config = await readFile(configPath, 'utf8');
+    await writeFile(configPath, config.replace(/  default_branch: master\n/, '').replace('spec_dir: specs/<branch>', 'spec_dir: specs/config-branch'), 'utf8');
+
+    const status = await getProjectStatus(root);
+
+    assert.equal(status.context.branch, 'config-branch');
+    assert.equal(status.context.branchSource, 'project_config');
+    assert.equal(status.context.specDir, 'specs/config-branch');
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('Phase 6.4 getProjectStatus resolves current Git branch before project config default', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-git-'));
+  try {
+    await execFileAsync('git', ['init'], { cwd: root });
+    await execFileAsync('git', ['checkout', '-b', 'git-branch'], { cwd: root });
+    await initProject(root);
+    await writeBranchDocs(root, 'git-branch', '# Tasks\n');
+
+    const status = await getProjectStatus(root);
+
+    assert.equal(status.context.rawBranch, 'git-branch');
+    assert.equal(status.context.branch, 'git-branch');
+    assert.equal(status.context.partition, 'git-branch');
+    assert.equal(status.context.branchSource, 'git_branch');
+    assert.equal(status.context.specDir, 'specs/git-branch');
+    assert.equal(status.workflowStatus, 'active');
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('Phase 6.4 maps slash Git branch names to stable safe partitions', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-git-slash-'));
+  const rawBranch = 'feature/login';
+  const partition = `feature-login-${createHash('sha256').update(rawBranch).digest('hex').slice(0, 8)}`;
+  try {
+    await execFileAsync('git', ['init'], { cwd: root });
+    await execFileAsync('git', ['checkout', '-b', rawBranch], { cwd: root });
+    await initProject(root);
+    await writeBranchDocs(root, partition, '# Tasks\n');
+
+    const status = await getProjectStatus(root);
+
+    assert.equal(status.context.rawBranch, rawBranch);
+    assert.equal(status.context.branch, partition);
+    assert.equal(status.context.partition, partition);
+    assert.equal(status.context.branchSource, 'git_branch');
+    assert.equal(status.context.specDir, `specs/${partition}`);
+    assert.equal(status.documents.tasksExists, true);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('Phase 6.4 marks plan and tasks stale after spec revision hash changes', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-revision-stale-'));
+  try {
+    await initProject(root);
+    const branchDir = path.join(root, 'specs', 'feature');
+    await mkdir(branchDir, { recursive: true });
+    const spec = '# Spec\n\nInitial requirement.\n';
+    const planTemplate = '# Plan\n\nbased_on_spec_hash: pending\n\nInitial plan.\n';
+    const specHash = createHash('sha256').update(spec.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+    const plan = planTemplate.replace('pending', specHash);
+    const planHash = createHash('sha256').update(plan.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+    await writeFile(path.join(branchDir, 'spec.md'), spec, 'utf8');
+    await writeFile(path.join(branchDir, 'plan.md'), plan, 'utf8');
+    await writeFile(path.join(branchDir, 'tasks.md'), `${validTaskMarkdown('T1', [])}\nbased_on_plan_hash: ${planHash}\n`, 'utf8');
+
+    const fresh = await getProjectStatus(root, { branch: 'feature' });
+    await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nChanged requirement.\n', 'utf8');
+    const stale = await getProjectStatus(root, { branch: 'feature' });
+
+    assert.equal(fresh.documents.planStale, false);
+    assert.equal(fresh.documents.tasksStale, false);
+    assert.equal(stale.documents.planStale, true);
+    assert.equal(stale.documents.tasksStale, true);
+    assert.equal(stale.gaps.some((gap) => gap.field === 'plan.md' && /stale/.test(gap.message)), true);
+    assert.equal(stale.gaps.some((gap) => gap.field === 'tasks.md' && /stale/.test(gap.message)), true);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('getProjectStatus rejects unresolved branch instead of silently using specs master', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-no-fallback-'));
+  try {
+    await initProject(root);
+    const configPath = path.join(root, '.sdd', 'project.yml');
+    const config = await readFile(configPath, 'utf8');
+    await writeFile(configPath, config.replace(/  default_branch: master\n/, ''), 'utf8');
+
+    await assert.rejects(() => getProjectStatus(root), /Cannot resolve SDD branch/);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('statusline token health uses context and team runtime projections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-token-health-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', contextBuildTaskMarkdown('T1'));
+    const unknown = await getStatuslineProjection(root, { branch: 'master' });
+    await buildContextBuildPackage(root, { taskId: 'T1', branch: 'master', mode: 'do', agent: 'implementer' });
+    const nominal = await getProjectStatus(root, { branch: 'master' });
+    await decideCommandTeamRuntime(root, { command: 'recover', activation: 'force', riskTags: ['blocked'] });
+    const pressure = await getStatuslineProjection(root, { branch: 'master' });
+
+    assert.equal(unknown.tokenHealth, 'unknown');
+    assert.notEqual(nominal.tokenProjection.health, 'unknown');
+    assert.equal(nominal.tokenProjection.contextPackages, 1);
+    assert.equal(pressure.tokenHealth, 'pressure');
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('getProjectStatus exposes observable workflow handoff projections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-handoff-'));
+  try {
+    await initProject(root);
+    await recordStageRunProjection(root, statusStageRun());
+    await recordWorkflowHandoffProjection(root, statusHandoff());
+
+    const status = await getProjectStatus(root, { branch: 'master' });
+
+    assert.equal(status.workflowHandoff.status, 'fresh');
+    assert.equal(status.workflowHandoff.latestStageRun?.stage, 'do');
+    assert.equal(status.workflowHandoff.latestHandoff?.status, 'accepted');
+    assert.equal(status.workflowHandoff.projectionCounts.stageRuns, 1);
+    assert.equal(status.workflowHandoff.projectionCounts.handoffs, 1);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+test('statusline exposes context offload and subagent dispatch projections', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-context-subagent-'));
+  try {
+    await initProject(root);
+    const signal = evaluateContextLoadSignal({
+      scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
+      refs: [{ kind: 'document', ref: 'specs/master/tasks.md' }],
+      fileCount: 20,
+      artifactBytes: 200_000,
+      dependencyFanout: 12,
+      unknownImpact: true,
+      generatedAt: '2026-05-18T00:00:00.000Z'
+    });
+    await recordContextLoadSignalProjection(root, signal);
+    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal, { dispatchRefs: [{ kind: 'projection', ref: 'phase8_subagent_dispatch:master:T1:run-1:none:dispatch-1' }] }));
+    await recordSubagentDispatchProjection(root, statusSubagentDispatch());
+
+    const statusline = await getStatuslineProjection(root, { branch: 'master' });
+
+    assert.equal(statusline.contextLoad, 'high');
+    assert.equal(statusline.contextAction, 'dispatch-subagent');
+    assert.equal(statusline.subagentHealth, 'blocked');
+    assert.equal(statusline.counts.subagentDispatches, 1);
+    assert.equal(statusline.counts.blockingSubagents, 1);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+function statusStageRun(): StageRun {
+  return {
+    contract: STAGE_RUN_CONTRACT_VERSION,
+    id: 'stage-status-do',
+    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
+    stage: 'do',
+    ownerAgent: 'implementer',
+    coMainAgents: ['reviewer'],
+    status: 'completed',
+    inputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    outputRefs: [{ kind: 'artifact', ref: 'artifacts/status-handoff.md' }],
+    decisionRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    blockingReasons: [],
+    createdAt: '2026-05-18T00:00:00.000Z',
+    updatedAt: '2026-05-18T00:01:00.000Z'
+  };
+}
+
+function statusHandoff(): WorkflowHandoff {
+  return {
+    contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+    id: 'handoff-status-do-test',
+    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
+    fromStage: 'do',
+    toStage: 'test',
+    fromAgent: 'implementer',
+    toAgent: 'validator',
+    status: 'accepted',
+    outputRefs: [{ kind: 'artifact', ref: 'artifacts/status-handoff.md' }],
+    requiredInputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    riskDecisionRef: { kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' },
+    evidenceRefs: [{ kind: 'evidence', ref: 'artifacts/status-handoff-validation.md#AC-1' }],
+    openQuestions: [],
+    blockingGaps: [],
+    createdAt: '2026-05-18T00:02:00.000Z',
+    decidedAt: '2026-05-18T00:03:00.000Z'
+  };
+}
+
+function statusSubagentDispatch(): SubagentDispatch {
+  return {
+    contract: SUBAGENT_DISPATCH_CONTRACT_VERSION,
+    id: 'dispatch-1',
+    scope: { branch: 'master', taskId: 'T1', runId: 'run-1' },
+    workUnitId: 'wu-subagent-1',
+    definitionName: 'test-writer',
+    mode: 'background',
+    status: 'queued',
+    blocking: true,
+    requiredBefore: 'handoff',
+    contextRef: { kind: 'projection', ref: 'sdd-scoped-context-handoff:T1' },
+    createdAt: '2026-05-18T00:00:00.000Z',
+    updatedAt: '2026-05-18T00:01:00.000Z'
+  };
+}