@deksden-com/dd-flow-cli 0.9.0-beta.121 → 0.9.0-beta.123

package/dist/services/vnext-plan.js

@@ -21,6 +21,7 @@ import { acceptStageReport, prepareStageReport } from "./stage-report-renderer.j
 import { applyExternalStageContext, prepareExternalStageContext } from "./stage-context.js";
 import { subagentCapacityKey } from "./vnext-fanout.js";
 import { stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
+import { prepareRunVerificationMatrix, acceptVerificationMatrix, commitVerificationMatrixStart, verificationMatrixInstruction } from "./verification-matrix.js";
 export function isVnextPlanRun(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return Boolean(context.db.get("SELECT id FROM runs WHERE project_id = ? AND id = ? AND flow_kind = 'vnext_protocolize'", [project.id, input.runId]));
@@ -41,7 +42,7 @@ export function prepareVnextPlanStart(context, input) {
     const { profile: codeCheckProfile } = readCodeCheckProfile(run.workspace_root);
     if (context.db.get("SELECT 1 FROM works WHERE project_id = ? AND run_id = ? AND task = ? AND status = 'running'", [project.id, run.id, planTask]))
         throw new AppError("invalid_work_state", "PLAN already has a running Work", 1, { run_id: run.id });
-    prepareFlowRunStageAttachment(context, { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" });
+    const attachment = prepareFlowRunStageAttachment(context, { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" });
     const root = path.join(home, vnextStageDirectory("plan"));
     if (input.externalContext)
         prepareExternalStageContext({ stageRoot: root, loaded: input.externalContext });
@@ -58,12 +59,16 @@ export function prepareVnextPlanStart(context, input) {
     const git = gitFacts(run.workspace_root);
     for (const file of [...planPaths, ...mapPaths, ...["stage-prompt.md", "work-context.json", "fixture-root.prompt.md"].map(name => path.join(root, name))])
         prepareOutputFile(file);
-    return { projectRoot, project, run, home, root, rootWork, workspaceRoute, protocols, template, codeCheckProfile, planPaths, mapPaths, owned, identities, aspects, runVariables, mergeRequired, git };
+    const matrix = prepareRunVerificationMatrix(context, { projectId: project.id, runId: run.id, stage: "plan", role: "input", stageAttempt: attachment.attempt });
+    return { projectRoot, project, run, home, root, rootWork, workspaceRoute, protocols, template, codeCheckProfile, planPaths, mapPaths, owned, identities, aspects, runVariables, mergeRequired, git, matrix };
 }
 export function startVnextPlan(context, input, prepared = prepareVnextPlanStart(context, input)) {
     const { projectRoot, project, run, root, rootWork, workspaceRoute, protocols, template, codeCheckProfile, planPaths, mapPaths, owned, identities, aspects, runVariables, mergeRequired, git, home } = prepared;
     ensureWorkRegistry(context);
     assertStageStartHookEvent(context, { projectId: project.id, eventKey: input.hookEventId, runId: run.id, stage: "plan", projectRoot, ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
+    if (context.db.get("SELECT 1 FROM works WHERE project_id = ? AND run_id = ? AND task = ? AND status = 'running'", [project.id, run.id, planTask]))
+        throw new AppError("invalid_work_state", "PLAN already has a running Work", 1, { run_id: run.id });
+    prepareFlowRunStageAttachment(context, { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" }, true);
     fs.mkdirSync(root, { recursive: true });
     const now = context.now();
     // Imported stage fixtures have a synthetic running root with no prior agent.
@@ -113,9 +118,13 @@ export function startVnextPlan(context, input, prepared = prepareVnextPlanStart(
         : `PLAN-REVIEW mode is ${planReviewMode}: include review groups only for genuinely applicable aspects; an empty set is allowed.`;
     fs.writeFileSync(promptPath, `${prompt}\n<review_mode_rule>${reviewModeRule}</review_mode_rule>\n<verification_rule>Every flow check must be an autonomous executable command. Do not declare external/manual proof or a human review as a check, evidence substitute, DEF, or gate. The only user interaction supported by this flow is an explicit stage pause for a material unanswered question.</verification_rule>\n${stageLifecycleInstruction}\n`);
     const externalContext = applyExternalStageContext({ stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
+    if (prepared.matrix)
+        fs.appendFileSync(promptPath, verificationMatrixInstruction(prepared.matrix.metadata, home, "designing the source PLAN and its tests"));
     fs.writeFileSync(path.join(root, "work-context.json"), JSON.stringify({ schema_id: "dd-flow/work-context@1", system: { run_id: run.id, work_id: planWorkId, stage: "plan" }, workspace: { project_root: projectRoot, workspace_root: run.workspace_root, stage_root: root }, artifacts: artifactMaterialization, input: { protocols, owned_obligations: Object.fromEntries(owned) } }, null, 2));
     const binding = bindStageCoordinatorWork(context, { workId: planWorkId, hookEventId: input.hookEventId, stage: "plan", promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
-    attachFlowRunStage(context, { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" });
+    const attachmentInput = { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" };
+    const attachment = prepareFlowRunStageAttachment(context, attachmentInput);
+    commitVerificationMatrixStart(context, prepared.matrix, () => attachFlowRunStage(context, attachmentInput, attachment));
     const workSessionId = String(binding.work_session_id);
     const sessionId = String(binding.session_id);
     refreshRunWorkProjection(context, project.id, run.id);
@@ -169,6 +178,9 @@ function finishVnextPlanOwned(context, input) {
         plan_checksums: planFiles.map((file) => ({ path: path.relative(run.workspace_root, file).split(path.sep).join("/"), sha256: checksum(file) })),
         aspect_map_checksums: mapFiles.map((file) => ({ path: path.relative(home, file).split(path.sep).join("/"), sha256: checksum(file) }))
     });
+    const matrix = prepareRunVerificationMatrix(context, { projectId: project.id, runId: run.id, stage: "plan", role: "output" });
+    if (matrix)
+        Object.assign(report.semantic, { verification_matrix: matrix.metadata });
     const preparedReport = prepareStageReport(report);
     validateSchema({ schemaName: "stage-report", file: path.join(root, "stage-report.json"), data: preparedReport.normalized, projectRoot, ddFlowHome: context.ddFlowHome, runId: run.id, runRoot: home });
     const completionInput = { projectRoot, runId: run.id, stage: "plan", status: "done", data: "stage-report.json", dataSchemaId: "dd-flow/stage-report@1", report: "stage-report.md", stageReport: "stage-report.html", dataSha256: preparedReport.sha256, git: report.mechanical.git };
@@ -179,6 +191,7 @@ function finishVnextPlanOwned(context, input) {
             throw new AppError("invalid_work_state", "PLAN Work changed during finish preparation", 1);
         context.db.run("UPDATE works SET status = 'completed', result = ?, completed_at = ?, updated_at = ? WHERE work_id = ?", ["PLAN accepted; awaiting PLAN-REVIEW", now, now, work.work_id]);
         context.db.run("UPDATE work_sessions SET status = 'completed', result_path = ?, updated_at = ?, completed_at = ? WHERE id = ?", [path.join(root, "stage-report.json"), now, now, workSession.id]);
+        acceptVerificationMatrix(context, matrix);
         acceptStageReport(context, { projectId: project.id, runId: run.id, stage: "plan", root, prepared: preparedReport });
         completeFlowRunStage(context, completionInput, preparedCompletion);
         refreshRunWorkProjection(context, project.id, run.id);

package/dist/services/work-registry.js

@@ -25,6 +25,7 @@ import { prepareError, prepareJsonFile } from "../cli/input-preparation.js";
 import { lifecycleRetryInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 import { acceptedDecisionPrecedence } from "./stage-context.js";
 import { reviewEnvironmentAllowed, reviewExecutionCopyHash, reviewSourceHash, reviewSourcePaths } from "./review-copy.js";
+import { latestRunVerificationMatrix, verificationMatrixInstruction, verificationMatrixContract } from "./verification-matrix.js";
 const workColumns = "work_id, project_id, run_id, parent_work_id, task, launch_policy, result_schema, payload_json, depends_on_json, status, result, created_at, started_at, updated_at, completed_at";
 export function ensureWorkRegistry(context) { context.db.exec("SELECT 1 FROM works LIMIT 1"); context.db.exec("SELECT 1 FROM work_sessions LIMIT 1"); }
 function ownsPhysicalWorkSession(context, projectId, owner, identity) {
@@ -986,6 +987,16 @@ function assertSharedReviewInput(context, work, run, generation = recoveryGuard(
         if (value.cycle !== payload?.review_cycle)
             throw new AppError("review_input_invalid", "CODE-REVIEW cycle differs from its Work", 1);
     }
+    const matrix = latestRunVerificationMatrix(context, work.project_id, work.run_id, String(kind), "input");
+    const marked = JSON.parse(context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [work.project_id, work.run_id]).index_json).verification_matrix_contract === verificationMatrixContract;
+    if (marked && !matrix)
+        throw new AppError("review_input_contract_missing", "Marked reviewer Stage lacks its immutable matrix baseline", 1, { stage: kind });
+    if (matrix) {
+        add("run", matrix.metadata.json.path, matrix.metadata.json.sha256);
+        add("run", matrix.metadata.markdown.path, matrix.metadata.markdown.sha256);
+    }
+    for (const item of value.reviewer_inputs ?? [])
+        add("workspace", item.path, item.sha256);
     const runInputs = [...expected].map(([key, sha]) => { const [root, ...parts] = key.split(":"); return { root: root, path: parts.join(":"), sha256: sha }; }).sort((a, b) => `${a.root}:${a.path}`.localeCompare(`${b.root}:${b.path}`));
     for (const item of runInputs) {
         const target = reviewInputPath(item.root === "run" ? home : run.workspace_root, item.path);
@@ -1236,7 +1247,10 @@ export function validateReviewResolutions(workId, assigned, resolutions) {
 }
 function renderWorkerPrompt(context, work, run, dependencies, commands) {
     const body = renderWorkerPromptBody(context, work, run, dependencies, commands);
-    return ["<accepted_decision_precedence>", `Read ${path.join(requireRunHome(run), "01-specify", "specify.json")} and later accepted RUN decisions relevant to this Work.`, acceptedDecisionPrecedence, "</accepted_decision_precedence>", "", body].join("\n");
+    const kind = parsePayload(work)?.kind;
+    const matrixStage = kind === "plan-review" || kind === "code-review" ? kind : codePacket(work) ? "code" : null;
+    const matrix = matrixStage ? latestRunVerificationMatrix(context, work.project_id, work.run_id, matrixStage, kind === "plan-review" || kind === "code-review" ? "input" : undefined) : null;
+    return ["<accepted_decision_precedence>", `Read ${path.join(requireRunHome(run), "01-specify", "specify.json")} and later accepted RUN decisions relevant to this Work.`, acceptedDecisionPrecedence, "</accepted_decision_precedence>", "", body, verificationMatrixInstruction(matrix?.metadata ?? null, requireRunHome(run), `assigned Work ${work.work_id}`)].join("\n");
 }
 function workerLifecycleCommands(context, work, run) {
     const resultInputPath = path.join(requireRunHome(run), "works", work.work_id, "result-input.json");

package/dist/storage/database.js

@@ -331,7 +331,16 @@ export function ensureWorkLaunchStorage(db) {
     CREATE INDEX IF NOT EXISTS idx_work_launches_status ON work_launches(status, updated_at DESC);
   `);
 }
-export function getDatabase(ddFlowHome, mode = "initialize", importPermitId) {
+export function getDatabase(ddFlowHome, mode = "initialize", importPermitId, hookDeadlineAt) {
+    if (hookDeadlineAt !== undefined && (!Number.isSafeInteger(hookDeadlineAt) || mode !== "hook"))
+        throw new AppError("hook_deadline_invalid", "Hook deadline must be a finite absolute millisecond deadline", 1, { effect: "unknown" });
+    const deadline = hookDeadlineAt === undefined ? undefined : (phase) => {
+        const remaining = hookDeadlineAt - Date.now();
+        if (remaining <= 0)
+            throw new AppError("native_hook_timeout", "Native hook deadline expired before durable admission", 1, { phase, deadline_at: hookDeadlineAt, effect: "unknown" });
+        return Math.max(1, Math.min(4000, remaining));
+    };
+    deadline?.("store_open");
     if (mode !== "read_existing")
         assertImportAdmission(ddFlowHome, importPermitId);
     const dbPath = path.join(ddFlowHome, "db.sqlite");
@@ -344,7 +353,12 @@ export function getDatabase(ddFlowHome, mode = "initialize", importPermitId) {
     if (!exists || mode === "migrate")
         ensureDir(ddFlowHome);
     const db = mode === "read_existing" ? new DatabaseSync(dbPath, { readOnly: true }) : new DatabaseSync(dbPath);
-    db.exec("PRAGMA busy_timeout = 4000");
+    try {
+        db.exec(`PRAGMA busy_timeout = ${deadline?.("store_open") ?? 4000}`);
+    }
+    catch (error) {
+        return closeAfterOpenFailure(db, error);
+    }
     if (mode !== "read_existing") {
         try {
             registerStoreWriter(db);
@@ -354,7 +368,7 @@ export function getDatabase(ddFlowHome, mode = "initialize", importPermitId) {
         }
     }
     try {
-        configureDatabase(db, mode);
+        configureDatabase(db, mode, deadline);
     }
     catch (error) {
         return closeAfterOpenFailure(db, error);
@@ -374,6 +388,7 @@ export function getDatabase(ddFlowHome, mode = "initialize", importPermitId) {
                 migrateSessionStorageKeys(db, dbPath);
             }
             else {
+                deadline?.("store_validation");
                 assertHookStoreReady(db);
             }
         }
@@ -384,7 +399,7 @@ export function getDatabase(ddFlowHome, mode = "initialize", importPermitId) {
     if (mode === "read_existing")
         db.exec("PRAGMA query_only = ON");
     db.exec("PRAGMA foreign_keys = ON");
-    return databaseFacade(dbPath, mode !== "read_existing", db);
+    return databaseFacade(dbPath, mode !== "read_existing", db, undefined, deadline);
 }
 /**
  * Hook ingress is a hot, synchronous path.  It may write receipts, but it
@@ -554,7 +569,7 @@ function emptyReadOnlyDatabase(dbPath) {
         all: () => []
     };
 }
-function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
+function databaseFacade(dbPath, writable, db, close = () => db.close?.(), deadline) {
     let reserved = false;
     let poisoned = false;
     let closed = false;
@@ -567,6 +582,14 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
     let manualFrames = [];
     let readDepth = 0;
     const writerTiming = channel("dd-flow.sqlite.writer");
+    const ingressPhase = channel("dd-flow.sqlite.ingress");
+    const bound = (phase) => {
+        const remaining = deadline?.(phase);
+        if (remaining !== undefined)
+            db.exec(`PRAGMA busy_timeout = ${remaining}`);
+        if (ingressPhase.hasSubscribers)
+            ingressPhase.publish({ phase, ...(remaining !== undefined ? { remaining_ms: remaining } : {}) });
+    };
     const publishCommitted = () => {
         const pending = afterCommit;
         afterCommit = [];
@@ -584,8 +607,11 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
             throw new AppError("read_snapshot_write", "Cannot reserve a writer inside a read snapshot", 1);
         if (!writable)
             throw new AppError("read_only_storage", "Read-only access cannot start a write transaction", 1, { path: dbPath });
+        bound("writer_reservation");
         db.exec("BEGIN IMMEDIATE");
         reserved = true;
+        if (ingressPhase.hasSubscribers)
+            ingressPhase.publish({ phase: "writer_reserved" });
     };
     const rollback = (sql, original) => {
         try {
@@ -626,6 +652,8 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
                 beginWriteTransaction();
         }
         catch (error) {
+            if (error instanceof AppError)
+                throw error;
             throw new AppError("storage_write_failed", "Cannot reserve SQLite writer", 1, { cause: errorDetails(error), transaction_phase: "begin", transaction_rolled_back: true });
         }
         let phase = "body";
@@ -636,11 +664,14 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
                 throw new AppError("write_transaction_async", "Write transaction callback must be synchronous", 1);
             }
             phase = "commit";
+            bound("commit");
             if (nested)
                 db.exec(`RELEASE ${marker}`);
             else
                 db.exec("COMMIT");
             phase = "committed";
+            if (ingressPhase.hasSubscribers)
+                ingressPhase.publish({ phase: "committed" });
             if (!nested && writerTiming.hasSubscribers)
                 writerTiming.publish({ operation: operationName, wall_time_ms: performance.now() - startedAt, path: dbPath });
             if (!nested)
@@ -786,22 +817,25 @@ function databaseFacade(dbPath, writable, db, close = () => db.close?.()) {
                 executePublications([operation]);
         } },
         run: (sql, params = []) => { assertUsable(); if (readDepth)
-            throw new AppError("read_snapshot_write", "Cannot write inside a read snapshot", 1); return db.prepare(sql).run(...params); },
-        get: (sql, params = []) => { assertUsable(); return db.prepare(sql).get(...params); },
-        all: (sql, params = []) => { assertUsable(); return db.prepare(sql).all(...params); }
+            throw new AppError("read_snapshot_write", "Cannot write inside a read snapshot", 1); bound("write"); return db.prepare(sql).run(...params); },
+        get: (sql, params = []) => { assertUsable(); bound("lookup"); return db.prepare(sql).get(...params); },
+        all: (sql, params = []) => { assertUsable(); bound("lookup"); return db.prepare(sql).all(...params); }
     };
 }
 function errorDetails(error) {
     const value = error;
     return { message: String(value?.message ?? error), ...(typeof value?.code === "string" ? { code: value.code } : {}), ...(typeof value?.errcode === "number" ? { sqlite_extended_code: value.errcode } : {}) };
 }
-function configureDatabase(db, mode) {
+function configureDatabase(db, mode, ingressDeadline) {
     if (mode !== "read_existing") {
         // Concurrent first openers can collide while changing journal mode, even
         // with busy_timeout set. Retrying this configuration does not replay writes.
         const deadline = performance.now() + 4000, pause = new Int32Array(new SharedArrayBuffer(4));
         for (;;) {
             try {
+                const remaining = ingressDeadline?.("store_configuration");
+                if (remaining !== undefined)
+                    db.exec(`PRAGMA busy_timeout = ${remaining}`);
                 const current = db.prepare("PRAGMA journal_mode").get();
                 if (current.journal_mode !== "wal")
                     db.exec("PRAGMA journal_mode = WAL");

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.121",
+  "version": "0.9.0-beta.123",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
+  "packageManager": "pnpm@10.23.0",
   "bin": {
     "dd-flow": "dist/cli.js",
     "dd-codex": "dist/harness-runtime/bin/dd-codex.mjs",
@@ -49,6 +50,8 @@
     "ajv": "^8.20.0",
     "shell-quote": "^1.10.0",
     "smol-toml": "^1.6.1",
+    "tree-sitter": "0.25.1",
+    "tree-sitter-bash": "0.25.1",
     "yaml": "^2.9.0"
   },
   "publishConfig": {