sdd-agent-platform 0.4.0 → 0.4.1

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

@@ -1,3 +1,5 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
 import { inspectAiToolEntryEvidence } from './checks/ai-entries.js';
 import { inspectDocumentChainEvidence } from './checks/document-chain.js';
 import { inspectLocalRunIndexEvidence } from './checks/local-run-index.js';
@@ -5,7 +7,10 @@ import { inspectGitRepository, inspectProjectConfig, inspectRunsDirectoryAccess,
 import { inspectRunEvidence } from './checks/run-evidence.js';
 import { inspectAgentCapabilityCatalogDoctorContract, inspectAgentSkillTeamRuntimeDoctorContract, inspectCapabilityRegistry, inspectCommandTeamRuntimeDoctorContract, inspectGovernancePolicyContract, inspectHarnessLearningDoctorContract, inspectProjectContextPackDoctorContract, inspectQueryStatusBoundaryContract, inspectSkillAgentEvalDoctorContract, inspectToolPluginContracts } from './checks/registries.js';
 import { inspectBackgroundExecutorContract, inspectDelegationQueueContract, inspectDelegationStateMachineContract, inspectLocalRunIndexContract, inspectTaskGraphPlannerContract, inspectWaveExecutorContract, inspectWavePlannerContract, inspectWorkerAdapterContracts, inspectWorktreeIsolationContract, inspectWorktreeLifecycleContract } from './checks/runtime-contracts.js';
-import { inspectRuntimeStoreEvidence } from '../storage/runtime-store.js';
+import { inspectRuntimeStoreEvidence, listRuntimeSyncBackDecisions } from '../storage/runtime-store.js';
+import { getLegacyAgentExecutionsDir, getLegacyRunDir, getLegacyTeamSessionsDir, getLegacyWorkerRuntimesDir } from '../runtime-paths.js';
+import { branchToSafePartition } from '../path-safety.js';
+import { readAllRunStates } from '../run-state/run-state.js';
 import { getProjectStatus, statuslineProjectionFromStatus, type ProjectStatus } from '../status/project-status.js';
 import type { DoctorCheck, DoctorReport } from './model.js';
 import { summarizeDoctorStatus } from './summary.js';
@@ -58,6 +63,12 @@ export async function doctor(projectRoot: string, options: { allRuns?: boolean;
   checks.push(...inspectWorkflowHandoffRuntime(statusSnapshot));
   checks.push(...inspectContextOffloadRuntime(statusSnapshot));
   checks.push(...inspectSubagentDispatchRuntime(statusSnapshot));
+  checks.push(...inspectCapabilityHealthRuntime(statusSnapshot));
+  checks.push(...inspectLatestEligibleRunSelector(statusSnapshot));
+  checks.push(...inspectDurableGapRuntime(statusSnapshot));
+  checks.push(...inspectStageTeamRuntime(statusSnapshot));
+  checks.push(...inspectWorkflowGateRuntime(statusSnapshot));
+  checks.push(...await inspectPhase818Compatibility(projectRoot, options));
 
   return {
     status: summarizeDoctorStatus(checks),
@@ -90,6 +101,83 @@ function unavailableRuntimeCheck(check: string, label: string, error: unknown):
   }];
 }
 
+async function inspectPhase818Compatibility(projectRoot: string, options: { allRuns?: boolean; branch?: string | null } = {}): Promise<DoctorCheck[]> {
+  try {
+    const branchPartition = options.branch ? branchToSafePartition(options.branch) : null;
+    const states = (await readAllRunStates(projectRoot))
+      .filter((state) => options.allRuns || state.status !== 'archived')
+      .filter((state) => !branchPartition || state.partition === branchPartition || state.gitBranch === options.branch || (state.gitBranch ? branchToSafePartition(state.gitBranch) === branchPartition : false));
+    const legacyRunFiles: string[] = [];
+    const legacySidecars: string[] = [];
+    const syncBackJsonOnly: string[] = [];
+    const syncBackDivergence: string[] = [];
+
+    for (const state of states) {
+      const legacyRunDir = getLegacyRunDir(projectRoot, state.runId);
+      const runLocalFiles = ['state.json', 'events.jsonl', 'invocations.jsonl'];
+      for (const fileName of runLocalFiles) {
+        if (await fileExists(path.join(legacyRunDir, fileName))) {
+          legacyRunFiles.push(`${state.runId}:${fileName}`);
+        }
+      }
+
+      const sidecarDirs = [
+        getLegacyAgentExecutionsDir(projectRoot, state.runId),
+        getLegacyTeamSessionsDir(projectRoot, state.runId),
+        getLegacyWorkerRuntimesDir(projectRoot, state.runId)
+      ];
+      if ((await Promise.all(sidecarDirs.map(directoryHasEntries))).some(Boolean)) {
+        legacySidecars.push(state.runId);
+      }
+
+      const decisions = await listRuntimeSyncBackDecisions(projectRoot, state.runId);
+      const latestDecision = decisions[0] ?? null;
+      if (state.syncBack.status !== 'not_created' && !latestDecision) {
+        syncBackJsonOnly.push(state.runId);
+      }
+      if (latestDecision && latestDecision.status !== state.syncBack.status) {
+        syncBackDivergence.push(`${state.runId}:${state.syncBack.status}->${latestDecision.status}`);
+      }
+    }
+
+    const oldSyncBackProjection = await fileExists(path.join(projectRoot, '.claude', 'commands', 'sdd', 'syncback.md'));
+    return [
+      legacyRunFiles.length > 0
+        ? { level: 'WARN', check: 'phase8_18_legacy_run_files', message: `legacy_run_files=${legacyRunFiles.join(',')}`, action: 'Runtime authority is runtime.sqlite; keep legacy run-local state/events/invocation files as import fallback only.' }
+        : { level: 'PASS', check: 'phase8_18_legacy_run_files', message: 'No legacy run-local state, event, or invocation files found in inspected runs.' },
+      legacySidecars.length > 0
+        ? { level: 'WARN', check: 'phase8_18_legacy_sidecars', message: `legacy_sidecar_runs=${legacySidecars.join(',')}`, action: 'Runtime authority is runtime.sqlite; keep old sidecars as import fallback and avoid writing new per-run structured sidecars.' }
+        : { level: 'PASS', check: 'phase8_18_legacy_sidecars', message: 'No legacy per-run agent/team/worker sidecar directories found in inspected runs.' },
+      syncBackJsonOnly.length > 0 || syncBackDivergence.length > 0
+        ? { level: 'WARN', check: 'phase8_18_sync_back_compat', message: `state_json_only=${syncBackJsonOnly.join(',') || 'none'} divergence=${syncBackDivergence.join(',') || 'none'}`, action: 'Use sdd sync-back inspect only for explicit diagnostic/recovery/replay, then reconcile canonical sync_back_decisions before relying on write-back state.' }
+        : { level: 'PASS', check: 'phase8_18_sync_back_compat', message: 'Canonical sync_back_decisions are consistent with inspected run compatibility summaries.' },
+      oldSyncBackProjection
+        ? { level: 'WARN', check: 'phase8_18_ai_projection_compat', message: 'Found legacy /sdd:syncback projection at .claude/commands/sdd/syncback.md.', action: 'Run sdd update to remove obsolete managed syncback projection; use diagnostic sync-back only when explicitly requested.' }
+        : { level: 'PASS', check: 'phase8_18_ai_projection_compat', message: 'No legacy /sdd:syncback projection found.' },
+      { level: 'PASS', check: 'phase9_readiness', message: 'code_graph_signals=optional_advisory_only authority=phase8_runtime_policy', action: 'Phase 9 graph providers may feed risk/context/test-impact/status/doctor signals but cannot replace Phase 8 gate truth.' }
+    ];
+  } catch (error) {
+    return unavailableRuntimeCheck('phase8_18_compatibility', 'Phase 8.18 compatibility diagnostics', error);
+  }
+}
+
+async function directoryHasEntries(directory: string): Promise<boolean> {
+  try {
+    return (await readdir(directory)).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function inspectContextTokenRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
   if (!snapshot.status) {
     return unavailableRuntimeCheck('context_token_runtime', 'token runtime projection', snapshot.error);
@@ -153,4 +241,79 @@ function inspectSubagentDispatchRuntime(snapshot: DoctorProjectStatusSnapshot):
     message: `status=${dispatches.status} dispatches=${dispatches.dispatches} blocking_open=${dispatches.blockingOpen} failed=${dispatches.failed} stale=${dispatches.stale} completed=${dispatches.completed} archived=${dispatches.archived} superseded=${dispatches.superseded}`,
     action: dispatches.status === 'fresh' || dispatches.status === 'missing' ? undefined : dispatches.reasons.join(' ')
   }];
+}
+
+function inspectCapabilityHealthRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('capability_health', 'capability health', snapshot.error);
+  }
+  const health = snapshot.status.capabilityHealth;
+  return [{
+    level: health.status === 'blocked' ? 'FAIL' : health.status === 'warn' ? 'WARN' : 'PASS',
+    check: 'capability_health',
+    message: `status=${health.status} baseline=${health.baselineDomains.length}/${health.requiredProfessionalDomains.length} packs=${health.materialPacks} active=${health.activeDomains.join(',') || 'none'} sources_quarantined=${health.sources.quarantined} sources_denied=${health.sources.denied} evidence_candidate=${health.evidence.candidate} release_critical_gaps=${health.releaseCriticalGaps.join(',') || 'none'}`,
+    action: health.status === 'pass' ? undefined : health.reasons.join(' ')
+  }];
+}
+
+function inspectWorkflowGateRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('workflow_gate_runtime', 'workflow gate runtime', snapshot.error);
+  }
+  const health = snapshot.status.workflowGateHealth;
+  const latest = health.latestDecision;
+  const level = health.blocked > 0 || health.humanRequired > 0 || health.warnings > 0 ? 'WARN' : 'PASS';
+  return [{
+    level,
+    check: 'workflow_gate_runtime',
+    message: `decisions=${health.decisions} blocked=${health.blocked} warn=${health.warnings} human_required=${health.humanRequired} latest=${latest ? `${latest.decisionKind}:${latest.status}:${latest.decisionId}` : 'none'}`,
+    action: level === 'PASS' ? undefined : `Workflow gate decisions are audit evidence; rerun the relevant gate command for current enforcement on ${snapshot.status.branch}.`
+  }];
+}
+
+function inspectStageTeamRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('stage_team_runtime', 'stage team runtime', snapshot.error);
+  }
+  const health = snapshot.status.stageTeamHealth;
+  const level = health.highConcernAdvisors > 0 || !health.directProfileRequiresNoTeam ? 'WARN' : 'PASS';
+  return [{
+    level,
+    check: 'stage_team_runtime',
+    message: `sessions=${health.sessions} role_results=${health.roleResults} advisors=${health.advisorAssessments} high_concern=${health.highConcernAdvisors} fan_in=${health.fanInEvidenceSets} profiles=${health.lifecycleProfiles.join(',') || 'none'} direct_required_team=${!health.directProfileRequiresNoTeam}`,
+    action: level === 'PASS' ? undefined : `Inspect task evidence for ${snapshot.status.branch}; agent-team and advisor outputs are gate inputs, not final lifecycle authority.`
+  }];
+}
+
+function inspectDurableGapRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('durable_gap_runtime', 'durable gap runtime', snapshot.error);
+  }
+  const gaps = snapshot.status.durableGaps;
+  const blocking = gaps.filter((gap) => gap.severity === 'blocking').length;
+  const warnings = gaps.filter((gap) => gap.severity === 'warning').length;
+  const tasks = [...new Set(gaps.map((gap) => gap.taskId).filter((taskId): taskId is string => typeof taskId === 'string'))].sort();
+  return [{
+    level: blocking > 0 ? 'FAIL' : warnings > 0 ? 'WARN' : 'PASS',
+    check: 'durable_gap_runtime',
+    message: `open=${gaps.length} blocking=${blocking} warning=${warnings} tasks=${tasks.join(',') || 'none'}`,
+    action: gaps.length > 0 ? `Inspect task evidence or status for ${snapshot.status.branch}; terminal durable gap closure is runtime/gate-policy controlled.` : undefined
+  }];
+}
+
+function inspectLatestEligibleRunSelector(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('latest_eligible_run_selector', 'latest eligible run selector', snapshot.error);
+  }
+  const selections = snapshot.status.latestEligibleRunsByTask;
+  const selected = selections.filter((selection) => selection.selected).length;
+  const candidates = selections.reduce((sum, selection) => sum + selection.candidates.length, 0);
+  const rejected = selections.reduce((sum, selection) => sum + selection.rejected.length, 0);
+  const blockedTasks = selections.filter((selection) => !selection.selected && selection.candidates.length > 0).map((selection) => selection.taskId);
+  return [{
+    level: blockedTasks.length > 0 ? 'WARN' : 'PASS',
+    check: 'latest_eligible_run_selector',
+    message: `tasks=${selections.length} selected=${selected} candidates=${candidates} rejected=${rejected} blocked_tasks=${blockedTasks.join(',') || 'none'}`,
+    action: blockedTasks.length > 0 ? `Inspect rejected candidates with sdd status --branch ${snapshot.status.branch}; default apply only uses compatible eligible runs.` : undefined
+  }];
 }

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

@@ -0,0 +1,80 @@
+import { branchToSafePartition } from '../path-safety.js';
+import { listRuntimeArtifactPayloads } from '../storage/runtime-store.js';
+import type { RuntimeArtifactPayloadRecord, RuntimeArtifactPayloadStatus } from '../storage/runtime-store.js';
+
+export const EVIDENCE_LOOKUP_CONTRACT_VERSION = 'phase-8.12-evidence-lookup-v1';
+
+export interface EvidenceLookupFilters {
+  branch?: string | null;
+  runId?: string | null;
+  taskId?: string | null;
+  logicalRef?: string | null;
+  status?: RuntimeArtifactPayloadStatus | 'any' | null;
+  role?: string | null;
+  kind?: string | null;
+}
+
+export interface EvidenceLookupResult {
+  contract: typeof EVIDENCE_LOOKUP_CONTRACT_VERSION;
+  generatedAt: string;
+  retrievalMemoryOnly: true;
+  gateTruthAuthority: false;
+  reason: string;
+  filters: EvidenceLookupFilters;
+  payloads: RuntimeArtifactPayloadRecord[];
+  resolvedPayloads: RuntimeArtifactPayloadRecord[];
+  counts: Record<RuntimeArtifactPayloadStatus, number>;
+}
+
+export async function lookupEvidence(projectRoot: string, filters: EvidenceLookupFilters = {}): Promise<EvidenceLookupResult> {
+  const payloads = await listRuntimeArtifactPayloads(projectRoot, {
+    runId: filters.runId ?? null,
+    branchSlug: filters.branch ? branchToSafePartition(filters.branch) : null,
+    taskId: filters.taskId ?? null,
+    logicalRef: filters.logicalRef ?? null,
+    status: filters.status && filters.status !== 'any' ? filters.status : null
+  });
+  const filtered = payloads.filter((payload) => matchesMetadata(payload, filters));
+  const resolvedPayloads = resolveActivePayloads(filtered);
+  return {
+    contract: EVIDENCE_LOOKUP_CONTRACT_VERSION,
+    generatedAt: new Date().toISOString(),
+    retrievalMemoryOnly: true,
+    gateTruthAuthority: false,
+    reason: 'Evidence Lookup is retrieval memory over SQLite metadata and payload refs; PASS, verify, and sync-back authority must use runtime evidence gates.',
+    filters,
+    payloads: filtered,
+    resolvedPayloads,
+    counts: {
+      active: filtered.filter((payload) => payload.status === 'active').length,
+      candidate: filtered.filter((payload) => payload.status === 'candidate').length,
+      rejected: filtered.filter((payload) => payload.status === 'rejected').length,
+      superseded: filtered.filter((payload) => payload.status === 'superseded').length
+    }
+  };
+}
+
+function matchesMetadata(payload: RuntimeArtifactPayloadRecord, filters: EvidenceLookupFilters): boolean {
+  if (filters.role && payload.artifactRole !== filters.role) {
+    return false;
+  }
+  if (filters.kind && payload.artifactRole !== filters.kind) {
+    return false;
+  }
+  return true;
+}
+
+function resolveActivePayloads(payloads: RuntimeArtifactPayloadRecord[]): RuntimeArtifactPayloadRecord[] {
+  const byLogicalRef = new Map<string, RuntimeArtifactPayloadRecord>();
+  for (const payload of payloads) {
+    if (payload.status !== 'active') {
+      continue;
+    }
+    const key = `${payload.branchSlug}\\0${payload.taskId ?? ''}\\0${payload.logicalRef}`;
+    const current = byLogicalRef.get(key);
+    if (!current || payload.sequence > current.sequence || (payload.sequence === current.sequence && payload.createdAt > current.createdAt)) {
+      byLogicalRef.set(key, payload);
+    }
+  }
+  return Array.from(byLogicalRef.values()).sort((left, right) => right.createdAt.localeCompare(left.createdAt) || right.sequence - left.sequence);
+}

package/node_modules/@sdd-agent-platform/core/src/evidence-runtime/contracts.ts

@@ -3,6 +3,7 @@ import { TEST_EVIDENCE_RUN_CONTRACT_VERSION } from '../contracts.js';
 
 export type TestEvidenceStatus = 'PASS' | 'FAIL' | 'BLOCKED';
 export type EvidenceCoverageStatus = 'complete' | 'partial' | 'missing' | 'stale';
+export type CapabilityEvidenceClass = 'accepted' | 'candidate' | 'quarantined' | 'diagnostic' | 'blocked';
 
 export interface TestCommandEvidence {
   command: string;
@@ -21,6 +22,16 @@ export interface AcceptanceEvidenceCoverage {
   gaps: string[];
 }
 
+export interface CapabilityEvidenceClassification {
+  class: CapabilityEvidenceClass;
+  source: 'professional_capability' | 'external_source' | 'runtime_diagnostic';
+  domainOrSourceId: string;
+  evidenceRefs: RuntimeRef[];
+  acceptanceRefs: string[];
+  provenanceRefs: RuntimeRef[];
+  reason: string;
+}
+
 export interface UnifiedTestEvidenceRun {
   contract: typeof TEST_EVIDENCE_RUN_CONTRACT_VERSION;
   id: string;
@@ -30,6 +41,7 @@ export interface UnifiedTestEvidenceRun {
   policyJudgment: TestEvidenceStatus;
   commands: TestCommandEvidence[];
   acceptanceCoverage: AcceptanceEvidenceCoverage[];
+  capabilityEvidence: CapabilityEvidenceClassification[];
   syncBackReady: boolean;
   gaps: string[];
   next: string;

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

@@ -1,17 +1,16 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import {
   AGENT_EXECUTION_RECORD_CONTRACT_VERSION,
   TEAM_SESSION_RECORD_CONTRACT_VERSION
 } from '../contracts.js';
 import {
-  getAgentExecutionRecordPath,
-  getAgentExecutionsDir,
-  getTeamSessionRecordPath,
-  getTeamSessionsDir
+  getLegacyAgentExecutionsDir,
+  getLegacyTeamSessionsDir
 } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
+import { listRuntimeAgentExecutions, listRuntimeTeamSessions, recordRuntimeAgentExecution, recordRuntimeTeamSession } from '../storage/runtime-store.js';
 import { BUILT_IN_SKILL_CAPABILITIES } from '../registries/skill-capabilities.js';
 import type { ArtifactResultIngestionRecord } from '../artifacts/ingestion.js';
 import type {
@@ -24,19 +23,21 @@ import type {
 } from '../router/agent-runtime.js';
 
 export async function writeAgentExecutionRecord(projectRoot: string, record: AgentExecutionRecord): Promise<AgentExecutionRecord> {
-  await mkdir(getAgentExecutionsDir(projectRoot, record.runId), { recursive: true });
-  await writeFile(getAgentExecutionRecordPath(projectRoot, record.runId, record.executionId), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+  await recordRuntimeAgentExecution(projectRoot, record);
   return record;
 }
 
 export async function writeTeamSessionRecord(projectRoot: string, record: TeamSessionRecord): Promise<TeamSessionRecord> {
-  await mkdir(getTeamSessionsDir(projectRoot, record.runId), { recursive: true });
-  await writeFile(getTeamSessionRecordPath(projectRoot, record.runId, record.teamId), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+  await recordRuntimeTeamSession(projectRoot, record);
   return record;
 }
 
 export async function listAgentExecutionRecords(projectRoot: string, runId: string): Promise<AgentExecutionRecord[]> {
-  const recordsDir = getAgentExecutionsDir(projectRoot, runId);
+  const runtimeRecords = await listRuntimeAgentExecutions(projectRoot, runId);
+  if (runtimeRecords.length > 0) {
+    return runtimeRecords;
+  }
+  const recordsDir = getLegacyAgentExecutionsDir(projectRoot, runId);
   if (!await exists(recordsDir)) {
     return [];
   }
@@ -54,7 +55,11 @@ export async function listAgentExecutionRecords(projectRoot: string, runId: stri
 }
 
 export async function listTeamSessionRecords(projectRoot: string, runId: string): Promise<TeamSessionRecord[]> {
-  const recordsDir = getTeamSessionsDir(projectRoot, runId);
+  const runtimeRecords = await listRuntimeTeamSessions(projectRoot, runId);
+  if (runtimeRecords.length > 0) {
+    return runtimeRecords;
+  }
+  const recordsDir = getLegacyTeamSessionsDir(projectRoot, runId);
   if (!await exists(recordsDir)) {
     return [];
   }

package/node_modules/@sdd-agent-platform/core/src/execution/background-executor.test.ts

@@ -9,6 +9,7 @@ import { doctor } from '../doctor/doctor.js';
 import { writeArtifact } from '../run-state/artifacts.js';
 import { readRunState } from '../run-state/run-state.js';
 import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
 import { inspectBackgroundExecutor, runBackgroundExecutor } from './background-executor.js';
 
 test('background executor claims one delegation and persists background run state', async () => {
@@ -16,6 +17,7 @@ test('background executor claims one delegation and persists background run stat
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const result = await runBackgroundExecutor(root, { taskId: 'B1' });
     const state = await readRunState(root, result.runId);
@@ -39,6 +41,7 @@ test('background executor ingests supplied artifact and reaches terminal state',
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const claimed = await runBackgroundExecutor(root, { taskId: 'B1' });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md'));
@@ -68,6 +71,7 @@ test('claude code subagent worker spawns host process and ingests stdout artifac
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
     const hostScript = path.join(root, 'fake-claude-host.mjs');
     await writeFile(hostScript, [
       "const prompt = process.argv[2] ?? '';",
@@ -101,6 +105,7 @@ test('background executor blocks invalid artifact evidence instead of completing
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const claimed = await runBackgroundExecutor(root, { taskId: 'B1' });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', '# Missing contract\n');
@@ -125,6 +130,7 @@ test('background executor requires approval for database manual gate and accepts
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []).replace('risk: []', 'risk:\n  - database'));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const blocked = await runBackgroundExecutor(root, { taskId: 'B1' });
     assert.equal(blocked.status, 'blocked');
@@ -153,6 +159,7 @@ test('background executor blocks manual handoff worker adapters', async () => {
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const result = await runBackgroundExecutor(root, { taskId: 'B1', workerAdapterId: 'manual-handoff-worker' });
 

package/node_modules/@sdd-agent-platform/core/src/execution/resident-worker.test.ts

@@ -11,6 +11,7 @@ import { writeArtifact } from '../run-state/artifacts.js';
 import { inspectRun } from '../run-state/inspect-run.js';
 import { readRunState } from '../run-state/run-state.js';
 import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
 import { runBackgroundExecutor } from './background-executor.js';
 import {
   claimResidentWorkerRuntime,
@@ -26,6 +27,7 @@ test('resident worker runtime claim persists run-bound runtime evidence', async
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const result = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-implementer-test', leaseSeconds: 60 });
     const runtime = await readResidentWorkerRuntimeRecord(root, result.runId, 'R-B1-implementer-test');
@@ -51,6 +53,7 @@ test('resident worker runtime heartbeat renews lease without completing task', a
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-heartbeat', leaseSeconds: 60 });
     const before = claimed.runtime?.leaseExpiresAt;
@@ -74,6 +77,7 @@ test('resident worker runtime stale lease is visible to status and doctor', asyn
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-stale', leaseSeconds: 60 });
     assert.ok(claimed.runtime);
@@ -104,6 +108,7 @@ test('resident worker runtime heartbeat does not reopen terminal delegations', a
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
 
     const claimed = await claimResidentWorkerRuntime(root, { taskId: 'B1', runtimeId: 'R-B1-terminal', leaseSeconds: 60 });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md'));

package/node_modules/@sdd-agent-platform/core/src/execution/resident-worker.ts

@@ -1,13 +1,14 @@
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { RESIDENT_WORKER_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
 import { contractIssue, messageFromError, type ContractValidationIssue } from '../contracts/issues.js';
 import { listDelegationQueueItems } from '../delegation/queue.js';
 import { isDelegationTerminal } from '../delegation/validation.js';
-import { getWorkerRuntimeRecordPath, getWorkerRuntimesDir } from '../runtime-paths.js';
+import { getLegacyWorkerRuntimeRecordPath, getLegacyWorkerRuntimesDir } from '../runtime-paths.js';
 import { appendEvent } from '../run-state/events.js';
 import { readRunState, writeRunState } from '../run-state/run-state.js';
 import { exists } from '../storage/json-io.js';
+import { listRuntimeWorkerRuntimes, readRuntimeWorkerRuntime, recordRuntimeWorkerRuntime } from '../storage/runtime-store.js';
 import type { DelegationQueueItem } from '../run-state/run-index.js';
 import { inspectWorkerAdapterContract, type WorkerAdapterContract } from '../registries/worker-adapters.js';
 import { toSafeRecordId } from './agent-execution-records.js';
@@ -108,18 +109,25 @@ export interface ResidentWorkerRuntimeList {
 }
 
 export async function writeResidentWorkerRuntimeRecord(projectRoot: string, record: ResidentWorkerRuntimeRecord): Promise<ResidentWorkerRuntimeRecord> {
-  await mkdir(getWorkerRuntimesDir(projectRoot, record.runId), { recursive: true });
-  await writeFile(getWorkerRuntimeRecordPath(projectRoot, record.runId, record.runtimeId), `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+  await recordRuntimeWorkerRuntime(projectRoot, record);
   return record;
 }
 
 export async function readResidentWorkerRuntimeRecord(projectRoot: string, runId: string, runtimeId: string): Promise<ResidentWorkerRuntimeRecord> {
-  const raw = await readFile(getWorkerRuntimeRecordPath(projectRoot, runId, runtimeId), 'utf8');
+  const runtimeRecord = await readRuntimeWorkerRuntime(projectRoot, runId, runtimeId);
+  if (runtimeRecord) {
+    return runtimeRecord;
+  }
+  const raw = await readFile(getLegacyWorkerRuntimeRecordPath(projectRoot, runId, runtimeId), 'utf8');
   return JSON.parse(raw) as ResidentWorkerRuntimeRecord;
 }
 
 export async function listResidentWorkerRuntimeRecords(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecord[]> {
-  const recordsDir = getWorkerRuntimesDir(projectRoot, runId);
+  const runtimeRecords = await listRuntimeWorkerRuntimes(projectRoot, runId);
+  if (runtimeRecords.length > 0) {
+    return runtimeRecords;
+  }
+  const recordsDir = getLegacyWorkerRuntimesDir(projectRoot, runId);
   if (!await exists(recordsDir)) {
     return [];
   }

package/node_modules/@sdd-agent-platform/core/src/execution/stage-team-runtime.test.ts

@@ -0,0 +1,102 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { STAGE_TEAM_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
+import { assertAdvisoryAssessment, assertValidFanInEvidenceSet, assertValidStageRoleResult, buildFanInEvidenceSet, describeStageTeamActivation, type FanInEvidenceSetRecord, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord } from './stage-team-runtime.js';
+
+test('stage role results reject lifecycle transition authority fields', () => {
+  const result = roleResult({ payload: { final_pass: true } });
+
+  assert.throws(() => assertValidStageRoleResult(result), /final_pass/);
+  assert.throws(() => assertValidStageRoleResult({ ...roleResult(), syncBackApproved: true }), /syncBackApproved/);
+  assert.doesNotThrow(() => assertValidStageRoleResult(roleResult()));
+});
+
+test('advisor assessments are advisory-only and cannot carry lifecycle transitions', () => {
+  assert.throws(() => assertAdvisoryAssessment(advisor({ advisoryOnly: false } as unknown as Partial<LlmAdvisorAssessmentRecord>)), /advisoryOnly=true/);
+  assert.throws(() => assertAdvisoryAssessment(advisor({ payload: { ship_ready: true } })), /ship_ready/);
+  assert.doesNotThrow(() => assertAdvisoryAssessment(advisor()));
+  assert.throws(() => assertAdvisoryAssessment(advisor({ validity: 'unknown' } as unknown as Partial<LlmAdvisorAssessmentRecord>)), /validity/);
+  assert.throws(() => assertAdvisoryAssessment(advisor({ confidence: 'none' } as unknown as Partial<LlmAdvisorAssessmentRecord>)), /confidence/);
+});
+
+test('fan-in evidence set is gate input only and deduplicates referenced inputs', () => {
+  const fanIn = buildFanInEvidenceSet({
+    fanInId: 'fanin-001',
+    partition: 'feature',
+    runId: 'run-001',
+    taskId: 'T1',
+    stage: 'test',
+    roleResultIds: ['role-result-2', 'role-result-1', 'role-result-1'],
+    durableGapIds: ['gap-1'],
+    proposalRefs: ['proposal.md'],
+    advisorAssessmentIds: ['advisor-1'],
+    evidenceRefs: ['artifacts/validation-T1.md'],
+    canonicalEvidenceRefs: ['payload-1'],
+    createdAt: '2026-01-01T00:00:00.000Z',
+    payload: { note: 'input only' }
+  });
+
+  assert.equal(fanIn.gateInputOnly, true);
+  assert.deepEqual(fanIn.roleResultIds, ['role-result-1', 'role-result-2']);
+  assert.throws(() => buildFanInEvidenceSet({ ...fanIn, payload: { stagePassed: true } }), /stagePassed/);
+  assert.throws(() => assertValidFanInEvidenceSet({ ...fanIn, gateInputOnly: false } as unknown as FanInEvidenceSetRecord), /gateInputOnly=true/);
+});
+
+test('lifecycle profiles explain team activation without requiring direct team mode', () => {
+  const direct = describeStageTeamActivation('direct');
+  const recover = describeStageTeamActivation('recover');
+
+  assert.equal(direct.requiredTeam, false);
+  assert.equal(direct.roles.length, 0);
+  assert.equal(recover.requiredTeam, true);
+  assert.equal(recover.roles.some((role) => role.roleId === 'role.sync-risk-reviewer' && role.required), true);
+});
+
+function roleResult(overrides: Partial<StageRoleResultRecord> & Record<string, unknown> = {}): StageRoleResultRecord & Record<string, unknown> {
+  return {
+    contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+    resultId: 'role-result-001',
+    sessionId: 'session-001',
+    assignmentId: 'assignment-001',
+    partition: 'feature',
+    runId: 'run-001',
+    taskId: 'T1',
+    roleId: 'role.evidence-runner',
+    agentId: 'validator',
+    outputKind: 'evidence',
+    authorityCeiling: 'gate_input',
+    status: 'accepted',
+    summary: 'Collected validation evidence.',
+    evidenceRefs: ['artifacts/validation-T1.md'],
+    durableGapIds: [],
+    proposalRefs: [],
+    advisorAssessmentIds: [],
+    createdAt: '2026-01-01T00:00:00.000Z',
+    payload: {},
+    ...overrides
+  };
+}
+
+function advisor(overrides: Partial<LlmAdvisorAssessmentRecord> & Record<string, unknown> = {}): LlmAdvisorAssessmentRecord & Record<string, unknown> {
+  return {
+    contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+    assessmentId: 'advisor-001',
+    sessionId: 'session-001',
+    partition: 'feature',
+    runId: 'run-001',
+    taskId: 'T1',
+    kind: 'evidence_sufficiency',
+    concern: 'medium',
+    validity: 'valid',
+    confidence: 'high',
+    advisoryOnly: true,
+    summary: 'Evidence is sufficient for gate input, pending deterministic checks.',
+    evidenceRefs: ['artifacts/validation-T1.md'],
+    durableGapIds: [],
+    proposalRefs: [],
+    createdAt: '2026-01-01T00:00:00.000Z',
+    payload: {},
+    ...overrides
+  };
+}