@skill-harness/adapters 0.8.0 → 0.10.0

package/dist/pi.js

@@ -2,7 +2,8 @@ import { existsSync, mkdtempSync, readFileSync, statSync } from "node:fs";
 import { tmpdir, homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { runPiJson } from "./pi-json.js";
-import { exec, onPath, envNum } from "@skill-harness/core";
+import { collectTrajectorySources, normalizePiTraces, resequence } from "./trajectory.js";
+import { exec, onPath, envNum, traceSha256 } from "@skill-harness/core";
 const PI_TIMEOUT_MS = envNum("PI_TIMEOUT_MS", 300_000);
 /**
  * Refuse to hand pi a skill dir it will silently ignore.
@@ -205,13 +206,40 @@ export const piAdapter = {
                     ` (exit ${r.code}${r.malformedLines ? `, ${r.malformedLines} malformed line(s)` : ""})` +
                     (r.stderr.trim() ? `: ${r.stderr.trim()}` : ""));
             }
+            if (r.malformedLines > 0) {
+                r.trace.capture_errors = [`pi JSONL contained ${r.malformedLines} malformed line(s); absence-based trace assertions are unsafe`];
+                r.trace.trace_sha256 = traceSha256(r.trace);
+            }
             traces.push(r.trace);
             parts.push(header(i + 1, total, req.turns[i]));
             parts.push(`<<< ASSISTANT:\n${r.trace.final_text.trim()}\n`);
             if (r.code !== 0)
                 parts.push(`[pi exited ${r.code} on turn ${i + 1}]\n${r.stderr.trim()}\n`);
         }
-        return { transcript: parts.join("\n"), traces };
+        const native = req.eventSources?.length
+            ? collectTrajectorySources(req.cwd, req.eventSources)
+            : { events: [], errors: [] };
+        const piEvents = normalizePiTraces(traces);
+        const combined = [...piEvents, ...native.events];
+        const chronologyErrors = [];
+        if (piEvents.length && native.events.length) {
+            if (combined.some((event) => !event.at || !Number.isFinite(Date.parse(event.at)))) {
+                chronologyErrors.push("pi/native events cannot be globally ordered because at least one event has no valid `at` timestamp");
+            }
+            else {
+                const piTimes = new Set(piEvents.map((event) => Date.parse(event.at)));
+                if (native.events.some((event) => piTimes.has(Date.parse(event.at)))) {
+                    chronologyErrors.push("pi/native events contain equal timestamps, so strict cross-source order is ambiguous");
+                }
+            }
+        }
+        const eventErrors = [...native.errors, ...chronologyErrors];
+        return {
+            transcript: parts.join("\n"),
+            traces,
+            events: resequence(combined),
+            ...(eventErrors.length ? { eventErrors } : {}),
+        };
     },
     /**
      * Run the judge: no skills, no context files, no session, single prompt.

package/dist/trajectory.d.ts

@@ -0,0 +1,56 @@
+import type { ExecutionTraceV1, TrajectoryEventSource, TrajectoryEventV1 } from "@skill-harness/core";
+export interface CollectedTrajectorySources {
+    events: TrajectoryEventV1[];
+    errors: string[];
+}
+/** Read and normalize declared workspace-local native ledger files. */
+export declare function collectTrajectorySources(cwd: string, sources: TrajectoryEventSource[]): CollectedTrajectorySources;
+/** Combine independently sequenced sources by recorded time while retaining each native sequence. */
+export declare function resequence(events: TrajectoryEventV1[]): TrajectoryEventV1[];
+/** Normalize pi's structured calls into adapter-neutral start/completion events. */
+export declare function normalizePiTraces(traces: ExecutionTraceV1[]): TrajectoryEventV1[];
+/** Normalize principal-pi-skills' immutable assurance event schema v1.0. */
+export declare function normalizePrincipalAssuranceLedger(text: string): TrajectoryEventV1[];
+/**
+ * Normalize pi-daddy's public ledgers: unversioned 0.17 GrantRecord lines and
+ * ledgerVersion 2 runtime events emitted by 0.18.0. Version detection precedes
+ * the legacy fallback so a new event can never be misdiagnosed as an old grant.
+ */
+export declare function normalizePiDaddyLedger(text: string): TrajectoryEventV1[];
+/**
+ * pi-daddy's canonical refusal vocabulary, in the pinned contract's own order.
+ *
+ * This is a copy of `#/$defs/refusalCode` from the pinned schema and is exported
+ * so `pi-daddy-contract.test.ts` can assert set equality against the producer
+ * artifact — a hand-maintained second vocabulary without that drift assertion is
+ * exactly how `GRANT_ID_MALFORMED` came to be rejected as "unsupported".
+ */
+export declare const V2_REFUSAL_CODES: Set<string>;
+/**
+ * Every vocabulary the adapter restates from the pinned contract, paired with the
+ * place in the schema it must equal.
+ *
+ * The closed schema gates first, so a semantic check that has drifted *narrower*
+ * than the contract no longer opens a hole — it produces the opposite failure:
+ * a contract-valid record admitted by the schema and then thrown out by a stale
+ * harness set, which is precisely what `GRANT_ID_MALFORMED` did. One manifest, one
+ * test over all of it, so re-pinning cannot quietly leave a set behind.
+ */
+export declare const V2_RESTATED_VOCABULARIES: ReadonlyArray<{
+    name: string;
+    kind: "enum" | "propertyNames" | "discriminators" | "typeNames" | "numericPropertyNames";
+    pointer: string;
+    values: ReadonlySet<string>;
+}>;
+/**
+ * Harness-side subsets of a contract vocabulary, not restatements of one. They encode
+ * the harness's own semantics — which lease outcomes a receipt may be appended after,
+ * and which may precede that release — so the assertion on them is containment, not
+ * equality. Anything the test *equality*-asserts belongs in the manifest above
+ * instead; membership here is a claim that the harness deliberately holds a subset.
+ */
+export declare const V2_VOCABULARY_SUBSETS: ReadonlyArray<{
+    name: string;
+    pointer: string;
+    values: ReadonlySet<string>;
+}>;