@deksden-com/dd-flow-cli 0.9.0-beta.140 → 0.9.0-beta.142

package/dist/services/vnext-protocolize.js

@@ -5,7 +5,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
-import { AppError } from "../shared/errors.js";
+import { AppError, errorRecord, redactDiagnostic, diagnosticJson } from "../shared/errors.js";
 import { projectFeatureWorktreePath, resolveProjectRoot } from "../storage/paths.js";
 import { previewNextEntityId } from "./ids.js";
 import { registerProtocol } from "./protocols.js";
@@ -291,6 +291,7 @@ async function prepareProtocolizeIntent(context, run, resultFile, result, obliga
     const protocolIds = allocateProtocolIds(context, run.project_id, projectRoot, result.delivery.members.map(member => member.slug));
     const psetId = result.delivery.kind === "protocol_set" ? allocatePsetId(context, run.project_id, projectRoot, result.delivery.slug) : null;
     const draft = fs.mkdtempSync(path.join(os.tmpdir(), "dd-flow-protocolize-"));
+    let draftFailure;
     try {
         // A draft must never follow a workspace symlink back into the live tree.
         fs.cpSync(path.join(projectRoot, ".memory-bank"), path.join(draft, ".memory-bank"), { recursive: true, filter: source => !fs.lstatSync(source).isSymbolicLink() });
@@ -321,9 +322,24 @@ async function prepareProtocolizeIntent(context, run, resultFile, result, obliga
             return candidate;
         });
     }
+    catch (error) {
+        draftFailure = error;
+        throw error;
+    }
     finally {
+        cleanupProtocolizeDraft(draft, draftFailure);
+    }
+}
+function cleanupProtocolizeDraft(draft, failure) {
+    try {
         fs.rmSync(draft, { recursive: true, force: true });
     }
+    catch (cleanup) {
+        if (!failure)
+            throw new AppError("protocolize_draft_cleanup_failed", "PROTOCOLIZE draft cleanup failed", 1, { cause: errorRecord(cleanup), draft_path: draft, recoverable: false, effect: "unknown" });
+        const primary = failure;
+        primary.details = { ...primary.details, draft_cleanup_error: errorRecord(cleanup), draft_path: draft, recoverable: false };
+    }
 }
 function readProtocolizeIntent(context, projectId, runId, attempt) {
     const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.protocolize_intent' ORDER BY id DESC", [projectId]);
@@ -465,20 +481,115 @@ async function materialize(projectRoot, runId, runHome, result, obligations, ids
             const absolute = path.resolve(projectRoot, file);
             return created.some((directory) => absolute.startsWith(`${directory}${path.sep}`)) || absolute === psetPath;
         });
-        await runTargetedMemoryBankLint(projectRoot, materializedFiles);
+        await runTargetedMemoryBankLint(projectRoot, materializedFiles, path.join(runHome, "diagnostics"));
         return { files, before: Object.fromEntries([...originals].map(([file, bytes]) => [path.relative(projectRoot, file), bytes === null ? null : sha256(bytes)])) };
     }
     catch (error) {
-        for (const [file, content] of originals) {
-            if (content === null)
-                fs.rmSync(file, { force: true });
-            else
-                fs.writeFileSync(file, content);
+        const primary = error instanceof Error ? error : new AppError("protocolize_materialization_failed", String(error));
+        const facts = {};
+        try {
+            facts.diagnostic_path = captureMaterializationFailure(projectRoot, runHome, [...changed].sort(), primary);
         }
-        for (const dir of created.reverse())
-            fs.rmSync(dir, { recursive: true, force: true });
-        throw error;
+        catch (capture) {
+            facts.capture_error = errorRecord(capture);
+        }
+        const rollback = rollbackMaterialization(projectRoot, originals, created);
+        const target = primary;
+        target.details = { ...target.details, ...facts, rollback,
+            ...(rollback.unrestored.length ? { effect: "unknown", recoverable: false, disposition: "tooling_blocker" } : {}) };
+        throw primary;
+    }
+}
+export function rollbackMaterialization(projectRoot, originals, created) {
+    const restored = [], unrestored = [];
+    const restore = (file, action) => {
+        try {
+            action();
+            restored.push(path.relative(projectRoot, file));
+        }
+        catch (cause) {
+            unrestored.push({ path: path.relative(projectRoot, file), error: errorRecord(cause) });
+        }
+    };
+    for (const [file, content] of originals)
+        restore(file, () => { if (content === null)
+            fs.rmSync(file, { force: true });
+        else
+            fs.writeFileSync(file, content); });
+    for (const dir of [...created].reverse())
+        restore(dir, () => fs.rmSync(dir, { recursive: true, force: true }));
+    return { restored, unrestored };
+}
+export function captureMaterializationFailure(projectRoot, runHome, files, error) {
+    const directory = path.join(runHome, "diagnostics", `protocolize-${crypto.randomUUID()}`);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    let remaining = 1024 * 1024;
+    const documents = files.slice(0, 64).map(relative => {
+        const absolute = path.resolve(projectRoot, relative);
+        if (!absolute.startsWith(`${path.resolve(projectRoot)}${path.sep}`))
+            return { path: relative, unavailable: "outside_workspace" };
+        try {
+            assertNoSymlinkPath(path.resolve(projectRoot), absolute);
+            inside(fs.realpathSync(projectRoot), fs.realpathSync(absolute));
+            const info = fs.lstatSync(absolute);
+            if (!info.isFile())
+                return { path: relative, unavailable: "not_regular_file" };
+            // ponytail: bounded diagnostic hash, never chase a growing live file.
+            // Larger inputs retain a prefix hash explicitly marked incomplete.
+            const hash = crypto.createHash("sha256"), fd = fs.openSync(absolute, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            const chunk = Buffer.alloc(64 * 1024), parts = [];
+            let kept = 0, offset = 0, complete = false;
+            try {
+                const opened = fs.fstatSync(fd);
+                if (!opened.isFile() || opened.dev !== info.dev || opened.ino !== info.ino)
+                    throw new AppError("diagnostic_input_changed", "Diagnostic input changed before capture");
+                const limit = Math.min(opened.size, 1024 * 1024);
+                while (offset < limit) {
+                    const read = fs.readSync(fd, chunk, 0, Math.min(chunk.length, limit - offset), offset);
+                    if (!read)
+                        break;
+                    offset += read;
+                    hash.update(chunk.subarray(0, read));
+                    if (kept < Math.min(remaining, 65536)) {
+                        const part = Buffer.from(chunk.subarray(0, Math.min(read, Math.min(remaining, 65536) - kept)));
+                        parts.push(part);
+                        kept += part.length;
+                    }
+                }
+                const after = fs.fstatSync(fd), current = fs.lstatSync(absolute);
+                complete = offset === opened.size && after.size === opened.size && after.mtimeMs === opened.mtimeMs && after.ctimeMs === opened.ctimeMs
+                    && current.dev === opened.dev && current.ino === opened.ino;
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const content = Buffer.from(redactDiagnostic(Buffer.concat(parts).toString("utf8"))).subarray(0, Math.min(remaining, 65536)).toString("utf8");
+            remaining -= Buffer.byteLength(content);
+            const digest = hash.digest("hex");
+            return { path: relative, sha256: complete ? digest : null, ...(!complete ? { prefix_sha256: digest, hashed_bytes: offset } : {}), hash_complete: complete, size: info.size, truncated: kept < info.size, content };
+        }
+        catch (cause) {
+            return { path: relative, unavailable: errorRecord(cause) };
+        }
+    });
+    const file = path.join(directory, "failure.json");
+    const capture = { schema_id: "dd-flow/protocolize-failure@1", error: errorRecord(error), documents, omitted_documents: Math.max(0, files.length - documents.length) };
+    let bytes = diagnosticJson(capture);
+    while (Buffer.byteLength(bytes) > 1024 * 1024) {
+        const contentLength = (document) => "content" in document ? String(document.content ?? "").length : 0;
+        const largest = documents.filter(document => contentLength(document) > 0).sort((a, b) => contentLength(b) - contentLength(a))[0];
+        if (largest && "content" in largest) {
+            largest.content = String(largest.content).slice(0, Math.floor(String(largest.content).length / 2));
+            largest.truncated = true;
+        }
+        else {
+            documents.pop();
+            capture.omitted_documents++;
+        }
+        bytes = diagnosticJson(capture);
     }
+    fs.writeFileSync(file, bytes, { flag: "wx", mode: 0o600 });
+    return file;
 }
 function protocolMarkdown(id, member, blockedBy, runId, psetPath, featurePath, result, obligations, rawIntakePath) {
     const a = member.primary_acceptance;

package/dist/services/worktrees.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { flowContractForState } from "../domain/flow-contract.js";
 import { requireStage } from "../domain/validation.js";
-import { AppError } from "../shared/errors.js";
+import { AppError, processEvidence, redactDiagnostic } from "../shared/errors.js";
 import { canonicalPath, projectCheckoutRoot, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
@@ -259,20 +259,23 @@ function activeWorktreeRecord(context, projectId, protocolId) {
 async function runExternal(command) {
     const [bin, ...args] = command;
     if (!bin) {
-        return { exit_code: null, stdout: "", stderr: "Missing executable." };
+        return { exit_code: null, signal: null, stdout: "", stderr: "Missing executable." };
     }
     const result = await commandResult(bin, args, { startupMs: SETUP_STARTUP_MS });
+    const evidence = processEvidence(result);
     return {
         exit_code: result.exit_code,
-        stdout: sanitizeOutput(result.stdout),
-        stderr: sanitizeOutput(result.stderr)
+        signal: result.signal,
+        stdout: result.exit_code === 0 && !result.signal ? sanitizeOutput(result.stdout) : evidence.stdout.text,
+        stderr: evidence.stderr.text,
+        output_truncated: { stdout: result.exit_code !== 0 && evidence.stdout.truncated, stderr: evidence.stderr.truncated }
     };
 }
 function sanitizeCommand(command) {
     return command.map((part) => (part.includes("=") ? part.replace(/=.*/, "=<redacted>") : part));
 }
 function sanitizeOutput(value) {
-    return value.replace(/(token|secret|password)=\S+/gi, "$1=<redacted>");
+    return redactDiagnostic(value);
 }
 function parseWorktrunkResponse(stdout, command) {
     let parsed;

package/dist/shared/errors.js

@@ -1,4 +1,5 @@
-import { errorRecord as nativeErrorRecord } from "../harness-runtime/lib/operation-errors.mjs";
+import { errorRecord as nativeErrorRecord, redactDiagnostic } from "../harness-runtime/lib/operation-errors.mjs";
+export { redactDiagnostic, diagnosticJson } from "../harness-runtime/lib/operation-errors.mjs";
 export class AppError extends Error {
     code;
     exitCode;
@@ -29,3 +30,12 @@ export function errorRecord(error, depth = 0) {
 export function isAppError(error) {
     return error instanceof AppError;
 }
+/** Bounded process diagnostics are observations, never command/retry authority. */
+export function processEvidence(result) {
+    const excerpt = (value, limit) => {
+        const safe = redactDiagnostic(value), bytes = Buffer.from(safe);
+        return { text: new TextDecoder().decode(bytes.subarray(0, limit), { stream: true }), truncated: bytes.length > limit, bytes: bytes.length };
+    };
+    return { exit_code: result.exit_code, signal: result.signal ?? null,
+        stdout: excerpt(result.stdout, 8192), stderr: excerpt(result.stderr, 16384) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.140",
+  "version": "0.9.0-beta.142",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",