voratiq 0.1.0-beta.21 → 0.1.0-beta.22

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

@@ -9,6 +9,30 @@ export { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_REC
 const RUNNING_MESSAGE_RECORD_STATUSES = [
     "running",
 ];
+const MESSAGE_TARGET_KIND_VALUES = [
+    "interactive",
+    "run",
+    "spec",
+    "reduce",
+    "verify",
+];
+export const messageTargetKindSchema = z.enum(MESSAGE_TARGET_KIND_VALUES);
+export const messageTargetSchema = z
+    .object({
+    kind: messageTargetKindSchema,
+    sessionId: z.string().min(1),
+    agentId: agentIdSchema.optional(),
+})
+    .strict()
+    .superRefine((target, ctx) => {
+    if (target.kind === "interactive" && target.agentId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["agentId"],
+            message: "interactive message targets must not persist an `agentId` lane reference",
+        });
+    }
+});
 export const messageRecipientEntrySchema = z
     .object({
     agentId: agentIdSchema,
@@ -48,6 +72,7 @@ export const messageRecordSchema = z
     status: messageStatusSchema,
     baseRevisionSha: z.string().optional(),
     prompt: z.string(),
+    target: messageTargetSchema.optional(),
     sourceInteractiveSessionId: z.string().optional(),
     extraContext: z.array(persistedExtraContextPathSchema).optional(),
     extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),

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

@@ -8,6 +8,7 @@ import { stageExtraContextFiles, } from "../../../competition/shared/extra-conte
 import { composeStageSandboxPolicy } from "../../../competition/shared/sandbox-policy.js";
 import { createTeardownController, runTeardown, } from "../../../competition/shared/teardown.js";
 import { readMessageRecords } from "../../../domain/message/persistence/adapter.js";
+import { deriveReductionStatusFromReducers } from "../../../domain/reduce/competition/finalize.js";
 import { validateReductionOutputContract } from "../../../domain/reduce/competition/output-validation.js";
 import { buildReducePrompt } from "../../../domain/reduce/competition/prompt.js";
 import { parseReductionArtifact } from "../../../domain/reduce/competition/reduction.js";
@@ -323,7 +324,7 @@ export function createReduceCompetitionAdapter(input) {
             };
         },
         finalizeCompetition: async () => {
-            const failed = failure !== undefined;
+            let finalizedStatus;
             const completedAt = new Date().toISOString();
             await rewriteReductionRecord({
                 root,
@@ -335,25 +336,30 @@ export function createReduceCompetitionAdapter(input) {
                         startedAt: record.startedAt ?? completedAt,
                         completedAt,
                     });
-                    const status = failed ? "failed" : "succeeded";
+                    const status = deriveReductionStatusFromReducers(record.reducers);
+                    finalizedStatus = status;
                     return {
                         ...record,
                         status,
                         ...recordComplete,
-                        error: failed ? toErrorMessage(failure) : null,
+                        error: status === "failed" && failure !== undefined
+                            ? toErrorMessage(failure)
+                            : null,
                         reducers: record.reducers.map((reducer) => {
                             if (reducer.status !== "running" && reducer.status !== "queued") {
                                 return reducer;
                             }
                             return {
                                 ...reducer,
-                                status,
+                                status: "failed",
                                 ...buildOperationLifecycleCompleteFields({
                                     existing: reducer,
                                     startedAt: reducer.startedAt ?? recordComplete.completedAt,
                                     completedAt: recordComplete.completedAt,
                                 }),
-                                error: failed ? toErrorMessage(failure) : null,
+                                error: failure !== undefined
+                                    ? toErrorMessage(failure)
+                                    : reducer.error,
                             };
                         }),
                     };
@@ -396,10 +402,11 @@ export function createReduceCompetitionAdapter(input) {
                 });
             }
             else {
+                const status = finalizedStatus ?? (failure === undefined ? "succeeded" : "failed");
                 emitStageProgressEvent(renderer, {
                     type: "stage.status",
                     stage: "reduce",
-                    status: failed ? "failed" : "succeeded",
+                    status,
                 });
             }
             await runTeardown(teardown);
@@ -617,6 +624,9 @@ async function prepareVerificationTargetContext(options) {
             ...(method.error ? { error: method.error } : {}),
         });
     }
+    if (artifacts.length === 0) {
+        throw new Error(`Verification session \`${target.id}\` has no reduction-ready artifacts.`);
+    }
     return {
         target,
         displayPath: `.voratiq/verify/sessions/${record.sessionId}`,
@@ -647,7 +657,11 @@ async function prepareReductionTargetContextInternal(options) {
     }
     const stagedFiles = [];
     const artifacts = [];
-    for (const reducer of record.reducers) {
+    const succeededReducers = record.reducers.filter((reducer) => reducer.status === "succeeded" && typeof reducer.outputPath === "string");
+    if (succeededReducers.length === 0) {
+        throw new Error(`Reduction session \`${target.id}\` has no successful reduction artifacts.`);
+    }
+    for (const reducer of succeededReducers) {
         const reductionRelative = `inputs/reducers/${reducer.agentId}/reduction.md`;
         stagedFiles.push({
             sourceAbsolutePath: resolvePath(root, reducer.outputPath),

package/dist/domain/reduce/competition/finalize.d.ts

@@ -0,0 +1,7 @@
+import type { ReductionRecord } from "../model/types.js";
+/**
+ * Derive the reduction session status from per-reducer outcomes.
+ * Returns "succeeded" when at least one reducer succeeds, "aborted" when all
+ * terminal reducers aborted, and "failed" otherwise.
+ */
+export declare function deriveReductionStatusFromReducers(reducers: readonly Pick<ReductionRecord["reducers"][number], "status">[]): ReductionRecord["status"];

package/dist/domain/reduce/competition/finalize.js

@@ -0,0 +1,19 @@
+/**
+ * Derive the reduction session status from per-reducer outcomes.
+ * Returns "succeeded" when at least one reducer succeeds, "aborted" when all
+ * terminal reducers aborted, and "failed" otherwise.
+ */
+export function deriveReductionStatusFromReducers(reducers) {
+    const terminalReducers = reducers.filter((reducer) => reducer.status === "succeeded" ||
+        reducer.status === "failed" ||
+        reducer.status === "aborted");
+    const hasSucceeded = terminalReducers.some((reducer) => reducer.status === "succeeded");
+    if (hasSucceeded) {
+        return "succeeded";
+    }
+    if (terminalReducers.length > 0 &&
+        terminalReducers.every((reducer) => reducer.status === "aborted")) {
+        return "aborted";
+    }
+    return "failed";
+}

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

@@ -4,8 +4,8 @@ export type { ReductionStatus };
 export { reductionStatusSchema, TERMINAL_REDUCTION_STATUSES };
 export declare const reductionTargetTypeSchema: z.ZodEnum<{
     message: "message";
-    reduce: "reduce";
     spec: "spec";
+    reduce: "reduce";
     run: "run";
     verify: "verify";
 }>;
@@ -13,8 +13,8 @@ export type ReductionTargetType = z.infer<typeof reductionTargetTypeSchema>;
 export declare const reductionTargetSchema: z.ZodObject<{
     type: z.ZodEnum<{
         message: "message";
-        reduce: "reduce";
         spec: "spec";
+        reduce: "reduce";
         run: "run";
         verify: "verify";
     }>;
@@ -60,8 +60,8 @@ export declare const reductionRecordSchema: z.ZodObject<{
     target: z.ZodObject<{
         type: z.ZodEnum<{
             message: "message";
-            reduce: "reduce";
             spec: "spec";
+            reduce: "reduce";
             run: "run";
             verify: "verify";
         }>;

package/dist/domain/run/competition/agents/artifacts.js

@@ -7,7 +7,9 @@ import { gitAddAll, gitCommitAll, gitDiff, gitDiffShortStat, gitHasStagedChanges
 import { enforceCredentialExclusion } from "../../../../workspace/credential-guard.js";
 import { cleanupWorkspaceDependencies, ensureWorkspaceDependencies, WorkspaceDependencyCleanupError, } from "../../../../workspace/dependencies.js";
 import { promoteWorkspaceFile } from "../../../../workspace/promotion.js";
+import { WORKSPACE_SHIM_RELATIVE_PATH } from "../../../../workspace/shim.js";
 import { WORKSPACE_SUMMARY_FILENAME, } from "./workspace.js";
+const EXPORT_EXCLUDED_PATHS = [WORKSPACE_SHIM_RELATIVE_PATH.join("/")];
 export async function collectAgentArtifacts(options) {
     const { baseRevisionSha, workspacePaths, root, environment, persona } = options;
     const { workspacePath, artifactsPath, summaryPath, diffPath } = workspacePaths;
@@ -33,7 +35,7 @@ export async function collectAgentArtifacts(options) {
     let artifactResult;
     let dependencyRestoreError;
     try {
-        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
+        await runGitStep("Git add failed", async () => gitAddAll(workspacePath, EXPORT_EXCLUDED_PATHS));
         const hasChangesBeforeSummary = await gitHasStagedChanges(workspacePath);
         if (!hasChangesBeforeSummary) {
             throw new AgentProcessError({
@@ -45,7 +47,7 @@ export async function collectAgentArtifacts(options) {
             artifactsPath,
             summaryPath,
         });
-        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
+        await runGitStep("Git add failed", async () => gitAddAll(workspacePath, EXPORT_EXCLUDED_PATHS));
         const hasChanges = await gitHasStagedChanges(workspacePath);
         if (!hasChanges) {
             throw new AgentProcessError({

package/dist/domain/run/competition/errors.d.ts

@@ -52,7 +52,7 @@ export declare class AuthProviderStageError extends RunCommandError {
 export declare class RunPreflightError extends RunCommandError {
     readonly kind: "workspace-setup";
     readonly issues: readonly PreflightIssue[];
-    constructor(issues: readonly PreflightIssue[], hintLines?: readonly string[]);
+    constructor(issues: readonly PreflightIssue[], preProviderIssueCount?: number);
 }
 export declare class NoAgentsEnabledError extends RunCommandError {
     readonly kind: "workspace-setup";

package/dist/domain/run/competition/errors.js

@@ -1,4 +1,4 @@
-import { formatPreflightIssueLines, PREFLIGHT_HINT, } from "../../../competition/shared/preflight.js";
+import { formatOperatorPreflightIssueLines, resolveOperatorPreflightHintLines, } from "../../../preflight/formatting.js";
 import { DisplayableError, } from "../../../utils/errors.js";
 export class RunCommandError extends DisplayableError {
     constructor(message, options = {}) {
@@ -76,16 +76,13 @@ export class AuthProviderStageError extends RunCommandError {
         });
     }
 }
-const RUN_PREFLIGHT_UNLABELED_AGENT_IDS = ["settings"];
 export class RunPreflightError extends RunCommandError {
     kind = "workspace-setup";
     issues;
-    constructor(issues, hintLines = [PREFLIGHT_HINT]) {
+    constructor(issues, preProviderIssueCount = issues.length) {
         super("Preflight failed. Aborting run.", {
-            detailLines: formatPreflightIssueLines(issues, {
-                unlabeledAgentIds: RUN_PREFLIGHT_UNLABELED_AGENT_IDS,
-            }),
-            hintLines,
+            detailLines: formatOperatorPreflightIssueLines(issues),
+            hintLines: resolveOperatorPreflightHintLines(issues, preProviderIssueCount) ?? [],
         });
         this.issues = Array.from(issues);
         this.name = "RunPreflightError";

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<{