sortie-dogs 0.14.9 → 0.15.2

package/README.md

@@ -19,8 +19,9 @@ 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.14.9](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.14.9)**
-· [Release notes](docs/release-v0.14.9.md) · [Execution vision](docs/v0.14.0-execution-vision.md)
+**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)
+· [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) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -77,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.14.9
+npm install --save-dev sortie-dogs@0.15.2
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -106,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.14.9
+npm install --save-dev sortie-dogs@0.15.2
 npx --no-install sortie-dogs init .
 ```
 
@@ -124,6 +125,18 @@ The `v010` command, profile and configuration names remain for compatibility; th
 v0.10 is installed. [OpenCode setup and configuration](docs/configuration.md) ·
 [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md).
 
+### Project Memory (OpenCode v010, opt-in)
+
+With v0.15.2 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
+current project vision and constraints as well as relevant decisions and source references.
+`sortie-dogs memory off .` stops capture and recall without deleting saved data.
+This is not a Codex natural-capture feature, execution permission, Review PASS or proof
+of completion. Existing reflection defaults and explicit settings are unchanged.
+[Scope, attachment retrieval, limits and recovery](docs/v0150-project-memory.md).
+
 ## Mission workflow
 
 ```text
@@ -271,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.14.9-optional-kofi-v1`; the Codex skill marker is
+The current Mission asset marker is `0.15.2-tactical-return-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;
@@ -287,7 +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).
-- **Releases:** [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) ·
+- **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).
 
 ## Support

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.14.9-optional-kofi-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.15.2-tactical-return-v1";
 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.14.9-optional-kofi-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.15.2-tactical-return-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

package/dist/cli/main.js

@@ -28,7 +28,8 @@ const USAGE = `Usage: sortie-dogs lint <handoff.json> [<handoff.json> ...]
   [--manifest <operation-manifest.json>]
   [--changed-paths-from <file|->]
   [--changed-path <path> ...]
-  [--format text|json] [--quiet] [--strict]`;
+  [--format text|json] [--quiet] [--strict]
+Project Memory (opt-in): sortie-dogs memory on|off|status [project-root]`;
 const INIT_USAGE = `Usage: sortie-dogs init [project-root] [--profile stable|v010]
        sortie-dogs init --global [--profile stable|v010]
 This beta package defaults to the v010 profile.`;
@@ -238,6 +239,24 @@ function render(output, format) {
     return output.map(({ file, pointer, code, severity, message }) => `${file} ${neutralizeTextControlCharacters(pointer || "/")} ${code} ${severity} ${neutralizeTextControlCharacters(message)}\n`).join("");
 }
 export async function run(argv) {
+    if (argv[0] === "memory") {
+        if (!["on", "off", "status"].includes(argv[1] ?? "") || argv.length > 3 || argv[2]?.startsWith("-")) {
+            process.stderr.write("Usage: sortie-dogs memory on|off|status [project-root]\nOpt-in once per local project; off retains data and stops capture/recall.\n");
+            return 2;
+        }
+        try {
+            const memoryModule = await import(__rewriteRelativeImportExtension(`../core/project-memory.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`));
+            const memory = new memoryModule.ProjectMemory(await memoryModule.projectMemoryFile(resolve(argv[2] ?? ".")));
+            if (argv[1] !== "status")
+                await memory.configure(argv[1] === "on");
+            process.stdout.write(JSON.stringify(await memory.recall(resolve(argv[2] ?? "."))) + "\n");
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`Project Memory: ${error instanceof Error ? error.message : String(error)}\n`);
+            return 1;
+        }
+    }
     if (argv[0] === "codex") {
         if (argv[1] === "init") {
             if (argv[2] === "--help" && argv.length === 3) {
@@ -354,6 +373,8 @@ export async function run(argv) {
             if (initialized.preservedLegacyPaths.length > 0) {
                 process.stdout.write(`Preserved legacy runtime files: ${initialized.preservedLegacyPaths.join(", ")}.\n`);
             }
+            if (profile === "v010")
+                process.stdout.write("Optional Project Memory: sortie-dogs memory on [project-root]. Off stops capture/recall and retains data. Reload the project plugin after first opt-in.\n");
             const override = profile === "v010"
                 ? await initializer.coordinatorModelOverride(global ? target : resolve(initArgs[0] ?? process.cwd()), global).catch(() => undefined)
                 : undefined;

package/dist/core/goal-bound.js

@@ -144,6 +144,9 @@ export function reduceGoalFlight(records) {
     const validationAdmissions = new Map();
     const validationSettlements = new Map();
     const reopenedValidationEvidence = new Set();
+    // Older revisions projected the unit ceiling onto validation capacity. Replay their
+    // subsequent, stricter recorded admissions without shrinking the retained capacity.
+    let validationAdmissionLimit = null;
     for (const [index, record] of records.entries()) {
         requireState(record.sequence === index + 1 && record.previous_hash === previous && HASH.test(record.event_hash), "invalid", "Goal ledger chain is malformed.");
         previous = record.event_hash;
@@ -170,6 +173,7 @@ export function reduceGoalFlight(records) {
             validationAdmissions.clear();
             validationSettlements.clear();
             reopenedValidationEvidence.clear();
+            validationAdmissionLimit = null;
             continue;
         }
         requireState(state.goal_id !== null && event.goal_id === state.goal_id, "transition", "Goal identity mismatch.");
@@ -182,14 +186,13 @@ export function reduceGoalFlight(records) {
         else if (event.kind === "goal.revised") {
             requireState(state.phase !== "terminal" && event.revision === state.revision + 1 && event.scope_epoch === state.scope_epoch + 1 &&
                 HASH.test(event.acceptance_fingerprint) && event.budget.max_units >= state.consumed_units &&
-                event.budget.max_units >= state.validation_budget.consumed &&
                 validAcceptanceContract(event.acceptance_contract) &&
                 (event.reset_no_progress === undefined || typeof event.reset_no_progress === "boolean"), "transition", "Scope revision is stale or resets consumed budget.");
             state = { ...state, revision: event.revision, scope_epoch: event.scope_epoch,
                 acceptance_fingerprint: event.acceptance_fingerprint, latest_user_message_id: event.origin_user_message_id,
                 selected_agent: event.selected_agent, delivery: event.delivery, budget: event.budget,
                 validation_budget: { ...state.validation_budget,
-                    limit: state.validation_budget.limit === null ? null : event.budget.max_units },
+                    limit: state.validation_budget.limit === null ? null : Math.max(state.validation_budget.limit, state.validation_budget.consumed, event.budget.max_units) },
                 acceptance_contract: event.acceptance_contract,
                 session_ids: addUnique(state.session_ids, event.session_id), phase: "active", stop_reason: null,
                 receipt: null, tickets: [], ...(event.reset_no_progress === true
@@ -198,6 +201,8 @@ export function reduceGoalFlight(records) {
             if (event.reset_no_progress === true)
                 replanRevision = null;
             legacyResetRevision = event.reset_no_progress === undefined;
+            if (validationAdmissionLimit !== null)
+                validationAdmissionLimit = Math.max(event.budget.max_units, state.validation_budget.consumed);
         }
         else if (event.kind === "ticket.issued") {
             requireState(state.phase === "active" && event.revision === state.revision && event.scope_epoch === state.scope_epoch &&
@@ -318,13 +323,15 @@ export function reduceGoalFlight(records) {
                 const latest = [...validationSettlements.values()].filter(entry => entry.evidence_key === event.evidence_key).at(-1);
                 const blocked = latest !== undefined && latest.outcome !== "passed" && !retryableValidationFailure(latest.outcome, latest.exit_code);
                 requireState(event.scope !== null && event.consumed === state.validation_budget.consumed + 1 &&
-                    (state.validation_budget.limit === null || event.limit >= state.validation_budget.limit) &&
+                    (validationAdmissionLimit === null || event.limit >= validationAdmissionLimit) &&
                     ((!duplicate && !blocked && !inFlight && reopen === undefined) || (validReopen && !inFlight)) &&
                     !state.validation_budget.reservations.some((entry) => entry.reservation_id === event.reservation_id), "budget", "Validation admission is stale, duplicated, or exhausted.");
-                state = { ...state, validation_budget: { ...state.validation_budget, consumed: event.consumed, limit: event.limit,
+                state = { ...state, validation_budget: { ...state.validation_budget, consumed: event.consumed,
+                        limit: Math.max(state.validation_budget.limit ?? event.limit, event.limit),
                         reservations: [...state.validation_budget.reservations,
                             { reservation_id: event.reservation_id, operation_id: event.operation_id, evidence_key: event.evidence_key }] } };
                 validationAdmissions.set(event.reservation_id, event);
+                validationAdmissionLimit = event.limit;
                 if (reopen !== undefined)
                     reopenedValidationEvidence.add(event.evidence_key);
             }

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

@@ -1,3 +1,4 @@
+import { type RareAwards } from "./rare-awards.ts";
 /** Optional, bounded telemetry retained with the existing terminal goal ledger, never an authority input. */
 export interface GoalReport {
     readonly definition: "pre-terminal-host-tokens/v1";
@@ -14,5 +15,6 @@ export interface GoalReport {
         readonly worker_ms: number;
         readonly wall_ms: number;
     };
+    readonly rare?: RareAwards;
 }
 export declare function validGoalReport(value: unknown): value is GoalReport;

package/dist/core/goal-report.js

@@ -1,3 +1,4 @@
+import { validRareAwards } from "./rare-awards.js";
 export function validGoalReport(value) {
     if (value === null || typeof value !== "object")
         return false;
@@ -5,11 +6,12 @@ export function validGoalReport(value) {
     const amount = (n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
     const duration = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
     const overlap = item.overlap;
-    return Object.keys(item).every((key) => ["definition", "terminal_key", "tokens", "models", "first_pass_eligible", "traits", "overlap"].includes(key)) &&
+    return Object.keys(item).every((key) => ["definition", "terminal_key", "tokens", "models", "first_pass_eligible", "traits", "overlap", "rare"].includes(key)) &&
         item.definition === "pre-terminal-host-tokens/v1" && /^sha256:[a-f0-9]{64}$/u.test(item.terminal_key) &&
         (item.tokens === null || amount(item.tokens)) && typeof item.first_pass_eligible === "boolean" &&
         Array.isArray(item.traits) && item.traits.length <= 3 && new Set(item.traits).size === item.traits.length &&
         item.traits.every((trait) => ["pack-tactics", "recovery", "clean-sweep"].includes(trait)) &&
+        (item.rare === undefined || validRareAwards(item.rare)) &&
         (overlap === undefined || overlap !== null && typeof overlap === "object" &&
             Object.keys(overlap).every((key) => ["definition", "worker_ms", "wall_ms"].includes(key)) && overlap.definition === "worker-span-union/v1" &&
             duration(overlap.worker_ms) && duration(overlap.wall_ms) && overlap.worker_ms >= overlap.wall_ms) &&

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.14 Mission line without selecting a v0.11 execution path.
+    // preview into the 0.12–0.15 Mission line without selecting a v0.11 execution path.
     const restoredPreview = v010Restore && installed.major === 0 && installed.minor === 10 &&
-        current.major === 0 && [12, 13, 14].includes(current.minor);
-    const retainedMission = v010Restore && installed.major === 0 && installed.minor === 12 &&
-        current.major === 0 && current.minor === 14;
+        current.major === 0 && [12, 13, 14, 15].includes(current.minor);
+    const retainedMission = v010Restore && installed.major === 0 &&
+        ((installed.minor === 12 && current.minor === 14) || ([12, 13].includes(installed.minor) && current.minor === 15)) &&
+        current.major === 0;
     return sameLine || adjacentPreOneLine || restoredPreview || retainedMission ? "compatible-update" : "incompatible";
 }
 async function metadata(path) {

package/dist/core/project-memory.d.ts

@@ -0,0 +1,136 @@
+export interface MemorySource {
+    id: string;
+    session: string;
+    message: string;
+    actor: string;
+    text: string;
+    attachments: Array<{
+        url: string;
+        mime?: string;
+        filename?: string;
+    }>;
+    observedAt: string;
+    availability: "retained-reference";
+}
+export interface MemoryChange {
+    key: string;
+    scope: "project" | "workspace" | "mission";
+    context: string;
+    kind: "vision" | "constraint" | "decision" | "unresolved" | "result";
+    status: "proposed" | "adopted" | "withdrawn" | "unverified";
+    text: string;
+    reason: string;
+    supersedes?: string;
+    consultation?: {
+        id: string;
+        callID: string;
+        disposition: "adopted" | "rejected" | "partial";
+        effect: "improved" | "unchanged" | "worsened" | "unverified";
+    };
+}
+export interface MemoryEvent extends MemoryChange {
+    id: string;
+    source: string;
+    operation: string;
+    actor: string;
+    at: string;
+}
+/** Stable repository identity uses local Git common-dir, never remote URL or a worktree path. */
+export declare function projectMemoryFile(root: string): Promise<string>;
+/** One atomic document commits events and processed markers together. No reflection TTL or schema reuse. */
+export declare class ProjectMemory {
+    readonly file: string;
+    constructor(file: string);
+    private load;
+    private transaction;
+    enabled(): Promise<boolean>;
+    source(id: string): Promise<MemorySource | undefined>;
+    sourceForModel(id: string): Promise<{
+        text: string;
+        text_truncated: boolean;
+        attachments: {
+            url: string | undefined;
+            url_omitted: boolean;
+            filename?: string | undefined;
+            mime?: string | undefined;
+            source: string;
+            index: number;
+        }[];
+        id: string;
+        session: string;
+        message: string;
+        actor: string;
+        observedAt: string;
+        availability: "retained-reference";
+    } | undefined>;
+    /** Materialize inline bytes only on demand; recall must never inject them as model text. */
+    attachment(id: string, index: number): Promise<{
+        source: string;
+        index: number;
+        url: string;
+        mime?: string;
+        filename?: string;
+    } | {
+        filename?: string | undefined;
+        source: string;
+        index: number;
+        path: string;
+        mime: string;
+    } | undefined>;
+    configure(enabled: boolean): Promise<void>;
+    capture(source: Omit<MemorySource, "observedAt" | "availability">): Promise<void>;
+    apply(source: string, operation: string, actor: string, changes: MemoryChange[]): Promise<string>;
+    recall(workspace: string, mission?: string, query?: string): Promise<{
+        enabled: false;
+        snapshot?: undefined;
+        protected_omitted?: undefined;
+        pending?: undefined;
+        pending_count?: undefined;
+        oldest_pending?: undefined;
+        last_success?: undefined;
+        sources?: undefined;
+    } | {
+        enabled: true;
+        snapshot: MemoryEvent[];
+        protected_omitted: number;
+        pending: {
+            text: string;
+            text_truncated: boolean;
+            attachments: {
+                url: string | undefined;
+                url_omitted: boolean;
+                filename?: string | undefined;
+                mime?: string | undefined;
+                source: string;
+                index: number;
+            }[];
+            id: string;
+            session: string;
+            message: string;
+            actor: string;
+            observedAt: string;
+            availability: "retained-reference";
+        }[];
+        pending_count: number;
+        oldest_pending: string;
+        last_success: string | null;
+        sources: {
+            text: string;
+            text_truncated: boolean;
+            attachments: {
+                url: string | undefined;
+                url_omitted: boolean;
+                filename?: string | undefined;
+                mime?: string | undefined;
+                source: string;
+                index: number;
+            }[];
+            id: string;
+            session: string;
+            message: string;
+            actor: string;
+            observedAt: string;
+            availability: "retained-reference";
+        }[];
+    }>;
+}

package/dist/core/project-memory.js

@@ -0,0 +1,217 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { durableScopeRoot } from "./durable-scope-root.js";
+import { configRoot } from "../reflection/config.js";
+const empty = () => ({ v: 1, enabled: false, sources: [], events: [], processed: {} });
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const text = (value, max = 8000) => typeof value === "string" && value.trim().length > 0 && value.length <= max;
+const sourceView = (source, fullText = false) => ({ ...source,
+    text: fullText ? source.text : source.text.slice(0, 2000), text_truncated: !fullText && source.text.length > 2000,
+    attachments: source.attachments.map((file, index) => ({ source: source.id, index,
+        ...(file.mime ? { mime: file.mime.slice(0, 256) } : {}), ...(file.filename ? { filename: file.filename.slice(0, 256) } : {}),
+        url: !file.url.startsWith("data:") && file.url.length <= 2048 ? file.url : undefined,
+        url_omitted: file.url.startsWith("data:") || file.url.length > 2048 })) });
+/** Stable repository identity uses local Git common-dir, never remote URL or a worktree path. */
+export async function projectMemoryFile(root) {
+    // The lease suffix need not exist yet; canonicalize its existing ancestors
+    // without creating metadata merely to compute the memory identity.
+    const canonical = async (path) => realpath(path).catch(async (error) => {
+        if (error.code !== "ENOENT" || dirname(path) === path)
+            throw error;
+        return join(await canonical(dirname(path)), basename(path));
+    });
+    const identity = await canonical(await durableScopeRoot(root) ?? resolve(root));
+    return join(configRoot(), "sortie-dogs", "project-memory", `${hash(identity)}.json`);
+}
+/** One atomic document commits events and processed markers together. No reflection TTL or schema reuse. */
+export class ProjectMemory {
+    file;
+    constructor(file) { this.file = file; }
+    async load() {
+        try {
+            const state = JSON.parse(await readFile(this.file, "utf8"));
+            if (state.v !== 1 || typeof state.enabled !== "boolean" || !Array.isArray(state.sources) ||
+                !Array.isArray(state.events) || !state.processed || typeof state.processed !== "object" || Array.isArray(state.processed) ||
+                !state.sources.every(source => source && text(source.id) && text(source.session) && text(source.message) && text(source.actor) &&
+                    typeof source.text === "string" && Array.isArray(source.attachments) && source.attachments.every(file => file && text(file.url, Number.MAX_SAFE_INTEGER)) &&
+                    typeof source.observedAt === "string" && source.availability === "retained-reference") ||
+                !state.events.every(event => event && text(event.id) && text(event.key) && text(event.context) && text(event.text) && text(event.reason) &&
+                    text(event.source) && text(event.actor) && text(event.operation) && typeof event.at === "string" &&
+                    ["project", "workspace", "mission"].includes(event.scope) && ["vision", "constraint", "decision", "unresolved", "result"].includes(event.kind) &&
+                    ["proposed", "adopted", "withdrawn", "unverified"].includes(event.status)) ||
+                !Object.values(state.processed).every(item => item && text(item.operation) && text(item.fingerprint) && typeof item.at === "string"))
+                throw new Error("project-memory-invalid-state");
+            return state;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return empty();
+            throw error;
+        }
+    }
+    async transaction(fn) {
+        await mkdir(dirname(this.file), { recursive: true, mode: 0o700 });
+        const lock = `${this.file}.lock`;
+        let handle;
+        for (let attempt = 0; attempt < 40; attempt++) {
+            try {
+                handle = await open(lock, "wx", 0o600);
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+        }
+        if (!handle)
+            throw new Error(`project-memory-busy: retry; if interrupted owner stopped, remove ${lock}`);
+        const temp = `${this.file}.${randomUUID()}.tmp`;
+        try {
+            await handle.writeFile(JSON.stringify({ pid: process.pid }));
+            const state = await this.load(), result = fn(state);
+            const output = await open(temp, "wx", 0o600);
+            try {
+                await output.writeFile(JSON.stringify(state));
+                await output.sync();
+            }
+            finally {
+                await output.close();
+            }
+            await rename(temp, this.file);
+            const directory = await open(dirname(this.file), "r").catch(() => undefined);
+            try {
+                await directory?.sync();
+            }
+            finally {
+                await directory?.close();
+            }
+            return result;
+        }
+        finally {
+            await unlink(temp).catch(() => undefined);
+            await handle.close();
+            await unlink(lock);
+        }
+    }
+    async enabled() { return (await this.load()).enabled; }
+    async source(id) {
+        const state = await this.load();
+        return state.enabled ? state.sources.find(source => source.id === id) : undefined;
+    }
+    async sourceForModel(id) {
+        const source = await this.source(id);
+        return source ? sourceView(source, true) : undefined;
+    }
+    /** Materialize inline bytes only on demand; recall must never inject them as model text. */
+    async attachment(id, index) {
+        if (!Number.isSafeInteger(index) || index < 0)
+            return undefined;
+        const source = await this.source(id), file = source?.attachments[index];
+        if (!file)
+            return undefined;
+        if (!file.url.startsWith("data:"))
+            return { ...file, source: id, index };
+        const response = await fetch(file.url);
+        if (!response.ok)
+            throw new Error("project-memory-attachment-unavailable");
+        const bytes = Buffer.from(await response.arrayBuffer());
+        const mime = file.mime ?? response.headers.get("content-type") ?? "application/octet-stream";
+        const extension = { "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp",
+            "application/pdf": ".pdf", "text/plain": ".txt" }[mime] ?? ".bin";
+        const directory = `${this.file}.attachments`, path = join(directory, `${hash(file.url)}${extension}`);
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, bytes, { flag: "wx", mode: 0o600 });
+            await rename(temporary, path);
+        }
+        finally {
+            await unlink(temporary).catch(() => undefined);
+        }
+        return { source: id, index, path, mime, ...(file.filename ? { filename: file.filename } : {}) };
+    }
+    async configure(enabled) { await this.transaction(state => { state.enabled = enabled; }); }
+    async capture(source) {
+        if (!await this.enabled())
+            return;
+        if (!text(source.id) || !text(source.session) || !text(source.message))
+            throw new Error("project-memory-invalid-source");
+        await this.transaction(state => {
+            if (!state.enabled)
+                return;
+            const previous = state.sources.find(item => item.id === source.id);
+            if (previous) {
+                if (JSON.stringify({ ...source }) !== JSON.stringify({ id: previous.id, session: previous.session, message: previous.message,
+                    actor: previous.actor, text: previous.text, attachments: previous.attachments }))
+                    throw new Error("project-memory-source-conflict");
+                return;
+            }
+            state.sources.push({ ...source, observedAt: new Date().toISOString(), availability: "retained-reference" });
+        });
+    }
+    async apply(source, operation, actor, changes) {
+        if (!text(operation, 256) || !text(actor, 256) || !Array.isArray(changes) || changes.length > 32)
+            throw new Error("project-memory-invalid-operation");
+        return this.transaction(state => {
+            if (!state.enabled)
+                throw new Error("project-memory-off");
+            if (!state.sources.some(item => item.id === source))
+                throw new Error("project-memory-source-not-found");
+            const fingerprint = hash(JSON.stringify({ operation, actor, changes }));
+            const previous = Object.hasOwn(state.processed, source) ? state.processed[source] : undefined;
+            if (previous) {
+                if (previous.fingerprint !== fingerprint)
+                    throw new Error("project-memory-operation-conflict");
+                return "already-processed";
+            }
+            if (Object.values(state.processed).some(item => item.operation === operation))
+                throw new Error("project-memory-operation-conflict");
+            for (const change of changes) {
+                if (!text(change.key, 256) || !text(change.context, 1024) || !text(change.text) || !text(change.reason) ||
+                    !["project", "workspace", "mission"].includes(change.scope) ||
+                    !["vision", "constraint", "decision", "unresolved", "result"].includes(change.kind) ||
+                    !["proposed", "adopted", "withdrawn", "unverified"].includes(change.status))
+                    throw new Error("project-memory-invalid-change");
+                const current = state.events.filter(item => item.key === change.key && item.scope === change.scope && item.context === change.context).at(-1);
+                if ((current?.id ?? undefined) !== change.supersedes)
+                    throw new Error("project-memory-snapshot-conflict");
+                if (change.consultation && (!text(change.consultation.id) || !text(change.consultation.callID) ||
+                    !["adopted", "rejected", "partial"].includes(change.consultation.disposition) ||
+                    !["improved", "unchanged", "worsened", "unverified"].includes(change.consultation.effect)))
+                    throw new Error("project-memory-invalid-consultation");
+                state.events.push({ ...change, id: randomUUID(), source, operation, actor, at: new Date().toISOString() });
+            }
+            Object.defineProperty(state.processed, source, { value: { operation, fingerprint, at: new Date().toISOString() }, enumerable: true, configurable: true, writable: true });
+            return changes.length ? "applied" : "no-change";
+        });
+    }
+    async recall(workspace, mission, query = "") {
+        const state = await this.load();
+        if (!state.enabled)
+            return { enabled: false };
+        const current = new Map();
+        for (const event of state.events)
+            current.set(JSON.stringify([event.scope, event.context, event.key]), event);
+        const snapshot = [...current.values()].filter(event => (event.scope === "project" ||
+            event.scope === "workspace" && event.context === workspace || event.scope === "mission" && event.context === mission));
+        const terms = query.toLocaleLowerCase().split(/\s+/u).filter(Boolean);
+        const protectedCondition = (event) => event.scope === "project" && event.status === "adopted" &&
+            (event.kind === "vision" || event.kind === "constraint");
+        // Preserve the current adopted purpose on ordinary resume, not obsolete or
+        // merely proposed guidance. Explicit searches retain their relevance ordering.
+        snapshot.sort((a, b) => (terms.length === 0 ? Number(protectedCondition(b)) - Number(protectedCondition(a)) :
+            terms.filter(term => b.text.toLocaleLowerCase().includes(term)).length -
+                terms.filter(term => a.text.toLocaleLowerCase().includes(term)).length) || b.at.localeCompare(a.at));
+        const selected = snapshot.slice(0, 24);
+        const pending = state.sources.filter(source => !Object.hasOwn(state.processed, source.id));
+        const excerpt = (source) => sourceView(source);
+        return { enabled: true, snapshot: selected,
+            protected_omitted: snapshot.filter(protectedCondition).length - selected.filter(protectedCondition).length,
+            pending: pending.slice(0, 8).map(excerpt),
+            pending_count: pending.length, oldest_pending: pending[0]?.observedAt ?? null,
+            last_success: Object.values(state.processed).map(item => item.at).sort().at(-1) ?? null,
+            sources: state.sources.filter(source => selected.some(event => event.source === source.id)).slice(-24).map(excerpt) };
+    }
+}

package/dist/core/rare-awards.d.ts

@@ -0,0 +1,26 @@
+/** Presentation telemetry only. Never an execution, review, or acceptance input. */
+export type ConditionState = "true" | "false" | "unknown";
+export type RareStatus = "earned" | "not-earned" | "unknown";
+export interface RareEvaluation {
+    readonly id: string;
+    readonly rule_version: number;
+    readonly status: RareStatus;
+    readonly evidence: readonly string[];
+}
+export interface RareAwards {
+    readonly definition: string;
+    readonly evaluations: readonly RareEvaluation[];
+}
+export declare const RARE_RULES: readonly [{
+    readonly id: "rare.clean-sweep";
+    readonly rule_version: 1;
+}, {
+    readonly id: "rare.recovery-coordination";
+    readonly rule_version: 1;
+}];
+/** False dominates unknown for an AND; absence of a positive trait is not a negative proof. */
+export declare function evaluateRareAwards(succeeded: boolean, clean: ConditionState, recovery: ConditionState, coordination: ConditionState): RareAwards;
+/** Bounded forward-compatible envelope: unknown definitions/rules remain telemetry, never awards. */
+export declare function validRareAwards(value: unknown): value is RareAwards;
+/** Recognize only this version and its host evidence contract, not a future rule's success string. */
+export declare function rareEvaluation(rare: RareAwards | undefined, id: string): RareEvaluation | undefined;