sortie-dogs 0.15.2 → 0.16.0

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.15.2](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.15.2)**
-· [Release notes](docs/release-v0.15.2.md)
+**Current release: [v0.15.3](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.15.3)**
+· [Release notes](docs/release-v0.15.3.md)
 · [Execution vision](docs/v0.14.0-execution-vision.md)
 
 [When to use](#when-to-use-sortie-dogs) · [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
@@ -78,7 +78,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.15.2
+npm install --save-dev sortie-dogs@0.15.3
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -107,7 +107,7 @@ bridge. [Codex guide: SDK, permissions, progress, resume and manifest route](doc
 Use **OpenCode V2**. In the target project:
 
 ```sh
-npm install --save-dev sortie-dogs@0.15.2
+npm install --save-dev sortie-dogs@0.15.3
 npx --no-install sortie-dogs init .
 ```
 
@@ -127,7 +127,7 @@ v0.10 is installed. [OpenCode setup and configuration](docs/configuration.md) ·
 
 ### Project Memory (OpenCode v010, opt-in)
 
-With v0.15.2 installed, run `sortie-dogs memory on .` once and reload
+With v0.15.3 installed, run `sortie-dogs memory on .` once and reload
 the project plugin. Ordinary public turns then become pending sources; the existing
 Operator records semantic additions, corrections, withdrawals and decisions without
 another save request or a dedicated model call per turn. New sessions recall the
@@ -284,7 +284,7 @@ Install the desired package version and rerun **your host's** initializer:
 
 An OpenCode config-local bridge may resolve a separate package; npm-global update alone does not
 update it. [Global/update instructions](docs/configuration.md#global-availability).
-The current Mission asset marker is `0.15.2-tactical-return-v1`; the Codex skill marker is
+The current Mission asset marker is `0.15.3-external-review-links-v1`; the Codex skill marker is
 `0.14.6-codex-skill-v1`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -300,6 +300,7 @@ follow the [manual removal guide](docs/uninstall.md), never delete the entire `.
   [SWE-bench history](docs/benchmarks/swebench-lite-history.md) · [Historical local case study](docs/benchmark-reference.md).
 - **Development:** [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md) ·
   [Windows tests](docs/windows-tests.md) · [Release routine](docs/release-batch.md).
+- **Current release:** [v0.15.3](docs/release-v0.15.3.md).
 - **Releases:** [v0.15.2](docs/release-v0.15.2.md) · [v0.15.1](docs/v0.15.1-migration.md) · [v0.15.0](docs/release-v0.15.0.md) · [v0.14.9](docs/release-v0.14.9.md) · [v0.14.8](docs/release-v0.14.8.md) · [v0.14.7](docs/release-v0.14.7.md) · [v0.14.6](docs/release-v0.14.6.md) · [v0.14.5](docs/release-v0.14.5.md) · [v0.14.4](docs/release-v0.14.4.md) · [v0.14.3](docs/release-v0.14.3.md) · [v0.14.2](docs/release-v0.14.2.md) · [v0.14.1](docs/release-v0.14.1.md) · [v0.14.0](docs/release-v0.14.0.md) · [v0.13.22](docs/release-v0.13.22.md) · [v0.13.21](docs/release-v0.13.21.md) · [v0.13.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
   [v0.13.9](docs/release-v0.13.9.md) · [All GitHub releases](https://github.com/zufall-upon/Sortie-dogs/releases).
 

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * 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.15.2-tactical-return-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.0-purpose-aligned-v2";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * 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.15.2-tactical-return-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.0-purpose-aligned-v2";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

package/dist/core/initialize.js

@@ -136,11 +136,12 @@ function classifyVersionTransition(installedValue, currentValue, v010Restore = f
     const adjacentPreOneLine = installed.major === 0 && current.major === 0 &&
         current.minor === installed.minor + 1;
     // v0.11 used a different runtime. The v010 asset migration restores the 0.10
-    // preview into the 0.12–0.15 Mission line without selecting a v0.11 execution path.
+    // preview into the 0.12–0.16 Mission line without selecting a v0.11 execution path.
     const restoredPreview = v010Restore && installed.major === 0 && installed.minor === 10 &&
-        current.major === 0 && [12, 13, 14, 15].includes(current.minor);
+        current.major === 0 && [12, 13, 14, 15, 16].includes(current.minor);
     const retainedMission = v010Restore && installed.major === 0 &&
-        ((installed.minor === 12 && current.minor === 14) || ([12, 13].includes(installed.minor) && current.minor === 15)) &&
+        ((installed.minor === 12 && current.minor === 14) || ([12, 13].includes(installed.minor) && current.minor === 15) ||
+            ([12, 13, 14].includes(installed.minor) && current.minor === 16)) &&
         current.major === 0;
     return sameLine || adjacentPreOneLine || restoredPreview || retainedMission ? "compatible-update" : "incompatible";
 }

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

@@ -0,0 +1,42 @@
+import type { OperatorMission } from "./operator-mission.js";
+export declare const PURPOSE_DECISIONS: readonly ["CONTINUE", "REUSE", "CHANGE_METHOD", "STOP_METHOD", "NEEDS_DECISION"];
+export interface PurposeDecisionInput {
+    decision: typeof PURPOSE_DECISIONS[number];
+    requirement_ids: string[];
+    observed_outcome: string;
+    unmet_work: string[];
+    reason: string;
+    evidence_refs: string[];
+    affected_method?: string;
+    next_action: string;
+}
+export interface PurposeDecision extends PurposeDecisionInput {
+    id: string;
+    mission_id: string;
+    run_id: string | null;
+    requirements_fingerprint: string;
+    recorded_at: string;
+}
+export declare function purposeRequirementsFingerprint(mission: OperatorMission): string;
+/** A bounded strategy observation, never an evidence receipt or an execution control. */
+export declare function validatePurposeDecision(mission: OperatorMission, raw: unknown): asserts raw is PurposeDecisionInput;
+export declare function appendPurposeDecision(mission: OperatorMission, raw: unknown): void;
+export declare function purposeDecisionView(mission: OperatorMission): {
+    current: PurposeDecision[];
+    historical: PurposeDecision[];
+    application_status: string;
+    interpretation: string;
+};
+export declare const purposeDecisionSchema: {
+    type: string;
+    "x-sortie-optional": boolean;
+    additionalProperties: boolean;
+    description: string;
+    required: string[];
+    properties: {
+        decision: {
+            type: string;
+            enum: ("CONTINUE" | "REUSE" | "CHANGE_METHOD" | "STOP_METHOD" | "NEEDS_DECISION")[];
+        };
+    };
+};

package/dist/core/mission-purpose.js

@@ -0,0 +1,56 @@
+import { createHash, randomUUID } from "node:crypto";
+export const PURPOSE_DECISIONS = ["CONTINUE", "REUSE", "CHANGE_METHOD", "STOP_METHOD", "NEEDS_DECISION"];
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const line = (value) => typeof value === "string" && !!value.trim() && value.length <= 2000;
+const lines = (value, min = 0) => Array.isArray(value) && value.length >= min && value.length <= 64 && value.every(line);
+const keys = ["decision", "requirement_ids", "observed_outcome", "unmet_work", "reason", "evidence_refs", "affected_method", "next_action"];
+function valid(value) {
+    return object(value) && PURPOSE_DECISIONS.includes(value.decision) &&
+        lines(value.requirement_ids, 1) && line(value.observed_outcome) && lines(value.unmet_work) && line(value.reason) &&
+        lines(value.evidence_refs) && (value.affected_method === undefined || line(value.affected_method)) && line(value.next_action) &&
+        (!["CHANGE_METHOD", "STOP_METHOD"].includes(String(value.decision)) || line(value.affected_method));
+}
+export function purposeRequirementsFingerprint(mission) {
+    return createHash("sha256").update(JSON.stringify(mission.requirements)).digest("hex");
+}
+/** A bounded strategy observation, never an evidence receipt or an execution control. */
+export function validatePurposeDecision(mission, raw) {
+    if (!valid(raw) || Object.keys(raw).some(key => !keys.includes(key)) ||
+        raw.requirement_ids.some(id => !mission.requirements.some(requirement => requirement.id === id))) {
+        throw new Error("mission-purpose-decision-invalid");
+    }
+}
+export function appendPurposeDecision(mission, raw) {
+    validatePurposeDecision(mission, raw);
+    const input = structuredClone(raw);
+    // Transport retries may repeat an observation; do not crowd out useful prior decisions.
+    const last = purposeDecisionView(mission).current.at(-1);
+    if (last && keys.every(key => JSON.stringify(last[key]) === JSON.stringify(input[key])))
+        return;
+    mission.purposeDecisions = [...retained(mission), { ...input, id: randomUUID(), mission_id: mission.id,
+            run_id: mission.runID, requirements_fingerprint: purposeRequirementsFingerprint(mission), recorded_at: new Date().toISOString() }].slice(-8);
+}
+function retained(mission) {
+    const raw = mission.purposeDecisions;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((value) => valid(value) && object(value) && line(value.id) &&
+        line(value.mission_id) && (value.run_id === null || line(value.run_id)) &&
+        typeof value.requirements_fingerprint === "string" && /^[a-f0-9]{64}$/u.test(value.requirements_fingerprint) &&
+        line(value.recorded_at) && Number.isFinite(Date.parse(value.recorded_at))).slice(-8);
+}
+export function purposeDecisionView(mission) {
+    const entries = retained(mission), fingerprint = purposeRequirementsFingerprint(mission);
+    const current = entries.filter(item => item.mission_id === mission.id && item.requirements_fingerprint === fingerprint &&
+        item.requirement_ids.every(id => mission.requirements.some(requirement => requirement.id === id)));
+    return { current, historical: entries.filter(item => !current.includes(item)),
+        application_status: "not-established-by-this-record",
+        interpretation: "Selected strategy observations, not proof that a plan was admitted or a method executed. observed_outcome and evidence_refs are model reports, not host observations. current means related to current requirements, not current evidence freshness. Original requirements and actual outcomes govern. REUSE does not establish evidence freshness or PASS. STOP_METHOD ends only the named method: it neither stops a live process nor completes/cancels the Mission. Required validation, explicit rollback, permissions, budget, Review and root acceptance remain unchanged. next_action here is advisory, not the host next_action." };
+}
+export const purposeDecisionSchema = { type: "object", "x-sortie-optional": true, additionalProperties: false,
+    description: "Optional important purpose/method decision accompanying useful planning or submission, not every Task. Record actual user outcome and concrete unmet work; references are not proof. No extra plan/approval solely to record it.",
+    required: ["decision", "requirement_ids", "observed_outcome", "unmet_work", "reason", "evidence_refs", "next_action"],
+    properties: { decision: { type: "string", enum: [...PURPOSE_DECISIONS] },
+        ...Object.fromEntries(["observed_outcome", "reason", "affected_method", "next_action"].map(key => [key, { type: "string", minLength: 1, maxLength: 2000 }])),
+        ...Object.fromEntries(["requirement_ids", "unmet_work", "evidence_refs"].map(key => [key, { type: "array", minItems: key === "requirement_ids" ? 1 : 0,
+                maxItems: 64, items: { type: "string", minLength: 1, maxLength: 2000 } }])) } };

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

@@ -2,6 +2,7 @@ import { type OperatorPlan, type OperatorState, type OperatorTask, type Operator
 import { type RuntimeProfile } from "./runtime-profile.js";
 import { type MissionContinuity } from "./mission-context.js";
 import { type WorkQuantityState } from "./work-quantity.js";
+import { type PurposeDecision } from "./mission-purpose.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 export declare const MISSION_REFERENCE = "SORTIE_MISSION_REF ";
 export declare const MISSION_REVIEW_REFERENCE = "SORTIE_MISSION_REVIEW_REF ";
@@ -220,6 +221,8 @@ export interface OperatorMission {
     context?: MissionContext[];
     /** Shared public context/working notes; observations, never extra requirements or acceptance. */
     continuity?: MissionContinuity;
+    /** Optional bounded strategy observations; never requirements, proof or authority. */
+    purposeDecisions?: PurposeDecision[];
     /** Operator recommendation from already-known context; not a requirement or execution lock. */
     preferredExecutor?: "coordinator" | "worker";
     /** Known unit facts passed to the Coordinator without pre-starting a Worker. */
@@ -398,6 +401,7 @@ export declare class OperatorMissionRuntime {
     }): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     recordConsultationSkip(root: string, role: MissionConsultation["role"], reason: string): Promise<OperatorMission>;
+    recordPurposeDecision(root: string, raw: unknown): Promise<OperatorMission>;
     recordConsultationDispatch(root: string, input: {
         role: MissionConsultation["role"];
         callID: string;

package/dist/core/operator-mission.js

@@ -9,6 +9,7 @@ import { missionValidationCommand } from "./mission-validation-command.js";
 import { retainMissionContext, missionContextView } from "./mission-context.js";
 import { planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
 import { applyPendingWork, rememberWorkMission, rememberedWorkRun } from "./work-quantity-observations.js";
+import { appendPurposeDecision, purposeDecisionView } from "./mission-purpose.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -332,6 +333,7 @@ export class OperatorMissionRuntime {
             launch_conditions: state.launchConditions ?? [],
             conversation: sources.some(source => source.session_id === state.root && source.entries > 0 && !("snapshot_available" in source)) ? [] : state.context ?? [],
             continuity: { notes: state.continuity?.notes, sources, progress: state.progress,
+                purpose_decisions: purposeDecisionView(state),
                 attempts: (state.attempts ?? []).map(({ runID, unitID, status, failure, resultClass, childSessionID }) => ({ run_id: runID, unit_id: unitID, status, failure, result_class: resultClass, session_id: childSessionID })),
                 execution: state.execution,
                 source_authors: state.sourceAuthors ?? [],
@@ -619,6 +621,9 @@ export class OperatorMissionRuntime {
                     reason: reason.trim(), at: new Date().toISOString() }].slice(-MISSION_CONSULTATION_LIMIT);
         });
     }
+    recordPurposeDecision(root, raw) {
+        return this.update(root, state => appendPurposeDecision(state, raw));
+    }
     recordConsultationDispatch(root, input) {
         if ((input.role !== "advisor" && input.role !== "scout") || !input.callID || !input.reason.trim() ||
             input.reason.length > 1000 || /[\r\n]/u.test(input.reason) ||
@@ -715,6 +720,7 @@ export class OperatorMissionRuntime {
             ...(state.suggestedUnit ? [`Known unit facts (reuse or adapt during actual work): ${JSON.stringify(state.suggestedUnit)}`] : []),
             "Escalate only a completion candidate, a user-only decision, or an extension of original requirements/budget. Unit progress is published without stopping you.",
             "Requirements:", ...state.requirements.map(item => `${item.id}: ${item.text}`),
+            `Purpose/method observations (advisory, not proof or authority): ${JSON.stringify(purposeDecisionView(state))}`,
             `Confirmed launch conditions (fixed limits, not consumption or remaining budget): ${JSON.stringify(state.launchConditions ?? [])}`,
             `Explicit user write prohibitions: ${JSON.stringify(state.prohibitedWrite ?? [])}`,
             `Work kind: ${state.kind ?? "implementation"}. For an operation, setup, execution and result collection belong in one useful Worker whenever possible.`,
@@ -872,6 +878,7 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
     return { original_requests: mission.requests, requirements: mission.requirements,
         original_attachments: (mission.continuity?.sources ?? []).flatMap(source => (source.attachments ?? []).map(file => ({ session_id: source.session_id, ...file }))),
         operation: missionOperationSummary(mission),
+        purpose_decisions: purposeDecisionView(mission),
         history: { status: missingAnchors.length ? "unavailable" : history.status,
             ...(history.reason ? { reason: history.reason } : missingAnchors.length ? { reason: "accepted-handoff-anchor-unavailable" } : {}),
             ...(missingAnchors.length ? { unavailable_anchors: missingAnchors } : {}),
@@ -914,6 +921,7 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
         accounting_scope: "Implementation units (Worker, direct controller execution or scoped Reviewer correction) are not benchmark attempts. Host budget uses the existing unit ledger; orchestration, read-only Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
         delivery_observation: mission.deliveryObservation?.run_id === (run?.runID ?? mission.runID) ? mission.deliveryObservation : null,
         submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
+        purpose_decisions: purposeDecisionView(mission),
         attempts: mission.attempts ?? [], corrections: (mission.corrections ?? []).map(({ findings: _findings, initialPrompt: _prompt, ...item }) => item), ...(mission.rescue ? { rescue: mission.rescue } : {}),
         operation: missionOperationSummary(mission),
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,

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

@@ -3,6 +3,7 @@
  */
 export declare function declaredArtifacts(paths: readonly string[], previewLimit?: number, options?: {
     reportUnreadableDirectories?: boolean;
+    reportOutsideLinks?: boolean;
 }): Promise<{
     entries: (readonly [string, string, (string | undefined)?])[];
     excerpt: string;

package/dist/plugin/declared-artifacts.js

@@ -62,8 +62,22 @@ export async function declaredArtifacts(paths, previewLimit = 0, options = {}) {
                 return;
             }
             entries.push([label, `symlink:${target}`, canonical]);
-            if (!physical.some(root => within(root, canonical)))
-                throw new Error("declared-artifact-link-outside-scope");
+            if (!physical.some(root => within(root, canonical))) {
+                if (!options.reportOutsideLinks)
+                    throw new Error("declared-artifact-link-outside-scope");
+                // Review records the link entry, not authority to inspect its target. Keep the
+                // strict default for validation snapshots and never recurse beyond declared roots.
+                entries.push([label, "target-not-inspected:outside-scope", canonical]);
+                const notice = Buffer.from(`\n--- external symlink: ${label} ---\n${target}\n[target not inspected: outside declared scope]\n`);
+                const bounded = notice.subarray(0, remaining);
+                if (bounded.length) {
+                    excerpts.push(bounded.toString("utf8"));
+                    remaining -= bounded.length;
+                }
+                if (bounded.length < notice.length)
+                    truncated = true;
+                return;
+            }
             if (ancestors.has(canonical))
                 return; // The link identity is recorded; do not traverse cycles.
             await visit(canonical, ancestors);

package/dist/plugin/mission-review.js

@@ -761,6 +761,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         untracked.add(path);
     const omitted = [];
     const unreadable = [];
+    const outsideLinks = [];
     let diff = scopedDiff;
     if (repository && local.length && displayBaseline) {
         // HEAD-only diffs are empty once the author commits. Display the original mission delta
@@ -881,19 +882,25 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         // A declared write scope can also be a host-managed runtime directory (e.g. Docker's data root).
         // Do not make review depend on listing it; record the missing coverage instead. Protected
         // validation still requires readable outputs and does not use this review-only option.
-        const artifacts = await declaredArtifacts(external, Math.max(1, 24_000 - Buffer.byteLength(excerpt)), { reportUnreadableDirectories: true });
+        const artifacts = await declaredArtifacts(external, Math.max(1, 24_000 - Buffer.byteLength(excerpt)), { reportUnreadableDirectories: true, reportOutsideLinks: true });
         sourceUpdate(JSON.stringify(artifacts.entries));
         excerpt += artifacts.excerpt;
         if (artifacts.truncated)
             omitted.push("external artifacts");
         unreadable.push(...artifacts.unreadable);
+        outsideLinks.push(...artifacts.entries.filter(([, kind]) => kind === "target-not-inspected:outside-scope").map(([path]) => path));
     }
     const bytes = Buffer.from(excerpt);
     const truncatedSource = [...new Set(omitted)];
     if (bytes.length > 24_000 && truncatedSource.length === 0)
         truncatedSource.push("(source diff exceeds excerpt budget)");
+    // Missing coverage is not a clipped source preview: disclose it even after that
+    // budget is exhausted. Full link identities remain in the fingerprint above.
+    const outsideNotice = outsideLinks.length ? `\n[UNINSPECTED EXTERNAL LINK TARGETS: ${outsideLinks.length} link(s); outside declared artifact roots; ` +
+        `target contents not inspected or fingerprinted through these links. Link entries (first 20, clipped preview): ` +
+        `${Buffer.from(JSON.stringify(outsideLinks.slice(0, 20))).subarray(0, 2_000).toString("utf8")}]` : "";
     return { fingerprint: `sha256:${hash.digest("hex")}`, candidateFingerprint: `sha256:${candidateHash.digest("hex")}`, excerpt: (bytes.length > 24_000 ? bytes.subarray(0, 24_000).toString("utf8") : excerpt) +
             (truncatedSource.length ? `\n[EXCERPT TRUNCATED: ${truncatedSource.slice(0, 20).join(", ")}; Reviewer can read/search the relevant source directly]` : "") +
-            (unreadable.length ? `\n[UNINSPECTED EXTERNAL DIRECTORIES: ${unreadable.slice(0, 20).join(", ")}; select specific result files as review evidence]` : ""),
+            (unreadable.length ? `\n[UNINSPECTED EXTERNAL DIRECTORIES: ${unreadable.slice(0, 20).join(", ")}; select specific result files as review evidence]` : "") + outsideNotice,
         truncatedEvidence, truncatedSource };
 }

package/dist/plugin/profiled.js

@@ -24,6 +24,7 @@ import { missionLocations, missionLocationPacket } from "./mission-location.js";
 import { prepareValidationScratch } from "./validation-scratch.js";
 import { SOURCE_REVIEW_RISK_TAGS } from "../core/consultation.js";
 import { createHash, randomUUID } from "node:crypto";
+import { appendPurposeDecision, purposeDecisionSchema, purposeDecisionView, validatePurposeDecision } from "../core/mission-purpose.js";
 import { proposeTerminalRescue } from "../core/terminal-rescue-policy.js";
 import { DEFAULT_TERMINAL_RESCUE_MODEL } from "./terminal-rescue-host.js";
 import { readHostModels } from "./model-routing-hook.js";
@@ -3149,12 +3150,15 @@ export function createProfiledPlugin(profile, assetVersion) {
                 execution: missionExecutionSchema,
                 handoff_context: handoffContextSchema,
                 reason: { type: "string", "x-sortie-optional": true },
+                purpose_decision: purposeDecisionSchema,
                 executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here. Use worker without units to yield the current direct unit, carrying remaining action in handoff_context; the same unit, edits, checks and budget continue. With units, worker/default retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 if (args.executor !== undefined && !["self", "worker"].includes(args.executor))
                     throw new Error("mission-executor-invalid");
                 try {
                     return await serializeDispatchTransition(root, async () => {
+                        if (args.purpose_decision !== undefined)
+                            await missions.recordPurposeDecision(root, args.purpose_decision);
                         if (args.executor === "worker" && args.units === undefined)
                             return handoffDirect(root, context.sessionID, context.callID, args.handoff_context);
                         const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID, args.handoff_context, args.work_quantities);
@@ -3402,6 +3406,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         tools[reviewMission] = { description: "Coordinator or direct Fast-lane root: prepare independent quality review or author read-only self-recheck. Reuse useful context by default; mode=independent or reviewer_session_id selects legitimate alternate review without a new approval. Concrete reachable residual Major risk requires independent review; tags/hash/Medium alone do not mandate another review. Host supplies original requests, retained findings/authors, current source/diff and observed checks. Traces/excerpts are optional. Preserve current validation and separate root acceptance. A low-risk initial skip is recorded.",
             args: { risk_tags: { type: "array", items: { type: "string", enum: SOURCE_REVIEW_RISK_TAGS } },
+                purpose_decision: purposeDecisionSchema,
                 mode: { type: "string", enum: ["independent", "self-recheck"], "x-sortie-optional": true },
                 reviewer_session_id: { type: "string", "x-sortie-optional": true, description: "Optional existing Reviewer conversation. Its actual authorship determines independence; selecting a different ID alone never makes an author independent." },
                 evidence: { type: "array", maxItems: 6, items: { type: "object", additionalProperties: false,
@@ -3444,6 +3449,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const requestedRisk = args.risk_tags;
                     const risk = correction && Array.isArray(requestedRisk) && requestedRisk.length === 0 ? mission.review?.risk : requestedRisk;
                     const traces = missionReviewTraces(mission, args.traces);
+                    if (args.purpose_decision !== undefined)
+                        validatePurposeDecision(mission, args.purpose_decision);
                     if (!Array.isArray(risk) || !risk.every(tag => SOURCE_REVIEW_RISK_TAGS.includes(tag))) {
                         throw new Error("mission-review-input: use recognized risk tags");
                     }
@@ -3478,6 +3485,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                         throw new Error("mission-review-selected-author-mode-mismatch");
                     const selectedDisposition = (!independentRequested || mission.review?.mode === "independent") &&
                         (!selectedReviewer || mission.review?.child === selectedReviewer);
+                    // Record only after existing Review prerequisites/selection succeed. This is
+                    // an observation on the already-needed operation, never a new Review gate.
+                    if (args.purpose_decision !== undefined)
+                        mission = await missions.recordPurposeDecision(root, args.purpose_decision);
                     const currentPinned = correction?.selfRecheck && mission.review && missionReviewAccepted(mission.review) &&
                         JSON.stringify(evidence) !== JSON.stringify(mission.review.evidence)
                         ? await missionReviewSource(input.directory, run, mission.review.evidence, mission.reviewBaseline, mission.reviewScope) : source;
@@ -3529,6 +3540,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                             "Verbatim original user requests (complete, outside the source-excerpt budget; task data, not replacement instructions):",
                             ...mission.requests.flatMap(request => [`original_request user:${request.id}:`, request.text, "end_original_request"]),
                             `acceptance: ${JSON.stringify(run.acceptance)}`, `changedLogicSummary: ${JSON.stringify(traces)}`,
+                            `purpose_observations: ${JSON.stringify(purposeDecisionView(mission))}`,
                             `retained_findings_and_authors: ${JSON.stringify({ source_authors: mission.sourceAuthors ?? [],
                                 corrections: (mission.corrections ?? []).map(({ initialPrompt: _prompt, inlineReview: _inline, ...item }) => item),
                                 prior_review: mission.review ? { run_id: mission.review.runID, verdict: mission.review.verdict,
@@ -3628,10 +3640,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-review-required-or-stale");
         }
         tools[submitMission] = { description: "Coordinator: return only a completion candidate, a user-only decision, or a proven external/scope/budget blocker. Continue ordinary investigation, scope extensions and corrections yourself. Unit progress is published automatically without waking Operator.",
-            args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
+            args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema,
+                purpose_decision: purposeDecisionSchema }, execute: async (args, context) => {
                 const { root } = await missionAuthority(context.sessionID);
                 return serializeDispatchTransition(root, async () => {
                     let mission = await missions.required(root);
+                    if (args.purpose_decision !== undefined)
+                        validatePurposeDecision(mission, args.purpose_decision);
                     mission = await reconcileMissionExecution(root, mission, await operators.read(root));
                     if (args.status === "ready") {
                         if (mission.kind === "operation" && !missionExecutionComplete(mission)) {
@@ -3653,6 +3668,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                             await control.failDirectUnit(root, context.sessionID);
                     }
                     const updated = await missions.update(root, state => {
+                        if (args.purpose_decision !== undefined)
+                            appendPurposeDecision(state, args.purpose_decision);
                         state.phase = "submitted";
                         state.submission = { status: args.status, summary: args.summary };
                     });

package/dist/runtime-mission-assets.d.ts

@@ -1,6 +1,8 @@
 import { type RuntimeProfile } from "./core/runtime-profile.ts";
 /** Repository-local dependency environment shared by all units; excluded from reviewed and captured source. */
 export declare const TOOL_ENVIRONMENT = ".sortie-env";
+/** Purpose alignment at existing decisions, not another role, gate or per-Task ritual. */
+export declare const MISSION_PURPOSE = "## Purpose and methods\nKeep the user's vision/required outcomes separate from the current method. At an existing material\ndecision (reusable result, failed approach, peripheral issue, or completion comparison), compare the\noriginal requirements with actual user outcomes, concrete unmet work and existing evidence. Choose\nCONTINUE, REUSE, CHANGE_METHOD, STOP_METHOD or NEEDS_DECISION during useful work, not a separate turn.\nReuse unchanged applicable evidence; inspect still-unmet outcomes rather than repeating the same method\nwithout a changed input or hypothesis. A successful small Task, title or instruction is not vision fulfillment.\nSTOP_METHOD ends only a named means, never a required outcome, live process or Mission. Finish required\nvalidation and explicit rollback/recovery. Do not expand into unrelated issues; only user-only choices\nor original scope/budget extensions require escalation. Normal in-scope correction continues autonomously.\nWhen a material rationale would otherwise be lost on resume, optionally attach purpose_decision to an\nalready-needed plan_units, review_mission or submit_mission: decision, requirement_ids, observed_outcome, unmet_work,\nreason, evidence_refs, affected_method (required for change/stop), next_action. No extra plan, Task or\napproval solely to record it. Reuse current purpose_decisions on resume; historical entries need fresh\ncomparison with current requirements. These are model observations, not evidence PASS/freshness or\npermission. A Fast-lane root has no submit_mission: use its already-needed review_mission or next useful\nplan, never replan solely for logging. Do not request another Review or elevate a low-risk skip to save a\nnote. Host next_action, budgets, history, validation, independent Review and root acceptance govern.";
 /** Static presentation guidance; observed values stay in ordinary tool results, not live instructions. */
 export declare const MISSION_PRESENTATION = "## Readable progress and return reports\nUse short, meaningful headings in ordinary user-facing updates: \u2691 start, \u25CE finding, \u270E note,\n[!] obstacle, \u21A9 recovered only after recovery is observed. Keep warnings, code and machine status exact.\nUse restrained spacing, not large ASCII frames, constant military metaphors, animation or typing delays.\nReserve a small margin note or doodle for a formal completion or earned distinction, not every message.\nWhen an ordinary Mission tool result supplies work_quantity_display, copy that host-generated label into\nyour next useful user-facing progress update. No separate progress-only status call or model turn.\nThis is estimated workload for the whole request, NOT elapsed time, cost, budget or completed-unit share.\nAn estimate revision may decrease it; only formal request completion means 100%. Do not extrapolate,\nrecompute or invent it. Task metadata may be saved without being displayed by the client; Direct may\nhave no Task card. Use ordinary response text, never a fake Task or a claim that metadata proves UI delivery.\nWhen complete_mission supplies return_report, append it verbatim exactly once outside any code fence.\nThe host-authored panel and formal receipt are authoritative; titles and decoration never prove success.\nDo not regenerate metrics, hide unknowns, schedule another model turn, or repeat work just to render it.";
 /** Task-specific environment limits qualify general dependency setup guidance. */

package/dist/runtime-mission-assets.js

@@ -3,6 +3,25 @@ import { STRATEGY_TRIGGERS, SOURCE_REVIEW_RISK_TAGS } from "./core/consultation.
 import { SCOUT_EVIDENCE_CODES } from "./core/scout-contract.js";
 /** Repository-local dependency environment shared by all units; excluded from reviewed and captured source. */
 export const TOOL_ENVIRONMENT = ".sortie-env";
+/** Purpose alignment at existing decisions, not another role, gate or per-Task ritual. */
+export const MISSION_PURPOSE = `## Purpose and methods
+Keep the user's vision/required outcomes separate from the current method. At an existing material
+decision (reusable result, failed approach, peripheral issue, or completion comparison), compare the
+original requirements with actual user outcomes, concrete unmet work and existing evidence. Choose
+CONTINUE, REUSE, CHANGE_METHOD, STOP_METHOD or NEEDS_DECISION during useful work, not a separate turn.
+Reuse unchanged applicable evidence; inspect still-unmet outcomes rather than repeating the same method
+without a changed input or hypothesis. A successful small Task, title or instruction is not vision fulfillment.
+STOP_METHOD ends only a named means, never a required outcome, live process or Mission. Finish required
+validation and explicit rollback/recovery. Do not expand into unrelated issues; only user-only choices
+or original scope/budget extensions require escalation. Normal in-scope correction continues autonomously.
+When a material rationale would otherwise be lost on resume, optionally attach purpose_decision to an
+already-needed plan_units, review_mission or submit_mission: decision, requirement_ids, observed_outcome, unmet_work,
+reason, evidence_refs, affected_method (required for change/stop), next_action. No extra plan, Task or
+approval solely to record it. Reuse current purpose_decisions on resume; historical entries need fresh
+comparison with current requirements. These are model observations, not evidence PASS/freshness or
+permission. A Fast-lane root has no submit_mission: use its already-needed review_mission or next useful
+plan, never replan solely for logging. Do not request another Review or elevate a low-risk skip to save a
+note. Host next_action, budgets, history, validation, independent Review and root acceptance govern.`;
 /** Static presentation guidance; observed values stay in ordinary tool results, not live instructions. */
 export const MISSION_PRESENTATION = `## Readable progress and return reports
 Use short, meaningful headings in ordinary user-facing updates: ⚑ start, ◎ finding, ✎ note,
@@ -314,6 +333,8 @@ ${MISSION_REFLECTION_WORKFLOW}
 
 ${MISSION_PRESENTATION}
 
+${MISSION_PURPOSE}
+
 Retain 🐾 Sortie presentation. When complete_mission returns return_report, append that host-authored
 Markdown verbatim exactly once after a concise final outcome and key checks, outside any code fence.
 Preserve the panel's headings, metrics, unknown values and caveats; do not recalculate, regenerate it or
@@ -540,6 +561,8 @@ Do not reconstruct or prepend the absolute workspace path. Preserve explicitly r
 
 ${MISSION_PRESENTATION}
 
+${MISSION_PURPOSE}
+
 For release/benchmark work, retain the user's selected package/environment and record its receipt/hash.
 A local repack and a published tarball can have different hashes; that alone does not prohibit a requested
 local run. Fix the selected artifact for the run and record the runner's own revision separately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",