intentdna 1.9.3 → 1.9.5

package/dist/runtime/providers/claude.js

@@ -1,11 +1,57 @@
-import { decodeDeclaredOutputs, MalformedProviderResultError, } from "../execution-provider.js";
+import { decodeDeclaredOutputs, MalformedProviderResultError, ProviderTerminatedError, } from "../execution-provider.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+const CLAUDE_HOOK_TERMINAL_REASONS = new Set([
+    "hook_stopped",
+    "stop_hook_prevented",
+]);
+const CLAUDE_DIAGNOSTIC_TOOL_NAMES = new Set([
+    "Bash",
+    "Edit",
+    "Glob",
+    "Grep",
+    "NotebookEdit",
+    "Read",
+    "Task",
+    "WebFetch",
+    "WebSearch",
+    "Write",
+]);
+function summarizePermissionDenials(value) {
+    if (!Array.isArray(value))
+        return null;
+    const toolNames = [...new Set(value.flatMap((denial) => (isRecord(denial)
+            && typeof denial.tool_name === "string"
+            && CLAUDE_DIAGNOSTIC_TOOL_NAMES.has(denial.tool_name)
+            ? [denial.tool_name]
+            : [])))].slice(0, 3);
+    const count = value.length > 999 ? "999+" : String(value.length);
+    return toolNames.length > 0
+        ? `permission_denials=${count}; denied_tools=${toolNames.join(",")}`
+        : `permission_denials=${count}`;
+}
+function standaloneClaudePrompt(packet) {
+    const workingDirectory = JSON.stringify(packet.workspace.working_directory);
+    return [
+        "IntentDNA runtime workspace contract:",
+        `- The exact, authoritative process working directory for this attempt is ${workingDirectory}.`,
+        "- Use paths relative to that working directory for repository-local file access whenever possible.",
+        "- Never infer, reconstruct, rename, or guess an absolute repository path from a session name, project name, transcript location, or encoded directory name.",
+        `- If an absolute repository path is required, copy ${workingDirectory} exactly instead of reconstructing it.`,
+        "- This is a standalone attempt. Do not search for or read Claude Code session transcripts, including files under ~/.claude/projects, to recover task context.",
+        "",
+        "Task:",
+        packet.standalone_prompt,
+    ].join("\n");
+}
 export function createClaudeExecutionProvider(options = {}) {
     return {
         name: "claude",
         createLaunch(packet) {
+            const mcpConfigPath = typeof options.mcpConfigPath === "function"
+                ? options.mcpConfigPath(packet)
+                : options.mcpConfigPath;
             return {
                 command: options.executable ?? "claude",
                 args: [
@@ -17,9 +63,12 @@ export function createClaudeExecutionProvider(options = {}) {
                     "--session-id",
                     packet.worker_session_id,
                     "--no-session-persistence",
+                    ...(mcpConfigPath === undefined || mcpConfigPath === null
+                        ? []
+                        : ["--mcp-config", mcpConfigPath]),
                     ...(options.extraArgs ?? []),
                 ],
-                stdin: packet.standalone_prompt,
+                stdin: standaloneClaudePrompt(packet),
                 cwd: packet.workspace.working_directory,
                 ...(options.env ? { env: options.env } : {}),
             };
@@ -35,6 +84,16 @@ export function createClaudeExecutionProvider(options = {}) {
             if (!isRecord(value)) {
                 throw new MalformedProviderResultError("Claude output must be a JSON object");
             }
+            const hookTerminalReason = typeof value.terminal_reason === "string"
+                && CLAUDE_HOOK_TERMINAL_REASONS.has(value.terminal_reason)
+                ? value.terminal_reason
+                : null;
+            if (hookTerminalReason !== null) {
+                const denials = summarizePermissionDenials(value.permission_denials);
+                throw new ProviderTerminatedError(hookTerminalReason, denials
+                    ? `Claude terminal_reason=${hookTerminalReason}; ${denials}`
+                    : `Claude terminal_reason=${hookTerminalReason}`);
+            }
             if (value.is_error === true) {
                 throw new MalformedProviderResultError(typeof value.result === "string"
                     ? value.result

package/dist/runtime/push-driver.d.ts

@@ -4,7 +4,7 @@ import type { ExecutionProvider } from "./execution-provider.js";
 import type { CanonicalAttemptOutcome, CanonicalEvidenceRef, CanonicalResultDigest, RunId, StepOutput, StepPacket, TerminalOutcome, WorkerSessionId } from "./run-contracts.js";
 import { type RunBindingPayload } from "./run-binding.js";
 import { executeWorkerAttempt, type WorkerExecutionAuthorityBinding, type WorkerExecutionWithEvents, type WorkerExecutorOptions } from "./worker-executor.js";
-export type PushDriverErrorCode = "invalid_configuration" | "invalid_service_response" | "invalid_execution_result" | "invalid_provider_output" | "unsupported_output_contract" | "unsupported" | "attempt_relaunch" | "attach_indeterminate" | "authority_preparation_abandon_failed" | "driver_failure_settlement_failed" | "wait_stopped";
+export type PushDriverErrorCode = "invalid_configuration" | "invalid_service_response" | "invalid_execution_result" | "invalid_provider_output" | "unsupported_output_contract" | "unsupported" | "attempt_relaunch" | "attach_indeterminate" | "submission_indeterminate" | "authority_preparation_abandon_failed" | "driver_failure_settlement_failed" | "wait_stopped";
 export declare class PushDriverError extends Error {
     readonly code: PushDriverErrorCode;
     constructor(code: PushDriverErrorCode, message: string, options?: ErrorOptions);
@@ -13,6 +13,10 @@ export declare class PushDriverIndeterminateAttachError extends PushDriverError
     readonly disposition: "retain_preparation";
     constructor(attemptId: string, cause: unknown);
 }
+export declare class PushDriverIndeterminateSubmissionError extends PushDriverError {
+    readonly disposition: "retain_attempt";
+    constructor(attemptId: string, cause: unknown);
+}
 export interface PushDriverService {
     inspect(runId: RunId): Promise<RunView>;
     resume(runId: RunId): Promise<RunView>;
@@ -175,6 +179,9 @@ export declare class PushDriver {
     private attemptError;
     private assertHeartbeatLease;
     private startHeartbeat;
+    private submissionIsCommitted;
+    private submissionIsDefinitivelyFenced;
+    private reconcileSubmission;
     private attachIsDefinitivelyFenced;
     private abandonPreparation;
     private reconcilePreparedAttach;

package/dist/runtime/push-driver.js

@@ -19,9 +19,34 @@ export class PushDriverIndeterminateAttachError extends PushDriverError {
         this.name = "PushDriverIndeterminateAttachError";
     }
 }
+export class PushDriverIndeterminateSubmissionError extends PushDriverError {
+    disposition = "retain_attempt";
+    constructor(attemptId, cause) {
+        super("submission_indeterminate", `attempt ${attemptId} submission disposition is indeterminate; the attempt was retained`, { cause });
+        this.name = "PushDriverIndeterminateSubmissionError";
+    }
+}
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 5_000;
 const DEFAULT_WAIT_POLL_MS = 50;
 const NO_ATTEMPT_ERROR = Symbol("no_attempt_error");
+function cancellableDelay(milliseconds) {
+    if (milliseconds <= 0) {
+        return { promise: Promise.resolve(), cancel: () => undefined };
+    }
+    let timer;
+    const promise = new Promise((resolve) => {
+        timer = setTimeout(resolve, milliseconds);
+    });
+    return {
+        promise,
+        cancel: () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}
 const DEFAULT_CAPABILITIES = {
     worktree_isolation: true,
     parallelism: true,
@@ -448,13 +473,16 @@ export class PushDriver {
         const schedule = (response) => {
             if (stopped)
                 return;
+            const heartbeatAt = Date.parse(response.heartbeat_at);
             const claimExpiresAt = Date.parse(response.claim_expires_at);
             const executionDeadline = Date.parse(response.execution_deadline_at);
             if (claimExpiresAt === executionDeadline)
                 return;
-            const leaseWindow = claimExpiresAt - Date.parse(response.heartbeat_at);
+            const leaseWindow = claimExpiresAt - heartbeatAt;
             const delay = Math.max(1, Math.min(this.heartbeatIntervalMs, Math.floor(leaseWindow / 2)));
             timer = setTimeout(() => {
+                if (stopped)
+                    return;
                 inFlight = heartbeat().then((next) => schedule(next), async (error) => {
                     failureError = error;
                     await this.emit({
@@ -469,7 +497,9 @@ export class PushDriver {
             }, delay);
             timer.unref?.();
         };
-        schedule(await heartbeat());
+        const initial = await heartbeat();
+        const drainDeadline = cancellableDelay(Math.max(0, Date.parse(initial.execution_deadline_at) - Date.parse(initial.heartbeat_at)));
+        schedule(initial);
         return {
             failure,
             race: (operation) => (failureError === NO_ATTEMPT_ERROR
@@ -479,10 +509,111 @@ export class PushDriver {
                 stopped = true;
                 if (timer !== undefined)
                     clearTimeout(timer);
-                await inFlight;
+                try {
+                    await Promise.race([inFlight, drainDeadline.promise]);
+                }
+                finally {
+                    drainDeadline.cancel();
+                    void inFlight.catch(() => undefined);
+                }
             },
         };
     }
+    submissionIsCommitted(view, lease) {
+        return view.results.some((result) => result.attempt_id === lease.attempt_id);
+    }
+    submissionIsDefinitivelyFenced(view, lease) {
+        const attempt = view.attempts.find((candidate) => candidate.attempt_id === lease.attempt_id);
+        const latestClaim = view.claims
+            .filter((candidate) => candidate.attempt_id === lease.attempt_id)
+            .sort((left, right) => right.claim_epoch - left.claim_epoch)[0];
+        return attempt?.phase === "terminal"
+            || view.run.terminal !== null
+            || view.run.status === "cancelling"
+            || (latestClaim !== undefined && (latestClaim.claim_epoch !== lease.claim_epoch
+                || latestClaim.owner_id !== lease.owner_id));
+    }
+    async reconcileSubmission(lease, rawSubmission, initialError, reconciliationDeadline) {
+        let lastInspectionError = initialError;
+        let acceptingEvents = true;
+        let waiter = null;
+        const queued = [];
+        const pushEvent = (event) => {
+            if (!acceptingEvents)
+                return;
+            if (waiter !== null) {
+                const resolve = waiter;
+                waiter = null;
+                resolve(event);
+            }
+            else {
+                queued.push(event);
+            }
+        };
+        const nextEvent = () => {
+            const event = queued.shift();
+            if (event !== undefined)
+                return Promise.resolve(event);
+            return new Promise((resolve) => { waiter = resolve; });
+        };
+        void rawSubmission.then((outcome) => {
+            pushEvent({ kind: "raw", outcome });
+        });
+        const deadline = cancellableDelay(Math.max(0, reconciliationDeadline - Date.now()));
+        void deadline.promise.then(() => pushEvent({ kind: "deadline" }));
+        const poll = { current: null };
+        let inspectionPending = false;
+        const inspect = () => {
+            if (inspectionPending)
+                return;
+            inspectionPending = true;
+            void this.service.inspect(lease.run_id).then((view) => pushEvent({ kind: "inspected", view }), (error) => pushEvent({ kind: "inspection_rejected", error }));
+        };
+        const schedulePoll = () => {
+            poll.current?.cancel();
+            poll.current = cancellableDelay(Math.min(DEFAULT_WAIT_POLL_MS, Math.max(0, reconciliationDeadline - Date.now())));
+            void poll.current.promise.then(() => pushEvent({ kind: "poll" }));
+        };
+        try {
+            inspect();
+            for (;;) {
+                const event = await nextEvent();
+                if (event.kind === "deadline") {
+                    throw new PushDriverIndeterminateSubmissionError(lease.attempt_id, new AggregateError([initialError, lastInspectionError], "submission could not be reconciled before its deadline"));
+                }
+                if (event.kind === "raw") {
+                    if (event.outcome.kind === "submitted")
+                        return event.outcome;
+                    lastInspectionError = new AggregateError([lastInspectionError, event.outcome.error], "submission transport rejected without authoritative disposition");
+                    if (!inspectionPending && poll.current === null)
+                        schedulePoll();
+                    continue;
+                }
+                if (event.kind === "poll") {
+                    poll.current = null;
+                    inspect();
+                    continue;
+                }
+                inspectionPending = false;
+                if (event.kind === "inspection_rejected") {
+                    lastInspectionError = event.error;
+                }
+                else if (this.submissionIsCommitted(event.view, lease)) {
+                    return { kind: "committed", run: event.view };
+                }
+                else if (this.submissionIsDefinitivelyFenced(event.view, lease)) {
+                    return { kind: "fenced", run: event.view };
+                }
+                schedulePoll();
+            }
+        }
+        finally {
+            acceptingEvents = false;
+            waiter = null;
+            poll.current?.cancel();
+            deadline.cancel();
+        }
+    }
     attachIsDefinitivelyFenced(view, lease, workerSessionId) {
         const attempt = view.attempts.find((candidate) => candidate.attempt_id === lease.attempt_id);
         const claims = view.claims
@@ -736,13 +867,49 @@ export class PushDriver {
                 const attestation = await heartbeat.race(Promise.resolve(authority.attest(attestationRequest)));
                 evidenceRefs = [assertCallerAttestation(authority, attestationRequest, attestation)];
             }
-            const response = await heartbeat.race(this.service.submitAttempt({
+            const rawSubmission = this.service.submitAttempt({
                 lease_token: lease.claim_token,
                 owner_id: lease.owner_id,
                 submission_key: submissionKey,
                 execution: submissionExecution,
                 ...(evidenceRefs === undefined ? {} : { evidence_refs: evidenceRefs }),
-            }));
+            }).then((value) => ({ kind: "submitted", value }), (error) => ({ kind: "rejected", error }));
+            let submission = null;
+            let submissionRaceError = NO_ATTEMPT_ERROR;
+            try {
+                submission = await heartbeat.race(rawSubmission);
+            }
+            catch (error) {
+                submissionRaceError = error;
+            }
+            const reconciliationRequired = submissionRaceError !== NO_ATTEMPT_ERROR
+                || submission?.kind === "rejected";
+            if (reconciliationRequired) {
+                let reconciliationCause;
+                if (submissionRaceError !== NO_ATTEMPT_ERROR) {
+                    reconciliationCause = submissionRaceError;
+                }
+                else if (submission?.kind === "rejected") {
+                    reconciliationCause = submission.error;
+                }
+                else {
+                    throw new PushDriverError("invalid_service_response", `submission reconciliation has no cause for attempt ${lease.attempt_id}`);
+                }
+                await heartbeat.stop();
+                heartbeat = null;
+                const reconciled = await this.reconcileSubmission(lease, rawSubmission, reconciliationCause, Date.parse(lease.execution_deadline_at) + node.attempt_policy.cancellation_grace_ms);
+                if (reconciled.kind === "committed" || reconciled.kind === "fenced") {
+                    return reconciled.run;
+                }
+                submission = reconciled;
+            }
+            if (submission === null) {
+                throw new PushDriverError("invalid_service_response", `submission reconciliation returned no disposition for attempt ${lease.attempt_id}`);
+            }
+            if (submission.kind === "rejected") {
+                throw new PushDriverError("invalid_service_response", `submission rejection was not reconciled for attempt ${lease.attempt_id}`);
+            }
+            const response = submission.value;
             if (response.replayed) {
                 await this.emit({
                     type: "submission_replayed",
@@ -929,6 +1096,10 @@ export class PushDriver {
                     const attemptError = firstAttemptError === NO_ATTEMPT_ERROR
                         ? completion.error
                         : firstAttemptError;
+                    if (attemptError instanceof PushDriverIndeterminateSubmissionError) {
+                        abandonActiveWaits();
+                        throw attemptError;
+                    }
                     if (attemptError instanceof PushDriverIndeterminateAttachError) {
                         const siblings = [...active.values()];
                         active.clear();

package/dist/runtime/result-store.js

@@ -420,7 +420,8 @@ function assertVerifierExecutionReceipt(value, verifierId, result, label) {
         "execution_authority",
     ], label);
     if (value.schema_version !== "intentdna.verifier_execution_receipt.v1"
-        || value.evidence_mode !== "historical_execution") {
+        || (value.evidence_mode !== "historical_execution"
+            && value.evidence_mode !== "historical_execution_with_unbound_external_dependencies")) {
         throw new ResultStoreError("invalid_result", `${label} has an unsupported receipt contract`);
     }
     assertCanonicalNonEmptyString(value.verifier_id, `${label}.verifier_id`);
@@ -577,7 +578,10 @@ function assertWorkspaceObservation(value, evidenceDigest, label, artifactCaptur
         "byte_count",
         "git",
     ], `${label}.workspace_observation`);
-    if (value.schema_version !== "intentdna.workspace_observation.v2") {
+    if (value.schema_version !== "intentdna.workspace_observation.v2"
+        && value.schema_version !== "intentdna.workspace_observation.v3"
+        && value.schema_version !== "intentdna.workspace_observation.v4"
+        && value.schema_version !== "intentdna.workspace_observation.v5") {
         throw new ResultStoreError("invalid_result", `${label}.workspace_observation.schema_version is unsupported`);
     }
     assertCanonicalNonEmptyString(value.workspace_id, `${label}.workspace_observation.workspace_id`);
@@ -593,14 +597,74 @@ function assertWorkspaceObservation(value, evidenceDigest, label, artifactCaptur
         throw new ResultStoreError("invalid_result", `${label}.workspace_observation.observed_digest does not match its evidence binding`);
     }
     assertRecord(value.scope, `${label}.workspace_observation.scope`);
-    assertExactKeys(value.scope, ["kind", "relative_root", "excluded_relative_paths"], `${label}.workspace_observation.scope`);
+    const hasOpaqueDependencies = value.schema_version === "intentdna.workspace_observation.v4"
+        || value.schema_version === "intentdna.workspace_observation.v5";
+    const legacyExcludedRelativePaths = [".dna/runtime", ".dna/worktrees/runtime"];
+    const codegraphExcludedRelativePaths = [...legacyExcludedRelativePaths, ".codegraph"];
+    const canonicalExcludedRelativePaths = Array.isArray(value.scope.excluded_relative_paths)
+        ? canonicalizeJson(value.scope.excluded_relative_paths)
+        : null;
+    const exclusionsAreCanonical = value.schema_version === "intentdna.workspace_observation.v4"
+        // Pre-release v4 records exist with both shapes because the version was reused during dogfood.
+        ? canonicalExcludedRelativePaths === canonicalizeJson(legacyExcludedRelativePaths)
+            || canonicalExcludedRelativePaths === canonicalizeJson(codegraphExcludedRelativePaths)
+        : canonicalExcludedRelativePaths === canonicalizeJson(legacyExcludedRelativePaths);
+    assertExactKeys(value.scope, hasOpaqueDependencies
+        ? ["kind", "relative_root", "excluded_relative_paths", "opaque_external_dependencies"]
+        : ["kind", "relative_root", "excluded_relative_paths"], `${label}.workspace_observation.scope`);
     if (value.scope.kind !== "attempt_workspace"
         || value.scope.relative_root !== "."
         || !Array.isArray(value.scope.excluded_relative_paths)
-        || canonicalizeJson(value.scope.excluded_relative_paths)
-            !== canonicalizeJson([".dna/runtime", ".dna/worktrees/runtime"])) {
+        || !exclusionsAreCanonical) {
         throw new ResultStoreError("invalid_result", `${label}.workspace_observation.scope is not canonical`);
     }
+    const opaqueDependencies = hasOpaqueDependencies
+        ? value.scope.opaque_external_dependencies
+        : [];
+    if (!Array.isArray(opaqueDependencies)) {
+        throw new ResultStoreError("invalid_result", `${label}.workspace_observation.scope.opaque_external_dependencies must be an array`);
+    }
+    let previousOpaquePath = null;
+    for (let index = 0; index < opaqueDependencies.length; index += 1) {
+        const dependency = opaqueDependencies[index];
+        const dependencyLabel = `${label}.workspace_observation.scope.opaque_external_dependencies[${index}]`;
+        assertRecord(dependency, dependencyLabel);
+        assertExactKeys(dependency, [
+            "kind",
+            "relative_path",
+            "link_target_digest",
+            "resolved_target_path_digest",
+            "git_ignore_evidence_digest",
+        ], dependencyLabel);
+        assertCanonicalNonEmptyString(dependency.relative_path, `${dependencyLabel}.relative_path`);
+        const relativePath = dependency.relative_path;
+        if (dependency.kind !== "gitignored_symlink_target"
+            || relativePath === "."
+            || relativePath.startsWith("/")
+            || relativePath.split("/").includes("..")
+            || (previousOpaquePath !== null
+                && Buffer.compare(Buffer.from(previousOpaquePath, "utf8"), Buffer.from(relativePath, "utf8")) >= 0)) {
+            throw new ResultStoreError("invalid_result", `${dependencyLabel} is not canonical`);
+        }
+        for (const field of [
+            "link_target_digest",
+            "resolved_target_path_digest",
+            "git_ignore_evidence_digest",
+        ]) {
+            if (!SHA256_DIGEST_PATTERN.test(dependency[field])) {
+                throw new ResultStoreError("invalid_result", `${dependencyLabel}.${field} must be a lowercase sha256 digest`);
+            }
+        }
+        previousOpaquePath = relativePath;
+    }
+    if (executionReceipt !== null) {
+        const expectedMode = opaqueDependencies.length === 0
+            ? "historical_execution"
+            : "historical_execution_with_unbound_external_dependencies";
+        if (executionReceipt.evidence_mode !== expectedMode) {
+            throw new ResultStoreError("invalid_result", `${label}.execution_receipt.evidence_mode does not match its workspace observation scope`);
+        }
+    }
     for (const field of ["entry_count", "byte_count"]) {
         if (!Number.isSafeInteger(value[field]) || value[field] < 0) {
             throw new ResultStoreError("invalid_result", `${label}.workspace_observation.${field} must be a non-negative safe integer`);

package/dist/runtime/run-contracts.d.ts

@@ -683,15 +683,16 @@ export interface CanonicalWorkerNonlaunchAttestation {
     readonly attestation_digest: CanonicalResultDigest;
     readonly payload: CanonicalWorkerNonlaunchAttestationPayload;
 }
-export declare const CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION: "intentdna.workspace_observation.v2";
-export interface CanonicalWorkspaceObservation {
-    readonly schema_version: typeof CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION;
+export declare const CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION: "intentdna.workspace_observation.v5";
+export interface CanonicalOpaqueExternalDependency {
+    readonly kind: "gitignored_symlink_target";
+    readonly relative_path: string;
+    readonly link_target_digest: CanonicalResultDigest;
+    readonly resolved_target_path_digest: CanonicalResultDigest;
+    readonly git_ignore_evidence_digest: CanonicalResultDigest;
+}
+interface CanonicalWorkspaceObservationBase {
     readonly workspace_id: string;
-    readonly scope: {
-        readonly kind: "attempt_workspace";
-        readonly relative_root: ".";
-        readonly excluded_relative_paths: readonly [".dna/runtime", ".dna/worktrees/runtime"];
-    };
     readonly observed_digest: CanonicalResultDigest;
     readonly entry_count: number;
     readonly byte_count: number;
@@ -703,10 +704,34 @@ export interface CanonicalWorkspaceObservation {
         readonly local_config_digest: CanonicalResultDigest;
     } | null;
 }
+interface CanonicalWorkspaceObservationScopeV2 {
+    readonly kind: "attempt_workspace";
+    readonly relative_root: ".";
+    readonly excluded_relative_paths: readonly [".dna/runtime", ".dna/worktrees/runtime"];
+    readonly opaque_external_dependencies?: never;
+}
+interface CanonicalWorkspaceObservationScopeV4 {
+    readonly kind: "attempt_workspace";
+    readonly relative_root: ".";
+    readonly excluded_relative_paths: readonly [".dna/runtime", ".dna/worktrees/runtime"] | readonly [".dna/runtime", ".dna/worktrees/runtime", ".codegraph"];
+    readonly opaque_external_dependencies: readonly CanonicalOpaqueExternalDependency[];
+}
+export type CanonicalWorkspaceObservation = CanonicalWorkspaceObservationBase & ({
+    readonly schema_version: "intentdna.workspace_observation.v2" | "intentdna.workspace_observation.v3";
+    readonly scope: CanonicalWorkspaceObservationScopeV2;
+} | {
+    readonly schema_version: "intentdna.workspace_observation.v4";
+    readonly scope: CanonicalWorkspaceObservationScopeV4;
+} | {
+    readonly schema_version: typeof CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION;
+    readonly scope: CanonicalWorkspaceObservationScopeV4 & {
+        readonly excluded_relative_paths: readonly [".dna/runtime", ".dna/worktrees/runtime"];
+    };
+});
 export declare const CANONICAL_VERIFIER_EXECUTION_RECEIPT_SCHEMA_VERSION: "intentdna.verifier_execution_receipt.v1";
 export interface CanonicalVerifierExecutionReceipt {
     readonly schema_version: typeof CANONICAL_VERIFIER_EXECUTION_RECEIPT_SCHEMA_VERSION;
-    readonly evidence_mode: "historical_execution";
+    readonly evidence_mode: "historical_execution" | "historical_execution_with_unbound_external_dependencies";
     readonly plan_id: CanonicalResultDigest;
     readonly verifier_id: string;
     readonly verifier_definition_digest: CanonicalResultDigest;

package/dist/runtime/run-contracts.js

@@ -115,5 +115,5 @@ export const CANONICAL_ATTEMPT_STOP_INTENT_SCHEMA_VERSION = "intentdna.attempt_s
 export const CANONICAL_WORKER_STOP_RECEIPT_SCHEMA_VERSION = "intentdna.worker_stop_receipt.v1";
 export const CANONICAL_WORKER_ALREADY_STOPPED_EVIDENCE_SCHEMA_VERSION = "intentdna.worker_already_stopped_evidence.v1";
 export const CANONICAL_WORKER_NONLAUNCH_ATTESTATION_SCHEMA_VERSION = "intentdna.worker_nonlaunch_attestation.v1";
-export const CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION = "intentdna.workspace_observation.v2";
+export const CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION = "intentdna.workspace_observation.v5";
 export const CANONICAL_VERIFIER_EXECUTION_RECEIPT_SCHEMA_VERSION = "intentdna.verifier_execution_receipt.v1";

package/dist/runtime/worker-executor.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { ProviderTerminatedError } from "./execution-provider.js";
 import { runProcessTree, } from "./process-tree.js";
 function eventId() {
     return randomUUID();
@@ -164,12 +165,19 @@ export async function executeWorkerAttempt(packet, provider, options = {}) {
             });
         }
         catch (error) {
-            outcome = {
-                kind: "malformed_result",
-                exit_code: processResult.status,
-                signal: null,
-                error: error instanceof Error ? error.message : String(error),
-            };
+            outcome = error instanceof ProviderTerminatedError
+                ? {
+                    kind: "cancelled",
+                    exit_code: processResult.status,
+                    signal: null,
+                    reason: error.message,
+                }
+                : {
+                    kind: "malformed_result",
+                    exit_code: processResult.status,
+                    signal: null,
+                    error: error instanceof Error ? error.message : String(error),
+                };
         }
     }
     if (outcome === null) {

package/dist/runtime/workspace-observation.d.ts

@@ -11,6 +11,8 @@ export interface WorkspaceObservationLimits {
 }
 export interface WorkspaceObservationHooks {
     after_directory_read?(relativePath: string): Promise<void> | void;
+    after_metadata_read?(relativePath: string): Promise<void> | void;
+    after_file_read?(relativePath: string): Promise<void> | void;
 }
 export interface ObserveWorkspaceRequest {
     readonly workspace_root: string;
@@ -26,19 +28,32 @@ export interface GitWorkspaceSnapshot {
     readonly local_config_digest: `sha256:${string}`;
 }
 export interface WorkspaceObservation {
-    readonly schema_version: "intentdna.workspace_observation.v2";
+    readonly schema_version: "intentdna.workspace_observation.v5";
     readonly observed_digest: `sha256:${string}`;
     readonly entry_count: number;
     readonly byte_count: number;
-    readonly excluded_relative_paths: readonly [".dna/runtime", ".dna/worktrees/runtime"];
+    readonly excluded_relative_paths: readonly [
+        ".dna/runtime",
+        ".dna/worktrees/runtime"
+    ];
+    readonly opaque_external_dependencies: readonly OpaqueExternalDependency[];
     readonly git: GitWorkspaceSnapshot | null;
 }
+export interface OpaqueExternalDependency {
+    readonly kind: "gitignored_symlink_target";
+    readonly relative_path: string;
+    readonly link_target_digest: `sha256:${string}`;
+    readonly resolved_target_path_digest: `sha256:${string}`;
+    readonly git_ignore_evidence_digest: `sha256:${string}`;
+}
 export declare const DEFAULT_WORKSPACE_OBSERVATION_LIMITS: WorkspaceObservationLimits;
 export declare const WORKSPACE_OBSERVATION_EXCLUDED_PATHS: readonly [".dna/runtime", ".dna/worktrees/runtime"];
 export declare function workspaceObservationPolicy(limits?: Partial<WorkspaceObservationLimits>): {
-    readonly schema_version: "intentdna.workspace_observation_policy.v1";
+    readonly schema_version: "intentdna.workspace_observation_policy.v4";
     readonly limits: WorkspaceObservationLimits;
     readonly excluded_relative_paths: typeof WORKSPACE_OBSERVATION_EXCLUDED_PATHS;
     readonly git_observation: "head_branch_status_local_config";
+    readonly symlink_observation: "reject_unignored_record_gitignored_target_as_opaque";
+    readonly special_file_observation: "metadata_only_no_open";
 };
 export declare function observeWorkspace(request: ObserveWorkspaceRequest): Promise<WorkspaceObservation>;