@davidorex/pi-agent-dispatch 0.28.0

package/dist/read-truncation-gate.d.ts

@@ -0,0 +1,143 @@
+/**
+ * read-truncation-gate — pi.on('tool_result', handler) registered from
+ * the pi-agent-dispatch extension factory that intercepts pi's built-in
+ * `read` tool responses when the underlying TruncationResult signals
+ * truncation, and REPLACES the content payload entirely with a single
+ * text item carrying a hard-refusal directive.
+ *
+ * Canonical model: the pi.on('tool_result') boundary mirrors the auth-
+ * gate's tool_call boundary — it runs at the pi-dispatch layer, after
+ * the tool's execute() body has produced its result, and before the
+ * LLM sees the result. Returning a ToolResultEventResult with `content`
+ * set REPLACES the corresponding event field entirely (no merge); the
+ * agent never sees the original (truncated head) content. The directive
+ * IS the content, so the agent cannot skim past it — there is no head
+ * to skim. The phrasing pattern (⚠️ prefix, INCOMPLETE / "do NOT"
+ * framing, explicit-next-action guidance naming concrete tools + params)
+ * mirrors pi-context's serializeForRead overCapDirective canon at
+ * read-element.ts:222-245, which proved itself across the typed-read
+ * surfaces (read-block-page / read-schema / read-samples-catalog).
+ *
+ * Why pi's built-in marker is insufficient: pi's read tool appends a
+ * single text marker at end-of-content on truncation (the marker IS
+ * structured + carries a continuation hint via `offset=N`), but its
+ * end-of-content position is trivially skimmable — LLMs scan content
+ * for the substantive bit they want and miss the marker. Empirically,
+ * an in-pi LLM reading a large file gets the head and proceeds with
+ * incomplete content as if it had the whole file. This handler closes
+ * that gap by making the directive the entire visible response.
+ *
+ * Coexists with auth-gate: that handler registers on pi.on('tool_call')
+ * for the substrate-write authorization surface; this handler registers
+ * on pi.on('tool_result') for the read-output integrity surface. The
+ * two events are orthogonal and the handlers do not interfere.
+ *
+ * No-op for non-read tools and for non-truncated read results — handler
+ * returns undefined, leaving the original event payload untouched.
+ */
+import type { ExtensionAPI, ExtensionContext, ToolResultEvent } from "@earendil-works/pi-coding-agent";
+/**
+ * Local mirror of pi's internal `ToolResultEventResult` shape (not
+ * re-exported from the SDK index.d.ts at present; declared at
+ * `node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/types.d.ts:726-730`).
+ * Carrying a local interface keeps the handler-return contract typed at
+ * the dispatch module without reaching into the SDK's internal-types
+ * subpath, which is not part of its public surface contract.
+ *
+ * Field semantics per the SDK: any field set REPLACES the corresponding
+ * event field entirely (no merge); omitted fields are left untouched.
+ */
+interface ToolResultGateOutcome {
+    content?: {
+        type: "text";
+        text: string;
+    }[];
+    details?: unknown;
+    isError?: boolean;
+}
+/**
+ * Minimal projection of pi's TruncationResult carrying the fields the
+ * directive renders. Mirrors the canonical shape declared at
+ * `node_modules/@earendil-works/pi-coding-agent/dist/core/tools/truncate.d.ts`
+ * — kept as a local interface (rather than a deep import) so the
+ * dispatch module is not coupled to an internal pi tool-types path
+ * that may shift across pi versions; the field set is the public
+ * contract on details.truncation.
+ */
+export interface TruncationProjection {
+    truncated: boolean;
+    truncatedBy?: "lines" | "bytes" | null;
+    outputLines?: number;
+    totalLines?: number;
+    outputBytes?: number;
+    totalBytes?: number;
+    maxLines?: number;
+    maxBytes?: number;
+    lastLinePartial?: boolean;
+    firstLineExceedsLimit?: boolean;
+}
+/**
+ * Pure function that constructs the directive text from the pi read
+ * tool call input + the structured TruncationResult. No I/O; identical
+ * inputs yield identical output. Exported separately from the handler
+ * so unit tests can drive directive composition in isolation.
+ *
+ * Renders:
+ *   - the file path (from `input.path`; defaults to "<unknown>" if the
+ *     input shape is unexpectedly empty — defensive guard, not a
+ *     contract);
+ *   - the truncation accounting (outputLines / totalLines and
+ *     outputBytes / totalBytes; numeric fields rendered with a default
+ *     of "?" if absent so a partial TruncationResult still produces a
+ *     readable directive);
+ *   - variant-conditional next-action guidance:
+ *       * firstLineExceedsLimit=true: pagination via `offset=N` is
+ *         operationally meaningless (offset=0 re-fires the same
+ *         truncation; offset>=1 jumps past the unreadable line losing
+ *         content); the directive instead names `grep` for targeted
+ *         search + bash `sed -n '<line>p' <path> | head -c <bytes>`
+ *         for byte-range slicing of the over-long single line.
+ *       * truncatedBy='bytes' (without firstLineExceedsLimit): the
+ *         byte cap fired (not line cap); paginating by line offset may
+ *         again exceed the byte cap on the next page with no agent
+ *         signal — directive surfaces this risk + prefers `grep`.
+ *       * truncatedBy='lines' (default): line cap fired; offset-by-
+ *         outputLines pagination works predictably.
+ *   - lastLinePartial=true clause (when set): warns the agent the
+ *     terminal characters of the returned content were cut mid-content
+ *     and should not be trusted (mid-JSON-object, mid-source-
+ *     expression, mid-log-entry); placed AFTER the truncation summary
+ *     + BEFORE the next-action clauses.
+ *
+ * The "The truncated head is NOT returned" sentence enforces the
+ * hard-refusal semantic at the language level — it signals the agent
+ * that the directive IS the entire response payload, not a header
+ * followed by content.
+ */
+export declare function buildTruncationDirective(input: Record<string, unknown> | undefined, truncation: TruncationProjection): string;
+/**
+ * The pi.on('tool_result') handler. Exported separately from the
+ * registration helper so unit tests can invoke it directly with a mock
+ * event and mock context, without driving a real pi extension factory.
+ *
+ * Returns:
+ *   - `undefined` (pass-through) when toolName !== "read";
+ *   - `undefined` (pass-through) when details.truncation is absent or
+ *     truncation.truncated is false (the read was complete);
+ *   - `{ content, isError }` REPLACING the event payload when the read
+ *     was truncated. `isError` is set false because the read itself
+ *     succeeded — only its completeness is at issue; raising isError
+ *     would surface as a tool failure to the LLM and trigger error-
+ *     handling paths instead of the canonical "use offset / use grep"
+ *     guidance the directive carries.
+ */
+export declare function readTruncationGateHandler(event: ToolResultEvent, _ctx: ExtensionContext): Promise<ToolResultGateOutcome | undefined>;
+/**
+ * Register the read-truncation-gate handler on a pi extension API.
+ * Single line at the factory call-site. Idempotent registration is the
+ * responsibility of the caller (the extension factory runs once per pi
+ * process; double-registration would produce duplicate replacements).
+ */
+export declare function registerReadTruncationGate(pi: ExtensionAPI): void;
+export {};
+//# sourceMappingURL=read-truncation-gate.d.ts.map

package/dist/read-truncation-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-truncation-gate.d.ts","sourceRoot":"","sources":["../src/read-truncation-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvG;;;;;;;;;;GAUG;AACH,UAAU,qBAAqB;IAC9B,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,UAAU,EAAE,oBAAoB,GAC9B,MAAM,CA6DR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,CAC9C,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,gBAAgB,GACpB,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAc5C;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAEjE"}

package/dist/read-truncation-gate.js

@@ -0,0 +1,175 @@
+/**
+ * read-truncation-gate — pi.on('tool_result', handler) registered from
+ * the pi-agent-dispatch extension factory that intercepts pi's built-in
+ * `read` tool responses when the underlying TruncationResult signals
+ * truncation, and REPLACES the content payload entirely with a single
+ * text item carrying a hard-refusal directive.
+ *
+ * Canonical model: the pi.on('tool_result') boundary mirrors the auth-
+ * gate's tool_call boundary — it runs at the pi-dispatch layer, after
+ * the tool's execute() body has produced its result, and before the
+ * LLM sees the result. Returning a ToolResultEventResult with `content`
+ * set REPLACES the corresponding event field entirely (no merge); the
+ * agent never sees the original (truncated head) content. The directive
+ * IS the content, so the agent cannot skim past it — there is no head
+ * to skim. The phrasing pattern (⚠️ prefix, INCOMPLETE / "do NOT"
+ * framing, explicit-next-action guidance naming concrete tools + params)
+ * mirrors pi-context's serializeForRead overCapDirective canon at
+ * read-element.ts:222-245, which proved itself across the typed-read
+ * surfaces (read-block-page / read-schema / read-samples-catalog).
+ *
+ * Why pi's built-in marker is insufficient: pi's read tool appends a
+ * single text marker at end-of-content on truncation (the marker IS
+ * structured + carries a continuation hint via `offset=N`), but its
+ * end-of-content position is trivially skimmable — LLMs scan content
+ * for the substantive bit they want and miss the marker. Empirically,
+ * an in-pi LLM reading a large file gets the head and proceeds with
+ * incomplete content as if it had the whole file. This handler closes
+ * that gap by making the directive the entire visible response.
+ *
+ * Coexists with auth-gate: that handler registers on pi.on('tool_call')
+ * for the substrate-write authorization surface; this handler registers
+ * on pi.on('tool_result') for the read-output integrity surface. The
+ * two events are orthogonal and the handlers do not interfere.
+ *
+ * No-op for non-read tools and for non-truncated read results — handler
+ * returns undefined, leaving the original event payload untouched.
+ */
+/**
+ * Pure function that constructs the directive text from the pi read
+ * tool call input + the structured TruncationResult. No I/O; identical
+ * inputs yield identical output. Exported separately from the handler
+ * so unit tests can drive directive composition in isolation.
+ *
+ * Renders:
+ *   - the file path (from `input.path`; defaults to "<unknown>" if the
+ *     input shape is unexpectedly empty — defensive guard, not a
+ *     contract);
+ *   - the truncation accounting (outputLines / totalLines and
+ *     outputBytes / totalBytes; numeric fields rendered with a default
+ *     of "?" if absent so a partial TruncationResult still produces a
+ *     readable directive);
+ *   - variant-conditional next-action guidance:
+ *       * firstLineExceedsLimit=true: pagination via `offset=N` is
+ *         operationally meaningless (offset=0 re-fires the same
+ *         truncation; offset>=1 jumps past the unreadable line losing
+ *         content); the directive instead names `grep` for targeted
+ *         search + bash `sed -n '<line>p' <path> | head -c <bytes>`
+ *         for byte-range slicing of the over-long single line.
+ *       * truncatedBy='bytes' (without firstLineExceedsLimit): the
+ *         byte cap fired (not line cap); paginating by line offset may
+ *         again exceed the byte cap on the next page with no agent
+ *         signal — directive surfaces this risk + prefers `grep`.
+ *       * truncatedBy='lines' (default): line cap fired; offset-by-
+ *         outputLines pagination works predictably.
+ *   - lastLinePartial=true clause (when set): warns the agent the
+ *     terminal characters of the returned content were cut mid-content
+ *     and should not be trusted (mid-JSON-object, mid-source-
+ *     expression, mid-log-entry); placed AFTER the truncation summary
+ *     + BEFORE the next-action clauses.
+ *
+ * The "The truncated head is NOT returned" sentence enforces the
+ * hard-refusal semantic at the language level — it signals the agent
+ * that the directive IS the entire response payload, not a header
+ * followed by content.
+ */
+export function buildTruncationDirective(input, truncation) {
+    const path = typeof input?.path === "string" && input.path.length > 0 ? input.path : "<unknown>";
+    const totalLines = truncation.totalLines ?? "?";
+    const totalBytes = truncation.totalBytes ?? "?";
+    const outputLines = truncation.outputLines ?? "?";
+    const outputBytes = truncation.outputBytes ?? "?";
+    const maxBytes = truncation.maxBytes ?? "?";
+    // pi's read.js builds its end-of-content marker with `Use offset=${nextOffset}`
+    // where nextOffset equals the count of complete lines emitted (outputLines).
+    // Mirror that convention so the directive's continuation hint matches the
+    // canonical semantics consumers may already expect from pi.
+    const nextOffset = truncation.outputLines ?? "?";
+    const summary = `⚠️ READ TRUNCATED — file \`${path}\` is ${totalLines} lines / ${totalBytes} bytes total; ` +
+        `only the first ${outputLines} lines / ${outputBytes} bytes were returned. ` +
+        `The content below is INCOMPLETE; do NOT proceed as if you have the full file.`;
+    // Discrete partial-last-line clause inserted between summary + next-actions.
+    // Placed before next-actions so the agent sees the integrity warning before
+    // composing a follow-up read.
+    const partialLineClause = truncation.lastLinePartial
+        ? `\n\nWARNING: the last returned line was cut mid-content; do not trust its trailing ` +
+            `characters. The next read with \`offset=${nextOffset}\` should start at the line AFTER ` +
+            `the partial one OR re-read the partial line in full via a smaller \`limit=\`.`
+        : "";
+    // Variant-conditional next-action block. firstLineExceedsLimit is the
+    // dominant signal (suppresses pagination clause entirely); otherwise
+    // truncatedBy discriminates between bytes-cap (pagination risk) and
+    // lines-cap (predictable pagination).
+    let nextActions;
+    if (truncation.firstLineExceedsLimit === true) {
+        nextActions =
+            `\n\nThe file's first line ALONE exceeds the read byte cap (${outputBytes} of ${maxBytes} ` +
+                `bytes returned; \`firstLineExceedsLimit=true\`). Pagination via the read tool cannot help: ` +
+                `re-issuing with a zero line offset re-fires this same truncation, and any positive line ` +
+                `offset jumps past the unreadable line losing its content entirely. Useful next actions:\n` +
+                `  - use \`grep\` with a pattern + path to find specific content within the over-long line;\n` +
+                `  - use \`bash\` to byte-slice the single line, e.g. \`sed -n '1p' ${path} | head -c ${maxBytes}\`, ` +
+                `adjusting the line number + byte count as needed.\n\n` +
+                `The truncated head is NOT returned in this response — use \`grep\` or byte-range slicing as above.`;
+    }
+    else if (truncation.truncatedBy === "bytes") {
+        nextActions =
+            `\n\nTruncation fired on the BYTES cap (not line count); paginating by line offset may again ` +
+                `exceed the byte cap on the next page. If the lines are long, prefer \`grep\` for targeted search.\n` +
+                `To continue from where the read stopped: call \`read\` again with \`offset=${nextOffset}\` ` +
+                `(and \`limit=...\` if desired).\n` +
+                `To find specific content without reading the rest of the file: use \`grep\` with a pattern + path.\n\n` +
+                `The truncated head is NOT returned in this response — re-issue the read with ` +
+                `\`offset=${nextOffset}\` or use \`grep\` for targeted search.`;
+    }
+    else {
+        nextActions =
+            `\n\nTo continue from where the read stopped: call \`read\` again with \`offset=${nextOffset}\` ` +
+                `(and \`limit=...\` if desired).\n` +
+                `To find specific content without reading the rest of the file: use \`grep\` with a pattern + path.\n\n` +
+                `The truncated head is NOT returned in this response — re-issue the read with ` +
+                `\`offset=${nextOffset}\` or use \`grep\` for targeted search.`;
+    }
+    return summary + partialLineClause + nextActions;
+}
+/**
+ * The pi.on('tool_result') handler. Exported separately from the
+ * registration helper so unit tests can invoke it directly with a mock
+ * event and mock context, without driving a real pi extension factory.
+ *
+ * Returns:
+ *   - `undefined` (pass-through) when toolName !== "read";
+ *   - `undefined` (pass-through) when details.truncation is absent or
+ *     truncation.truncated is false (the read was complete);
+ *   - `{ content, isError }` REPLACING the event payload when the read
+ *     was truncated. `isError` is set false because the read itself
+ *     succeeded — only its completeness is at issue; raising isError
+ *     would surface as a tool failure to the LLM and trigger error-
+ *     handling paths instead of the canonical "use offset / use grep"
+ *     guidance the directive carries.
+ */
+export async function readTruncationGateHandler(event, _ctx) {
+    if (event.toolName !== "read") {
+        return; // pass-through: only intercept read tool results
+    }
+    const details = event.details;
+    const truncation = details?.truncation;
+    if (!truncation?.truncated) {
+        return; // pass-through: read was not truncated, original content stands
+    }
+    const directive = buildTruncationDirective(event.input, truncation);
+    return {
+        content: [{ type: "text", text: directive }],
+        isError: false,
+    };
+}
+/**
+ * Register the read-truncation-gate handler on a pi extension API.
+ * Single line at the factory call-site. Idempotent registration is the
+ * responsibility of the caller (the extension factory runs once per pi
+ * process; double-registration would produce duplicate replacements).
+ */
+export function registerReadTruncationGate(pi) {
+    pi.on("tool_result", readTruncationGateHandler);
+}
+//# sourceMappingURL=read-truncation-gate.js.map

package/dist/read-truncation-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-truncation-gate.js","sourceRoot":"","sources":["../src/read-truncation-gate.ts"],"names":[],"mappings":"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"}

package/dist/real-check-runner.d.ts

@@ -0,0 +1,66 @@
+/**
+ * real-check-runner — deterministic verdict gate for agent-authored work-orders
+ * (TASK-090 / DEC-0018 / FGAP-102 / DEC-0047 clause 5). Runs the real-checks
+ * declared in a work-order's `real_check_criteria`: build/check/test exit,
+ * runtime-demo invocation + expected-substring presence, adversarial-probe
+ * grep-based evidence enumeration. Returns a structured RealCheckResult; the
+ * orchestrator (or `run-real-checks` Pi tool) interprets the verdict —
+ * never the executing agent's self-report.
+ *
+ * The runner buffers full stdout/stderr (no truncation) and surfaces the
+ * raw shell exit code so callers can diagnose. Timeouts terminate the
+ * spawned shell via SIGTERM; the captured streams up to that point are
+ * preserved and a non-zero exit code is reported.
+ */
+export interface BuildCheckTestResult {
+    passed: boolean;
+    exit_code: number;
+    stdout: string;
+    stderr: string;
+    duration_ms: number;
+}
+export interface RuntimeDemoResult {
+    passed: boolean;
+    output: string;
+    expected: string;
+    duration_ms: number;
+}
+export interface AdversarialProbeResult {
+    passed: boolean;
+    per_target: Array<{
+        target: string;
+        hits: string;
+    }>;
+    duration_ms: number;
+}
+export interface RealCheckCriteria {
+    build_check_test?: boolean;
+    runtime_demo?: {
+        invocation: string;
+        expected: string;
+    };
+    adversarial_probe?: {
+        targets: string[];
+    };
+}
+export interface RealCheckResult {
+    passed: boolean;
+    work_order_id: string;
+    details: {
+        build_check_test?: BuildCheckTestResult;
+        runtime_demo?: RuntimeDemoResult;
+        adversarial_probe?: AdversarialProbeResult;
+    };
+    total_duration_ms: number;
+    timestamp: string;
+}
+/**
+ * Run all declared real-checks for a work-order. The criteria object selects
+ * which checks fire; absent fields are skipped (not failed). Aggregate
+ * `passed` is the AND of every declared check; an empty criteria block
+ * passes trivially (no gate declared).
+ */
+export declare function runRealChecks(cwd: string, work_order_id: string, criteria: RealCheckCriteria, opts?: {
+    max_check_time_ms?: number;
+}): Promise<RealCheckResult>;
+//# sourceMappingURL=real-check-runner.d.ts.map

package/dist/real-check-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-check-runner.d.ts","sourceRoot":"","sources":["../src/real-check-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACxD,iBAAiB,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE;QACR,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;QACxC,YAAY,CAAC,EAAE,iBAAiB,CAAC;QACjC,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;KAC3C,CAAC;IACF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CAClB;AA0GD;;;;;GAKG;AACH,wBAAsB,aAAa,CAClC,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,CAAC,EAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAE,GACnC,OAAO,CAAC,eAAe,CAAC,CA4B1B"}

package/dist/real-check-runner.js

@@ -0,0 +1,133 @@
+/**
+ * real-check-runner — deterministic verdict gate for agent-authored work-orders
+ * (TASK-090 / DEC-0018 / FGAP-102 / DEC-0047 clause 5). Runs the real-checks
+ * declared in a work-order's `real_check_criteria`: build/check/test exit,
+ * runtime-demo invocation + expected-substring presence, adversarial-probe
+ * grep-based evidence enumeration. Returns a structured RealCheckResult; the
+ * orchestrator (or `run-real-checks` Pi tool) interprets the verdict —
+ * never the executing agent's self-report.
+ *
+ * The runner buffers full stdout/stderr (no truncation) and surfaces the
+ * raw shell exit code so callers can diagnose. Timeouts terminate the
+ * spawned shell via SIGTERM; the captured streams up to that point are
+ * preserved and a non-zero exit code is reported.
+ */
+import { spawn } from "node:child_process";
+/**
+ * Run a shell command via `sh -c <cmd>`, buffering full stdout/stderr.
+ * Resolves on close (regardless of exit code); rejects only on spawn-error.
+ * Timeout terminates via SIGTERM, preserving captured streams; the eventual
+ * non-zero exit code surfaces in the resolved result.
+ */
+function runShell(cwd, cmd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        let child;
+        try {
+            child = spawn("sh", ["-c", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const timer = setTimeout(() => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                // child may have already exited between timer fire and kill
+            }
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            const durationMs = Date.now() - start;
+            // when killed via SIGTERM (timeout), code is null + signal is set;
+            // surface a synthetic non-zero exit so callers see a failure.
+            const exitCode = code ?? (signal ? 124 : 1);
+            resolve({ exitCode, stdout, stderr, durationMs });
+        });
+    });
+}
+async function runBCT(cwd, timeoutMs) {
+    // single shell call so the `&&` chain runs sequentially in one process
+    const r = await runShell(cwd, "npm run check && npm test", timeoutMs);
+    return {
+        passed: r.exitCode === 0,
+        exit_code: r.exitCode,
+        stdout: r.stdout,
+        stderr: r.stderr,
+        duration_ms: r.durationMs,
+    };
+}
+async function runRD(cwd, demo, timeoutMs) {
+    const r = await runShell(cwd, demo.invocation, timeoutMs);
+    // pass requires BOTH clean exit and expected-substring presence in stdout —
+    // covers the "side-effect masks feature" failure mode (DEC-0018) where the
+    // invocation exits 0 but produces unexpected output.
+    const passed = r.exitCode === 0 && r.stdout.includes(demo.expected);
+    return {
+        passed,
+        output: r.stdout,
+        expected: demo.expected,
+        duration_ms: r.durationMs,
+    };
+}
+async function runAP(cwd, targets, timeoutMs) {
+    const start = Date.now();
+    const per_target = [];
+    for (const target of targets) {
+        // grep -rn over cwd; exit 1 (no match) is data, not error — captured stdout
+        // is the evidence enumeration the orchestrator inspects.
+        const r = await runShell(cwd, `grep -rn ${JSON.stringify(target)} .`, timeoutMs);
+        per_target.push({ target, hits: r.stdout });
+    }
+    const passed = per_target.length > 0 && per_target.every((t) => t.hits.length > 0);
+    return {
+        passed,
+        per_target,
+        duration_ms: Date.now() - start,
+    };
+}
+/**
+ * Run all declared real-checks for a work-order. The criteria object selects
+ * which checks fire; absent fields are skipped (not failed). Aggregate
+ * `passed` is the AND of every declared check; an empty criteria block
+ * passes trivially (no gate declared).
+ */
+export async function runRealChecks(cwd, work_order_id, criteria, opts) {
+    const timeoutMs = opts?.max_check_time_ms ?? 600_000;
+    const start = Date.now();
+    const timestamp = new Date(start).toISOString();
+    const details = {};
+    if (criteria.build_check_test === true) {
+        details.build_check_test = await runBCT(cwd, timeoutMs);
+    }
+    if (criteria.runtime_demo) {
+        details.runtime_demo = await runRD(cwd, criteria.runtime_demo, timeoutMs);
+    }
+    if (criteria.adversarial_probe?.targets && criteria.adversarial_probe.targets.length > 0) {
+        details.adversarial_probe = await runAP(cwd, criteria.adversarial_probe.targets, timeoutMs);
+    }
+    const declared = [details.build_check_test, details.runtime_demo, details.adversarial_probe].filter((d) => d !== undefined);
+    const passed = declared.every((d) => d.passed);
+    return {
+        passed,
+        work_order_id,
+        details,
+        total_duration_ms: Date.now() - start,
+        timestamp,
+    };
+}
+//# sourceMappingURL=real-check-runner.js.map

package/dist/real-check-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"real-check-runner.js","sourceRoot":"","sources":["../src/real-check-runner.ts"],"names":[],"mappings":"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"}

package/dist/run-real-checks-tool.d.ts

@@ -0,0 +1,28 @@
+/**
+ * run-real-checks Pi tool — loads a work-order by id from the substrate
+ * `work-orders` block (TASK-088 schema) and invokes the real-check-runner
+ * (TASK-090). The returned RealCheckResult carries the deterministic
+ * verdict the orchestrator inspects — never the executing agent's
+ * self-report (FGAP-102 + DEC-0047 clause 5).
+ */
+import { Type } from "@earendil-works/pi-ai";
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type RealCheckResult } from "./real-check-runner.js";
+export declare class WorkOrderNotFoundError extends Error {
+    constructor(workOrderId: string);
+}
+export declare const runRealChecksTool: {
+    name: string;
+    label: string;
+    description: string;
+    promptSnippet: string;
+    parameters: Type.TObject<{
+        work_order_id: Type.TString;
+        max_check_time_ms: Type.TOptional<Type.TNumber>;
+    }>;
+    execute(_toolCallId: string, params: {
+        work_order_id: string;
+        max_check_time_ms?: number;
+    }, _signal: AbortSignal, _onUpdate: AgentToolUpdateCallback, ctx: ExtensionContext): Promise<AgentToolResult<RealCheckResult>>;
+};
+//# sourceMappingURL=run-real-checks-tool.d.ts.map

package/dist/run-real-checks-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-real-checks-tool.d.ts","sourceRoot":"","sources":["../src/run-real-checks-tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAClH,OAAO,EAA0B,KAAK,eAAe,EAAiB,MAAM,wBAAwB,CAAC;AAOrG,qBAAa,sBAAuB,SAAQ,KAAK;gBACpC,WAAW,EAAE,MAAM;CAI/B;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;yBAef,MAAM,UACX;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAE,WACpD,WAAW,aACT,uBAAuB,OAC7B,gBAAgB,GACnB,OAAO,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;CAmB5C,CAAC"}

package/dist/run-real-checks-tool.js

@@ -0,0 +1,47 @@
+/**
+ * run-real-checks Pi tool — loads a work-order by id from the substrate
+ * `work-orders` block (TASK-088 schema) and invokes the real-check-runner
+ * (TASK-090). The returned RealCheckResult carries the deterministic
+ * verdict the orchestrator inspects — never the executing agent's
+ * self-report (FGAP-102 + DEC-0047 clause 5).
+ */
+import { readBlock } from "@davidorex/pi-context/block-api";
+import { Type } from "@earendil-works/pi-ai";
+import { runRealChecks } from "./real-check-runner.js";
+export class WorkOrderNotFoundError extends Error {
+    constructor(workOrderId) {
+        super(`run-real-checks: work-order '${workOrderId}' not found in work-orders block`);
+        this.name = "WorkOrderNotFoundError";
+    }
+}
+export const runRealChecksTool = {
+    name: "run-real-checks",
+    label: "Run Real Checks",
+    description: "Run the deterministic real-checks declared on a work-order (build/check/test exit + runtime-demo + adversarial-probe). Returns a structured RealCheckResult. NEVER LLM self-report; verdict is the actual exit code.",
+    promptSnippet: "Run a work-order's declared real-checks for verdict gating.",
+    parameters: Type.Object({
+        work_order_id: Type.String({
+            description: "ID of the work-order whose real_check_criteria to run (e.g. 'WO-NNN').",
+        }),
+        max_check_time_ms: Type.Optional(Type.Number({ description: "Max total time per check in milliseconds. Defaults to 600000 (10 minutes)." })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        const data = readBlock(ctx.cwd, "work-orders");
+        const wo = data.work_orders.find((w) => w.id === params.work_order_id);
+        if (!wo)
+            throw new WorkOrderNotFoundError(params.work_order_id);
+        const result = await runRealChecks(ctx.cwd, wo.id, wo.real_check_criteria ?? {}, {
+            max_check_time_ms: params.max_check_time_ms,
+        });
+        return {
+            details: result,
+            content: [
+                {
+                    type: "text",
+                    text: `run-real-checks ${wo.id}: ${result.passed ? "PASSED" : "FAILED"} (${result.total_duration_ms}ms)`,
+                },
+            ],
+        };
+    },
+};
+//# sourceMappingURL=run-real-checks-tool.js.map

package/dist/run-real-checks-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-real-checks-tool.js","sourceRoot":"","sources":["../src/run-real-checks-tool.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAE7C,OAAO,EAAgD,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAOrG,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAChD,YAAY,WAAmB;QAC9B,KAAK,CAAC,gCAAgC,WAAW,kCAAkC,CAAC,CAAC;QACrF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACtC,CAAC;CACD;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAChC,IAAI,EAAE,iBAAiB;IACvB,KAAK,EAAE,iBAAiB;IACxB,WAAW,EACV,sNAAsN;IACvN,aAAa,EAAE,6DAA6D;IAC5E,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC;QACvB,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC;YAC1B,WAAW,EAAE,wEAAwE;SACrF,CAAC;QACF,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAC/B,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,4EAA4E,EAAE,CAAC,CAC1G;KACD,CAAC;IACF,KAAK,CAAC,OAAO,CACZ,WAAmB,EACnB,MAA6D,EAC7D,OAAoB,EACpB,SAAkC,EAClC,GAAqB;QAErB,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAiC,CAAC;QAC/E,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,aAAa,CAAC,CAAC;QACvE,IAAI,CAAC,EAAE;YAAE,MAAM,IAAI,sBAAsB,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAEhE,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,mBAAmB,IAAI,EAAE,EAAE;YAChF,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;SAC3C,CAAC,CAAC;QAEH,OAAO;YACN,OAAO,EAAE,MAAM;YACf,OAAO,EAAE;gBACR;oBACC,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,CAAC,iBAAiB,KAAK;iBACxG;aACD;SACD,CAAC;IACH,CAAC;CACD,CAAC"}