sdd-agent-platform 0.4.0 → 0.4.1

package/node_modules/@sdd-agent-platform/core/src/router/runtime-validation.ts

@@ -123,12 +123,36 @@ function validateAgentSkillTeamRuntimeInspection(inspection: AgentSkillTeamRunti
     if (!source.attribution.trim()) {
       issues.push(contractIssue(`${source.id}.attribution`, 'Capability source has no attribution.', 'Declare attribution before external material can enter the runtime registry.'));
     }
-    if (source.quarantineRequired && source.reuseDecision === 'reuse_direct') {
-      issues.push(contractIssue(`${source.id}.reuseDecision`, 'Quarantined source cannot be reused directly.', 'Use adapt_via_host_adapter or borrow_mechanism until quarantine evidence promotes the source.'));
+    if (source.permissionModel.length === 0) {
+      issues.push(contractIssue(`${source.id}.permissionModel`, 'Capability source has no permission model.', 'Declare how host/tool permissions are bounded before routing this source.'));
     }
-    if (source.quarantineRequired && sourceDeclaresUnsafeAuthority(source)) {
+    if (source.provenanceRequirements.length === 0) {
+      issues.push(contractIssue(`${source.id}.provenanceRequirements`, 'Capability source has no provenance requirements.', 'Declare source, session, artifact, or tool provenance before external output can be cited.'));
+    }
+    if (source.hostCompatibility.length === 0) {
+      issues.push(contractIssue(`${source.id}.hostCompatibility`, 'Capability source has no host compatibility declaration.', 'Declare supported, future_adapter, or unsupported host compatibility.'));
+    }
+    if (source.allowedEvidenceTypes.length === 0) {
+      issues.push(contractIssue(`${source.id}.allowedEvidenceTypes`, 'Capability source has no allowed evidence type.', 'Declare whether output is none, candidate evidence, command output, browser snapshot, design context, execution record, or external reference.'));
+    }
+    if (source.forbiddenAuthority.length === 0 || !sourceForbidsRuntimeAuthority(source)) {
+      issues.push(contractIssue(`${source.id}.forbiddenAuthority`, 'Capability source does not forbid runtime authority.', 'External sources must forbid lifecycle, completion, sync-back, ship, and permission authority.'));
+    }
+    if (!source.quarantineRequired && source.quarantineStatus !== 'not_required') {
+      issues.push(contractIssue(`${source.id}.quarantineStatus`, 'Non-quarantined source has a quarantine status.', 'Use not_required unless quarantine is required.'));
+    }
+    if (source.quarantineRequired && source.quarantineStatus === 'not_required') {
+      issues.push(contractIssue(`${source.id}.quarantineStatus`, 'Quarantined source is missing active quarantine status.', 'Use required, quarantined, or denied for external sources that require quarantine.'));
+    }
+    if ((source.quarantineRequired || source.quarantineStatus === 'quarantined' || source.quarantineStatus === 'denied') && source.reuseDecision === 'reuse_direct') {
+      issues.push(contractIssue(`${source.id}.reuseDecision`, 'Quarantined source cannot be reused directly.', 'Use adapt_via_host_adapter, borrow_mechanism, or avoid until quarantine evidence promotes the source.'));
+    }
+    if ((source.quarantineRequired || source.quarantineStatus === 'quarantined') && sourceDeclaresUnsafeAuthority(source)) {
       issues.push(contractIssue(`${source.id}.allowedUse`, 'Quarantined source requests prompt import, direct execution, or lifecycle authority.', 'Keep external material declarative and route only through validated profiles, capabilities, and adapter mappings.'));
     }
+    if (source.quarantineStatus === 'denied' && source.reuseDecision !== 'avoid') {
+      issues.push(contractIssue(`${source.id}.reuseDecision`, 'Denied capability source is still routable.', 'Set reuse_decision to avoid for denied or unsupported sources.'));
+    }
   }
   for (const capability of inspection.skillCapabilities) {
     const registrySource = inspectionRegistrySource(inspection, 'skill_capability', capability.id);
@@ -226,6 +250,11 @@ function sourceDeclaresUnsafeAuthority(source: CapabilitySourceCatalogEntry): bo
   return /prompt\s*(body|import)|direct\s+execution|execute\s+(third[- ]party|external)|run\s+(agent\s+)?pack|lifecycle\s+authority|completion\s+authority|unscoped\s+write|permission\s+escalation/i.test([source.allowedUse, source.rationale].join('\n'));
 }
 
+function sourceForbidsRuntimeAuthority(source: CapabilitySourceCatalogEntry): boolean {
+  const forbidden = source.forbiddenAuthority.join('\n').toLowerCase();
+  return ['lifecycle', 'stage completion', 'sync-back', 'ship', 'permission'].every((term) => forbidden.includes(term));
+}
+
 function builtInProfileAliasTarget(value: string): AgentProfileId | null {
   const normalized = normalizeAgentToken(value);
   if (normalized === 'scout') {

package/node_modules/@sdd-agent-platform/core/src/run-state/artifacts.ts

@@ -1,16 +1,17 @@
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { getArtifactPath, getEvidenceAttachmentPath, getRunRelativeArtifactPath, normalizeArtifactRootRelativePath } from '../runtime-paths.js';
-import { readRuntimeRunState, recordRuntimeEvidenceAttachment, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
-import { exists } from '../storage/json-io.js';
+import { getEvidenceAttachmentPath, getLegacyArtifactPath, getRunRelativeArtifactPath, normalizeArtifactRootRelativePath } from '../runtime-paths.js';
+import { readRuntimeRunState, recordRuntimeArtifactPayload, recordRuntimeEvidenceAttachment, resolveRuntimeArtifactPayload, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
 import { appendArtifactHashLedgerEntry } from './invocation-ledger.js';
 
 export async function writeArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string): Promise<{ absolutePath: string; runRelativePath: string }> {
   const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
   const runRelativePath = getRunRelativeArtifactPath(normalized);
-  const branchSlug = await resolveRunBranchSlug(projectRoot, runId);
-  const absolutePath = getEvidenceAttachmentPath(projectRoot, branchSlug, runRelativePath);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const contentHash = hashDocumentContent(content);
+  const physicalPayloadPath = uniquePhysicalPayloadPath(runRelativePath, runId, contentHash);
+  const absolutePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, physicalPayloadPath);
   await mkdir(path.dirname(absolutePath), { recursive: true });
   await writeFile(absolutePath, content, 'utf8');
   await appendArtifactHashLedgerEntry(projectRoot, {
@@ -19,15 +20,29 @@ export async function writeArtifact(projectRoot: string, runId: string, artifact
     content,
     status: 'written'
   });
-  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written' });
+  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written', taskId: runScope.taskId });
+  await recordRuntimeArtifactPayload(projectRoot, {
+    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
+    runId,
+    sourceRunId: runId,
+    branchSlug: runScope.branchSlug,
+    taskId: runScope.taskId,
+    logicalRef: runRelativePath,
+    physicalPayloadPath,
+    artifactRole: artifactKind(runRelativePath),
+    digest: contentHash,
+    status: 'active',
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, artifactPath: runRelativePath, status: 'written' }
+  });
   await recordRuntimeEvidenceAttachment(projectRoot, {
-    branchSlug,
+    branchSlug: runScope.branchSlug,
     runId,
+    taskId: runScope.taskId,
     kind: artifactKind(runRelativePath),
-    relativePath: runRelativePath,
-    contentHash: hashDocumentContent(content),
+    relativePath: physicalPayloadPath,
+    contentHash,
     bytes: Buffer.byteLength(content, 'utf8'),
-    payload: { artifactPath: runRelativePath, status: 'written' }
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, status: 'written' }
   });
   return { absolutePath, runRelativePath };
 }
@@ -35,11 +50,23 @@ export async function writeArtifact(projectRoot: string, runId: string, artifact
 export async function readArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string): Promise<string> {
   const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
   const runRelativePath = getRunRelativeArtifactPath(normalized);
-  const evidencePath = getEvidenceAttachmentPath(projectRoot, await resolveRunBranchSlug(projectRoot, runId), runRelativePath);
-  if (await exists(evidencePath)) {
+  const payload = await resolveRuntimeArtifactPayload(projectRoot, runId, runRelativePath);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const evidencePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, payload?.physicalPayloadPath ?? runRelativePath);
+  if (payload) {
     return readFile(evidencePath, 'utf8');
   }
-  return readFile(getArtifactPath(projectRoot, runId, normalized), 'utf8');
+  try {
+    return await readFile(evidencePath, 'utf8');
+  } catch {
+    return readFile(getLegacyArtifactPath(projectRoot, runId, normalized), 'utf8');
+  }
+}
+
+function uniquePhysicalPayloadPath(logicalRef: string, runId: string, digest: string): string {
+  const parsed = path.posix.parse(logicalRef.replace(/\\/g, '/'));
+  const suffix = `${runId}-${digest.slice(0, 12)}`;
+  return path.posix.join(parsed.dir, `${parsed.name}-${suffix}${parsed.ext}`);
 }
 
 export function artifactKind(artifactPath: string): string {
@@ -53,6 +80,9 @@ export function artifactKind(artifactPath: string): string {
   if (fileName.startsWith('debug-')) {
     return 'debug';
   }
+  if (fileName.startsWith('test-validation-')) {
+    return 'test-validation';
+  }
   if (fileName.startsWith('validation-')) {
     return 'validation';
   }
@@ -75,9 +105,12 @@ async function recordRuntimeArtifact(projectRoot: string, input: { runId: string
   });
 }
 
-async function resolveRunBranchSlug(projectRoot: string, runId: string): Promise<string> {
+async function resolveRunScope(projectRoot: string, runId: string): Promise<{ branchSlug: string; taskId: string | null }> {
   const state = await readRuntimeRunState(projectRoot, runId);
-  return state?.gitBranch ?? state?.partition ?? 'unscoped';
+  return {
+    branchSlug: state?.gitBranch ?? state?.partition ?? 'unscoped',
+    taskId: state?.taskId ?? state?.currentTask ?? null
+  };
 }
 
 function hashDocumentContent(raw: string): string {

package/node_modules/@sdd-agent-platform/core/src/run-state/events.ts

@@ -1,7 +1,7 @@
 
 import path from 'node:path';
 import { EVENT_LOG_CONTRACT } from '../contracts.js';
-import { getRunDir } from '../runtime-paths.js';
+import { getLegacyRunDir } from '../runtime-paths.js';
 
 import { importLegacyRunEventsIfNeeded, readRuntimeRunEvents, recordRuntimeEvent } from '../storage/runtime-store.js';
 import type { RuntimeEvent } from './model.js';
@@ -21,7 +21,7 @@ export async function readRunEvents(projectRoot: string, runId: string): Promise
   if (storedEvents.length > 0) {
     return storedEvents;
   }
-  const eventPath = path.join(getRunDir(projectRoot, runId), 'events.jsonl');
+  const eventPath = path.join(getLegacyRunDir(projectRoot, runId), 'events.jsonl');
   await importLegacyRunEventsIfNeeded(projectRoot, runId, eventPath);
   return readRuntimeRunEvents(projectRoot, runId);
 }

package/node_modules/@sdd-agent-platform/core/src/run-state/inspect-run.ts

@@ -1,12 +1,11 @@
-import { readdir, readFile } from 'node:fs/promises';
-import path from 'node:path';
 import { TASK_RUN_EVIDENCE_CONTRACT_VERSION } from '../contracts.js';
-import { getAgentExecutionsDir, getTeamSessionsDir, getWorkerRuntimesDir } from '../runtime-paths.js';
-import { exists } from '../storage/json-io.js';
+import { listAgentExecutionRecords as listRuntimeBackedAgentExecutionRecords, listTeamSessionRecords as listRuntimeBackedTeamSessionRecords } from '../execution/agent-execution-records.js';
+import { listResidentWorkerRuntimeRecords as listRuntimeBackedResidentWorkerRuntimeRecords } from '../execution/resident-worker.js';
 import type { ArtifactIndexEntry, InvocationLedgerEntry, RunState, RunStateArtifactIngestionRecord, RunStateWorktreeLifecycleRecord, RunStatus, RunSummary, RuntimeEvent } from './model.js';
 import { readRunEvents } from './events.js';
 import { listInvocationLedgerEntries } from './invocation-ledger.js';
 import { readRunState, summarizeRunState } from './run-state.js';
+import { readTaskEvidenceView, type TaskEvidenceView } from './task-evidence.js';
 
 export interface TaskRunEvidenceGap {
   type: string;
@@ -26,7 +25,7 @@ export interface AgentExecutionRecordView {
   artifacts: string[];
   toolPermission: { profile?: string } | null;
   routeId: string;
-  routeDecision: { recommendedProfile?: string };
+  routeDecision: { recommendedProfile?: string | null };
   createdAt: string;
   [key: string]: unknown;
 }
@@ -84,6 +83,7 @@ export interface RunInspection {
   syncBack: RunState['syncBack'];
   tasks: Record<string, unknown>;
   taskRunEvidence: TaskRunEvidenceContract;
+  taskEvidenceView: TaskEvidenceView | null;
   agentExecutions: AgentExecutionRecordView[];
   invocationLedger: InvocationLedgerEntry[];
   teamSessions: TeamSessionRecordView[];
@@ -94,11 +94,15 @@ export async function inspectRun(projectRoot: string, runId: string): Promise<Ru
   const state = await readRunState(projectRoot, runId);
   const [events, agentExecutions, teamSessions, workerRuntimes, invocationLedger] = await Promise.all([
     readRunEvents(projectRoot, runId),
-    listAgentExecutionRecords(projectRoot, runId),
-    listTeamSessionRecords(projectRoot, runId),
-    listResidentWorkerRuntimeRecords(projectRoot, runId),
+    listRuntimeBackedAgentExecutionRecords(projectRoot, runId),
+    listRuntimeBackedTeamSessionRecords(projectRoot, runId),
+    listRuntimeBackedResidentWorkerRuntimeRecords(projectRoot, runId),
     listInvocationLedgerEntries(projectRoot, runId)
   ]);
+  const agentExecutionViews = agentExecutions.map((record) => ({ ...record }) as AgentExecutionRecordView);
+  const teamSessionViews = teamSessions.map((record) => ({ ...record }) as TeamSessionRecordView);
+  const workerRuntimeViews = workerRuntimes.map((record) => ({ ...record }) as ResidentWorkerRuntimeRecordView);
+  const taskEvidenceView = state.partition && state.taskId ? await readTaskEvidenceView(projectRoot, { branch: state.partition, taskId: state.taskId }) : null;
   return {
     summary: summarizeRunState(state),
     state,
@@ -110,55 +114,16 @@ export async function inspectRun(projectRoot: string, runId: string): Promise<Ru
     worktrees: Object.values(state.worktrees ?? {}),
     validation: state.validation,
     syncBack: state.syncBack,
-    taskRunEvidence: buildTaskRunEvidence(state, events, agentExecutions, teamSessions, workerRuntimes, invocationLedger),
+    taskRunEvidence: buildTaskRunEvidence(state, events, agentExecutionViews, teamSessionViews, workerRuntimeViews, invocationLedger),
+    taskEvidenceView,
     tasks: state.tasks,
-    agentExecutions,
-    teamSessions,
-    workerRuntimes,
+    agentExecutions: agentExecutionViews,
+    teamSessions: teamSessionViews,
+    workerRuntimes: workerRuntimeViews,
     invocationLedger
   };
 }
 
-async function listAgentExecutionRecords(projectRoot: string, runId: string): Promise<AgentExecutionRecordView[]> {
-  const recordsDir = getAgentExecutionsDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<AgentExecutionRecordView>(recordsDir);
-  return records.sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.executionId.localeCompare(right.executionId));
-}
-
-async function listTeamSessionRecords(projectRoot: string, runId: string): Promise<TeamSessionRecordView[]> {
-  const recordsDir = getTeamSessionsDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<TeamSessionRecordView>(recordsDir);
-  return records.sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.teamId.localeCompare(right.teamId));
-}
-
-async function listResidentWorkerRuntimeRecords(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecordView[]> {
-  const recordsDir = getWorkerRuntimesDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<ResidentWorkerRuntimeRecordView>(recordsDir);
-  return records.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt) || left.runtimeId.localeCompare(right.runtimeId));
-}
-
-async function readJsonRecords<T>(recordsDir: string): Promise<T[]> {
-  const entries = await readdir(recordsDir, { withFileTypes: true });
-  const records: T[] = [];
-  for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith('.json'))) {
-    try {
-      const raw = await readFile(path.join(recordsDir, entry.name), 'utf8');
-      records.push(JSON.parse(raw) as T);
-    } catch {
-      continue;
-    }
-  }
-  return records;
-}
 
 function buildTaskRunEvidence(state: RunState, events: RuntimeEvent[], agentExecutions: AgentExecutionRecordView[] = [], teamSessions: TeamSessionRecordView[] = [], workerRuntimes: ResidentWorkerRuntimeRecordView[] = [], invocationLedger: InvocationLedgerEntry[] = []): TaskRunEvidenceContract {
   return {

package/node_modules/@sdd-agent-platform/core/src/run-state/invocation-ledger.ts

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { INVOCATION_LEDGER_CONTRACT_VERSION } from '../contracts.js';
-import { getInvocationLedgerPath } from '../runtime-paths.js';
+import { getLegacyInvocationLedgerPath } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
 import { RuntimeStoreError, legacyImportId, readRuntimeActivities, recordLegacyImportFailure, recordRuntimeActivity, withRuntimeStore } from '../storage/runtime-store.js';
 import type { InvocationLedgerEntry } from './model.js';
@@ -24,7 +24,7 @@ export async function listInvocationLedgerEntries(projectRoot: string, runId: st
   if (entries.length > 0) {
     return entries;
   }
-  const ledgerPath = getInvocationLedgerPath(projectRoot, runId);
+  const ledgerPath = getLegacyInvocationLedgerPath(projectRoot, runId);
   await importLegacyInvocationLedgerIfNeeded(projectRoot, runId, ledgerPath);
   return readRuntimeActivities(projectRoot, runId);
 }

package/node_modules/@sdd-agent-platform/core/src/run-state/model.ts

@@ -25,8 +25,13 @@ export interface RunDocumentSnapshot {
   specHash: string | null;
   planHash: string | null;
   tasksHash: string | null;
+  specContractHash: string | null;
+  planContractHash: string | null;
+  tasksContractHash: string | null;
   planBasedOnSpecHash: string | null;
   tasksBasedOnPlanHash: string | null;
+  planBasedOnSpecContractHash: string | null;
+  tasksBasedOnPlanContractHash: string | null;
 }
 
 export interface RunStateContractValidationIssue {
@@ -117,6 +122,28 @@ export interface RunStateWorktreeLifecycleRecord {
   dirty: boolean;
 }
 
+export type RunTaskImplementationStatus = 'not_started' | 'running' | 'implemented' | 'blocked' | 'failed';
+
+export type RunTaskVerificationStatus = 'not_run' | 'pending_batch' | 'ready_for_validation' | 'running' | 'pass' | 'pass_with_gaps' | 'blocked' | 'failed';
+
+export interface RunStateTaskRuntime {
+  status: string;
+  implementationStatus?: RunTaskImplementationStatus;
+  verificationStatus?: RunTaskVerificationStatus;
+  validationBatch?: string | null;
+  validationTiming?: 'task_end' | 'batch_end' | 'wave_end';
+  requiresVerifyBeforeNext?: boolean;
+  gaps?: unknown[];
+  artifacts?: string[];
+  testStatus?: string;
+  validationStatus?: string;
+  verifyStatus?: string;
+  workflowGateStatus?: string;
+  workflowGateDecisionId?: string;
+  evidence?: string[];
+  acceptanceCoverage?: unknown[];
+}
+
 export interface RunState {
   contract: typeof RUN_STATE_CONTRACT;
   runtimeVersion: typeof RUNTIME_VERSION;
@@ -136,7 +163,7 @@ export interface RunState {
   eventLogPath: string;
   artifactRoot: string;
   lifecycleDecision: RunStateLifecycleDecisionRecord | null;
-  tasks: Record<string, unknown>;
+  tasks: Record<string, RunStateTaskRuntime>;
   agents: Record<string, unknown>;
   delegations: Record<string, RunStateDelegationRecord>;
   artifacts: ArtifactIndexEntry[];

package/node_modules/@sdd-agent-platform/core/src/run-state/run-state.test.ts

@@ -8,6 +8,8 @@ import { initProject } from '../config/init-project.js';
 import { readRunEvents } from './events.js';
 import { createRun, listRuns, readRunState, writeRunState } from './run-state.js';
 import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { getRunDir } from '../runtime-paths.js';
+import { exists } from '../storage/json-io.js';
 
 test('createRun writes state and append-only events', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-'));
@@ -21,6 +23,7 @@ test('createRun writes state and append-only events', async () => {
     const events = await readRunEvents(root, state.runId);
     assert.equal(events.some((event) => event.event === 'run_started'), true);
     assert.equal(events.some((event) => event.event === 'lifecycle_decision_recorded'), true);
+    assert.equal(await exists(getRunDir(root, state.runId)), false);
   } finally {
     await rm(root, { recursive: true, force: true });
   }

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

@@ -2,13 +2,10 @@ import { createHash } from 'node:crypto';
 import { mkdir, readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import {
-  getAgentExecutionsDir,
   getEvidenceDir,
+  getLegacyRunDir,
   getProjectConfigPath,
-  getRunDir,
-  getRunsDir,
-  getTeamSessionsDir,
-  getWorkerRuntimesDir
+  getRunsDir
 } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
 import { RuntimeStoreError, legacyImportId, listRuntimeRunStates, readRuntimeRunState, recordLegacyImportFailure, runtimeScopedId, upsertRuntimeRunState, withRuntimeStore } from '../storage/runtime-store.js';
@@ -26,7 +23,7 @@ export async function readRunState(projectRoot: string, runId: string): Promise<
   if (storedState) {
     return normalizeRunState(storedState);
   }
-  const statePath = path.join(getRunDir(projectRoot, runId), 'state.json');
+  const statePath = path.join(getLegacyRunDir(projectRoot, runId), 'state.json');
   const legacyState = await importLegacyRunStateIfNeeded(projectRoot, runId, statePath);
   if (legacyState) {
     return legacyState;
@@ -94,14 +91,6 @@ export async function createRun(projectRoot: string, options: CreateRunOptions =
   await mkdir(getRunsDir(projectRoot), { recursive: true });
   const runId = options.runId ?? await createUniqueRunId(projectRoot);
 
-  const agentExecutionsDir = getAgentExecutionsDir(projectRoot, runId);
-  const teamSessionsDir = getTeamSessionsDir(projectRoot, runId);
-  const workerRuntimesDir = getWorkerRuntimesDir(projectRoot, runId);
-  await Promise.all([
-    mkdir(agentExecutionsDir, { recursive: true }),
-    mkdir(teamSessionsDir, { recursive: true }),
-    mkdir(workerRuntimesDir, { recursive: true })
-  ]);
 
   const now = new Date().toISOString();
   const state: RunState = {
@@ -175,7 +164,7 @@ export async function createUniqueRunId(projectRoot: string): Promise<string> {
   for (let sequence = 1; sequence <= 999; sequence += 1) {
     const runId = `${base}-${String(sequence).padStart(3, '0')}`;
     const storedState = await readRuntimeRunState(projectRoot, runId);
-    if (!storedState && !await exists(getRunDir(projectRoot, runId))) {
+    if (!storedState && !await exists(getLegacyRunDir(projectRoot, runId))) {
       return runId;
     }
   }
@@ -261,8 +250,13 @@ export function normalizeRunDocumentSnapshot(snapshot: unknown): RunDocumentSnap
     specHash: stringOrNull(snapshot.specHash),
     planHash: stringOrNull(snapshot.planHash),
     tasksHash: stringOrNull(snapshot.tasksHash),
+    specContractHash: stringOrNull(snapshot.specContractHash),
+    planContractHash: stringOrNull(snapshot.planContractHash),
+    tasksContractHash: stringOrNull(snapshot.tasksContractHash),
     planBasedOnSpecHash: stringOrNull(snapshot.planBasedOnSpecHash),
-    tasksBasedOnPlanHash: stringOrNull(snapshot.tasksBasedOnPlanHash)
+    tasksBasedOnPlanHash: stringOrNull(snapshot.tasksBasedOnPlanHash),
+    planBasedOnSpecContractHash: stringOrNull(snapshot.planBasedOnSpecContractHash),
+    tasksBasedOnPlanContractHash: stringOrNull(snapshot.tasksBasedOnPlanContractHash)
   };
 }
 
@@ -271,8 +265,13 @@ export function emptyRunDocumentSnapshot(): RunDocumentSnapshot {
     specHash: null,
     planHash: null,
     tasksHash: null,
+    specContractHash: null,
+    planContractHash: null,
+    tasksContractHash: null,
     planBasedOnSpecHash: null,
-    tasksBasedOnPlanHash: null
+    tasksBasedOnPlanHash: null,
+    planBasedOnSpecContractHash: null,
+    tasksBasedOnPlanContractHash: null
   };
 }
 
@@ -324,8 +323,13 @@ async function resolveCreateRunScope(projectRoot: string, branch: string, taskId
       specHash: model.documents.specHash ?? null,
       planHash: model.documents.planHash ?? null,
       tasksHash: model.documents.tasksHash ?? null,
+      specContractHash: model.documents.specContractHash ?? null,
+      planContractHash: model.documents.planContractHash ?? null,
+      tasksContractHash: model.documents.tasksContractHash ?? null,
       planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
-      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null
+      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
+      planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
+      tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
     }
   };
 }