@deksden-com/dd-flow-cli 0.9.0-beta.144 → 0.9.0-beta.149

package/dist/services/memory-repair-document-delta.js

@@ -32,12 +32,16 @@ function inventory(root) {
         if (depth > 64 || entries.length >= 20_000 || logical.length > 4096)
             refuse("unbounded_document_inventory");
         const file = path.join(root, logical), stat = fs.lstatSync(file);
-        if (stat.isSymbolicLink() || !stat.isDirectory() && !stat.isFile() || stat.isFile() && stat.nlink !== 1)
+        if (!stat.isSymbolicLink() && !stat.isDirectory() && !stat.isFile() || stat.isFile() && stat.nlink !== 1)
             refuse("linked_or_special_document");
         if (aliases.has(alias(logical)))
             refuse("aliased_document_inventory");
         aliases.add(alias(logical));
-        entries.push({ path: logical, kind: stat.isDirectory() ? "directory" : "file", mode: stat.mode & 0o7777, sha256: null });
+        const link = stat.isSymbolicLink() ? fs.readlinkSync(file, { encoding: "buffer" }) : null;
+        if (link && link.length > 64 * 1024)
+            refuse("unbounded_document_inventory");
+        entries.push({ path: logical, kind: stat.isSymbolicLink() ? "link" : stat.isDirectory() ? "directory" : "file", mode: stat.mode & 0o7777,
+            sha256: link ? createHash("sha256").update(link).digest("hex") : null });
         if (stat.isDirectory())
             for (const name of fs.readdirSync(file).sort()) {
                 if (!name || name.includes("\\") || name.includes("\0") || name === "." || name === "..")
@@ -83,7 +87,7 @@ function capture(root) {
         if (hybridDigest(inventory(root)) !== hybridDigest(initial))
             refuse("inventory_changed_during_capture");
         const hashes = new Map([...observed.hashes(), ...protectedBefore]), entries = initial.map(entry => ({ ...entry,
-            sha256: entry.kind === "file" ? hashes.get(memorySourceKey("workspace", entry.path)) : null }));
+            sha256: entry.kind === "file" ? hashes.get(memorySourceKey("workspace", entry.path)) : entry.sha256 }));
         return { entries, observed, sha256: hybridDigest(entries) };
     }
     catch (error) {
@@ -92,6 +96,15 @@ function capture(root) {
         return refuse("documents_unavailable_or_changed");
     }
 }
+/** Reuse the protected inventory without inventing repair write permissions.
+ * Private files and symlinks remain opaque hashes, never exported bytes. */
+export function observeMemoryDocumentInventory(workspace) {
+    const snapshot = capture(workspace);
+    return { entries: () => structuredClone(snapshot.entries), revalidate: () => {
+            if (hybridDigest(capture(workspace).entries) !== hybridDigest(snapshot.entries))
+                refuse("documents_changed_after_baseline");
+        } };
+}
 /** Physical MB-only observation, not provider/Session authority or permission to
  * write the shared workspace. A registered owner must bind this start baseline,
  * inspect the rest of its private workspace and journal bounded publication.
@@ -101,47 +114,60 @@ export class MemoryRepairDocumentBaseline {
     sha256;
     #entries;
     #paths;
-    constructor(entries, paths) {
+    #canonical;
+    #material(entries = this.#entries, paths = this.#paths) {
+        return { entries, write_paths: paths, ...(this.#canonical.length ? { canonical_write_paths: this.#canonical } : {}) };
+    }
+    constructor(entries, paths, canonical = []) {
         this.#entries = structuredClone(entries);
         this.#paths = [...paths];
-        this.sha256 = hybridDigest({ entries, write_paths: paths });
+        this.#canonical = [...canonical].sort();
+        this.sha256 = hybridDigest(this.#material());
         Object.freeze(this);
     }
-    static capture(workspace, writePaths) {
-        assertMemoryRepairWritePaths(writePaths);
+    static capture(workspace, writePaths, canonicalPaths = new Set()) {
+        assertMemoryRepairWritePaths(writePaths, canonicalPaths);
         const snapshot = capture(workspace), byPath = new Map(snapshot.entries.map(entry => [entry.path, entry]));
+        const aliases = new Map(snapshot.entries.map(entry => [alias(entry.path), entry.path]));
         for (const logical of writePaths) {
             if (byPath.get(logical)?.kind === "directory")
                 refuse("write_path_is_directory");
-            if (snapshot.entries.some(entry => alias(entry.path) === alias(logical) && entry.path !== logical))
+            if (byPath.get(logical)?.kind === "link")
+                refuse("write_path_is_link");
+            const existingAlias = aliases.get(alias(logical));
+            if (existingAlias !== undefined && existingAlias !== logical)
                 refuse("aliased_write_path");
             const parts = logical.split("/");
             for (let index = 1; index < parts.length; index++) {
                 const parent = parts.slice(0, index).join("/");
-                if (byPath.get(parent)?.kind === "file" || snapshot.entries.some(entry => alias(entry.path) === alias(parent) && entry.path !== parent))
+                const parentAlias = aliases.get(alias(parent));
+                if (byPath.has(parent) && byPath.get(parent)?.kind !== "directory" || parentAlias !== undefined && parentAlias !== parent)
                     refuse("invalid_write_parent");
             }
         }
-        return new MemoryRepairDocumentBaseline(snapshot.entries, writePaths);
+        const prepared = new MemoryRepairDocumentBaseline(snapshot.entries, writePaths, [...canonicalPaths]);
+        return MemoryRepairDocumentBaseline.restore(prepared.bytes(), prepared.sha256);
     }
     entries() { return structuredClone(this.#entries); }
+    canonicalWritePaths() { return new Set(this.#canonical); }
     /** Adapt an independently accepted document view to the next registered
      * Work's approved paths without re-capturing mutable workspace bytes.
      * The caller still owns graph/current-view authority; this grants none.
      */
     withWritePaths(writePaths) {
-        assertMemoryRepairWritePaths(writePaths);
-        const value = { schema_id: "dd-flow/memory-repair-document-baseline@1", entries: this.entries(), write_paths: [...writePaths] };
-        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify(value)), hybridDigest({ entries: value.entries, write_paths: value.write_paths }));
+        assertMemoryRepairWritePaths(writePaths, new Set(this.#canonical));
+        const material = this.#material(this.entries(), [...writePaths]);
+        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify({ schema_id: "dd-flow/memory-repair-document-baseline@1", ...material })), hybridDigest(material));
     }
     /** Metadata composition only, never admission or filesystem publication.
      * A caller must independently prove both retained views belong to a settled
      * repair. Disjoint concurrent deltas preserve the current inventory; file
      * conflicts never rebase. Identical new parent directories may be shared.
      */
-    composeSettledDelta(before, after) {
+    composeSettledDelta(before, after, outcome = "accepted") {
         if (!(before instanceof MemoryRepairDocumentBaseline) || !(after instanceof MemoryRepairDocumentBaseline)
-            || hybridDigest(before.#paths) !== hybridDigest(after.#paths))
+            || !["accepted", "reconciled"].includes(outcome)
+            || hybridDigest(before.#paths) !== hybridDigest(after.#paths) || hybridDigest(before.#canonical) !== hybridDigest(after.#canonical))
             refuse("invalid_settled_document_views");
         const prior = new Map(before.#entries.map(entry => [entry.path, entry]));
         const final = new Map(after.#entries.map(entry => [entry.path, entry]));
@@ -160,7 +186,7 @@ export class MemoryRepairDocumentBaseline {
                     refuse("settled_document_conflict");
             }
             else {
-                if (!before.#paths.includes(logical) || old?.kind === "directory" || next && next.kind !== "file"
+                if (!before.#paths.includes(logical) || old && old.kind !== "file" || next && next.kind !== "file"
                     || next && (old ? next.mode !== old.mode : ![0o600, 0o644].includes(next.mode))
                     || old && next && old.sha256 === next.sha256)
                     refuse("invalid_settled_file_delta");
@@ -173,10 +199,10 @@ export class MemoryRepairDocumentBaseline {
             else
                 current.delete(logical);
         }
-        if (!changedFiles)
-            refuse("empty_settled_document_delta");
-        const entries = ordered(current.values()), value = { schema_id: "dd-flow/memory-repair-document-baseline@1", entries, write_paths: [...this.#paths] };
-        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify(value)), hybridDigest({ entries, write_paths: value.write_paths }));
+        if (outcome === "reconciled" ? changedFiles !== 0 : changedFiles === 0)
+            refuse(outcome === "reconciled" ? "nonempty_reconciled_document_delta" : "empty_settled_document_delta");
+        const material = this.#material(ordered(current.values()));
+        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify({ schema_id: "dd-flow/memory-repair-document-baseline@1", ...material })), hybridDigest(material));
     }
     /** Project only the independently selected regular files into a sanitized
      * writer view. The protected source snapshot stays intact. This is metadata
@@ -214,12 +240,12 @@ export class MemoryRepairDocumentBaseline {
                 refuse("write_target_not_exported");
             parents(logical);
         }
-        const exported = new MemoryRepairDocumentBaseline(this.#entries.filter(entry => retained.has(entry.path)), this.#paths);
+        const exported = new MemoryRepairDocumentBaseline(this.#entries.filter(entry => retained.has(entry.path)), this.#paths, this.#canonical);
         // Apply the same bounded, strict representation used by SQL restoration.
         return MemoryRepairDocumentBaseline.restore(exported.bytes(), exported.sha256);
     }
     bytes() {
-        const bytes = Buffer.from(JSON.stringify({ schema_id: "dd-flow/memory-repair-document-baseline@1", entries: this.#entries, write_paths: this.#paths }));
+        const bytes = Buffer.from(JSON.stringify({ schema_id: "dd-flow/memory-repair-document-baseline@1", ...this.#material() }));
         if (bytes.length > 8 * 1024 * 1024)
             refuse("unbounded_baseline_receipt");
         return bytes;
@@ -233,39 +259,48 @@ export class MemoryRepairDocumentBaseline {
                 || typeof expectedSha256 !== "string" || !/^[a-f0-9]{64}$/.test(expectedSha256))
                 refuse("invalid_baseline_receipt");
             const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-            if (!value || Object.keys(value).sort().join(",") !== "entries,schema_id,write_paths"
+            if (!value || Object.keys(value).filter(key => key !== "canonical_write_paths").sort().join(",") !== "entries,schema_id,write_paths"
                 || value.schema_id !== "dd-flow/memory-repair-document-baseline@1" || !Array.isArray(value.entries)
                 || !value.entries.length || value.entries.length > 20_000)
                 refuse("invalid_baseline_receipt");
-            assertMemoryRepairWritePaths(value.write_paths);
-            const byPath = new Map(), aliases = new Set();
+            const canonical = value.canonical_write_paths ?? [];
+            if (!Array.isArray(canonical) || canonical.length > 20_000 || new Set(canonical).size !== canonical.length
+                || canonical.some(logical => typeof logical !== "string" || ![".memory-bank/dd-flow/", ".memory-bank/mbb/"].some(prefix => logical.startsWith(prefix))))
+                refuse("invalid_baseline_receipt");
+            const permitted = new Set(canonical);
+            for (const logical of canonical)
+                assertMemoryRepairWritePaths([logical], permitted);
+            assertMemoryRepairWritePaths(value.write_paths, permitted);
+            const byPath = new Map(), aliases = new Map();
             for (const entry of value.entries) {
                 if (!entry || Object.keys(entry).sort().join(",") !== "kind,mode,path,sha256"
                     || typeof entry.path !== "string" || entry.path.length > 4096 || entry.path.split("/").length > 65
                     || entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/")
                     || entry.path.includes("\\") || entry.path.includes("\0") || entry.path.split("/").some(part => !part || part === "." || part === "..")
-                    || !["file", "directory"].includes(entry.kind) || !Number.isInteger(entry.mode) || entry.mode < 0 || entry.mode > 0o7777
+                    || !["file", "directory", "link"].includes(entry.kind) || !Number.isInteger(entry.mode) || entry.mode < 0 || entry.mode > 0o7777
                     || entry.kind === "directory" && entry.sha256 !== null
-                    || entry.kind === "file" && (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256))
+                    || entry.kind !== "directory" && (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256))
                     || aliases.has(alias(entry.path)))
                     refuse("invalid_baseline_receipt");
                 if (entry.path === ".memory-bank" ? byPath.size !== 0 || entry.kind !== "directory"
                     : byPath.get(path.posix.dirname(entry.path))?.kind !== "directory")
                     refuse("invalid_baseline_receipt");
-                aliases.add(alias(entry.path));
+                aliases.set(alias(entry.path), entry.path);
                 byPath.set(entry.path, entry);
             }
             for (const logical of value.write_paths) {
-                if (byPath.get(logical)?.kind === "directory" || value.entries.some((entry) => alias(entry.path) === alias(logical) && entry.path !== logical))
+                const existingAlias = aliases.get(alias(logical));
+                if (byPath.has(logical) && byPath.get(logical)?.kind !== "file" || existingAlias !== undefined && existingAlias !== logical)
                     refuse("invalid_baseline_receipt");
                 const parts = logical.split("/");
                 for (let index = 1; index < parts.length; index++) {
                     const parent = parts.slice(0, index).join("/");
-                    if (byPath.get(parent)?.kind === "file" || value.entries.some((entry) => alias(entry.path) === alias(parent) && entry.path !== parent))
+                    const parentAlias = aliases.get(alias(parent));
+                    if (byPath.has(parent) && byPath.get(parent)?.kind !== "directory" || parentAlias !== undefined && parentAlias !== parent)
                         refuse("invalid_baseline_receipt");
                 }
             }
-            const prepared = new MemoryRepairDocumentBaseline(value.entries, value.write_paths);
+            const prepared = new MemoryRepairDocumentBaseline(value.entries, value.write_paths, canonical);
             if (prepared.sha256 !== expectedSha256 || !prepared.bytes().equals(Buffer.from(bytes)))
                 refuse("baseline_receipt_changed");
             return prepared;
@@ -344,6 +379,8 @@ export class MemoryRepairDocumentBaseline {
             }
             if (!this.#paths.includes(logical))
                 refuse("undeclared_document_delta");
+            if (old?.kind === "link" || current?.kind === "link")
+                refuse("link_document_delta");
             if (old && current && old.mode !== current.mode || !old && current && ![0o600, 0o644].includes(current.mode))
                 refuse("document_mode_delta");
             if (old?.sha256 === current?.sha256)
@@ -354,7 +391,7 @@ export class MemoryRepairDocumentBaseline {
         changes.sort((a, b) => a.path.localeCompare(b.path, "en"));
         if (hybridDigest(changes) !== hybridDigest(proposed))
             refuse("claimed_delta_differs_from_bytes");
-        if (result.outcome === "blocked" && changed.length || result.outcome === "accepted" && !changes.length)
+        if (["blocked", "reconciled"].includes(result.outcome) && changed.length || result.outcome === "accepted" && !changes.length)
             refuse("outcome_differs_from_physical_delta");
         return new ObservedMemoryRepairDelta(observationToken, this.sha256, workspace, snapshot.sha256, changes, snapshot.observed, snapshot.entries);
     }
@@ -423,7 +460,7 @@ export class MemoryRepairDocumentTransition {
         }
         const retained = JSON.parse(this.#before.bytes().toString("utf8"));
         const value = { ...retained, entries: ordered(entries.values()) };
-        const expected = hybridDigest({ entries: value.entries, write_paths: value.write_paths });
+        const expected = hybridDigest({ ...value, schema_id: undefined });
         return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify(value)), expected);
     }
     after() { return this.state(this.#actions.length); }

package/dist/services/memory-repair-history.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { readMemoryRepairPhysicalBinding } from "./memory-repair-physical-binding.js";
 import { createHash } from "node:crypto";
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedRegisteredMemoryCorrections, memoryRepairWorkerSchema } from "./memory-repair-registration.js";
@@ -12,7 +13,7 @@ import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication
 import { deriveRetainedMemoryRepairViews } from "./memory-repair-publication.js";
 import { retainedMemoryRepairPublicationPlans } from "./memory-repair-publication-intent.js";
 import { PreparedMemoryRepairWorkspace } from "./memory-repair-workspace.js";
-import { memoryRepairCurrentReferences, validateMemoryRepairWorkResult } from "./memory-repair-work-results.js";
+import { isCompletedMemoryRepairClaim, memoryRepairCurrentReferences, validateMemoryRepairWorkResult } from "./memory-repair-work-results.js";
 import { readMemoryRepairCurrentViewReceipt } from "./memory-repair-current-view.js";
 import { runtimeHarness } from "./execution-policy.js";
 import { ObservedMemorySources } from "./memory-source-observations.js";
@@ -190,7 +191,7 @@ function snapshot(context, registration, workId, validateReferencedViews = true)
                     const after = MemoryRepairDocumentBaseline.restore(bytes(peer.intent.after_base64, 8 * 1024 * 1024), peer.intent.after_sha256);
                     if (!prefixes.has(hybridDigest(before.entries())))
                         refuse("historical_second_current_view_prefix_changed");
-                    composed = composed.composeSettledDelta(before, after);
+                    composed = composed.composeSettledDelta(before, after, JSON.parse(peer.work.result).outcome);
                     prefixes.add(hybridDigest(composed.entries()));
                     const peerInputs = JSON.parse(bytes(peer.build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries
                         .filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/"));
@@ -332,7 +333,7 @@ function snapshot(context, registration, workId, validateReferencedViews = true)
                 }
                 if (!versions.has(hybridDigest(peerBefore.entries())))
                     refuse("historical_publication_source_prefix_changed");
-                composed = composed.composeSettledDelta(peerBefore, peerAfter);
+                composed = composed.composeSettledDelta(peerBefore, peerAfter, JSON.parse(peer.work.result).outcome);
                 versions.add(hybridDigest(composed.entries()));
                 const peerInputs = JSON.parse(bytes(peer.build.workspace_manifest_base64, 8 * 1024 * 1024).toString("utf8")).entries.filter((entry) => entry.path !== ".memory-bank" && !entry.path.startsWith(".memory-bank/"));
                 if (hybridDigest(peerInputs) !== immutableInputs)
@@ -407,6 +408,7 @@ function viewInput(registration) {
  * and compare the physical shared inventory before admitting new work.
  */
 export class PreparedSettledMemoryRepair {
+    #custodyKey = {};
     sha256;
     workId;
     #registration;
@@ -448,7 +450,7 @@ export class PreparedSettledMemoryRepair {
         const result = validateMemoryRepairWorkResult(Buffer.from(value.work.result), historyBundle(registration).engine(), { workId, packet: value.assigned.payload.memory_repair,
             ...(value.currentView || PreparedRetainedSecondMemoryRepairs.isPrepared(registration)
                 ? { effectiveInputs: memoryRepairCurrentReferences(value.assigned.payload.memory_repair, workspace) } : {}) });
-        if (result.outcome !== "accepted")
+        if (!isCompletedMemoryRepairClaim(result))
             refuse("accepted_settled_repair_required");
         const { plan, privatePlan } = retainedMemoryRepairPublicationPlans(value.intent);
         const derived = deriveRetainedMemoryRepairViews(before, exported, plan, result, privatePlan);
@@ -478,14 +480,17 @@ export class PreparedSettledMemoryRepair {
         if (context.db.isOwnedWriteTransaction?.())
             refuse("historical_preparation_outside_writer_required");
         this.revalidate(context);
-        const composed = current.composeSettledDelta(this.#before, this.#after);
+        const composed = current.composeSettledDelta(this.#before, this.#after, this.#result.outcome);
         this.assertCustody(context);
         return composed;
     }
     reference() { return { ...this.#reference }; }
     assertCustody(context) {
-        if (hybridDigest(snapshot(context, this.#registration, this.workId)) !== this.sha256)
-            refuse("historical_custody_changed");
+        const registration = this.#registration;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            if (hybridDigest(snapshot(context, registration, this.workId)) !== this.sha256)
+                refuse("historical_custody_changed");
+        });
     }
     revalidate(context) { this.assertCustody(context); this.#observed.revalidate(); }
 }

package/dist/services/memory-repair-physical-binding.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
@@ -8,7 +7,6 @@ import { hybridDigest } from "./hybrid-contracts.js";
 import { runtimeHarness } from "./execution-policy.js";
 import { parseLifecycleCommand, commandPosition } from "./lifecycle-command.js";
 import { resolveWorkReference } from "../storage/work-references.js";
-import { assertRunMutationAllowed } from "./run-recovery-guard.js";
 import { currentLifecycleAdmission } from "./lifecycle-invocations.js";
 import { recoveryGuard } from "./run-recovery-guard.js";
 const event = "memory.repair_native_binding";
@@ -53,123 +51,7 @@ export function memoryRepairExecutionIdentity(context, input) {
         return refuse("repair_execution_cwd_unproven");
     }
 }
-/** Hook ingress selects only an independently prepared repair copy. This
- * establishes a command's assigned directory, not claim/repair authority. */
-export function memoryRepairAssignedHookCwd(context, input) {
-    const work = context.db.get("SELECT payload_json,result_schema,status FROM works WHERE project_id=? AND run_id=? AND work_id=?", [input.projectId, input.runId, input.workId]);
-    let payload;
-    try {
-        payload = JSON.parse(work?.payload_json ?? "null");
-    }
-    catch {
-        return null;
-    }
-    if (payload?.kind !== "memory-repair" && work?.result_schema !== "dd-flow/memory-repair-work-result@1")
-        return null;
-    const run = context.db.get("SELECT r.run_root,r.run_dir,r.flow_kind,p.root AS project_root FROM runs r JOIN projects p ON p.id=r.project_id WHERE r.project_id=? AND r.id=?", [input.projectId, input.runId]);
-    if (!run || run.flow_kind !== "mb-init" || run.project_root !== input.projectRoot || payload.read_only !== false
-        || ![1, 2].includes(payload.memory_repair?.wave ?? 0) || work?.result_schema !== "dd-flow/memory-repair-work-result@1")
-        refuse("registered_memory_repair_required");
-    const generation = assertRunMutationAllowed(context, input.projectId, input.runId), runRoot = run.run_root ?? run.run_dir;
-    const external = context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='work_launches'")
-        ? context.db.get("SELECT operation_id,status,profile_json,profile_hash,provider_session_id FROM work_launches WHERE work_id=?", [input.workId]) : undefined;
-    const native = !external;
-    const admitted = (root) => {
-        if (native && input.observedCwd !== root && input.literalExecutionCwd !== root)
-            throw new AppError("memory_repair_native_copy_route_unavailable", "Native repair requires a genuinely observed child execution directory inside its owned writer copy", 1, { phase: "prepare", effect: "no_effect", recoverable: false, expected: root, actual: input.observedCwd ?? null,
-                next_action: "Use only a documented native child/tool capability that establishes this exact directory; otherwise stop and select external delegation in a new RUN." });
-        return { root, native };
-    };
-    if (work.status === "created") {
-        // Routing consumes registered copy custody only. Actual Work start owns
-        // physical source/copy/profile admission after the durable native Hook.
-        const rows = (eventType) => context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? AND json_extract(payload_json,'$.generation')=? LIMIT 2", [input.projectId, eventType, input.runId, input.workId, generation]);
-        const intents = rows("memory.repair_writer_copy_intent"), copies = rows("memory.repair_writer_copy_ready");
-        if (intents.length !== 1 || copies.length !== 1 || Buffer.byteLength(intents[0].payload_json) > 1024 * 1024
-            || Buffer.byteLength(copies[0].payload_json) > 12 * 1024 * 1024)
-            refuse("owned_ready_copy_required");
-        try {
-            const intent = JSON.parse(intents[0].payload_json), ready = JSON.parse(copies[0].payload_json);
-            const workspace_manifest_sha256 = ready.workspace_manifest_sha256, readyIntent = { ...ready };
-            delete readyIntent.workspace_manifest_sha256;
-            delete readyIntent.workspace_manifest_base64;
-            const relative = `works/${input.workId}/writer-workspaces/generation-${generation}`;
-            if (intent.schema_id !== "dd-flow/memory-repair-writer-copy-intent@1" || intent.project_id !== input.projectId || intent.run_id !== input.runId
-                || intent.work_id !== input.workId || intent.generation !== generation || intent.run_root !== runRoot || !path.isAbsolute(runRoot)
-                || intent.copy_relative !== relative || !/^[a-f0-9]{64}$/.test(intent.baseline_registration_sha256)
-                || !/^[a-f0-9]{64}$/.test(workspace_manifest_sha256) || hybridDigest(readyIntent) !== hybridDigest(intent))
-                refuse("owned_ready_copy_required");
-            if (external) {
-                if (external.provider_session_id !== input.providerSessionId)
-                    refuse("foreign_physical_session");
-                const profile = JSON.parse(external.profile_json), metadata = profile.memory_repair_copy;
-                if (profile.delegation?.mode !== "external" || hybridDigest(metadata) !== hybridDigest({ root: relative, copy_intent_sha256: hybridDigest(intent),
-                    workspace_manifest_sha256, baseline_registration_sha256: intent.baseline_registration_sha256 }))
-                    refuse("native_copy_cwd_mismatch");
-            }
-            if (fs.realpathSync(runRoot) !== path.resolve(runRoot))
-                refuse("owned_ready_copy_required");
-            let destination = runRoot;
-            for (const part of relative.split('/')) {
-                destination = path.join(destination, part);
-                if (!fs.lstatSync(destination).isDirectory())
-                    refuse("owned_ready_copy_required");
-            }
-            return admitted(destination);
-        }
-        catch (error) {
-            if (error instanceof AppError)
-                throw error;
-            return refuse("owned_ready_copy_required");
-        }
-    }
-    // Running writers retain their committed directory, not today's source bytes.
-    let binding = external;
-    let nativeStart;
-    if (!binding) {
-        const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_native_binding' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 2", [input.projectId, input.runId, input.workId]);
-        if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 1024 * 1024)
-            refuse("native_registered_start_changed");
-        try {
-            const retained = JSON.parse(rows[0].payload_json);
-            if (retained.schema_id !== "dd-flow/memory-repair-native-binding@1" || retained.project_id !== input.projectId || retained.run_id !== input.runId || retained.work_id !== input.workId
-                || typeof retained.work_session_id !== "string" || typeof retained.hook_event_key !== "string")
-                refuse("native_registered_start_changed");
-            binding = retained.binding;
-            nativeStart = retained;
-        }
-        catch (error) {
-            if (error instanceof AppError)
-                throw error;
-            return refuse("native_registered_start_changed");
-        }
-    }
-    const starts = context.db.all("SELECT ws.id,ws.hook_event_id,ws.start_receipt_json FROM work_sessions ws JOIN sessions s ON s.project_id=? AND s.session_id=ws.session_id WHERE ws.work_id=? AND ws.status='running' AND s.run_id=? AND s.worker_id=? AND s.provider_session_id=? LIMIT 2", [input.projectId, input.workId, input.runId, input.workId, input.providerSessionId]);
-    if (work.status !== "running" || !binding || binding.provider_session_id !== input.providerSessionId || starts.length !== 1)
-        refuse("native_registered_start_changed");
-    if (nativeStart && (nativeStart.work_session_id !== starts[0].id || nativeStart.hook_event_key !== starts[0].hook_event_id
-        || binding.operation_id !== `native-hook:${nativeStart.hook_event_key}`
-        || !context.db.get("SELECT 1 FROM hook_events WHERE project_id=? AND event_key=? AND status='claimed' AND provider_session_id=?", [input.projectId, nativeStart.hook_event_key, input.providerSessionId])))
-        refuse("native_registered_start_changed");
-    try {
-        const text = starts[0].start_receipt_json;
-        if (typeof text !== "string" || Buffer.byteLength(text) > 16 * 1024 * 1024)
-            refuse("native_registered_start_changed");
-        const start = JSON.parse(text), packet = JSON.parse(start.context), profile = JSON.parse(binding.profile_json), metadata = profile.memory_repair_copy;
-        if (profile.delegation?.mode !== (native ? "native" : "external") || start.version !== 2 || createHash("sha256").update(start.context).digest("hex") !== start.context_sha256
-            || typeof metadata?.root !== "string" || metadata.root !== `works/${input.workId}/writer-workspaces/generation-${start.generation}`
-            || packet.work_id !== input.workId || packet.run_id !== input.runId || packet.workspace_root !== path.join(runRoot, metadata.root)
-            || packet.memory_repair_input?.provider_session_id !== input.providerSessionId
-            || packet.memory_repair_input?.launch_operation_id !== binding.operation_id)
-            refuse("native_registered_start_changed");
-        return admitted(packet.workspace_root);
-    }
-    catch (error) {
-        if (error instanceof AppError)
-            throw error;
-        return refuse("native_registered_start_changed");
-    }
-}
+export { memoryRepairAssignedHookCwd } from "./hook-memory-routing.js";
 /** Native children have no external launch row. Read the immutable physical
  * Hook and copy journal instead; preparation cannot manufacture a Session. */
 export function readMemoryRepairPhysicalBinding(context, workId, route, operationId) {

package/dist/services/memory-repair-publication-plan.js

@@ -57,6 +57,8 @@ export class RetainedMemoryRepairPublicationPlan {
             const writes = JSON.parse(before.bytes().toString("utf8")).write_paths;
             if (hybridDigest(writes) !== hybridDigest(JSON.parse(after.bytes().toString("utf8")).write_paths))
                 refuse("write_paths_changed");
+            if (hybridDigest([...before.canonicalWritePaths()]) !== hybridDigest([...after.canonicalWritePaths()]))
+                refuse("canonical_permissions_changed");
             const current = new Map(before.entries().map(entry => [entry.path, entry]));
             const final = new Map(after.entries().map(entry => [entry.path, entry]));
             const directories = new Set();
@@ -133,11 +135,11 @@ export class RetainedMemoryRepairPublicationPlan {
             else
                 entries.delete(action.path);
         }
-        const value = { schema_id: "dd-flow/memory-repair-document-baseline@1", entries: ordered(entries.values()), write_paths: this.#writePaths };
-        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify(value)), hybridDigest({ entries: value.entries, write_paths: value.write_paths }));
+        const value = { ...JSON.parse(this.#before.bytes().toString("utf8")), entries: ordered(entries.values()) };
+        return MemoryRepairDocumentBaseline.restore(Buffer.from(JSON.stringify(value)), hybridDigest({ ...value, schema_id: undefined }));
     }
     classify(workspace) {
-        const actual = MemoryRepairDocumentBaseline.capture(workspace, this.#writePaths);
+        const actual = MemoryRepairDocumentBaseline.capture(workspace, this.#writePaths, this.#before.canonicalWritePaths());
         const entries = new Map(actual.entries().map(entry => [entry.path, entry]));
         let completed = 0, pending = false;
         for (const action of this.#receipt.actions) {

package/dist/services/memory-repair-publication-source.js

@@ -54,7 +54,7 @@ function compose(start, histories, paths) {
     for (const history of histories) {
         if (!versions.has(hybridDigest(history.before().entries())))
             refuse("unexplained_peer_input_view");
-        current = current.composeSettledDelta(history.before(), history.after());
+        current = current.composeSettledDelta(history.before(), history.after(), history.result().outcome);
         versions.add(hybridDigest(current.entries()));
     }
     if (!versions.has(hybridDigest(start.entries())))

package/dist/services/memory-repair-publication.js

@@ -5,6 +5,7 @@ import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedMemoryRepairWorkBaseline } from "./memory-repair-work-baseline.js";
 import { PreparedBoundMemoryRepairCopy } from "./memory-repair-writer-copy.js";
+import { isCompletedMemoryRepairClaim } from "./memory-repair-work-results.js";
 import { appendAudit } from "./audit.js";
 import { stageRetainedMemoryRepairFile, verifyRetainedMemoryRepairFile } from "./memory-repair-publication-files.js";
 import { acquireInstallationLock } from "./installation-lock.js";
@@ -30,7 +31,7 @@ export function deriveRetainedMemoryRepairViews(start, exported, plan, result, p
         || hybridDigest(ordered(changes(privatePlan))) !== hybridDigest(ordered(result.changes)))
         refuse("reserved_delta_differs_from_result");
     const after = privatePlan.state(privatePlan.actions().length);
-    const merged = plan.state(0).composeSettledDelta(start, after);
+    const merged = plan.state(0).composeSettledDelta(start, after, result.outcome);
     if (merged.sha256 !== plan.state(actions.length).sha256)
         refuse("unexplained_retained_publication_view");
     const available = new Set(after.entries().filter(entry => entry.kind === "file").map(entry => entry.path));
@@ -103,7 +104,7 @@ export class PreparedRetainedMemoryRepairPublication {
             if (bytes.length > 1024 * 1024 || bytes.toString("base64") !== receipt.result_base64 || hash(bytes) !== receipt.result_sha256)
                 refuse("retained_result_changed");
             const result = baseline.validateResult(context, bytes);
-            if (result.outcome !== "accepted")
+            if (!isCompletedMemoryRepairClaim(result))
                 refuse("accepted_reserved_result_required");
             const { exportedAfter, deltaSha256, transitionSha256 } = deriveRetainedMemoryRepairViews(baseline.baseline(), baseline.exportedBaseline(), plan, result, privatePlan);
             const outputSha256 = hybridDigest({ input: copy.input(), start_receipt_sha256: hybridDigest(copy.startedReceipt()), work_session_id: workSessionId,

package/dist/services/memory-repair-registration.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
 import { hybridDigest } from "./hybrid-contracts.js";
-import { PreparedMemoryInitialCorrectionPlan, validateMemoryReviewCorrectionPlan } from "./memory-review-correction-plan.js";
+import { PreparedMemoryInitialCorrectionPlan, validateMemoryReviewCorrectionPlan, memoryRepairCanonicalPaths } from "./memory-review-correction-plan.js";
 import { PreparedRetainedMemoryReviewResults } from "./memory-retained-review-results.js";
 import { memoryReviewWaveProjection } from "./memory-review-acceptance.js";
 import { addWorkBatch, prepareWorkBatch, readWorkBatchCustody } from "./work-registry.js";
@@ -155,6 +155,7 @@ export class PreparedRegisteredMemoryCorrections {
         if (expectedBytes !== undefined && (!(expectedBytes instanceof Uint8Array) || !bytes.equals(Buffer.from(expectedBytes))))
             refuse("plan_replay_conflict");
         const plan = validateMemoryReviewCorrectionPlan(bytes, bundle.engine(), { runId: original.run_id, wave: 1,
+            canonicalPaths: memoryRepairCanonicalPaths(context, bundle),
             reviewSha256: review.sha256, units: original.view.unit_inventory, findings: memoryReviewWaveProjection(review.results(), original.view.diagnostic_findings).findings });
         for (const work of plan.works)
             bundle.execution.work("review", work.profile_id ?? undefined);

package/dist/services/memory-repair-work-baseline.js

@@ -1,3 +1,4 @@
+import { memoryRepairCanonicalPaths } from "./memory-review-correction-plan.js";
 import { createHash } from "node:crypto";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
@@ -108,7 +109,7 @@ export class PreparedMemoryRepairWorkBaseline {
         const sourceHash = () => reviewSourceHash(workspace, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base);
         if (sourceHash() !== view.source_sha256)
             refuse("original_source_changed_before_writer");
-        const baseline = MemoryRepairDocumentBaseline.capture(workspace, assigned.payload.memory_repair.write_paths);
+        const baseline = MemoryRepairDocumentBaseline.capture(workspace, assigned.payload.memory_repair.write_paths, memoryRepairCanonicalPaths(context, registration.review().original().bundle()));
         const selected = reviewSourcePaths(workspace, view.run_inputs.filter(ref => ref.root === "workspace").map(ref => ref.path), view.base);
         if (selected === null)
             refuse("export_source_inventory_unavailable");
@@ -351,11 +352,12 @@ export class PreparedMemoryRepairWorkBaseline {
             refuse("registered_baseline_receipt_required");
     }
     assertCustody(context) {
-        this.#assertCurrentView(context);
         if (this.#startedWorkSessionId) {
+            // The registered start owner also rechecks this baseline's current view.
             this.assertRegisteredStartCustody(context, this.#startedWorkSessionId);
             return;
         }
+        this.#assertCurrentView(context);
         this.#registration.assertCustody(context);
         assertRunMutationAllowed(context, this.#scope.project_id, this.#scope.run_id, this.#scope.generation);
         if (hybridDigest(readWorkBatchCustody(context, this.workId)) !== hybridDigest(this.#allocation))