sdd-agent-platform 0.3.0 → 0.4.0

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

@@ -0,0 +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 } 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'
+  };
+}

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

@@ -0,0 +1,362 @@
+import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import type { ContextBranchSource, ContextResolverContract } from '../sdd-docs/context.js';
+import type { SddTaskGap, SddTaskModel } from '../sdd-docs/task-parser.js';
+import type { RunSummary } from '../run-state/model.js';
+import { readRunEvents } from '../run-state/events.js';
+import { readRunState } from '../run-state/run-state.js';
+import { listAgentExecutionRecords, listTeamSessionRecords } from '../execution/agent-execution-records.js';
+import { listResidentWorkerRuntimes } from '../execution/resident-worker.js';
+import { runDocumentStaleReasons } from '../sync-back/inspect.js';
+import { resolveWorkflowState, type WorkflowLatestTaskRun } from '../workflow-state/resolve.js';
+import type { WorkflowAffectedFileConflict } from '../workflow-state/affected-file-conflicts.js';
+import type { WorkflowDependencyBlocker } from '../workflow-state/dependencies.js';
+import { buildTaskRiskProfile } from '../task-risk-profile.js';
+import { listRuntimeProjections } from '../storage/runtime-store.js';
+import { inspectLifecycleRiskDecisionForModel, type LifecycleRiskConsumerDiagnostic } from '../risk.js';
+import { inspectWorkflowStageHandoff, type WorkflowStageHandoffDiagnostic } from '../stage-runtime.js';
+import { inspectContextOffloadRuntime, type ContextRuntimeDiagnostic } from '../context-offload.js';
+import { inspectSubagentDispatches, type SubagentDispatchDiagnostic } from '../subagents.js';
+
+const execFileAsync = promisify(execFile);
+
+export interface RunEvidenceSummary {
+  agentExecutions: number;
+  teamSessions: number;
+  artifactIngestions: number;
+  workerRuntimes: number;
+  staleWorkerRuntimes: number;
+  routePreflight: boolean;
+  tasksChangedAfterRun: boolean;
+  tasksUpdatedAt: string | null;
+  runUpdatedAt: string | null;
+}
+
+export interface TaskRiskSummary {
+  highRiskTasks: string[];
+  mediumRiskTasks: string[];
+  sourceBoundaryTasks: string[];
+  contextRiskTasks: string[];
+  tokenRiskTasks: string[];
+  performanceRiskTasks: string[];
+}
+
+export interface TokenRuntimeProjection {
+  health: 'unknown' | 'nominal' | 'pressure';
+  estimatedTokens: number | null;
+  contextPackages: number;
+  teamRuntimeDecisions: number;
+  pressureReasons: string[];
+}
+
+export interface ProjectStatus {
+  branch: string;
+  workflowStatus: 'active' | 'not_started';
+  context: ContextResolverContract;
+  gitRoot: string | null;
+  documents: SddTaskModel['documents'];
+  tasks: {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+    blocked: number;
+    deferred: number;
+    unknown: number;
+    gaps: number;
+  };
+  taskRisk: TaskRiskSummary;
+  latestRun: RunSummary | null;
+  latestRunsByTask: WorkflowLatestTaskRun[];
+  latestRunEvidence: RunEvidenceSummary | null;
+  latestRunStaleReasons: string[];
+  affectedFileConflicts: WorkflowAffectedFileConflict[];
+  dependencyBlockers: WorkflowDependencyBlocker[];
+  recommendedNextCommand: string;
+  tokenProjection: TokenRuntimeProjection;
+  contextRuntime: ContextRuntimeDiagnostic;
+  subagentDispatches: SubagentDispatchDiagnostic;
+  lifecycleRisk: LifecycleRiskConsumerDiagnostic;
+  workflowHandoff: WorkflowStageHandoffDiagnostic;
+  gaps: SddTaskGap[];
+}
+
+export interface StatuslineProjection {
+  contract: 'sdd-statusline-projection-v1';
+  branch: string;
+  workflow: ProjectStatus['workflowStatus'];
+  taskHealth: 'empty' | 'active' | 'blocked' | 'complete';
+  runtimeHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  testHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  teamHealth: 'none' | 'active';
+  tokenHealth: 'unknown' | 'nominal' | 'pressure';
+  contextLoad: ProjectStatus['contextRuntime']['level'];
+  contextAction: ProjectStatus['contextRuntime']['action'];
+  subagentHealth: ProjectStatus['subagentDispatches']['status'];
+  evidenceHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  latestRunId: string | null;
+  counts: {
+    tasks: ProjectStatus['tasks'];
+    agentExecutions: number;
+    teamSessions: number;
+    workerRuntimes: number;
+    staleWorkerRuntimes: number;
+    artifactIngestions: number;
+    staleReasons: number;
+    affectedFileConflicts: number;
+    subagentDispatches: number;
+    blockingSubagents: number;
+  };
+  taskRisk: TaskRiskSummary;
+  next: string;
+}
+
+export async function getProjectStatus(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<ProjectStatus> {
+  const [workflow, gitRoot] = await Promise.all([resolveWorkflowState(projectRoot, options), getGitRoot(projectRoot)]);
+  const latestRun = workflow.latestRun;
+  const latestRunState = workflow.latestRunState;
+  const latestRunEvidence = latestRun ? await inspectRunEvidenceSummary(projectRoot, latestRun.runId) : null;
+  const enrichedLatestRunEvidence = latestRun && latestRunEvidence
+    ? await addTaskDocumentStalenessToRunEvidence(workflow.model.tasksPath, latestRun, latestRunEvidence)
+    : latestRunEvidence;
+  const latestRunStaleReasons = latestRunState ? await runDocumentStaleReasons(projectRoot, latestRunState, workflow.model) : [];
+  const taskRisk = summarizeTaskRisk(workflow.model.tasks);
+  const tokenProjection = await inspectTokenRuntimeProjection(projectRoot);
+  const lifecycleRisk = await inspectLifecycleRiskDecisionForModel(projectRoot, workflow.branch, workflow.model);
+  const workflowHandoff = await inspectWorkflowStageHandoff(projectRoot, workflow.branch);
+  const contextRuntime = await inspectContextOffloadRuntime(projectRoot, workflow.branch);
+  const subagentDispatches = await inspectSubagentDispatches(projectRoot, workflow.branch);
+
+  return {
+    branch: workflow.branch,
+    workflowStatus: workflow.workflowStatus,
+    context: workflow.context,
+    gitRoot,
+    documents: workflow.documents,
+    tasks: workflow.taskCounts,
+    taskRisk,
+    latestRun,
+    latestRunsByTask: workflow.latestRunsByTask,
+    latestRunEvidence: enrichedLatestRunEvidence,
+    latestRunStaleReasons,
+    affectedFileConflicts: workflow.affectedFileConflicts,
+    dependencyBlockers: workflow.dependencyBlockers,
+    recommendedNextCommand: workflow.recommendedNextCommand,
+    tokenProjection,
+    contextRuntime,
+    subagentDispatches,
+    lifecycleRisk,
+    workflowHandoff,
+    gaps: workflow.visibleGaps
+  };
+}
+
+export async function getStatuslineProjection(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<StatuslineProjection> {
+  return statuslineProjectionFromStatus(await getProjectStatus(projectRoot, options));
+}
+
+export function statuslineProjectionFromStatus(status: ProjectStatus): StatuslineProjection {
+  const evidence = status.latestRunEvidence;
+  const runtimeHealth = status.latestRun
+    ? status.latestRun.status === 'completed' && status.latestRun.validationStatus === 'pass' ? 'pass' : 'blocked'
+    : 'none';
+  const staleReasons = status.latestRunStaleReasons.length;
+  const affectedFileConflicts = status.affectedFileConflicts.length;
+  return {
+    contract: 'sdd-statusline-projection-v1',
+    branch: status.branch,
+    workflow: status.workflowStatus,
+    taskHealth: taskHealth(status),
+    runtimeHealth,
+    testHealth: testHealth(status),
+    teamHealth: (evidence?.teamSessions ?? 0) > 0 ? 'active' : 'none',
+    tokenHealth: status.tokenProjection.health,
+    contextLoad: status.contextRuntime.level,
+    contextAction: status.contextRuntime.action,
+    subagentHealth: status.subagentDispatches.status,
+    evidenceHealth: evidenceHealth(status, runtimeHealth),
+    latestRunId: status.latestRun?.runId ?? null,
+    counts: {
+      tasks: status.tasks,
+      agentExecutions: evidence?.agentExecutions ?? 0,
+      teamSessions: evidence?.teamSessions ?? 0,
+      workerRuntimes: evidence?.workerRuntimes ?? 0,
+      staleWorkerRuntimes: evidence?.staleWorkerRuntimes ?? 0,
+      artifactIngestions: evidence?.artifactIngestions ?? 0,
+      staleReasons,
+      affectedFileConflicts,
+      subagentDispatches: status.subagentDispatches.dispatches,
+      blockingSubagents: status.subagentDispatches.blockingOpen
+    },
+    taskRisk: status.taskRisk,
+    next: status.recommendedNextCommand
+  };
+}
+
+function summarizeTaskRisk(tasks: Array<Parameters<typeof buildTaskRiskProfile>[0]>): TaskRiskSummary {
+  const entries = tasks.map((task) => ({ taskId: task?.id ?? null, profile: buildTaskRiskProfile(task) }));
+  return {
+    highRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'high').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    mediumRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'medium').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    sourceBoundaryTasks: entries.filter(({ profile }) => profile.sourceBoundary).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    contextRiskTasks: entries.filter(({ profile }) => profile.contextRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    tokenRiskTasks: entries.filter(({ profile }) => profile.tokenRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    performanceRiskTasks: entries.filter(({ profile }) => profile.performanceRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort()
+  };
+}
+
+function taskHealth(status: ProjectStatus): StatuslineProjection['taskHealth'] {
+  if (status.tasks.total === 0) {
+    return 'empty';
+  }
+  if (status.tasks.blocked > 0 || status.gaps.some((gap) => gap.severity === 'blocking') || status.dependencyBlockers.length > 0) {
+    return 'blocked';
+  }
+  if (status.tasks.completed === status.tasks.total) {
+    return 'complete';
+  }
+  return 'active';
+}
+
+function testHealth(status: ProjectStatus): StatuslineProjection['testHealth'] {
+  if (!status.latestRun) {
+    return 'none';
+  }
+  if (status.latestRun.validationStatus === 'pass') {
+    return 'pass';
+  }
+  if (status.latestRun.validationStatus === 'pass_with_gaps') {
+    return 'warn';
+  }
+  return 'blocked';
+}
+
+function evidenceHealth(status: ProjectStatus, runtimeHealth: StatuslineProjection['runtimeHealth']): StatuslineProjection['evidenceHealth'] {
+  if (!status.latestRunEvidence) {
+    return 'none';
+  }
+  if (status.latestRunStaleReasons.length > 0 || status.affectedFileConflicts.length > 0 || status.latestRunEvidence.staleWorkerRuntimes > 0) {
+    return 'blocked';
+  }
+  if (runtimeHealth === 'blocked' || status.latestRunEvidence.tasksChangedAfterRun) {
+    return 'warn';
+  }
+  return 'pass';
+}
+
+async function inspectTokenRuntimeProjection(projectRoot: string): Promise<TokenRuntimeProjection> {
+  const projections = await listRuntimeProjections(projectRoot, ['context_build', 'team_runtime_decision']);
+  const contextPackages = projections.filter((projection) => projection.projectionType === 'context_build');
+  const teamRuntimeDecisions = projections.filter((projection) => projection.projectionType === 'team_runtime_decision');
+  const contextTokenEstimates = contextPackages.map((projection) => tokenEstimateFromContextBuildPayload(projection.payload)).filter((value): value is number => value !== null);
+  const teamTokenEstimates = teamRuntimeDecisions.map((projection) => tokenEstimateFromTeamRuntimePayload(projection.payload)).filter((value): value is number => value !== null);
+  const estimatedTokens = [...contextTokenEstimates, ...teamTokenEstimates].reduce((total, value) => total + value, 0);
+  const pressureReasons = [
+    ...contextPackages.map((projection) => contextPressureReason(projection.payload)).filter((value): value is string => value !== null),
+    ...teamRuntimeDecisions.map((projection) => teamPressureReason(projection.payload)).filter((value): value is string => value !== null)
+  ];
+
+  return {
+    health: projections.length === 0 ? 'unknown' : pressureReasons.length > 0 ? 'pressure' : 'nominal',
+    estimatedTokens: projections.length === 0 ? null : estimatedTokens,
+    contextPackages: contextPackages.length,
+    teamRuntimeDecisions: teamRuntimeDecisions.length,
+    pressureReasons
+  };
+}
+
+function tokenEstimateFromContextBuildPayload(payload: unknown): number | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const budget = (payload as { budget?: { estimatedTokens?: unknown } }).budget;
+  return typeof budget?.estimatedTokens === 'number' ? budget.estimatedTokens : null;
+}
+
+function tokenEstimateFromTeamRuntimePayload(payload: unknown): number | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const decision = payload as { roleIds?: unknown; telemetryPolicy?: { contextBudget?: unknown } | null };
+  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
+  const contextBudget = decision.telemetryPolicy?.contextBudget;
+  const perRole = contextBudget === 'medium' ? 3000 : contextBudget === 'small' ? 1200 : 600;
+  return roleCount * perRole;
+}
+
+function contextPressureReason(payload: unknown): string | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const contextPackage = payload as { taskId?: unknown; profile?: unknown; budget?: { estimatedBytes?: unknown; maxBytes?: unknown } };
+  const estimatedBytes = contextPackage.budget?.estimatedBytes;
+  const maxBytes = contextPackage.budget?.maxBytes;
+  if (contextPackage.profile === 'brief') {
+    return null;
+  }
+  if (typeof estimatedBytes === 'number' && typeof maxBytes === 'number' && estimatedBytes >= maxBytes * 0.85) {
+    return `context_budget_pressure:${String(contextPackage.taskId ?? 'unknown')}`;
+  }
+  return null;
+}
+
+function teamPressureReason(payload: unknown): string | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const decision = payload as { command?: unknown; mode?: unknown; roleIds?: unknown };
+  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
+  if (decision.mode === 'team-required' || roleCount > 2) {
+    return `team_runtime_pressure:${String(decision.command ?? 'unknown')}`;
+  }
+  return null;
+}
+
+async function inspectRunEvidenceSummary(projectRoot: string, runId: string): Promise<RunEvidenceSummary> {
+  const [state, events, agentExecutions, teamSessions, workerRuntimeList] = await Promise.all([
+    readRunState(projectRoot, runId),
+    readRunEvents(projectRoot, runId),
+    listAgentExecutionRecords(projectRoot, runId),
+    listTeamSessionRecords(projectRoot, runId),
+    listResidentWorkerRuntimes(projectRoot, { runId })
+  ]);
+  return {
+    agentExecutions: agentExecutions.length,
+    teamSessions: teamSessions.length,
+    artifactIngestions: Object.keys(state.artifactIngestions ?? {}).length,
+    workerRuntimes: workerRuntimeList.runtimes.length,
+    staleWorkerRuntimes: workerRuntimeList.staleRuntimes,
+    routePreflight: events.some((event) => event.event === 'agent_router_preflight'),
+    tasksChangedAfterRun: false,
+    tasksUpdatedAt: null,
+    runUpdatedAt: state.updatedAt ?? null
+  };
+}
+
+async function addTaskDocumentStalenessToRunEvidence(tasksPath: string, latestRun: RunSummary, evidence: RunEvidenceSummary): Promise<RunEvidenceSummary> {
+  try {
+    const tasksStat = await stat(tasksPath);
+    const runUpdatedAtMs = Date.parse(latestRun.updatedAt);
+    if (Number.isNaN(runUpdatedAtMs)) {
+      return { ...evidence, runUpdatedAt: latestRun.updatedAt };
+    }
+    return {
+      ...evidence,
+      tasksChangedAfterRun: tasksStat.mtimeMs > runUpdatedAtMs,
+      tasksUpdatedAt: tasksStat.mtime.toISOString(),
+      runUpdatedAt: latestRun.updatedAt
+    };
+  } catch {
+    return { ...evidence, runUpdatedAt: latestRun.updatedAt };
+  }
+}
+
+async function getGitRoot(projectRoot: string): Promise<string | null> {
+  try {
+    const result = await execFileAsync('git', ['-C', projectRoot, 'rev-parse', '--show-toplevel']);
+    return result.stdout.trim();
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './config/init-project.js';
+export * from './status/project-status.js';

package/node_modules/@sdd-agent-platform/core/src/storage/json-io.ts

@@ -0,0 +1,10 @@
+import { stat } from 'node:fs/promises';
+
+export async function exists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}