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

package/dist/services/harness-version-probe.js

@@ -0,0 +1,100 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { parse } from "semver";
+import { stopProcessGroup } from "../harness-runtime/lib/managed-daemon.mjs";
+import { AppError } from "../shared/errors.js";
+import { runScopedProbe } from "./harness-probe-effects.js";
+// Even --version runs operator-installed code. Do not infer credential/write
+// isolation from an argument spelling or execute it during static discovery.
+export const versionProbeEffects = Object.freeze({
+    child_process: true, service_process: false, credential_access: "possible",
+    filesystem: "temporary_or_runtime_writes", model_turn: "not_requested",
+    source_owner: "services/harness-version-probe.ts:probeHarnessVersion"
+});
+/** Recognized version fields only; unrelated diagnostic numbers are not facts. */
+export function parseHarnessVersion(harness, stdout) {
+    const normalize = (value) => {
+        const version = parse(value);
+        return version ? `${version.version}${version.build.length ? `+${version.build.join(".")}` : ""}` : null;
+    };
+    if (harness === "grok") {
+        try {
+            const value = JSON.parse(stdout);
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            const reported = value.currentVersion;
+            return typeof reported === "string" ? normalize(reported.trim().split(/\s+/)[0]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    const labels = {
+        codex: "codex(?:-cli)?", zcode: "zcode", agy: "(?:agy|antigravity)", opencode: "opencode", droid: "droid"
+    };
+    const pattern = new RegExp(`^(?:${labels[harness]}\\s+)?(v?[0-9]+\\.[0-9]+\\.[0-9]+(?:-[A-Za-z0-9.-]+)?(?:\\+[A-Za-z0-9.-]+)?)$`, "i");
+    const versions = new Set(stdout.split(/\r?\n/).flatMap(line => {
+        const matched = line.trim().match(pattern)?.[1];
+        const version = matched ? normalize(matched) : null;
+        return version ? [version] : [];
+    }));
+    return versions.size === 1 ? [...versions][0] : null;
+}
+/** Diagnostic only: a version is not protocol, account or flow qualification. */
+export function probeHarnessVersion(input) {
+    const timeoutMs = input.timeoutMs ?? 3000;
+    if (!["codex", "zcode", "agy", "opencode", "grok", "droid"].includes(input.harness)) {
+        throw new AppError("usage", "Unknown harness family", 2, { effect: "no_effect" });
+    }
+    if (!path.isAbsolute(input.executable) || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000) {
+        throw new AppError("usage", "Version probe requires an absolute executable and a timeout of 1–60000 ms", 2, { effect: "no_effect" });
+    }
+    return runScopedProbe(versionProbeEffects, input.scope, () => new Promise((resolve, reject) => {
+        const args = input.harness === "grok" ? ["version", "--json"] : ["--version"];
+        const detached = process.platform !== "win32";
+        const child = spawn(input.executable, args, { env: input.env, detached, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let bytes = 0;
+        let failure;
+        let cleanup;
+        const stop = (code, message) => {
+            failure ??= new AppError(code, message, 1, { phase: "version_probe", effect: "process_dispatched" });
+            cleanup ??= stopProcessGroup(child, 1000, { detached });
+            // Observe immediately; close may arrive after asynchronous cleanup failure.
+            void cleanup.catch(() => { });
+        };
+        const timer = setTimeout(() => stop("probe_timeout", "Version probe exceeded its deadline"), timeoutMs);
+        child.stdout.setEncoding("utf8").on("data", (chunk) => {
+            bytes += Buffer.byteLength(chunk);
+            if (bytes > 64_000)
+                stop("probe_output_limit", "Version probe exceeded its output limit");
+            else
+                stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > 64_000)
+                stop("probe_output_limit", "Version probe exceeded its output limit");
+        });
+        child.on("error", () => { failure ??= new AppError("probe_launch_failed", "Version probe could not start", 1); });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            void (async () => {
+                try {
+                    await cleanup;
+                    if (failure)
+                        throw failure;
+                    if (code !== 0 || signal)
+                        throw new AppError("probe_failed", "Version probe did not exit successfully", 1);
+                    // Never expose arbitrary subprocess output: it can contain secrets.
+                    const version = parseHarnessVersion(input.harness, stdout);
+                    resolve({ harness: input.harness, version, status: version ? "observed" : "unrecognized",
+                        compatible: "unknown", protocol: "unknown", auth: "unknown", qualified: "unknown" });
+                }
+                catch (error) {
+                    reject(error instanceof AppError ? error : new AppError("probe_cleanup_unconfirmed", "Version probe cleanup could not be confirmed", 1));
+                }
+            })();
+        });
+    }));
+}

package/dist/services/hooks.js

@@ -9,6 +9,8 @@ import { parseJsonObject } from "../shared/json.js";
 import { canonicalPath, ensureDir, resolveProjectRoot } from "../storage/paths.js";
 import { resolveWorkReference } from "../storage/work-references.js";
 import { appendAudit } from "./audit.js";
+import { memoryRepairAssignedHookCwd } from "./memory-repair-physical-binding.js";
+import { memoryNativeReviewAssignedHookCwd } from "./memory-native-review-copy.js";
 import { prepareTextFile, prepareJsonText, prepareError } from "../cli/input-preparation.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
 import { assertRecoveryHookCurrent } from "./run-recovery.js";
@@ -714,6 +716,11 @@ export function handleDroidEvent(context, input) {
     return handleControlledToolEvent(context, input, event, "droid-cli");
 }
 /** Stable project identity is not the native Session's execution workspace. */
+function requiresAssignedLifecycleCwd(facts) {
+    // Settlement and user interaction address the retained RUN explicitly;
+    // their tools/checks receive owned paths, not the shell's working directory.
+    return !facts || !["stage_finish", "stage_pause", "stage_resume", "work_finish", "work_fail"].includes(facts.invocation.operation);
+}
 function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, command, observedCwd, identity, harness) {
     const auxiliary = continuationCommand(command);
     if ((!facts && !auxiliary) || facts?.analysis.supported === false)
@@ -723,7 +730,9 @@ function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, co
     const issuedRunId = facts && !facts.runId && !facts.workId && !facts.bootstrapStageStart && constraint ? observedLifecycleInvocation(context, command, constraint, identity ? { identity } : undefined)?.scope.runId : null;
     if (facts?.invocation.operation.startsWith("stage_") && !facts.bootstrapStageStart && !facts.runId && !issuedRunId)
         throw new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
-    const expected = controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId);
+    if (!requiresAssignedLifecycleCwd(facts))
+        return undefined;
+    const expected = controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId, observedCwd);
     // Unknown CLI targets have no assigned workspace. Recording their native
     // observation must not turn the stable identity root into cwd authority.
     if (!expected)
@@ -737,7 +746,7 @@ function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, co
     // physical process directory, rather than inventing native observation.
     return expected;
 }
-function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId) {
+function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId, observedCwd) {
     if (facts?.bootstrapStageStart)
         return projectRoot;
     const project = context.db.get("SELECT id FROM projects WHERE root = ?", [projectRoot]);
@@ -768,6 +777,14 @@ function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId,
     if (!run)
         return undefined; // Hook ingress does not validate a mistyped CLI target.
     if (work) {
+        const repair = memoryRepairAssignedHookCwd(context, { projectRoot, projectId: project.id, runId: run.id,
+            workId: work.work_id, providerSessionId, ...(observedCwd ? { observedCwd: resolveProjectRoot(observedCwd) } : {}),
+            ...(facts?.invocation.expectedCwd ? { literalExecutionCwd: resolveProjectRoot(facts.invocation.expectedCwd) } : {}) });
+        if (repair)
+            return resolveProjectRoot(repair.root);
+        const nativeReview = memoryNativeReviewAssignedHookCwd(context, { projectId: project.id, runId: run.id, workId: work.work_id, providerSessionId });
+        if (nativeReview)
+            return resolveProjectRoot(nativeReview);
         // PROTOCOLIZE provisions the feature checkout after its coordinator
         // Session has launched in the stable project root. Its transition Work
         // must keep that physical route until the Stage is complete. Child Works
@@ -862,12 +879,13 @@ function handleControlledToolEvent(context, input, event, harness) {
     }
     // These controlled platforms additionally qualify their native launch
     // route against the stable project root when no CLI target is assigned.
-    const expectedCwd = shellRefusal ? observedCwd : controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId) ?? expectedRoot;
-    const executionRoute = shellRefusal ? undefined : lifecycle?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
+    const workspaceBound = requiresAssignedLifecycleCwd(lifecycle);
+    const expectedCwd = shellRefusal || !workspaceBound ? observedCwd : controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId, observedCwd) ?? expectedRoot;
+    const executionRoute = shellRefusal || !workspaceBound ? undefined : lifecycle?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
     if (executionRoute && resolveProjectRoot(executionRoute) !== expectedCwd) {
         throw new AppError(`${errorPrefix}_directory_mismatch`, "Literal shell cd route does not match the assigned lifecycle workspace", 1, { expected: expectedCwd, actual: executionRoute, actual_provenance: "shell_literal_route", effect: "no_effect", recoverable: false });
     }
-    if (!executionRoute && observedCwd !== expectedCwd) {
+    if (workspaceBound && !executionRoute && observedCwd !== expectedCwd) {
         throw new AppError(`${errorPrefix}_directory_mismatch`, `${label} ${agy ? "launch route" : "Session directory"} does not match the assigned execution workspace`, 1, { expected: expectedCwd, actual: observedCwd, effect: "no_effect", recoverable: false, ...(agy ? { actual_provenance: stringValue(event.cwd_provenance) ?? "unknown" } : {}) });
     }
     const bootstrapStageStart = !shellRefusal && lifecycle?.bootstrapStageStart;
@@ -906,7 +924,7 @@ function handleControlledToolEvent(context, input, event, harness) {
         let inserted = false;
         const receipt = observeLifecycleInvocation(context, {
             currentEventKey: baseKey,
-            command, harness, projectId: project.id, ...(!shellRefusal ? { executionCwd: expectedCwd } : {}), identity: { daemonId, rootSessionId: nativeParentId ?? providerSessionId, sessionId: providerSessionId, parentSessionId: nativeParentId ?? null, toolCallId: toolCallId },
+            command, harness, projectId: project.id, ...(!shellRefusal && workspaceBound ? { executionCwd: expectedCwd } : {}), identity: { daemonId, rootSessionId: nativeParentId ?? providerSessionId, sessionId: providerSessionId, parentSessionId: nativeParentId ?? null, toolCallId: toolCallId },
             recordReceipt: scope => { inserted = persist(scope); return baseKey; }
         });
         const admitted = { ...result(inserted), ...lifecycleObservationResult(receipt), ...(receipt.invocationId ? { invocation_id: receipt.invocationId } : {}) };