@deksden-com/dd-flow-cli 0.9.0-beta.136 → 0.9.0-beta.138

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

@@ -0,0 +1,312 @@
+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";
+import { hookSessionIdentity } from "./hooks.js";
+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";
+function refuse(reason) {
+    throw new AppError("memory_repair_native_binding_invalid", "Native repair requires its actual direct-child Hook and independently owned copy", 1, { reason, effect: "no_effect" });
+}
+/** Preserve raw Hook CWD. A scoped literal shell route becomes physical
+ * execution proof only after the CLI independently admitted process.cwd. */
+export function memoryRepairExecutionIdentity(context, input) {
+    const reader = { ...context };
+    delete reader.observeLifecycleHook;
+    const identity = hookSessionIdentity(reader, input.projectId, input.eventKey);
+    if (identity.cwd === input.root)
+        return { identity, invocationId: null };
+    const rows = context.db.all("SELECT id,status,command,scope_json,identity_json FROM lifecycle_invocations WHERE event_key=? AND status IN ('executing','settled') LIMIT 2", [input.eventKey]);
+    if (rows.length !== 1)
+        refuse("repair_execution_cwd_unproven");
+    const row = rows[0];
+    try {
+        if ([row.command, row.scope_json, row.identity_json].some(value => typeof value !== "string" || Buffer.byteLength(value) > 1024 * 1024))
+            refuse("repair_execution_cwd_unproven");
+        const scope = JSON.parse(row.scope_json), native = JSON.parse(row.identity_json), parsed = parseLifecycleCommand(row.command);
+        const project = context.db.get("SELECT root FROM projects WHERE id=?", [input.projectId]);
+        const parent = context.db.get("SELECT provider_session_id FROM sessions WHERE project_id=? AND session_id=? AND run_id=?", [input.projectId, identity.parentSessionId, input.runId]);
+        if (parsed.kind === "none" || parsed.supported === false || parsed.invocation.operation !== "work_start"
+            || scope.runId !== input.runId || scope.projectRoot !== project?.root || !Array.isArray(native) || native.length !== 6
+            || native[0] !== identity.daemonId || scope.daemonId !== identity.daemonId || native[1] !== scope.rootSessionId
+            || !parent || native[3] !== parent.provider_session_id || typeof native[4] !== "string" || !native[4]
+            || native[2] !== identity.providerSessionId || native[5]?.executionCwd !== input.root)
+            refuse("repair_execution_cwd_unproven");
+        const target = resolveWorkReference(context, commandPosition(parsed.invocation, 0), { projectId: input.projectId });
+        if (target.work_id !== input.workId)
+            refuse("repair_execution_cwd_unproven");
+        const retained = context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id=ws.work_id JOIN hook_events he ON he.project_id=w.project_id AND he.event_key=ws.hook_event_id WHERE w.project_id=? AND w.run_id=? AND w.work_id=? AND ws.hook_event_id=? AND ws.session_id=? AND he.status='claimed' AND EXISTS (SELECT 1 FROM audit_events a WHERE a.project_id=w.project_id AND a.event_type IN ('memory.repair_work_start','memory.native_review_binding') AND json_extract(a.payload_json,'$.run_id')=w.run_id AND json_extract(a.payload_json,'$.work_id')=w.work_id AND json_extract(a.payload_json,'$.work_session_id')=ws.id AND (a.event_type='memory.repair_work_start' OR json_extract(a.payload_json,'$.invocation_id')=?))", [input.projectId, input.runId, input.workId, input.eventKey, identity.sessionId, row.id]);
+        if (!currentLifecycleAdmission(context, row.id) && !retained)
+            refuse("repair_execution_cwd_not_admitted");
+        return { identity: { ...identity, cwd: input.root }, invocationId: row.id };
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "memory_repair_native_binding_invalid")
+            throw error;
+        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");
+    }
+}
+/** 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) {
+    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=?", [workId]) : undefined;
+    if (route.delegation.mode === "external")
+        return external;
+    if (external)
+        refuse("native_work_has_external_launch");
+    const work = context.db.get("SELECT project_id,run_id,parent_work_id FROM works WHERE work_id=?", [workId]);
+    if (!work?.parent_work_id)
+        refuse("owned_native_work_required");
+    const run = context.db.get("SELECT run_root,run_dir FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
+    if (!run)
+        refuse("owned_native_run_required");
+    const retained = 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')=? LIMIT 2", [work.project_id, event, work.run_id, workId]);
+    let prior;
+    if (retained.length) {
+        try {
+            if (retained.length !== 1 || Buffer.byteLength(retained[0].payload_json) > 1024 * 1024)
+                refuse("ambiguous_native_binding");
+            prior = JSON.parse(retained[0].payload_json);
+            if (!prior || prior.schema_id !== "dd-flow/memory-repair-native-binding@1" || prior.project_id !== work.project_id
+                || prior.run_id !== work.run_id || prior.work_id !== workId || typeof prior.work_session_id !== "string"
+                || !prior.work_session_id || Object.keys(prior).sort().join(",") !== "binding,hook_event_key,parent_provider_session_id,parent_session_id,project_id,run_id,schema_id,work_id,work_session_id")
+                refuse("foreign_native_binding");
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                throw error;
+            refuse("invalid_native_binding");
+        }
+    }
+    const key = prior?.hook_event_key ?? (operationId?.startsWith("native-hook:") ? operationId.slice(12) : context.env.DD_FLOW_MEMORY_REPAIR_HOOK_EVENT);
+    if (!key || key.length > 1024)
+        refuse("native_start_hook_required");
+    const reader = { ...context };
+    delete reader.observeLifecycleHook;
+    let identity;
+    try {
+        identity = hookSessionIdentity(reader, work.project_id, key);
+    }
+    catch (error) {
+        if (error instanceof AppError && error.code === "hook_event_not_found")
+            refuse("native_start_hook_required");
+        throw error;
+    }
+    const hook = context.db.get("SELECT status,created_at FROM hook_events WHERE project_id=? AND event_key=? AND id=? AND event_name='PreToolUse'", [work.project_id, key, identity.hookEventId]);
+    const parents = context.db.all("SELECT DISTINCT s.session_id,s.harness,s.status,s.current_stage,s.run_id,s.worker_id,s.provider_session_id FROM work_sessions ws JOIN sessions s ON s.project_id=? AND s.session_id=ws.session_id WHERE ws.work_id=? AND s.session_id=? LIMIT 2", [work.project_id, work.parent_work_id, identity.parentSessionId]);
+    if (!hook || !["observed", "claimed"].includes(hook.status) || parents.length !== 1)
+        refuse("native_parent_or_hook_required");
+    const parent = parents[0];
+    if (parent.run_id !== work.run_id || !prior && parent.worker_id !== work.parent_work_id || parent.harness !== runtimeHarness(route.coordinator)
+        || identity.parentSessionId !== parent.session_id || identity.sessionId === parent.session_id
+        || identity.harness !== runtimeHarness(route.worker) || identity.model !== route.worker.model
+        || identity.provider && identity.provider !== route.worker.provider)
+        refuse("native_route_or_parent_mismatch");
+    if (context.db.get("SELECT 1 FROM work_sessions ws JOIN works w ON w.work_id=ws.work_id JOIN sessions s ON s.project_id=w.project_id AND s.session_id=ws.session_id WHERE w.project_id=? AND w.run_id=? AND w.work_id<>? AND s.harness=? AND s.provider_session_id=? LIMIT 1", [work.project_id, work.run_id, workId, identity.harness, identity.providerSessionId]))
+        refuse("native_repair_session_not_fresh");
+    let freshnessAt = context.now();
+    const currentId = context.env.DD_FLOW_CURRENT_INVOCATION;
+    const admission = currentId ? currentLifecycleAdmission(context, currentId) : null;
+    if (admission) {
+        const project = context.db.get("SELECT root FROM projects WHERE id=?", [work.project_id]);
+        const attempt = context.db.get("SELECT event_key,scope_json,command FROM lifecycle_invocations WHERE id=?", [currentId]);
+        if (attempt?.event_key === key) {
+            const scope = JSON.parse(attempt.scope_json), parsed = parseLifecycleCommand(attempt.command);
+            if (scope.runId !== work.run_id || scope.projectRoot !== project?.root
+                || scope.generation !== (recoveryGuard(context, work.project_id, work.run_id)?.generation ?? 0))
+                refuse("native_invocation_scope_changed");
+            if (parsed.kind !== "none" && parsed.supported !== false
+                && parsed.invocation.operation === "work_start"
+                && resolveWorkReference(context, commandPosition(parsed.invocation, 0), { projectId: work.project_id }).work_id === workId)
+                freshnessAt = admission.admittedAt;
+        }
+    }
+    if (!prior && (parent.status !== "active" || parent.current_stage !== "review" || Date.parse(hook.created_at) < Date.parse(freshnessAt) - 60_000
+        || Date.parse(hook.created_at) > Date.parse(freshnessAt) || Date.parse(freshnessAt) > Date.parse(context.now())
+        || !Number.isFinite(Date.parse(hook.created_at))))
+        refuse("native_hook_or_parent_not_current");
+    if (prior && (hook.status !== "claimed" || !context.db.get("SELECT 1 FROM work_sessions ws JOIN sessions s ON s.project_id=? AND s.session_id=ws.session_id WHERE ws.id=? AND ws.work_id=? AND ws.hook_event_id=? AND ws.session_id=? AND s.run_id=? AND s.worker_id=? AND s.provider_session_id=? AND s.provider_parent_session_id=?", [work.project_id, prior.work_session_id, workId, key, identity.sessionId, work.run_id, workId, identity.providerSessionId, parent.session_id])))
+        refuse("native_registered_start_changed");
+    const copies = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='memory.repair_writer_copy_ready' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.work_id')=? LIMIT 2", [work.project_id, work.run_id, workId]);
+    if (copies.length !== 1 || Buffer.byteLength(copies[0].payload_json) > 12 * 1024 * 1024)
+        refuse("owned_ready_copy_required");
+    let copy;
+    let intent;
+    try {
+        const value = JSON.parse(copies[0].payload_json), workspace_manifest_sha256 = value.workspace_manifest_sha256;
+        delete value.workspace_manifest_sha256;
+        delete value.workspace_manifest_base64;
+        copy = { ...value, workspace_manifest_sha256 };
+        intent = value;
+        if (value.schema_id !== "dd-flow/memory-repair-writer-copy-intent@1" || value.project_id !== work.project_id
+            || value.run_id !== work.run_id || value.work_id !== workId || !Number.isSafeInteger(value.generation) || value.generation < 0
+            || !path.isAbsolute(value.run_root) || value.run_root !== (run.run_root ?? run.run_dir)
+            || value.copy_relative !== `works/${workId}/writer-workspaces/generation-${value.generation}`
+            || !/^[a-f0-9]{64}$/.test(workspace_manifest_sha256) || !/^[a-f0-9]{64}$/.test(value.baseline_registration_sha256))
+            refuse("foreign_ready_copy");
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        return refuse("invalid_ready_copy");
+    }
+    const physical = memoryRepairExecutionIdentity(context, { projectId: work.project_id, runId: work.run_id,
+        workId, eventKey: key, root: path.join(copy.run_root, copy.copy_relative) });
+    const frozen = { coordinator: route.coordinator, worker: route.worker, delegation: { mode: "native", max_parallel: null } };
+    const binding = { operation_id: `native-hook:${key}`, status: "start_requested",
+        profile_json: JSON.stringify({ ...frozen, memory_repair_copy: { root: copy.copy_relative,
+                copy_intent_sha256: hybridDigest(intent), workspace_manifest_sha256: copy.workspace_manifest_sha256,
+                baseline_registration_sha256: copy.baseline_registration_sha256 },
+            ...(physical.invocationId ? { native_execution_cwd: { invocation_id: physical.invocationId, root: physical.identity.cwd } } : {}) }),
+        profile_hash: createHash("sha256").update(JSON.stringify(frozen)).digest("hex"), provider_session_id: identity.providerSessionId };
+    if (prior && (prior.parent_session_id !== parent.session_id || prior.parent_provider_session_id !== parent.provider_session_id
+        || hybridDigest(prior.binding) !== hybridDigest(binding)))
+        refuse("native_binding_changed");
+    return binding;
+}
+/** Commit only inside the same writer that claimed the Hook and inserted
+ * the physical WorkSession; rollback removes both authorities together. */
+export function recordMemoryRepairNativeBinding(context, workId, route, binding, workSessionId) {
+    if (route.delegation.mode !== "native")
+        return;
+    if (context.db.isOwnedWriteTransaction?.() !== true)
+        refuse("owned_claim_writer_required");
+    const actual = readMemoryRepairPhysicalBinding(context, workId, route, binding.operation_id);
+    const key = binding.operation_id.slice(12);
+    const row = context.db.get("SELECT w.project_id,w.run_id,he.parent_session_id,p.provider_session_id AS parent_provider_session_id FROM works w JOIN work_sessions ws ON ws.work_id=w.work_id JOIN hook_events he ON he.project_id=w.project_id AND he.event_key=ws.hook_event_id AND he.session_id=ws.session_id JOIN sessions p ON p.project_id=w.project_id AND p.session_id=he.parent_session_id WHERE w.work_id=? AND ws.id=? AND ws.status='running' AND he.status='claimed' AND he.event_key=? AND he.provider_session_id=?", [workId, workSessionId, key, binding.provider_session_id]);
+    if (!row || hybridDigest(actual) !== hybridDigest(binding))
+        refuse("native_claim_identity_changed");
+    const payload = { schema_id: "dd-flow/memory-repair-native-binding@1", project_id: row.project_id, run_id: row.run_id,
+        work_id: workId, work_session_id: workSessionId, parent_session_id: row.parent_session_id,
+        parent_provider_session_id: row.parent_provider_session_id, hook_event_key: key, binding };
+    const prior = context.db.get("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')=?", [row.project_id, event, row.run_id, workId]);
+    if (prior && hybridDigest(JSON.parse(prior.payload_json)) !== hybridDigest(payload))
+        refuse("native_binding_changed");
+    if (!prior)
+        appendAudit(context, { projectId: row.project_id, eventType: event, payload });
+}

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

@@ -0,0 +1,152 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+function refuse(reason) {
+    throw new AppError("memory_repair_staging_invalid", "Publication staging file is not the owned exact output prefix", 1, { reason, effect: "no_effect" });
+}
+const noFollow = (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0);
+function regular(stat, limit) {
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > limit)
+        refuse("linked_special_or_oversized_staging_file");
+}
+function same(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mode === right.mode
+        && left.nlink === right.nlink && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+/** Read-only verification after independently retained readiness. Unlike staging
+ * recovery, a ready file is never repaired if it becomes missing or partial.
+ */
+export function verifyRetainedMemoryRepairFile(file, value, mode) {
+    if (!(value instanceof Uint8Array) || value.byteLength > 16 * 1024 * 1024)
+        refuse("invalid_ready_bytes");
+    const before = fs.lstatSync(file);
+    regular(before, value.byteLength);
+    if (before.size !== value.byteLength || (before.mode & 0o7777) !== mode)
+        refuse("ready_staging_file_changed");
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+    try {
+        if (!same(before, fs.fstatSync(fd)))
+            refuse("staging_identity_changed");
+        const bytes = Buffer.alloc(value.byteLength);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const count = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
+            if (!count)
+                refuse("ready_staging_file_changed");
+            offset += count;
+        }
+        if (!bytes.equals(Buffer.from(value)) || !same(before, fs.fstatSync(fd)) || !same(before, fs.lstatSync(file)))
+            refuse("ready_staging_file_changed");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Low-level staging effects only. The publication owner must independently
+ * journal this exact directory/slot before calling. This function grants no
+ * SQL/Session authority and never changes an MB destination. Unknown existing
+ * bytes are preserved; an owned exact partial file is completed by append.
+ */
+export function stageRetainedMemoryRepairFile(directory, slot, value, mode) {
+    if (!path.isAbsolute(directory) || fs.realpathSync(directory) !== path.resolve(directory)
+        || !fs.lstatSync(directory).isDirectory() || (fs.lstatSync(directory).mode & 0o7777) !== 0o700
+        || !/^action-[0-9]{1,6}\.tmp$/.test(slot) || !(value instanceof Uint8Array) || value.byteLength > 16 * 1024 * 1024
+        || !Number.isInteger(mode) || mode < 0 || mode > 0o7777)
+        refuse("invalid_staging_binding");
+    const directoryIdentity = fs.lstatSync(directory);
+    const bytes = Buffer.from(value), file = path.join(directory, slot);
+    let fd, changed = false, initialSize = 0, replayed = false;
+    try {
+        const prior = fs.lstatSync(file, { throwIfNoEntry: false });
+        if (prior) {
+            replayed = true;
+            regular(prior, bytes.length);
+            if ((prior.mode & 0o7777) !== 0o600 && (prior.size !== bytes.length || (prior.mode & 0o7777) !== mode))
+                refuse("staging_mode_changed");
+            fd = fs.openSync(file, fs.constants.O_RDONLY | noFollow);
+            if (!same(prior, fs.fstatSync(fd)))
+                refuse("staging_identity_changed");
+        }
+        else {
+            fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
+            changed = true;
+        }
+        const before = fs.fstatSync(fd);
+        regular(before, bytes.length);
+        initialSize = before.size;
+        const retained = Buffer.alloc(initialSize);
+        let read = 0;
+        while (read < retained.length) {
+            const count = fs.readSync(fd, retained, read, retained.length - read, read);
+            if (!count)
+                refuse("staging_changed_during_read");
+            read += count;
+        }
+        if (!same(before, fs.fstatSync(fd)) || !retained.equals(bytes.subarray(0, initialSize)))
+            refuse("unknown_staging_bytes");
+        if (initialSize < bytes.length && replayed) {
+            fs.closeSync(fd);
+            fd = undefined;
+            fd = fs.openSync(file, fs.constants.O_RDWR | noFollow);
+            if (!same(before, fs.fstatSync(fd)))
+                refuse("staging_identity_changed");
+        }
+        let written = initialSize;
+        while (written < bytes.length) {
+            changed = true;
+            const count = fs.writeSync(fd, bytes, written, bytes.length - written, written);
+            if (!count)
+                throw new Error("No progress writing retained staging bytes");
+            written += count;
+        }
+        if ((fs.fstatSync(fd).mode & 0o7777) !== mode) {
+            changed = true;
+            fs.fchmodSync(fd, mode);
+        }
+        fs.fsyncSync(fd);
+        const after = fs.fstatSync(fd);
+        regular(after, bytes.length);
+        if ((after.mode & 0o7777) !== mode)
+            refuse("staging_final_mode_changed");
+        if (after.size !== bytes.length)
+            refuse("staging_identity_changed");
+        const verified = Buffer.alloc(bytes.length);
+        let checked = 0;
+        while (checked < verified.length) {
+            const count = fs.readSync(fd, verified, checked, verified.length - checked, checked);
+            if (!count)
+                refuse("staging_changed_during_read");
+            checked += count;
+        }
+        if (!verified.equals(bytes) || !same(after, fs.fstatSync(fd)))
+            refuse("staging_output_changed");
+        const named = fs.lstatSync(file);
+        if (after.size !== bytes.length || !same(after, named))
+            refuse("staging_identity_changed");
+        fs.closeSync(fd);
+        fd = undefined;
+        const parent = fs.openSync(directory, fs.constants.O_RDONLY | noFollow);
+        try {
+            const current = fs.fstatSync(parent), namedDirectory = fs.lstatSync(directory);
+            if (!current.isDirectory() || current.dev !== directoryIdentity.dev || current.ino !== directoryIdentity.ino
+                || current.dev !== namedDirectory.dev || current.ino !== namedDirectory.ino || (current.mode & 0o7777) !== 0o700)
+                refuse("staging_directory_changed");
+            fs.fsyncSync(parent);
+        }
+        finally {
+            fs.closeSync(parent);
+        }
+        return { path: file, sha256: createHash("sha256").update(bytes).digest("hex"), status: "ready", replayed,
+            bytes_appended: bytes.length - initialSize };
+    }
+    catch (error) {
+        if (!changed && error instanceof AppError)
+            throw error;
+        throw new AppError("memory_repair_staging_pending", "Owned staging output remains pending; preserve it for exact-prefix reconciliation", 1, { effect: "publication_pending", path: file, cause: error instanceof Error ? error.message : String(error) });
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { RetainedMemoryRepairPublicationPlan } from "./memory-repair-publication-plan.js";
+/** Metadata decoding only: no start, source, Session or publication authority.
+ * v1 is never promoted to v2 by optional caller fields. */
+export function retainedMemoryRepairPublicationPlans(receipt) {
+    if (!receipt || typeof receipt !== "object" || Array.isArray(receipt)) {
+        throw new AppError("memory_repair_publication_invalid", "Retained publication intent must be an object", 1, { reason: "invalid_retained_intent_shape", effect: "no_effect" });
+    }
+    const fields = ["schema_id", "project_id", "run_id", "work_id", "generation", "work_session_id", "source_root", "private_root", "output_sha256",
+        "start_receipt_sha256", "result_sha256", "result_base64", "delta_sha256", "transition_sha256", "before_sha256", "before_base64", "after_sha256", "after_base64", "actions"];
+    const current = receipt.schema_id === "dd-flow/memory-repair-publication-intent@2";
+    if (current)
+        fields.push("source_view_sha256", "source_receipt_sha256", "private_plan_sha256", "private_plan");
+    if ((!current && receipt.schema_id !== "dd-flow/memory-repair-publication-intent@1")
+        || Object.keys(receipt).sort().join(",") !== fields.sort().join(",")
+        || current && (!receipt.private_plan || typeof receipt.private_plan !== "object" || Array.isArray(receipt.private_plan)
+            || [receipt.source_view_sha256, receipt.source_receipt_sha256, receipt.private_plan_sha256].some(value => typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)))
+        || Buffer.byteLength(JSON.stringify(receipt)) > 160 * 1024 * 1024) {
+        throw new AppError("memory_repair_publication_invalid", "Retained publication intent has a foreign version or shape", 1, { reason: "invalid_retained_intent_shape", effect: "no_effect" });
+    }
+    const retained = { before_sha256: receipt.before_sha256, before_base64: receipt.before_base64,
+        after_sha256: receipt.after_sha256, after_base64: receipt.after_base64, actions: receipt.actions };
+    const plan = RetainedMemoryRepairPublicationPlan.restore(Buffer.from(JSON.stringify(retained)), hybridDigest(retained));
+    const privatePlan = current ? RetainedMemoryRepairPublicationPlan.restore(Buffer.from(JSON.stringify(receipt.private_plan)), receipt.private_plan_sha256) : plan;
+    return { current, plan, privatePlan };
+}