@deksden-com/dd-flow-cli 0.9.0-beta.15 → 0.9.0-beta.150

package/dist/services/memory-init-stores.js

@@ -0,0 +1,359 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { createContext } from "../runtime/context.js";
+import { getDatabase, getResourceDatabase } from "../storage/database.js";
+import { canonicalPath, resolveDdFlowHome } from "../storage/paths.js";
+import { assertImportAdmission } from "../storage/import-guard.js";
+import { publishImmutableInput } from "../storage/immutable-input.js";
+import { withStoreCleanup } from "../storage/native-cleanup.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { validateMemoryInitStartupScope } from "./memory-init-startup-custody.js";
+import { PreparedMemoryInitRuntimeStorage } from "./memory-init-storage.js";
+import { PreparedMemoryInitResourceStorage } from "./memory-init-resource-storage.js";
+const limit = 64 * 1024 * 1024;
+const bytes = (value) => Buffer.from(JSON.stringify(value));
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+function refuse(reason) {
+    throw new AppError("memory_init_stores_invalid", "Init stores require exact creation ownership or existing prepared storage", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_store_owner" });
+}
+function exists(file) {
+    try {
+        fs.lstatSync(file);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function directory(file) {
+    const stat = fs.lstatSync(file);
+    if (!stat.isDirectory() || fs.realpathSync(file) !== file)
+        refuse("linked_or_unavailable_directory");
+    return stat;
+}
+function sync(file) {
+    const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function regular(file) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return refuse("store_owner_missing");
+        throw error;
+    }
+    if (!stat.isFile() || stat.nlink < 1 || stat.nlink > 2)
+        refuse("linked_or_unavailable_store");
+    return stat;
+}
+function read(file) { return JSON.parse(readBoundedReleaseFile(file, 16 * 1024).toString("utf8")); }
+function owner(file) {
+    const stat = regular(file);
+    sync(file);
+    const content = readBoundedReleaseFile(file, limit), current = regular(file);
+    if (stat.dev !== current.dev || stat.ino !== current.ino || stat.size !== content.length || current.size !== content.length)
+        refuse("staged_store_changed");
+    return { schema_id: "dd-flow/memory-init-staged-store@1", dev: stat.dev, ino: stat.ino, bytes: content.length, sha256: hash(content) };
+}
+function readOwner(file) {
+    const value = read(file);
+    if (!value || Object.keys(value).sort().join() !== "bytes,dev,ino,schema_id,sha256"
+        || value.schema_id !== "dd-flow/memory-init-staged-store@1" || !Number.isSafeInteger(value.dev) || value.dev < 0
+        || !Number.isSafeInteger(value.ino) || value.ino <= 0 || !Number.isSafeInteger(value.bytes) || value.bytes <= 0 || value.bytes > limit
+        || typeof value.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.sha256))
+        refuse("invalid_staged_store_owner");
+    return value;
+}
+function matches(file, expected, immutable) {
+    const actual = regular(file);
+    if (actual.dev !== expected.dev || actual.ino !== expected.ino
+        || immutable && (actual.size !== expected.bytes || hash(readBoundedReleaseFile(file, limit)) !== expected.sha256))
+        refuse("store_owner_changed");
+}
+function pristine(file) {
+    if (exists(file))
+        refuse("foreign_store_footprint");
+    noSidecars(file);
+}
+function noSidecars(file) {
+    for (const suffix of ["-wal", "-shm", "-journal"])
+        if (exists(`${file}${suffix}`))
+            refuse("foreign_store_footprint");
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function freshHome(home) {
+    pristine(path.join(home, "db.sqlite"));
+    const namespace = path.join(home, "memory-init-store-creations");
+    if (["projects", "memory-layer-publications"].some(name => exists(path.join(home, name)))
+        || exists(namespace) && (directory(namespace), fs.readdirSync(namespace).length))
+        refuse("historical_home_missing_stores");
+}
+function existingResource(env) {
+    const home = resolveDdFlowHome(env), resource = env.DD_FLOW_RESOURCE_HOME ?? home;
+    directory(resource);
+    try {
+        fs.accessSync(resource, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+        fs.accessSync(path.join(resource, "runtime.sqlite"), fs.constants.R_OK | fs.constants.W_OK);
+    }
+    catch {
+        return refuse("store_access_unavailable");
+    }
+    const facts = PreparedMemoryInitResourceStorage.prepare({ ddFlowHome: home, env }).facts();
+    return { dev: facts.store_dev, ino: facts.store_ino };
+}
+function admit(env, created) {
+    const home = resolveDdFlowHome(env), resourceHome = env.DD_FLOW_RESOURCE_HOME ?? home;
+    directory(resourceHome);
+    if (regular(path.join(home, "db.sqlite")).nlink !== 1 || regular(path.join(resourceHome, "runtime.sqlite")).nlink !== 1)
+        refuse("linked_published_store");
+    try {
+        for (const dir of new Set([home, resourceHome]))
+            fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+        for (const file of [path.join(home, "db.sqlite"), path.join(resourceHome, "runtime.sqlite")])
+            fs.accessSync(file, fs.constants.R_OK | fs.constants.W_OK);
+    }
+    catch {
+        return refuse("store_access_unavailable");
+    }
+    const context = createContext(env, "prepared_existing", undefined, { resourceDatabaseMode: "prepared_existing" });
+    let admitted = false;
+    return withStoreCleanup(() => {
+        PreparedMemoryInitRuntimeStorage.prepare(context);
+        PreparedMemoryInitResourceStorage.prepare(context);
+        admitted = true;
+        return { context, created };
+    }, () => { if (!admitted)
+        context.db.close?.(); }, () => ({ store_path: context.db.path }));
+}
+/** Native qualification must discover an already incompatible/partial store
+ * before provider effects. Missing pristine stores remain the normal fresh
+ * startup owner's responsibility; this function never initializes them. */
+export function assertMemoryInitStorePrerequisites(env, scope) {
+    validateMemoryInitStartupScope(scope);
+    const home = resolveDdFlowHome(env), resource = env.DD_FLOW_RESOURCE_HOME ?? home;
+    directory(home);
+    if (!path.isAbsolute(resource) || canonicalPath(resource, false) !== resource
+        || [scope.projectRoot, scope.workspaceRoot].some(root => inside(root, home) || inside(root, resource)))
+        refuse("foreign_store_scope");
+    assertImportAdmission(home);
+    assertImportAdmission(resource);
+    const runFile = path.join(home, "db.sqlite"), resourceFile = path.join(resource, "runtime.sqlite");
+    if (!exists(runFile) && exists(resourceFile)) {
+        freshHome(home);
+        existingResource(env);
+        return;
+    }
+    if (exists(runFile) !== exists(resourceFile))
+        refuse("partial_existing_store_pair");
+    if (exists(runFile)) {
+        const checked = admit(env, false);
+        checked.context.db.close?.();
+    }
+    else {
+        pristine(runFile);
+        pristine(resourceFile);
+    }
+}
+/** Fresh RUN publication and creation or reuse of the shared resource store.
+ * The caller supplies the digest of its independently prepared raw selection.
+ * No initializer ever opens an existing target. Incomplete publication may
+ * resume only from the original journal and the same staged file identities.
+ * Lost staging/receipts remain unknown; ready historical stores are never
+ * recreated. Creating both stores requires one filesystem; a reused prepared
+ * registry may live separately. The caller must close the returned connection. */
+export function openMemoryInitStores(env, request) {
+    if (!request || Object.keys(request).sort().join() !== "scope,selectionSha256")
+        refuse("invalid_store_request");
+    validateMemoryInitStartupScope(request.scope);
+    if (typeof request.selectionSha256 !== "string" || !/^[a-f0-9]{64}$/.test(request.selectionSha256))
+        refuse("invalid_selection_digest");
+    const home = resolveDdFlowHome(env), resourceHome = env.DD_FLOW_RESOURCE_HOME ?? home;
+    if (!path.isAbsolute(resourceHome) || path.resolve(resourceHome) !== resourceHome || canonicalPath(resourceHome, false) !== resourceHome)
+        refuse("resource_home_not_canonical");
+    directory(home);
+    if ([request.scope.projectRoot, request.scope.workspaceRoot].some(root => inside(root, home) || inside(root, resourceHome)))
+        refuse("stores_inside_project");
+    assertImportAdmission(home);
+    assertImportAdmission(resourceHome);
+    const run = path.join(home, "db.sqlite"), resource = path.join(resourceHome, "runtime.sqlite");
+    const namespace = path.join(home, "memory-init-store-creations"), journal = path.join(namespace, hybridDigest([home, resourceHome]));
+    const intentFile = path.join(journal, "intent.json"), readyFile = path.join(journal, "ready.json");
+    let sharedResource;
+    if (exists(namespace))
+        directory(namespace);
+    if (!exists(journal)) {
+        if (exists(run) && exists(resource)) {
+            if (exists(namespace) && !fs.readdirSync(namespace).length)
+                refuse("creation_journal_missing");
+            return admit(env, false);
+        }
+        if (exists(run))
+            refuse("partial_existing_store_pair");
+        freshHome(home);
+        if (exists(resource))
+            sharedResource = existingResource(env);
+        else
+            pristine(resource);
+        let parent = resourceHome;
+        while (!exists(parent))
+            parent = path.dirname(parent);
+        if (!sharedResource && directory(parent).dev !== directory(home).dev)
+            refuse("cross_device_fresh_publication_unavailable");
+    }
+    let started = false;
+    try {
+        if (!exists(namespace)) {
+            fs.mkdirSync(namespace, { mode: 0o700 });
+            started = true;
+            sync(home);
+        }
+        directory(namespace);
+        if (!exists(journal)) {
+            fs.mkdirSync(journal, { mode: 0o700 });
+            started = true;
+            sync(namespace);
+            const stat = directory(journal);
+            const intent = { schema_id: "dd-flow/memory-init-store-creation@1", home, resource_home: resourceHome,
+                scope: request.scope, selection_sha256: request.selectionSha256, journal_owner: { dev: stat.dev, ino: stat.ino },
+                ...(sharedResource ? { resource_existing: sharedResource } : {}) };
+            publishImmutableInput(intentFile, bytes(intent), "memory_init_store_request_conflict");
+        }
+        const stat = directory(journal);
+        if (!exists(intentFile))
+            refuse("creation_intent_missing");
+        const intent = read(intentFile);
+        if (!intent || Object.keys(intent).sort().join() !== (intent.resource_existing
+            ? "home,journal_owner,resource_existing,resource_home,schema_id,scope,selection_sha256"
+            : "home,journal_owner,resource_home,schema_id,scope,selection_sha256")
+            || intent.schema_id !== "dd-flow/memory-init-store-creation@1" || intent.home !== home || intent.resource_home !== resourceHome
+            || !intent.journal_owner || Object.keys(intent.journal_owner).sort().join() !== "dev,ino"
+            || intent.journal_owner?.dev !== stat.dev || intent.journal_owner?.ino !== stat.ino
+            || typeof intent.selection_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(intent.selection_sha256))
+            refuse("creation_intent_changed");
+        validateMemoryInitStartupScope(intent.scope);
+        const assertExistingResource = () => {
+            if (!intent.resource_existing)
+                return;
+            const expected = intent.resource_existing;
+            if (Object.keys(expected).sort().join() !== "dev,ino" || !Number.isSafeInteger(expected.dev) || expected.dev < 0
+                || !Number.isSafeInteger(expected.ino) || expected.ino <= 0
+                || hybridDigest(existingResource(env)) !== hybridDigest(expected))
+                refuse("store_owner_changed");
+        };
+        assertExistingResource();
+        const ready = { schema_id: "dd-flow/memory-init-store-ready@1", intent_sha256: hybridDigest(intent),
+            run: path.join(journal, "run-ready.json"), resource: intent.resource_existing ?? path.join(journal, "resource-ready.json") };
+        if (exists(readyFile)) {
+            if (hybridDigest(read(readyFile)) !== hybridDigest(ready))
+                refuse("store_ready_receipt_changed");
+            matches(run, readOwner(ready.run), false);
+            if (typeof ready.resource === "string")
+                matches(resource, readOwner(ready.resource), false);
+            if (regular(run).nlink !== 1 || regular(resource).nlink !== 1)
+                refuse("linked_published_store");
+            return admit(env, false);
+        }
+        if (hybridDigest(intent.scope) !== hybridDigest(request.scope) || intent.selection_sha256 !== request.selectionSha256)
+            refuse("foreign_creation_request");
+        started = true;
+        const assertJournalOwner = () => {
+            directory(home);
+            directory(namespace);
+            const current = directory(journal);
+            if (current.dev !== intent.journal_owner.dev || current.ino !== intent.journal_owner.ino)
+                refuse("creation_intent_changed");
+        };
+        const entries = [
+            { staged: path.join(journal, "db.sqlite"), target: run, receipt: ready.run,
+                create: () => getDatabase(journal, "create_new") },
+            ...(typeof ready.resource === "string" ? [{ staged: path.join(journal, "runtime.sqlite"), target: resource, receipt: ready.resource,
+                    create: () => getResourceDatabase(journal, "create_new") }] : [])
+        ];
+        // New stores have durable staged identities; a reused registry stays mutable.
+        for (const entry of entries) {
+            assertJournalOwner();
+            if (!exists(entry.receipt)) {
+                pristine(entry.target);
+                pristine(entry.staged);
+                const database = entry.create();
+                database.close?.();
+                assertJournalOwner();
+                publishImmutableInput(entry.receipt, bytes(owner(entry.staged)), "memory_init_store_owner_conflict");
+            }
+            const expected = readOwner(entry.receipt);
+            noSidecars(entry.staged);
+            if (exists(entry.staged))
+                matches(entry.staged, expected, true);
+            else if (!exists(entry.target))
+                refuse("staged_store_missing");
+        }
+        if (!exists(resourceHome)) {
+            const missing = [];
+            let parent = resourceHome;
+            while (!exists(parent)) {
+                missing.push(parent);
+                parent = path.dirname(parent);
+            }
+            fs.mkdirSync(resourceHome, { recursive: true, mode: 0o700 });
+            for (const created of missing.reverse()) {
+                directory(created);
+                sync(path.dirname(created));
+            }
+        }
+        directory(resourceHome);
+        for (const entry of entries) {
+            assertJournalOwner();
+            directory(resourceHome);
+            assertExistingResource();
+            const expected = readOwner(entry.receipt);
+            noSidecars(entry.target);
+            if (!exists(entry.target)) {
+                pristine(entry.target);
+                if (!exists(entry.staged))
+                    refuse("staged_store_missing");
+                try {
+                    fs.linkSync(entry.staged, entry.target);
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST")
+                        throw error;
+                }
+            }
+            matches(entry.target, expected, true);
+            sync(path.dirname(entry.target));
+            if (exists(entry.staged)) {
+                matches(entry.staged, expected, true);
+                fs.unlinkSync(entry.staged);
+                sync(journal);
+            }
+            if (regular(entry.target).nlink !== 1)
+                refuse("linked_published_store");
+            matches(entry.target, expected, true);
+        }
+        assertJournalOwner();
+        assertExistingResource();
+        publishImmutableInput(readyFile, bytes(ready), "memory_init_store_ready_conflict");
+        return admit(env, true);
+    }
+    catch (error) {
+        if (!started)
+            throw error;
+        throw new AppError("memory_init_store_creation_incomplete", "Store publication requires exact-request reconciliation", 1, { effect: "partial", journal_path: journal, cause: errorRecord(error), next_action: "reconcile_exact_store_owner" });
+    }
+}

package/dist/services/memory-init-worktrunk-capability.js

@@ -0,0 +1,174 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { PreparedMemoryInitTarget } from "./memory-init-preflight.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { runMemoryToolProbe } from "./memory-tool-probe.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason, diagnostics) {
+    throw new AppError("memory_init_worktrunk_capability_failed", "Selected Worktrunk cannot create the required workspace", 1, { reason, effect: "no_effect", next_action: "repair_prerequisite_then_retry", ...(diagnostics ? { tool_probe: diagnostics } : {}) });
+}
+/** Historical custody shape only; it does not run or qualify an executable. */
+export function isMemoryInitWorktrunkCapabilityFacts(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const facts = value;
+    return Object.keys(facts).length === 7 && facts.schema_id === "dd-flow/memory-init-worktrunk-capability@1"
+        && typeof facts.executable === "string" && path.isAbsolute(facts.executable)
+        && typeof facts.git_executable === "string" && path.isAbsolute(facts.git_executable)
+        && typeof facts.version === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(facts.version)
+        && ["executable_sha256", "git_executable_sha256", "behavior_sha256"].every(key => typeof facts[key] === "string" && /^[a-f0-9]{64}$/.test(facts[key]));
+}
+/** Functional prerequisite, not productive workspace creation or provider readiness.
+ * Only an owned temporary Git repository is mutated. Explicit user/system/project
+ * configs, empty templates/hooks and private XDG directories exclude operator
+ * configuration. Raw probe paths/output never enter retained stable facts.
+ */
+export class PreparedMemoryInitWorktrunkCapability {
+    sha256;
+    #facts;
+    constructor(facts) {
+        this.#facts = facts;
+        this.sha256 = hybridDigest(facts);
+        Object.freeze(this);
+    }
+    static prepare(target, env) {
+        if (!(target instanceof PreparedMemoryInitTarget))
+            refuse("unprepared_target");
+        const selected = target.facts(), probe = selected.tool_probes?.wt, gitProbe = selected.tool_probes?.git;
+        if (!probe || !gitProbe)
+            refuse("missing_selected_tool_probe");
+        const checksum = (file) => {
+            try {
+                return hash(readBoundedReleaseFile(file, 64 * 1024 * 1024));
+            }
+            catch {
+                return refuse("selected_executable_unavailable");
+            }
+        };
+        const unchanged = () => {
+            if (checksum(selected.tools.wt) !== probe.executable_sha256 || checksum(selected.tools.git) !== gitProbe.executable_sha256)
+                refuse("selected_executable_changed");
+        };
+        unchanged();
+        let scratch, owner, primary, prepared;
+        try {
+            scratch = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "dd-flow-init-wt-")));
+            owner = fs.lstatSync(scratch);
+            const ownRoot = () => {
+                const actual = fs.lstatSync(scratch);
+                if (!actual.isDirectory() || actual.dev !== owner.dev || actual.ino !== owner.ino)
+                    refuse("probe_root_owner_changed");
+            };
+            const repo = path.join(scratch, "repo"), workspace = path.join(scratch, "workspace"), bin = path.join(scratch, "bin"), hooks = path.join(scratch, "hooks");
+            for (const name of ["repo", "bin", "hooks", "template", "config", "cache", "data", "state", "tmp"])
+                fs.mkdirSync(path.join(scratch, name), { mode: 0o700 });
+            fs.symlinkSync(selected.tools.git, path.join(bin, process.platform === "win32" ? "git.exe" : "git"));
+            const config = path.join(scratch, "config", "empty.toml"), gitConfig = path.join(scratch, "config", "git.config");
+            fs.writeFileSync(config, "", { flag: "wx", mode: 0o600 });
+            fs.writeFileSync(gitConfig, "", { flag: "wx", mode: 0o600 });
+            // No ambient WORKTRUNK_* or GIT_* selection/configuration survives.
+            const baseEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_") && !key.startsWith("WORKTRUNK_") && key !== "RUST_LOG"));
+            const probeEnv = { ...baseEnv, PATH: bin + path.delimiter + path.dirname(selected.tools.git),
+                TMPDIR: path.join(scratch, "tmp"), TMP: path.join(scratch, "tmp"), TEMP: path.join(scratch, "tmp"),
+                XDG_CONFIG_HOME: path.join(scratch, "config"), XDG_CACHE_HOME: path.join(scratch, "cache"), XDG_DATA_HOME: path.join(scratch, "data"), XDG_STATE_HOME: path.join(scratch, "state"), XDG_CONFIG_DIRS: path.join(scratch, "config"),
+                WORKTRUNK_CONFIG_PATH: config, WORKTRUNK_SYSTEM_CONFIG_PATH: config, WORKTRUNK_PROJECT_CONFIG_PATH: config, WORKTRUNK_VERBOSE: "0",
+                GIT_CONFIG_GLOBAL: gitConfig, GIT_CONFIG_SYSTEM: gitConfig, GIT_CONFIG_NOSYSTEM: "1", GIT_OPTIONAL_LOCKS: "0",
+                GIT_CONFIG_COUNT: "2", GIT_CONFIG_KEY_0: "core.hooksPath", GIT_CONFIG_VALUE_0: hooks, GIT_CONFIG_KEY_1: "core.fsmonitor", GIT_CONFIG_VALUE_1: "false",
+                GIT_AUTHOR_NAME: "dd-flow isolated probe", GIT_AUTHOR_EMAIL: "probe@example.invalid", GIT_COMMITTER_NAME: "dd-flow isolated probe", GIT_COMMITTER_EMAIL: "probe@example.invalid",
+                GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z", GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z", NO_COLOR: "1", CLICOLOR_FORCE: "0" };
+            const run = (file, args) => {
+                ownRoot();
+                unchanged();
+                const { result, diagnostics } = runMemoryToolProbe(file, args, { cwd: repo, env: probeEnv });
+                if (result.error || result.signal || result.status !== 0)
+                    refuse("worktrunk_probe_execution_failed", {
+                        ...diagnostics, name: path.basename(file), phase: "workspace_probe", expected_status: 0
+                    });
+                ownRoot();
+                unchanged();
+                return new TextDecoder("utf-8", { fatal: true }).decode(result.stdout);
+            };
+            const git = (directory, args) => run(selected.tools.git, ["-C", directory, ...args]).trim();
+            git(repo, ["init", "--initial-branch=probe-main", `--template=${path.join(scratch, "template")}`]);
+            const seed = Buffer.from("dd-flow isolated Worktrunk capability\n");
+            fs.writeFileSync(path.join(repo, "probe.txt"), seed, { flag: "wx", mode: 0o600 });
+            git(repo, ["add", "--", "probe.txt"]);
+            git(repo, ["-c", "commit.gpgSign=false", "commit", "-m", "Isolated Worktrunk capability"]);
+            const head = git(repo, ["rev-parse", "--verify", "HEAD"]);
+            const output = run(selected.tools.wt, ["-C", repo, "--config", config, "--config-set", `worktree-path = ${JSON.stringify(workspace)}`,
+                "switch", "--create", "probe-work", "--base", head, "--no-hooks", "--no-cd", "--format=json", "--yes"]);
+            let response;
+            try {
+                response = JSON.parse(output);
+            }
+            catch {
+                return refuse("worktrunk_probe_invalid_json");
+            }
+            if (!response || typeof response !== "object" || Array.isArray(response))
+                refuse("worktrunk_probe_invalid_json");
+            const returned = response.workspace_path ?? response.path;
+            if (typeof returned !== "string" || returned !== workspace)
+                refuse("worktrunk_probe_foreign_workspace");
+            if (!fs.lstatSync(workspace).isDirectory() || fs.realpathSync(workspace) !== workspace)
+                refuse("worktrunk_probe_linked_workspace");
+            if (git(workspace, ["rev-parse", "--show-toplevel"]) !== workspace
+                || git(workspace, ["symbolic-ref", "--short", "HEAD"]) !== "probe-work"
+                || git(workspace, ["rev-parse", "--verify", "HEAD"]) !== head
+                || fs.realpathSync(path.resolve(workspace, git(workspace, ["rev-parse", "--git-common-dir"]))) !== path.join(repo, ".git")
+                || git(workspace, ["status", "--porcelain=v1", "--untracked-files=all"]) !== "")
+                refuse("worktrunk_probe_git_identity_changed");
+            if (!readBoundedReleaseFile(path.join(workspace, "probe.txt"), 1024).equals(seed)
+                || !readBoundedReleaseFile(path.join(repo, "probe.txt"), 1024).equals(seed)
+                || git(repo, ["status", "--porcelain=v1", "--untracked-files=all"]) !== ""
+                || git(repo, ["symbolic-ref", "--short", "HEAD"]) !== "probe-main" || git(repo, ["rev-parse", "HEAD"]) !== head)
+                refuse("worktrunk_probe_source_changed");
+            prepared = new PreparedMemoryInitWorktrunkCapability({ schema_id: "dd-flow/memory-init-worktrunk-capability@1",
+                executable: selected.tools.wt, executable_sha256: probe.executable_sha256, version: probe.version,
+                git_executable: selected.tools.git, git_executable_sha256: gitProbe.executable_sha256,
+                behavior_sha256: hybridDigest({ branch: "probe-work", seed_head: head, seed_sha256: hash(seed), returned_exact_workspace: true, shared_repository: true, hooks_disabled: true, source_unchanged: true, clean: true }) });
+        }
+        catch (error) {
+            primary = error instanceof AppError ? error : new AppError("memory_init_worktrunk_capability_failed", "Worktrunk probe observation failed", 1, { reason: "worktrunk_probe_observation_failed", effect: "no_effect", next_action: "repair_prerequisite_then_retry" });
+        }
+        if (scratch)
+            try {
+                const actual = fs.lstatSync(scratch);
+                if (!owner || !actual.isDirectory() || actual.dev !== owner.dev || actual.ino !== owner.ino)
+                    refuse("probe_root_owner_changed");
+                fs.rmSync(scratch, { recursive: true });
+            }
+            catch {
+                throw new AppError("memory_init_worktrunk_probe_cleanup_failed", "Isolated Worktrunk probe requires cleanup", 1, { reason: primary instanceof AppError ? primary.details.reason : primary ? "probe_failed" : "cleanup_failed", effect: "partial", owned_probe_path: scratch, next_action: "reconcile_owned_probe" });
+            }
+        if (primary)
+            throw primary;
+        return prepared;
+    }
+    facts() { return { ...this.#facts }; }
+    revalidate(target, _env) {
+        if (!(target instanceof PreparedMemoryInitTarget))
+            refuse("unprepared_target");
+        const selected = target.facts(), probe = selected.tool_probes?.wt, gitProbe = selected.tool_probes?.git;
+        if (!probe || !gitProbe || selected.tools.wt !== this.#facts.executable || probe.version !== this.#facts.version
+            || probe.executable_sha256 !== this.#facts.executable_sha256 || selected.tools.git !== this.#facts.git_executable
+            || gitProbe.executable_sha256 !== this.#facts.git_executable_sha256)
+            refuse("worktrunk_capability_changed");
+        // Keep the initial isolated workspace proof; checkpoints only revalidate
+        // the selected Worktrunk/Git bytes, without creating another probe workspace.
+        const checksum = (file) => {
+            try {
+                return hash(readBoundedReleaseFile(file, 64 * 1024 * 1024));
+            }
+            catch {
+                return refuse("selected_executable_unavailable");
+            }
+        };
+        if (checksum(this.#facts.executable) !== this.#facts.executable_sha256
+            || checksum(this.#facts.git_executable) !== this.#facts.git_executable_sha256)
+            refuse("selected_executable_changed");
+    }
+}