sortie-dogs 0.12.11 → 0.12.13

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.12.11-operation-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.12.11-operation-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";

package/dist/core/goal-bound.d.ts

@@ -38,7 +38,7 @@ export interface GoalEvidence {
         readonly source_paths: readonly string[];
         readonly candidate_paths: readonly string[];
         /** Missing on legacy evidence: retain its original all-paths snapshot recipe. */
-        readonly source_policy?: "project-files-v1";
+        readonly source_policy?: "project-files-v1" | "declared-paths-v1";
     };
     readonly execution: {
         readonly command: readonly string[];
@@ -167,6 +167,15 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly evidence: readonly GoalEvidence[];
     readonly elapsed_ms: number | null;
     readonly cost_usd: number | null;
+    readonly native_session_id?: string;
+    readonly native_started_at?: string;
+}) | (GoalEventBase & {
+    readonly kind: "unit.usage-reconciled";
+    readonly goal_id: string;
+    readonly reservation_id: string;
+    readonly native_session_id: string;
+    readonly cost_usd: number;
+    readonly source: "native-usage-price-table";
 }) | (GoalEventBase & {
     readonly kind: "unit.evidence-reconciled";
     readonly goal_id: string;

package/dist/core/goal-bound.js

@@ -62,7 +62,8 @@ export function validGoalEvidence(value, state) {
         text(protectedBinding.project_root) && text(protectedBinding.manifest_path) && Array.isArray(protectedBinding.source_paths) &&
         protectedBinding.source_paths.every(text) && Array.isArray(protectedBinding.candidate_paths) &&
         protectedBinding.candidate_paths.every(text) &&
-        (protectedBinding.source_policy === undefined || protectedBinding.source_policy === "project-files-v1");
+        (protectedBinding.source_policy === undefined || protectedBinding.source_policy === "project-files-v1" ||
+            protectedBinding.source_policy === "declared-paths-v1");
     const matches = criteria.length > 0 && criteria.length === value.measurement.criterion_ids.length &&
         criteria.every((criterion) => criterion.target === value.measurement.target &&
             criterion.entrypoint === value.measurement.entrypoint && criterion.workload === value.measurement.workload &&
@@ -114,6 +115,7 @@ export function reduceGoalFlight(records) {
     let legacyResetRevision = false;
     let previous = null;
     const processDefects = new Map();
+    const unitCosts = new Map();
     const validationAdmissions = new Map();
     const validationSettlements = new Map();
     const reopenedValidationEvidence = new Set();
@@ -127,6 +129,7 @@ export function reduceGoalFlight(records) {
             continue;
         requireState(instant(event.at), "invalid", "Goal event timestamp is invalid.");
         if (event.kind === "goal.accepted") {
+            unitCosts.clear();
             requireState(state.goal_id === null || state.phase === "terminal" || state.phase === "stopped", "transition", "An active goal already owns this root.");
             requireState(text(event.goal_id) && HASH.test(event.acceptance_fingerprint) && text(event.origin_user_message_id) &&
                 text(event.origin_session_id) && text(event.selected_agent) && event.budget.max_units > 0 &&
@@ -221,6 +224,7 @@ export function reduceGoalFlight(records) {
                 : state.no_progress_results;
             const elapsed = state.consumed_time_ms === null || event.elapsed_ms === null ? null : state.consumed_time_ms + event.elapsed_ms;
             const cost = state.consumed_cost_usd === null || event.cost_usd === null ? null : state.consumed_cost_usd + event.cost_usd;
+            unitCosts.set(event.reservation_id, { cost: event.cost_usd, session: event.native_session_id });
             state = { ...state, consumed_units: state.consumed_units + 1, consumed_time_ms: elapsed, consumed_cost_usd: cost,
                 no_progress_results: nextNoProgress, replan_required: nextNoProgress >= 2,
                 outstanding_reservations: state.outstanding_reservations.filter((entry) => entry.reservation_id !== event.reservation_id),
@@ -231,6 +235,17 @@ export function reduceGoalFlight(records) {
                 processDefects.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch });
             }
         }
+        else if (event.kind === "unit.usage-reconciled") {
+            const prior = unitCosts.get(event.reservation_id);
+            requireState(event.goal_id === state.goal_id && prior !== undefined && prior.session === event.native_session_id &&
+                event.source === "native-usage-price-table" &&
+                Number.isFinite(event.cost_usd) && event.cost_usd >= 0 &&
+                (prior.cost === null || prior.cost === event.cost_usd), "transition", "Usage reconciliation must identify one settled native unit.");
+            unitCosts.set(event.reservation_id, { cost: event.cost_usd, session: event.native_session_id });
+            const costs = [...unitCosts.values()];
+            state = { ...state, consumed_cost_usd: costs.some(item => item.cost === null) ? null
+                    : costs.reduce((sum, item) => sum + item.cost, 0) };
+        }
         else if (event.kind === "unit.evidence-reconciled") {
             const old = processDefects.get(event.previous_receipt_id);
             requireState(state.phase === "active" && state.receipt === null && old?.unitID === event.unit_id &&

package/dist/core/operator-mission.d.ts

@@ -17,6 +17,8 @@ export interface OperatorMission {
         id: string;
         text: string;
     }[];
+    /** The current user intentionally replaced the predecessor's requirements. */
+    requirementsReplaced?: boolean;
     phase: "open" | "running" | "submitted" | "completed" | "cancelled";
     coordinator: string | null;
     callID: string | null;
@@ -74,7 +76,7 @@ export declare class OperatorMissionRuntime {
     read(root: string): Promise<OperatorMission | undefined>;
     required(root: string): Promise<OperatorMission>;
     capture(root: string, request: MissionRequest): Promise<void>;
-    start(root: string, requirements: unknown): Promise<OperatorMission>;
+    start(root: string, requirements: unknown, replaceRequirements?: boolean): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     /** Keep host-accepted criteria ahead of new text, including an exactly linked settled predecessor. */
     carryForward(root: string, missionID: string, acceptance: readonly string[], supersededRunID?: string): Promise<OperatorMission>;

package/dist/core/operator-mission.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { normalizeRelativeScope } from "./path.js";
+import { normalizeExecutionScope } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
@@ -160,7 +160,7 @@ export class OperatorMissionRuntime {
             }
         });
     }
-    start(root, requirements) {
+    start(root, requirements, replaceRequirements = false) {
         return this.serial(root, async () => {
             if (!Array.isArray(requirements) || requirements.length === 0 || requirements.length > 64 ||
                 !requirements.every(item => typeof item === "string" && item.trim() && !/[\r\n]/u.test(item))) {
@@ -182,6 +182,7 @@ export class OperatorMissionRuntime {
                 await this.save(this.file(root, `.${previous.id}`), previous);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
+                ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
                 ...(previous?.phase === "cancelled" &&
                     (previous.runID === null || request.id !== previous.requests[0]?.id) &&
@@ -286,7 +287,7 @@ export function missionPlan(mission, raw) {
             const entries = value[field] ?? [];
             if (!Array.isArray(entries) || !entries.every(item => typeof item === "string"))
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
-            return [...new Set(entries.map(item => normalizeRelativeScope(item)))];
+            return [...new Set(entries.map(item => normalizeExecutionScope(item)))];
         };
         const ids = value.requirement_ids ?? mission.requirements.map(item => item.id);
         if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id => mission.requirements.some(item => item.id === id))) {
@@ -328,12 +329,18 @@ export function missionPlan(mission, raw) {
             // Keep all detailed instructions in the handoff, not in a 512-character wire label.
             criteria: units.map(unit => ({ criterion_id: unit.id, target: unit.title.slice(0, 512),
                 entrypoint: (unit.write[0] ?? unit.read[0] ?? unit.id).slice(0, 512), validation_command: unit.validation.at(-1) })) },
-        units });
+        units }, "execution");
 }
 export function missionPacket(mission, run) {
+    const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;
+    if (predecessor)
+        run = undefined;
     const currentReview = mission.review !== undefined && mission.review.runID === (run?.runID ?? mission.runID);
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
+        ...(predecessor ? { predecessor: { run_id: predecessor.runID, status: predecessor.phase,
+                completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
+                note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
         submission: mission.submission, progress: mission.progress,
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
@@ -350,11 +357,14 @@ export function missionPacket(mission, run) {
             passed: currentReview && mission.review.verdict === "PASS", permits_submission: reviewAccepted } : null,
         ...(run ? { run_id: run.runID, status: run.phase, decision: run.decision,
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
-                child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence })) } : {}),
+                child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
+                ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"
                 ? "Operator: compare the submitted candidate with the original requirements and actual evidence, then complete_mission if satisfied. Report remaining evidence gaps; they are not a review PASS."
-                : run?.phase === "awaiting-decision" ? "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative."
+                : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
+                    ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
+                    : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
                     : run?.phase === "awaiting-acceptance" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted
                         ? "Coordinator: the Reviewer found only missing evidence. Supply it through review_mission traces (or at most one evidence-only unit) and re-review once; do not re-implement. At the evidence-gap limit, submit_mission ready with the gaps listed."
                         : reviewAccepted

package/dist/core/operator-runtime.d.ts

@@ -115,6 +115,7 @@ interface UnitState {
     childSessionID: string | null;
     evidence: readonly GoalEvidence[];
     resultClass: string | null;
+    dispatchDenial?: string;
     repairValidationAttempts: number;
     repairValidation: {
         readonly repair_fingerprint: string;
@@ -203,6 +204,8 @@ export interface OperatorState {
     operatorCallID: string | null;
     operatorSessionID: string | null;
     dispatched: number;
+    /** Native interrupt acknowledgements for this cancelled run, persisted before settlement. */
+    stoppedChildren?: string[];
     units: UnitState[];
     decision: string | null;
     receipt: GoalTerminalReceipt | null;
@@ -210,7 +213,7 @@ export interface OperatorState {
 /** A later mission may replace an unexecuted cancellation, but must retain settled work's acceptance. */
 export declare function cancelledMissionRetainsAcceptance(state: OperatorState): boolean;
 export declare function operatorGitPathAuthorized(path: string, scopes: readonly string[], platform?: NodeJS.Platform): boolean;
-export declare function parseOperatorPlan(value: unknown): OperatorPlan;
+export declare function parseOperatorPlan(value: unknown, scopeFormat?: "repository" | "execution"): OperatorPlan;
 /** Root-owned durable queue. It never executes code, changes acceptance, or accepts a candidate. */
 export declare class OperatorRuntime {
     readonly profile: RuntimeProfile;
@@ -247,7 +250,7 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string, terminalChildren?: readonly string[]): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean): Promise<OperatorState>;
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root: string, runID: string, raw: unknown, dispatcher?: {
         sessionID: string;
@@ -284,7 +287,7 @@ export declare class OperatorRuntime {
     private nextOnce;
     admitWorker(root: string, actor: string, callID: string, args: unknown): Promise<OperatorTask>;
     private admitWorkerOnce;
-    rejectedAdmission(root: string, callID: string): Promise<void>;
+    rejectedAdmission(root: string, callID: string, reason?: string): Promise<void>;
     rejectDispatch(root: string, callID: string, decision?: string): Promise<void>;
     private rejectDispatchOnce;
     private repairPathProtected;
@@ -322,6 +325,7 @@ export declare class OperatorRuntime {
     processReplacementRequired(root: string, runID: string): Promise<OperatorState>;
     private operatorReturnedOnce;
     interrupted(root: string, reason: string): Promise<readonly string[]>;
+    recordStoppedChild(root: string, runID: string, child: string): Promise<void>;
     private interruptedOnce;
     terminal(root: string, receipt: GoalTerminalReceipt): Promise<void>;
     private terminalOnce;

package/dist/core/operator-runtime.js

@@ -5,7 +5,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { acceptanceContinuityFingerprint, inspectAcceptanceContinuity, normalizeAcceptanceCriteria, ACCEPTANCE_CONTINUITY_EXTENSION, MAX_ACCEPTANCE_CONTINUITY_BYTES, MAX_ACCEPTANCE_CRITERIA } from "./acceptance-continuity.js";
 import { expandGoalDeclaration, goalDeclarationDefaults, goalDeclarationFieldDiagnostics, hasGoalCommandAliasConflict } from "./goal-declaration-format.js";
-import { normalizeManifestPath, normalizeManifestScope, normalizeRelativePath } from "./path.js";
+import { normalizeExecutionScope, normalizeManifestPath, normalizeManifestScope, normalizeRelativePath } from "./path.js";
 import { CONTRACT_TEXT_LIMITS, validateHandoffSchema, validateOperationManifestSchema } from "./validate-schema.js";
 import { validateManifest } from "./validate-manifest.js";
 import { profileAgent, RUNTIME_PROFILES } from "./runtime-profile.js";
@@ -83,7 +83,7 @@ function scopePaths(value, limit) {
     };
     return paths.every(normalized) && new Set(paths).size === paths.length;
 }
-export function parseOperatorPlan(value) {
+export function parseOperatorPlan(value, scopeFormat = "repository") {
     if (!record(value) || !exactKeys(value, ["schema_version", "acceptance", "acceptance_proof", "source_refs", "goal_declaration", "units", "git_lifecycle"])) {
         return planError("/", "operator-plan-invalid", "operator-plan-fields");
     }
@@ -207,11 +207,11 @@ export function parseOperatorPlan(value) {
             for (const [pathIndex, name] of unit[field].entries()) {
                 let valid = false;
                 try {
-                    valid = normalizeRelativePath(name) === name;
+                    valid = (scopeFormat === "execution" ? normalizeExecutionScope(name) : normalizeRelativePath(name)) === name;
                 }
                 catch { /* Return only a typed pointer, never the path value. */ }
                 if (!valid)
-                    return planError(`/units/${unitIndex}/${field}/${pathIndex}`, "operator-scope-invalid", "repository-relative-scope");
+                    return planError(`/units/${unitIndex}/${field}/${pathIndex}`, "operator-scope-invalid", scopeFormat === "execution" ? "normalized-execution-scope" : "repository-relative-scope");
             }
         }
         for (const name of unit.write) {
@@ -686,8 +686,8 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = []) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements }));
     }
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root, runID, raw, dispatcher) {
@@ -716,7 +716,7 @@ export class OperatorRuntime {
             }
             immutableReplacement = { ...immutableReplacement, goal_declaration: declaration };
         }
-        const plan = parseOperatorPlan(immutableReplacement);
+        const plan = parseOperatorPlan(immutableReplacement, mission ? "execution" : "repository");
         const validatedPlanHash = hash(JSON.stringify(plan));
         const replanning = mission?.replaceRunID !== undefined;
         if (replanning) {
@@ -758,12 +758,12 @@ export class OperatorRuntime {
                 return previous;
             throw new Error("operator-active-contract-immutable");
         }
-        // Cancellation stops execution, not the accepted user order. A replacement
-        // plan must carry the original ordered criteria; only a completed root clears them.
+        // Same-request continuation retains acceptance. Explicit user replacement keeps the
+        // predecessor's history/spend but uses the current requirements instead of an old prefix.
         // Treat the predecessor as retired only in this staged replacement. Its durable state remains
         // intact through schema checks, control writes and archive creation, until save atomically switches it.
         const parent = replanning ? { ...previous, phase: "cancelled", decision: "mission-replan" }
-            : (!superseding || retainAcceptance) && previous?.phase === "cancelled" ? previous : undefined;
+            : (!superseding || (retainAcceptance && !mission?.replaceRequirements)) && previous?.phase === "cancelled" ? previous : undefined;
         if (parent && ["explicit-cancellation", "agent-changed"].includes(parent.decision ?? "")) {
             const cancelled = parent.units.flatMap(unit => (parent.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null
                 ? [unit.childSessionID] : []);
@@ -837,6 +837,13 @@ export class OperatorRuntime {
         const units = [];
         const controls = [{ path: declarationPath, content: declaration }];
         for (const [index, unit] of plan.units.entries()) {
+            for (const name of unit.write) {
+                const scoped = relative(this.projectRoot, resolve(this.projectRoot, normalizeManifestScope(name).path)).replaceAll("\\", "/");
+                if ([".git", ...Object.values(RUNTIME_PROFILES).map(profile => profile.stateDirectory)]
+                    .some(directory => scoped === directory || scoped.startsWith(`${directory}/`))) {
+                    return planError(`/units/${index}/write`, "operator-control-write-forbidden", "control-write-forbidden");
+                }
+            }
             const taskID = `${runID}-${index + 1}`;
             const manifestPath = join(directory, `${taskID}.operation-manifest.json`);
             const manifestRelative = `${this.profile.stateDirectory}/contracts/${taskID}.operation-manifest.json`;
@@ -1232,19 +1239,21 @@ export class OperatorRuntime {
         await this.save(state);
         return admitted;
     }
-    async rejectedAdmission(root, callID) {
-        await this.rejectDispatch(root, callID, "dispatch-admission-rejected");
+    async rejectedAdmission(root, callID, reason) {
+        await this.serial(root, () => this.rejectDispatchOnce(root, callID, "dispatch-admission-rejected", reason));
     }
     rejectDispatch(root, callID, decision = "native-task-rejected") {
         return this.serial(root, () => this.rejectDispatchOnce(root, callID, decision));
     }
-    async rejectDispatchOnce(root, callID, decision) {
+    async rejectDispatchOnce(root, callID, decision, reason) {
         const state = await this.required(root);
         const unit = state.units.find(item => item.callID === callID && item.status === "running");
         if (!unit)
             return;
         unit.status = "failed";
         unit.resultClass = "process-defect";
+        if (reason)
+            unit.dispatchDenial = reason.slice(0, 4000);
         state.phase = "awaiting-decision";
         state.decision = decision;
         await this.save(state);
@@ -1570,6 +1579,15 @@ export class OperatorRuntime {
     interrupted(root, reason) {
         return this.serial(root, () => this.interruptedOnce(root, reason));
     }
+    recordStoppedChild(root, runID, child) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            if (state.runID !== runID || state.phase !== "cancelled")
+                return;
+            state.stoppedChildren = [...new Set([...(state.stoppedChildren ?? []), child])];
+            await this.save(state);
+        });
+    }
     async interruptedOnce(root, reason) {
         const state = await this.read(root);
         if (!state || state.phase === "completed")

package/dist/core/path.d.ts

@@ -28,3 +28,5 @@ export declare function normalizeManifestScope(input: string): ManifestPath & {
     readonly directory: boolean;
 };
 export declare function normalizeRelativeScope(input: string): string;
+/** Execution scopes may name native absolute destinations (for example global installs). */
+export declare function normalizeExecutionScope(input: string): string;

package/dist/core/path.js

@@ -67,3 +67,8 @@ export function normalizeRelativeScope(input) {
         throw new RelativePathError("absolute");
     return scope.path + (scope.directory ? "/**" : "");
 }
+/** Execution scopes may name native absolute destinations (for example global installs). */
+export function normalizeExecutionScope(input) {
+    const scope = normalizeManifestScope(input);
+    return scope.path + (scope.directory ? "/**" : "");
+}

package/dist/core/run-flight-ledger.js

@@ -918,6 +918,10 @@ export class RunFlightLedger {
             const records = await this.#readGoalRecords();
             if (guard !== undefined)
                 guard(reduceGoalFlight(records));
+            if (event.kind === "unit.usage-reconciled" && records.some(({ event: stored }) => stored.kind === "unit.usage-reconciled" && stored.goal_id === event.goal_id &&
+                stored.reservation_id === event.reservation_id && stored.native_session_id === event.native_session_id &&
+                stored.cost_usd === event.cost_usd))
+                return reduceGoalFlight(records);
             if (event.kind === "goal.accepted") {
                 const prior = records.find(({ event: stored }) => stored.kind === "goal.accepted" &&
                     stored.origin_user_message_id === event.origin_user_message_id);

package/dist/plugin/declared-artifacts.d.ts

@@ -0,0 +1,8 @@
+/** Explicit external artifacts are filesystem inputs, not Git pathspecs. Stream complete bytes;
+ * previews are bounded independently. Follow package links only inside a declared physical root.
+ */
+export declare function declaredArtifacts(paths: readonly string[], previewLimit?: number): Promise<{
+    entries: (readonly [string, string, (string | undefined)?])[];
+    excerpt: string;
+    truncated: boolean;
+}>;

package/dist/plugin/declared-artifacts.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, readdir, readlink, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+const within = (root, path) => {
+    const rest = relative(root, path);
+    return rest === "" || (rest !== ".." && !rest.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(rest));
+};
+/** Explicit external artifacts are filesystem inputs, not Git pathspecs. Stream complete bytes;
+ * previews are bounded independently. Follow package links only inside a declared physical root.
+ */
+export async function declaredArtifacts(paths, previewLimit = 0) {
+    const roots = [...new Set(paths.map(path => resolve(path)))].sort();
+    const physical = await Promise.all(roots.map(path => realpath(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return path;
+        throw error;
+    })));
+    const entries = [];
+    const excerpts = [];
+    let remaining = previewLimit, truncated = false;
+    const visited = new Set();
+    const visit = async (path, ancestors) => {
+        if (visited.has(path))
+            return;
+        visited.add(path);
+        const label = path.replaceAll("\\", "/");
+        const metadata = await lstat(path).catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (!metadata) {
+            entries.push([label, "missing"]);
+            return;
+        }
+        const canonical = await realpath(path);
+        if (metadata.isSymbolicLink()) {
+            entries.push([label, `symlink:${await readlink(path)}`, canonical]);
+            if (!physical.some(root => within(root, canonical)))
+                throw new Error("declared-artifact-link-outside-scope");
+            if (ancestors.has(canonical))
+                return; // The link identity is recorded; do not traverse cycles.
+            await visit(canonical, ancestors);
+            return;
+        }
+        if (metadata.isDirectory()) {
+            entries.push([label, "directory", canonical]);
+            const next = new Set([...ancestors, canonical]);
+            for (const child of (await readdir(path)).sort())
+                await visit(join(path, child), next);
+            return;
+        }
+        if (!metadata.isFile())
+            throw new Error("declared-artifact-not-file-or-directory");
+        const hash = createHash("sha256");
+        const room = remaining;
+        let preview = Buffer.alloc(0);
+        for await (const part of createReadStream(path)) {
+            const bytes = Buffer.isBuffer(part) ? part : Buffer.from(part);
+            hash.update(bytes);
+            if (preview.length < room)
+                preview = Buffer.concat([preview, bytes.subarray(0, room - preview.length)]);
+        }
+        entries.push([label, `file:${metadata.mode}`, hash.digest("hex")]);
+        if (previewLimit > 0) {
+            if (room) {
+                const excerpt = `\n--- external file: ${label} ---\n${preview.includes(0) ? "[binary artifact: bytes fingerprinted]" : preview.toString("utf8")}`;
+                const bounded = Buffer.from(excerpt).subarray(0, remaining);
+                excerpts.push(bounded.toString("utf8"));
+                remaining -= bounded.length;
+            }
+            if (metadata.size > room || remaining === 0)
+                truncated = true;
+        }
+    };
+    for (const path of roots)
+        await visit(path, new Set());
+    return { entries, excerpt: excerpts.join(""), truncated };
+}

package/dist/plugin/gate.js

@@ -1175,7 +1175,7 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
             const absolute = resolve(manifestPath.path);
             if (await project.contains(absolute)) {
                 const normalized = await project.toRelativePath(absolute);
-                if (!await isWritable(normalized))
+                if (!await isWritable(normalized) && !await isExternalWritable(absolute))
                     throw new WriteDeniedError("manifest-scope", normalized);
                 return;
             }
@@ -1240,21 +1240,16 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
                 : undefined;
             if (command !== undefined && declaredValidation.has(command))
                 return;
+            // Shell syntax is not an execution permission boundary. Mission workers already use
+            // native host permissions; only declared checks produce formal validation evidence.
+            if (options?.investigativeShell && ["bash", "shell"].includes(_input.tool))
+                return;
             const extracted = extractWritePaths(_input.tool, output.args);
             if (!extracted.applies)
                 return;
-            // Mission workers may investigate with repository-specific executables without registering
-            // every diagnostic as a formal check. Known write destinations/Git mutations still use the
-            // same scope gate; this option never makes diagnostic output acceptance evidence.
-            if (options?.investigativeShell && ["bash", "shell"].includes(_input.tool) &&
-                extracted.issue?.cause === "executable-not-allowlisted" && extracted.paths.length === 0 &&
-                !extracted.gitMutation && !extracted.remoteMutation)
-                return;
             if (extracted.ambiguous || (extracted.paths.length === 0 && !extracted.gitCommit)) {
                 if (extracted.issue !== undefined) {
-                    const formatCorrection = options?.investigativeShell === true &&
-                        ["unsupported-curl-form", "unsupported-git-archive-form", "unsupported-webrequest-form"].includes(extracted.issue.cause);
-                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue, formatCorrection));
+                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue));
                 }
                 throw new WriteDeniedError("path-required", "<missing-path>");
             }