voratiq 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/domain/run/model/types.d.ts

@@ -3,8 +3,327 @@ import { type AgentStatus, agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMIN
 import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
 export type { AgentStatus };
 export { agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES, };
+export declare const runSpecTargetKindSchema: z.ZodEnum<{
+    file: "file";
+    spec: "spec";
+}>;
+export declare const runSpecProvenanceLineageSchema: z.ZodEnum<{
+    exact: "exact";
+    derived: "derived";
+    derived_modified: "derived_modified";
+    invalid: "invalid";
+}>;
+export declare const runSpecProvenanceIssueSchema: z.ZodEnum<{
+    malformed_frontmatter: "malformed_frontmatter";
+    stale_source: "stale_source";
+}>;
+export declare const runSpecContentHashSchema: z.ZodString;
+export declare const runSpecSourceDescriptorSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"spec">;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    outputPath: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type RunSpecSourceDescriptor = z.infer<typeof runSpecSourceDescriptorSchema>;
+export declare const runSpecSourceHintSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const exactRunSpecProvenanceSchema: z.ZodObject<{
+    lineage: z.ZodLiteral<"exact">;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const derivedRunSpecProvenanceSchema: z.ZodObject<{
+    lineage: z.ZodLiteral<"derived">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    currentContentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const derivedModifiedRunSpecProvenanceSchema: z.ZodObject<{
+    lineage: z.ZodLiteral<"derived_modified">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    currentContentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const invalidRunSpecProvenanceSchema: z.ZodObject<{
+    lineage: z.ZodLiteral<"invalid">;
+    issueCode: z.ZodEnum<{
+        malformed_frontmatter: "malformed_frontmatter";
+        stale_source: "stale_source";
+    }>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    currentContentHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const runSpecProvenanceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    lineage: z.ZodLiteral<"exact">;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    lineage: z.ZodLiteral<"derived">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    currentContentHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    lineage: z.ZodLiteral<"derived_modified">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        outputPath: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    currentContentHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    lineage: z.ZodLiteral<"invalid">;
+    issueCode: z.ZodEnum<{
+        malformed_frontmatter: "malformed_frontmatter";
+        stale_source: "stale_source";
+    }>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+        contentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    currentContentHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export type RunSpecProvenance = z.infer<typeof runSpecProvenanceSchema>;
+export declare const fileRunSpecTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    provenance: z.ZodOptional<z.ZodObject<{
+        lineage: z.ZodLiteral<"invalid">;
+        issueCode: z.ZodEnum<{
+            malformed_frontmatter: "malformed_frontmatter";
+            stale_source: "stale_source";
+        }>;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            outputPath: z.ZodOptional<z.ZodString>;
+            contentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        currentContentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sessionRunSpecTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"spec">;
+    sessionId: z.ZodString;
+    provenance: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        lineage: z.ZodLiteral<"exact">;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"derived">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"derived_modified">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"invalid">;
+        issueCode: z.ZodEnum<{
+            malformed_frontmatter: "malformed_frontmatter";
+            stale_source: "stale_source";
+        }>;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            outputPath: z.ZodOptional<z.ZodString>;
+            contentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        currentContentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const runSpecTargetSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    provenance: z.ZodOptional<z.ZodObject<{
+        lineage: z.ZodLiteral<"invalid">;
+        issueCode: z.ZodEnum<{
+            malformed_frontmatter: "malformed_frontmatter";
+            stale_source: "stale_source";
+        }>;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            outputPath: z.ZodOptional<z.ZodString>;
+            contentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        currentContentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"spec">;
+    sessionId: z.ZodString;
+    provenance: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        lineage: z.ZodLiteral<"exact">;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"derived">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"derived_modified">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            agentId: z.ZodString;
+            outputPath: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        currentContentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        lineage: z.ZodLiteral<"invalid">;
+        issueCode: z.ZodEnum<{
+            malformed_frontmatter: "malformed_frontmatter";
+            stale_source: "stale_source";
+        }>;
+        source: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+            outputPath: z.ZodOptional<z.ZodString>;
+            contentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        currentContentHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>]>;
+export type RunSpecTarget = z.infer<typeof runSpecTargetSchema>;
 export declare const runSpecDescriptorSchema: z.ZodObject<{
     path: z.ZodString;
+    target: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        provenance: z.ZodOptional<z.ZodObject<{
+            lineage: z.ZodLiteral<"invalid">;
+            issueCode: z.ZodEnum<{
+                malformed_frontmatter: "malformed_frontmatter";
+                stale_source: "stale_source";
+            }>;
+            source: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                agentId: z.ZodOptional<z.ZodString>;
+                outputPath: z.ZodOptional<z.ZodString>;
+                contentHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            currentContentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spec">;
+        sessionId: z.ZodString;
+        provenance: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            lineage: z.ZodLiteral<"exact">;
+            source: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"spec">;
+                sessionId: z.ZodString;
+                agentId: z.ZodString;
+                outputPath: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            lineage: z.ZodLiteral<"derived">;
+            source: z.ZodObject<{
+                kind: z.ZodLiteral<"spec">;
+                sessionId: z.ZodString;
+                agentId: z.ZodString;
+                outputPath: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            currentContentHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            lineage: z.ZodLiteral<"derived_modified">;
+            source: z.ZodObject<{
+                kind: z.ZodLiteral<"spec">;
+                sessionId: z.ZodString;
+                agentId: z.ZodString;
+                outputPath: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            currentContentHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            lineage: z.ZodLiteral<"invalid">;
+            issueCode: z.ZodEnum<{
+                malformed_frontmatter: "malformed_frontmatter";
+                stale_source: "stale_source";
+            }>;
+            source: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                agentId: z.ZodOptional<z.ZodString>;
+                outputPath: z.ZodOptional<z.ZodString>;
+                contentHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            currentContentHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>]>>;
 }, z.core.$strip>;
 export type RunSpecDescriptor = z.infer<typeof runSpecDescriptorSchema>;
 export declare const CHAT_USAGE_PROVIDER_IDS: readonly ["claude", "codex", "gemini"];
@@ -224,6 +543,71 @@ export declare const runRecordSchema: z.ZodObject<{
     rootPath: z.ZodString;
     spec: z.ZodObject<{
         path: z.ZodString;
+        target: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            provenance: z.ZodOptional<z.ZodObject<{
+                lineage: z.ZodLiteral<"invalid">;
+                issueCode: z.ZodEnum<{
+                    malformed_frontmatter: "malformed_frontmatter";
+                    stale_source: "stale_source";
+                }>;
+                source: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    agentId: z.ZodOptional<z.ZodString>;
+                    outputPath: z.ZodOptional<z.ZodString>;
+                    contentHash: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                currentContentHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            sessionId: z.ZodString;
+            provenance: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                lineage: z.ZodLiteral<"exact">;
+                source: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodLiteral<"spec">;
+                    sessionId: z.ZodString;
+                    agentId: z.ZodString;
+                    outputPath: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                lineage: z.ZodLiteral<"derived">;
+                source: z.ZodObject<{
+                    kind: z.ZodLiteral<"spec">;
+                    sessionId: z.ZodString;
+                    agentId: z.ZodString;
+                    outputPath: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                currentContentHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                lineage: z.ZodLiteral<"derived_modified">;
+                source: z.ZodObject<{
+                    kind: z.ZodLiteral<"spec">;
+                    sessionId: z.ZodString;
+                    agentId: z.ZodString;
+                    outputPath: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                currentContentHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                lineage: z.ZodLiteral<"invalid">;
+                issueCode: z.ZodEnum<{
+                    malformed_frontmatter: "malformed_frontmatter";
+                    stale_source: "stale_source";
+                }>;
+                source: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodOptional<z.ZodLiteral<"spec">>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    agentId: z.ZodOptional<z.ZodString>;
+                    outputPath: z.ZodOptional<z.ZodString>;
+                    contentHash: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                currentContentHash: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>;
     }, z.core.$strip>;
     extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/domain/run/model/types.js

@@ -5,8 +5,95 @@ import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-s
 import { agentStatusSchema, applyStatusSchema as applyStatusValueSchema, IN_PROGRESS_AGENT_STATUSES, runStatusSchema, TERMINAL_AGENT_STATUSES, TERMINAL_RUN_STATUSES, } from "../../../status/index.js";
 import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
 export { agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES, };
+const RUN_SPEC_TARGET_KIND_VALUES = ["file", "spec"];
+const RUN_SPEC_PROVENANCE_LINEAGE_VALUES = [
+    "exact",
+    "derived",
+    "derived_modified",
+    "invalid",
+];
+const RUN_SPEC_PROVENANCE_ISSUE_VALUES = [
+    "malformed_frontmatter",
+    "stale_source",
+];
+export const runSpecTargetKindSchema = z.enum(RUN_SPEC_TARGET_KIND_VALUES);
+export const runSpecProvenanceLineageSchema = z.enum(RUN_SPEC_PROVENANCE_LINEAGE_VALUES);
+export const runSpecProvenanceIssueSchema = z.enum(RUN_SPEC_PROVENANCE_ISSUE_VALUES);
+export const runSpecContentHashSchema = z
+    .string()
+    .regex(/^sha256:[a-f0-9]{64}$/u);
+export const runSpecSourceDescriptorSchema = z
+    .object({
+    kind: z.literal("spec"),
+    sessionId: z.string().min(1),
+    agentId: agentIdSchema,
+    outputPath: repoRelativeRecordPathSchema,
+    contentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const runSpecSourceHintSchema = z
+    .object({
+    kind: z.literal("spec").optional(),
+    sessionId: z.string().min(1).optional(),
+    agentId: agentIdSchema.optional(),
+    outputPath: repoRelativeRecordPathSchema.optional(),
+    contentHash: runSpecContentHashSchema.optional(),
+})
+    .strict();
+export const exactRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("exact"),
+    source: runSpecSourceDescriptorSchema.optional(),
+})
+    .strict();
+export const derivedRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("derived"),
+    source: runSpecSourceDescriptorSchema,
+    currentContentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const derivedModifiedRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("derived_modified"),
+    source: runSpecSourceDescriptorSchema,
+    currentContentHash: runSpecContentHashSchema,
+})
+    .strict();
+export const invalidRunSpecProvenanceSchema = z
+    .object({
+    lineage: z.literal("invalid"),
+    issueCode: runSpecProvenanceIssueSchema,
+    source: runSpecSourceHintSchema.optional(),
+    currentContentHash: runSpecContentHashSchema.optional(),
+})
+    .strict();
+export const runSpecProvenanceSchema = z.union([
+    exactRunSpecProvenanceSchema,
+    derivedRunSpecProvenanceSchema,
+    derivedModifiedRunSpecProvenanceSchema,
+    invalidRunSpecProvenanceSchema,
+]);
+export const fileRunSpecTargetSchema = z
+    .object({
+    kind: z.literal("file"),
+    provenance: invalidRunSpecProvenanceSchema.optional(),
+})
+    .strict();
+export const sessionRunSpecTargetSchema = z
+    .object({
+    kind: z.literal("spec"),
+    sessionId: z.string().min(1),
+    provenance: runSpecProvenanceSchema.optional(),
+})
+    .strict();
+export const runSpecTargetSchema = z.union([
+    fileRunSpecTargetSchema,
+    sessionRunSpecTargetSchema,
+]);
 export const runSpecDescriptorSchema = z.object({
     path: repoRelativeRecordPathSchema,
+    target: runSpecTargetSchema.optional(),
 });
 const CHAT_ARTIFACT_FORMATS = [
     "json",

package/dist/domain/spec/competition/adapter.d.ts

@@ -15,6 +15,7 @@ export interface SpecCompetitionExecution {
     readonly agentId: string;
     readonly outputPath?: string;
     readonly dataPath?: string;
+    readonly contentHash?: `sha256:${string}`;
     readonly status: "succeeded" | "failed";
     readonly tokenUsage?: ExtractedTokenUsage;
     readonly tokenUsageResult: TokenUsageResult;

package/dist/domain/spec/competition/adapter.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { detectAgentProcessFailureDetail } from "../../../agents/runtime/failures.js";
@@ -5,7 +6,7 @@ import { runSandboxedAgent } from "../../../agents/runtime/harness.js";
 import { teardownSessionAuth } from "../../../agents/runtime/registry.js";
 import { stageExtraContextFiles, } from "../../../competition/shared/extra-context.js";
 import { composeStageSandboxPolicy } from "../../../competition/shared/sandbox-policy.js";
-import { createTeardownController, runTeardown, } from "../../../competition/shared/teardown.js";
+import { createTeardownController, registerScratchWorkspaceTeardownPaths, runTeardown, } from "../../../competition/shared/teardown.js";
 import { buildUnavailableTokenUsageResult, resolveTokenUsage, } from "../../../domain/shared/token-usage.js";
 import { buildSpecPrompt } from "../../../domain/spec/competition/prompt.js";
 import { parseSpecData } from "../../../domain/spec/model/output.js";
@@ -13,9 +14,9 @@ import { toErrorMessage } from "../../../utils/errors.js";
 import { normalizePathForDisplay, relativeToRoot, } from "../../../utils/path.js";
 import { slugify } from "../../../utils/slug.js";
 import { extractProviderNativeTokenUsageForSession } from "../../../workspace/chat/native-usage.js";
+import { VORATIQ_SPEC_DIR } from "../../../workspace/constants.js";
 import { buildAgentSessionWorkspacePaths, scaffoldAgentWorkspace, } from "../../../workspace/layout.js";
 import { promoteWorkspaceFile } from "../../../workspace/promotion.js";
-import { VORATIQ_SPEC_DIR } from "../../../workspace/structure.js";
 const SPEC_MARKDOWN_FILENAME = "spec.md";
 const SPEC_DATA_FILENAME = "spec.json";
 export function createSpecCompetitionAdapter(input) {
@@ -40,7 +41,7 @@ export function createSpecCompetitionAdapter(input) {
                     sessionId,
                     agentId: candidate.id,
                 });
-                registerScratchWorkspaceTeardown(teardown, workspacePaths, candidate.id);
+                registerScratchWorkspaceTeardownPaths(teardown, workspacePaths, candidate.id);
                 try {
                     await scaffoldAgentWorkspace(workspacePaths);
                     await stageExtraContextFiles({
@@ -138,7 +139,7 @@ export function createSpecCompetitionAdapter(input) {
                 }
                 const stagedMarkdownPath = join(workspacePaths.workspacePath, SPEC_MARKDOWN_FILENAME);
                 const stagedDataPath = join(workspacePaths.workspacePath, SPEC_DATA_FILENAME);
-                await readFile(stagedMarkdownPath, "utf8");
+                const markdownContent = await readFile(stagedMarkdownPath, "utf8");
                 const specData = parseSpecData(await readFile(stagedDataPath, "utf8"));
                 const artifactBasename = slugify(specData.title, "spec");
                 const artifactMarkdownFilename = `${artifactBasename}.md`;
@@ -161,6 +162,7 @@ export function createSpecCompetitionAdapter(input) {
                     agentId: candidate.id,
                     outputPath: normalizePathForDisplay(relativeToRoot(root, markdownPromoteResult.artifactPath)),
                     dataPath: normalizePathForDisplay(relativeToRoot(root, dataPromoteResult.artifactPath)),
+                    contentHash: hashSpecContent(markdownContent),
                     status: "succeeded",
                     tokenUsage,
                     tokenUsageResult,
@@ -185,12 +187,9 @@ export function createSpecCompetitionAdapter(input) {
         sortResults: compareSpecExecutionsByAgentId,
     };
 }
-function registerScratchWorkspaceTeardown(teardown, workspacePaths, agentId) {
-    teardown.addPath(workspacePaths.workspacePath, `${agentId} workspace`);
-    teardown.addPath(workspacePaths.contextPath, `${agentId} context`);
-    teardown.addPath(workspacePaths.runtimePath, `${agentId} runtime`);
-    teardown.addPath(workspacePaths.sandboxPath, `${agentId} sandbox`);
-}
 function compareSpecExecutionsByAgentId(left, right) {
     return left.agentId.localeCompare(right.agentId);
 }
+function hashSpecContent(content) {
+    return `sha256:${createHash("sha256").update(content, "utf8").digest("hex")}`;
+}

package/dist/domain/spec/model/mutators.d.ts

@@ -0,0 +1,20 @@
+import type { SpecAgentEntry, SpecRecord, SpecRecordStatus } from "./types.js";
+export interface SpecRecordMutators {
+    recordAgentRunning: (options: {
+        agentId: string;
+        timestamp?: string;
+    }) => Promise<SpecRecord>;
+    recordAgentSnapshot: (agent: SpecAgentEntry) => Promise<SpecRecord>;
+    completeSpec: (options: {
+        status: SpecRecordStatus;
+        agents?: readonly SpecAgentEntry[];
+        error?: string | null;
+    }) => Promise<SpecRecord>;
+    readRecord: () => Promise<SpecRecord | undefined>;
+}
+export interface CreateSpecRecordMutatorsInput {
+    readonly root: string;
+    readonly specsFilePath: string;
+    readonly sessionId: string;
+}
+export declare function createSpecRecordMutators(input: CreateSpecRecordMutatorsInput): SpecRecordMutators;