dsh-doublecheck 0.9.30 → 0.9.31

package/lib/grill/index.js

@@ -348,6 +348,7 @@ export function apply(ctx, config) {
                         ],
                         required: true,
                     },
+                    verificationNote: { oneOf: [{ type: 'string' }, { type: 'null' }], required: true },
                     path: { oneOf: [{ type: 'string' }, { type: 'null' }], required: true },
                     written: { type: 'boolean', required: true },
                 },
@@ -365,13 +366,14 @@ export function apply(ctx, config) {
                 ? { spec: null, testRuns: { failed: 0, passed: 0 }, timeline: [], edits: 0, review: null }
                 : foldReportFacts(sessionEvents(session), reportDetection);
             const verify = args.verify ?? config.reportVerify;
-            const verification = verify
+            const attempt = verify
                 ? await runVerifyWorkflow(ctx, config, facts.spec, exec)
-                : null;
+                : { verification: null, note: null };
             const report = {
                 ...facts,
-                verdict: deriveReportVerdict(facts, verification),
-                verification,
+                verdict: deriveReportVerdict(facts, attempt.verification),
+                verification: attempt.verification,
+                verificationNote: attempt.note,
                 path: null,
                 written: false,
             };
@@ -379,7 +381,7 @@ export function apply(ctx, config) {
             report.path = outcome.path;
             report.written = outcome.written;
             if (session !== undefined) {
-                ctx.emit('doublecheck/report', { session, verdict: report.verdict, verification, path: report.path, written: report.written });
+                ctx.emit('doublecheck/report', { session, verdict: report.verdict, verification: report.verification, verificationNote: report.verificationNote, path: report.path, written: report.written });
             }
             return report;
         },
@@ -394,19 +396,65 @@ export function apply(ctx, config) {
     }));
 }
 /**
- * Run the per-dimension verification workflow through the workflow seam,
- * when one is mounted. A missing seam or a non-completed run settles as
- * `null` (no verification) — the report states it did not run.
- * @returns the settled checks with the completeness flag, or null when
- * verification did not run at all.
+ * Resolve the workflow engine for this call.
+ *
+ * A profile-level bundle row lives in the Host realm, but the web profile
+ * mounts the engine inside the calling preset's isolated `delegation` group,
+ * so `ctx.get('workflowEngine')` from the plugin context returns undefined
+ * even though the service is registered. `agentPresets.serviceFor()` is the
+ * host's explicit cross-realm accessor (it inspects the agent's retained
+ * composition), so it is tried first; the plain lookup stays as the fallback
+ * for profiles that mount the engine on the host plane.
+ * @param ctx - the plugin context (Host/profile realm).
+ * @param agent - the calling agent, when the tool call has one.
+ * @returns the engine, or a human-readable reason it is unreachable.
+ */
+function resolveWorkflowEngine(ctx, agent) {
+    const presets = ctx.get('agentPresets');
+    if (agent?.ctx !== undefined && typeof presets?.serviceFor === 'function') {
+        try {
+            const scoped = presets.serviceFor(agent, 'workflowEngine');
+            if (scoped !== undefined)
+                return { engine: scoped };
+        }
+        catch (error) {
+            ctx.logger.debug(`dsh-doublecheck: preset workflowEngine lookup failed: ${String(error)}`);
+        }
+    }
+    const host = ctx.get('workflowEngine');
+    if (host !== undefined)
+        return { engine: host };
+    return {
+        why: presets === undefined
+            ? 'the agent-preset registry is not mounted and the host plane has no workflowEngine'
+            : typeof presets.serviceFor !== 'function'
+                ? 'the mounted agentPresets service has no serviceFor() and the host plane has no workflowEngine'
+                : 'the calling agent preset does not mount a workflow engine (standard/cordis enable workflow-ptc; ptc/minimal do not) and the host plane has none',
+    };
+}
+/**
+ * Run the per-dimension verification workflow through the workflow seam.
+ *
+ * Every way this can fail — no spec, no agent, an engine that is unreachable
+ * from this realm, a rejected start, an early stop, a malformed value, a
+ * rejected result — settles as `verification: null` plus a note that the
+ * report renders. A missing seam must not fail the report call itself, but it
+ * must not look like "the checks all passed and there was nothing to say"
+ * either.
+ * @returns the settled checks, or null verification with the reason.
  */
 async function runVerifyWorkflow(ctx, config, spec, exec) {
-    if (spec === null || exec.agent === undefined)
-        return null;
-    const engine = ctx.get('workflowEngine');
+    if (spec === null) {
+        return { verification: null, note: 'no committed spec is on record; record one with doublecheck_spec before verification' };
+    }
+    if (exec.agent === undefined) {
+        return { verification: null, note: 'the call has no owning agent, so no agent preset can supply a workflow engine' };
+    }
+    const { engine, why } = resolveWorkflowEngine(ctx, exec.agent);
     if (engine === undefined) {
-        ctx.logger.warn('dsh-doublecheck: verification skipped: the workflowEngine seam is not mounted');
-        return null;
+        const note = `verification did not run: ${why}`;
+        ctx.logger.warn(`dsh-doublecheck: ${note}`);
+        return { verification: null, note };
     }
     let run;
     try {
@@ -423,16 +471,20 @@ async function runVerifyWorkflow(ctx, config, spec, exec) {
     catch (error) {
         // Invalid script/meta or an absent verify provider: verification did not
         // run, and the report states so instead of failing the report itself.
-        ctx.logger.warn(`dsh-doublecheck: verification workflow rejected: ${String(error)}`);
-        return null;
+        const note = `verification did not run: the workflow engine rejected the verify run: ${String(error)}`;
+        ctx.logger.warn(`dsh-doublecheck: ${note}`);
+        return { verification: null, note };
     }
     try {
         const result = await run.result;
-        if (result.stopReason !== 'completed')
-            return null;
+        if (result.stopReason !== 'completed') {
+            const detail = result.error === undefined ? '' : `: ${result.error}`;
+            return { verification: null, note: `verification did not run: the verify workflow stopped with "${result.stopReason}" before completing${detail}` };
+        }
         const value = result.value;
-        if (value === null || value === undefined || !Array.isArray(value.checks))
-            return null;
+        if (value === null || value === undefined || !Array.isArray(value.checks)) {
+            return { verification: null, note: 'verification did not run: the verify workflow completed without a structured checks array' };
+        }
         const checks = [];
         for (const check of value.checks) {
             if (!VERIFY_DIMENSIONS.includes(check.dimension))
@@ -443,17 +495,23 @@ async function runVerifyWorkflow(ctx, config, spec, exec) {
         // judged here so a checker that silently dropped a dimension cannot
         // upgrade the delivery.
         const complete = VERIFY_DIMENSIONS.every(dimension => checks.some(check => check.dimension === dimension));
-        return { checks, complete };
+        return { verification: { checks, complete }, note: null };
     }
     catch (error) {
         // A broken workflow engine must not fail the report call itself: the
         // delivery settles as unverified and the markdown says verification did
-        // not run.
-        ctx.logger.warn(`dsh-doublecheck: verification workflow failed: ${String(error)}`);
-        return null;
+        // not run, with the reason.
+        const note = `verification did not run: the verify workflow failed: ${String(error)}`;
+        ctx.logger.warn(`dsh-doublecheck: ${note}`);
+        return { verification: null, note };
     }
     finally {
-        await run.dispose();
+        try {
+            await run.dispose();
+        }
+        catch (error) {
+            ctx.logger.warn(`dsh-doublecheck: verify run disposal failed: ${String(error)}`);
+        }
     }
 }
 /** Write the report markdown through the filesystem seam, when one exists. */

package/lib/guard/command.js

@@ -113,6 +113,7 @@ export function doublecheckHandler(deps) {
                 ...facts,
                 verdict: deriveReportVerdict(facts, null),
                 verification: null,
+                verificationNote: null,
                 path: null,
                 written: false,
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-doublecheck",
-  "version": "0.9.30",
+  "version": "0.9.31",
   "description": "Delivery quality gate for DeepSeek Harness: grill the requirements, test the implementation, prove the delivery, and gate the handoff with a deliverable/rework decision.",
   "packageManager": "pnpm@11.7.0",
   "repository": {