@cleocode/core 2026.6.12 → 2026.6.13

package/dist/selfimprove/draft-pr.js

@@ -0,0 +1,158 @@
+/**
+ * Draft-PR egress for the self-improvement loop (T11889 · T11889-C).
+ *
+ * On a detected regression the loop's ONLY outbound action is to open ONE DRAFT
+ * PR against the cleocode repo (ADR-065 — PRs target `main` via the Merge Queue;
+ * NEVER a direct push to `main`, NEVER an auto-merge, NEVER a publish). This module
+ * is the egress primitive, modeled on `propose-patch.ts` (the closest "agent
+ * proposes a fix PR" exemplar) with three self-dogfooding hardenings:
+ *
+ *   1. **`--draft` is ALWAYS appended** to `gh pr create` — the PR is never
+ *      ready-for-merge; a human reviews and undrafts it.
+ *   2. **Dry-run is the DEFAULT.** `openDraftPr` returns the planned `steps[]`
+ *      WITHOUT invoking git/gh unless `execute: true` is passed. So the loop is
+ *      side-effect-free at egress by default.
+ *   3. **Branch `feat/T11889-selfimprove-<scenario>-<ts>`** — a feature branch
+ *      (ADR-065); no main mutation path exists in this module.
+ *
+ * The live path wraps the git/gh shell-out in
+ * {@link "../sentient/skill-provenance.js".withProvenance}`('pr-generator', …)`
+ * (the established legal PR-cutting origin — the `SkillWriteOrigin` union is
+ * closed) and returns the `gh`-emitted PR URL so the caller can record it back
+ * into `selfimprove_dhq.pr_url` via the leased adapter.
+ *
+ * This module is import-time side-effect-free.
+ *
+ * @module @cleocode/core/selfimprove/draft-pr
+ * @epic T11889
+ * @task T11913
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { cwd as processCwd } from 'node:process';
+import { withProvenance } from '../sentient/skill-provenance.js';
+/**
+ * The required Claude Code trailer every self-improvement PR body ends with.
+ * Matches the project PR-body convention.
+ */
+const PR_BODY_TRAILER = '\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)';
+/** Default command runner — wraps `execFileSync` with stdout-piped semantics. */
+const defaultRun = (file, args) => execFileSync(file, [...args], { stdio: 'pipe' }).toString('utf8');
+/**
+ * Compute the feature branch name for a scenario's draft PR (ADR-065 feature
+ * branch — `feat/T11889-selfimprove-<scenario>-<ts>`). The timestamp is
+ * colon/dot-sanitized so it is a valid git ref.
+ *
+ * @param scenario - The scenario name.
+ * @param ts - The ISO timestamp string.
+ * @returns The branch name.
+ */
+export function draftPrBranchName(scenario, ts) {
+    const safeScenario = scenario.replace(/[^a-z0-9-]/gi, '-');
+    const safeTs = ts.replace(/[:.]/g, '-');
+    return `feat/T11889-selfimprove-${safeScenario}-${safeTs}`;
+}
+/**
+ * Open ONE DRAFT PR carrying a proposed self-improvement fix.
+ *
+ * DRY-RUN by default ({@link OpenDraftPrArgs.execute} falsey): returns the planned
+ * `steps[]` (the `gh pr create` step ALWAYS carries `--draft`) WITHOUT touching
+ * git/gh — so the loop is egress-side-effect-free unless `--execute` is threaded
+ * through. The live path (`execute: true`) cuts the feature branch, applies the
+ * diff, commits, pushes the FEATURE branch (NEVER `main`), and runs
+ * `gh pr create --base main --head <branch> --draft`, returning the PR URL.
+ *
+ * NEVER pushes `main`, NEVER auto-merges, NEVER publishes — the only egress is a
+ * draft PR against a feature branch.
+ *
+ * @param args - See {@link OpenDraftPrArgs}.
+ * @returns A {@link DraftPrResult} describing the outcome.
+ *
+ * @example
+ * ```ts
+ * // dry-run (default): no side effects, steps include `--draft`
+ * const plan = await openDraftPr({ scenario: 'x', diffPath: 'fix.patch', title, body });
+ * // live: cuts branch + opens draft PR
+ * const res = await openDraftPr({ scenario: 'x', diffPath: 'fix.patch', title, body, execute: true });
+ * ```
+ */
+export async function openDraftPr(args) {
+    const cwd = args.cwd ?? processCwd();
+    const run = args.run ?? defaultRun;
+    const execute = args.execute === true;
+    const isoNow = (args.timestamp ?? (() => new Date().toISOString()))();
+    const base = 'main';
+    const body = `${args.body}${PR_BODY_TRAILER}`;
+    const resolvedDiff = resolvePath(cwd, args.diffPath);
+    if (!existsSync(resolvedDiff)) {
+        return {
+            kind: 'error',
+            code: 'E_NOT_FOUND',
+            message: `Patch file not found at '${resolvedDiff}'`,
+        };
+    }
+    const diffBytes = readFileSync(resolvedDiff, 'utf8');
+    if (diffBytes.length === 0) {
+        return {
+            kind: 'error',
+            code: 'E_PATCH_EMPTY',
+            message: `Patch file '${resolvedDiff}' is empty`,
+        };
+    }
+    if (execute) {
+        try {
+            run('gh', ['--version']);
+        }
+        catch {
+            return {
+                kind: 'error',
+                code: 'E_GH_UNAVAILABLE',
+                message: 'gh CLI not found or not authenticated — install gh and run `gh auth login`',
+            };
+        }
+    }
+    const branchName = draftPrBranchName(args.scenario, isoNow);
+    const steps = [
+        `git checkout -b ${branchName}`,
+        `git apply ${resolvedDiff}`,
+        'git add -A',
+        `git commit -m "fix(selfimprove): ${args.scenario} regression"`,
+        `git push -u origin ${branchName}`,
+        `gh pr create --base ${base} --head ${branchName} --draft --title "${args.title}" --body <stdin>`,
+    ];
+    if (!execute) {
+        return { kind: 'dry-run', scenario: args.scenario, branchName, steps };
+    }
+    try {
+        const prUrl = await withProvenance('pr-generator', () => {
+            run('git', ['checkout', '-b', branchName]);
+            run('git', ['apply', resolvedDiff]);
+            run('git', ['add', '-A']);
+            run('git', ['commit', '-m', `fix(selfimprove): ${args.scenario} regression`]);
+            run('git', ['push', '-u', 'origin', branchName]);
+            return run('gh', [
+                'pr',
+                'create',
+                '--base',
+                base,
+                '--head',
+                branchName,
+                '--draft',
+                '--title',
+                args.title,
+                '--body',
+                body,
+            ]).trim();
+        });
+        return { kind: 'ok', scenario: args.scenario, branchName, prUrl };
+    }
+    catch (err) {
+        return {
+            kind: 'error',
+            code: 'E_DRAFT_PR_FAILED',
+            message: `draft-pr failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+//# sourceMappingURL=draft-pr.js.map

package/dist/selfimprove/draft-pr.js.map

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

package/dist/selfimprove/envelope-diff.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Envelope normalization + structural diff vs a golden (T11889-B).
+ *
+ * The self-improvement loop replays a scenario (see {@link "./replay.js"}) and
+ * diffs each captured envelope against the golden expected envelope. This module:
+ *
+ *   1. {@link normalizeEnvelope} — strips the VOLATILE `meta` fields so only
+ *      deterministic structure is compared. Two classes are stripped:
+ *      timing/trace fields (`timestamp`, `requestId`, `duration_ms` /
+ *      `durationMs`) AND the per-run session-lineage UUIDs (`sessionId`,
+ *      `originSessionId`, `executionSessionId`). The latter are non-deterministic:
+ *      the live `Dispatcher` defaults `executionSessionId`/`originSessionId` to a
+ *      fresh `randomUUID()` per request
+ *      (`ensureRequestSessionLineage`), then stamps all three onto `response.meta`
+ *      — so a real envelope carries UUIDs the hand-authored golden cannot know.
+ *      Stripping them prevents a permanent phantom DHQ that self-fires on every
+ *      clean run. (The runtime field is `meta` with snake_case `duration_ms`; the
+ *      spec wording uses `_meta`/`durationMs`, so both spellings and both
+ *      container keys are stripped defensively.)
+ *   2. {@link diffEnvelopes} — structurally compares the normalized envelope set
+ *      against the golden, producing `{ regressions: DiffEntry[] }`. Zero
+ *      regressions on a golden match; N on injected divergence. The `meta`
+ *      container is compared as a SUBSET (only golden-declared meta keys are
+ *      asserted) so deterministic-but-golden-absent infra keys
+ *      (`specVersion`, `schemaVersion`, `transport`, `mvi`, `contextVersion`,
+ *      `strict`, `x-cleo-transport`, …) stamped by the runtime are NOT phantom
+ *      regressions. The semantic payload (`data`/`error`) is still compared by
+ *      full key-union — a missing or extra payload key IS a regression.
+ *   3. {@link computeQuestionHash} — sha256 of the normalized regression
+ *      signature (op coordinates + diff path set) so the SAME regression maps to
+ *      the SAME open DHQ row (the idempotency partial-UNIQUE index in T11889-A).
+ *
+ * `extractFieldFromResult` from `@cleocode/lafs` is reused for targeted-field
+ * asserts where a full structural compare would be too brittle.
+ *
+ * This module is PURE — no DB, no native handle, no `cleo` mutation.
+ * Import-time side-effect-free.
+ *
+ * @module @cleocode/core/selfimprove/envelope-diff
+ * @epic T11889
+ * @task T11912
+ */
+import type { ReplayEnvelope } from './replay.js';
+import type { GoldenEntry, ScenarioOp } from './scenario.js';
+/**
+ * A normalized envelope: the replayed envelope with volatile `meta` fields removed.
+ *
+ * Structurally identical to {@link ReplayEnvelope} except every volatile
+ * meta field is absent. Stored as a plain JSON-serializable record so it can be
+ * compared deeply and hashed deterministically.
+ */
+export type NormalizedEnvelope = Record<string, unknown>;
+/**
+ * A single structural difference between a normalized envelope and its golden.
+ */
+export interface DiffEntry {
+    /** Zero-based index of the op in the scenario whose envelope diverged. */
+    opIndex: number;
+    /** The op coordinate (`domain.operation`) for the diverging op. */
+    opCoord: string;
+    /** JSON-pointer-ish path to the diverging value (e.g. `data/tasks/0/id`). */
+    path: string;
+    /** The value found in the replayed (actual) normalized envelope. */
+    actual: unknown;
+    /** The value found in the golden (expected) envelope. */
+    expected: unknown;
+}
+/** The result of diffing a replayed envelope set against a golden. */
+export interface EnvelopeDiffResult {
+    /** All structural regressions; empty ⇒ the replay matched the golden. */
+    regressions: DiffEntry[];
+}
+/**
+ * Strip the volatile `meta`/`_meta` fields from an envelope.
+ *
+ * Returns a NEW object; the input is not mutated. The volatile timing/trace fields
+ * AND the per-run session-lineage UUIDs (`sessionId`, `originSessionId`,
+ * `executionSessionId`) are removed — see {@link VOLATILE_META_FIELDS}. The stable
+ * meta remnant (`gateway`, `domain`, `operation`, `source`, …) is preserved so
+ * structural identity (which operation produced the envelope) still compares.
+ *
+ * Note: deterministic-but-golden-absent infra meta keys (`specVersion`,
+ * `transport`, …) are NOT stripped here — they are tolerated by the SUBSET compare
+ * in {@link diffEnvelopes} instead, so the strip set stays exactly the volatile
+ * fields and nothing semantic.
+ *
+ * @param envelope - The replayed envelope to normalize.
+ * @returns The normalized envelope with volatile meta fields removed.
+ *
+ * @example
+ * ```ts
+ * const norm = normalizeEnvelope(envelope);
+ * // norm.meta has no timestamp / requestId / duration_ms / *SessionId
+ * ```
+ */
+export declare function normalizeEnvelope(envelope: ReplayEnvelope): NormalizedEnvelope;
+/**
+ * Diff a set of replayed envelopes against the golden envelope set.
+ *
+ * Normalizes each replayed envelope (volatile meta stripped) and structurally
+ * compares it against the positionally-aligned golden entry. The op coordinate
+ * for each `DiffEntry` is taken from `ops[opIndex]`. Callers MUST pass aligned
+ * arrays (`ops.length === replayed.length === golden.length`); the function
+ * diffs up to the shortest length and reports an extra regression for any length
+ * mismatch.
+ *
+ * The `meta` container is compared as a SUBSET (only golden-declared meta keys are
+ * asserted) so deterministic-but-golden-absent infra keys the runtime stamps
+ * (`specVersion`, `transport`, …) are not phantom regressions; the semantic
+ * payload (`data`/`error`) keeps a full key-union compare where an extra or
+ * missing key IS a regression. Together with the volatile-lineage strip in
+ * {@link normalizeEnvelope}, a real live envelope that matches the golden body
+ * yields ZERO regressions.
+ *
+ * @param ops - The scenario ops (for op-coordinate labelling).
+ * @param replayed - The captured envelopes, one per op (replay order).
+ * @param golden - The golden expected entries, positionally aligned with `ops`.
+ * @returns `{ regressions }` — empty when the replay matches the golden.
+ *
+ * @example
+ * ```ts
+ * const { regressions } = diffEnvelopes(scenario.ops, replayed, golden.envelopes);
+ * if (regressions.length === 0) { /* happy path — no DHQ, no PR *\/ }
+ * ```
+ */
+export declare function diffEnvelopes(ops: ScenarioOp[], replayed: ReplayEnvelope[], golden: GoldenEntry[]): EnvelopeDiffResult;
+/**
+ * Extract a targeted field from a normalized envelope's `data` payload.
+ *
+ * Reuses the LAFS `--field` extractor (`extractFieldFromResult`) for cases where
+ * a full structural diff is too brittle and only a specific field's value matters
+ * (e.g. assert `data.tasks[0].id` without comparing the whole envelope).
+ *
+ * @param normalized - A normalized envelope (from {@link normalizeEnvelope}).
+ * @param field - The field name to extract from the envelope's `data` payload.
+ * @returns The extracted value, or `undefined` when absent.
+ *
+ * @example
+ * ```ts
+ * const id = extractTargetedField(normalizeEnvelope(env), 'id');
+ * ```
+ */
+export declare function extractTargetedField(normalized: NormalizedEnvelope, field: string): unknown;
+/**
+ * Compute the sha256 `question_hash` of a diff result's normalized signature.
+ *
+ * The hash is over the {@link regressionSignature} (op coordinates + diff path
+ * set), so it is stable across runs of the SAME regression and feeds the
+ * idempotency partial-UNIQUE index (`ux_selfimprove_dhq_open`, T11889-A): one
+ * open DHQ row per `question_hash`. An empty regression set hashes the empty
+ * signature deterministically (callers should not persist on the happy path).
+ *
+ * @param result - The diff result whose regressions are hashed.
+ * @returns The lowercase hex sha256 of the regression signature.
+ *
+ * @example
+ * ```ts
+ * const hash = computeQuestionHash(diffEnvelopes(ops, replayed, golden));
+ * ```
+ */
+export declare function computeQuestionHash(result: EnvelopeDiffResult): string;
+//# sourceMappingURL=envelope-diff.d.ts.map

package/dist/selfimprove/envelope-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope-diff.d.ts","sourceRoot":"","sources":["../../src/selfimprove/envelope-diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAmD7D;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAC;IAChB,yDAAyD;IACzD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,WAAW,EAAE,SAAS,EAAE,CAAC;CAC1B;AAeD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,kBAAkB,CAY9E;AAkED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EAAE,EACjB,QAAQ,EAAE,cAAc,EAAE,EAC1B,MAAM,EAAE,WAAW,EAAE,GACpB,kBAAkB,CAqCpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAO3F;AAqBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAGtE"}

package/dist/selfimprove/envelope-diff.js

@@ -0,0 +1,321 @@
+/**
+ * Envelope normalization + structural diff vs a golden (T11889-B).
+ *
+ * The self-improvement loop replays a scenario (see {@link "./replay.js"}) and
+ * diffs each captured envelope against the golden expected envelope. This module:
+ *
+ *   1. {@link normalizeEnvelope} — strips the VOLATILE `meta` fields so only
+ *      deterministic structure is compared. Two classes are stripped:
+ *      timing/trace fields (`timestamp`, `requestId`, `duration_ms` /
+ *      `durationMs`) AND the per-run session-lineage UUIDs (`sessionId`,
+ *      `originSessionId`, `executionSessionId`). The latter are non-deterministic:
+ *      the live `Dispatcher` defaults `executionSessionId`/`originSessionId` to a
+ *      fresh `randomUUID()` per request
+ *      (`ensureRequestSessionLineage`), then stamps all three onto `response.meta`
+ *      — so a real envelope carries UUIDs the hand-authored golden cannot know.
+ *      Stripping them prevents a permanent phantom DHQ that self-fires on every
+ *      clean run. (The runtime field is `meta` with snake_case `duration_ms`; the
+ *      spec wording uses `_meta`/`durationMs`, so both spellings and both
+ *      container keys are stripped defensively.)
+ *   2. {@link diffEnvelopes} — structurally compares the normalized envelope set
+ *      against the golden, producing `{ regressions: DiffEntry[] }`. Zero
+ *      regressions on a golden match; N on injected divergence. The `meta`
+ *      container is compared as a SUBSET (only golden-declared meta keys are
+ *      asserted) so deterministic-but-golden-absent infra keys
+ *      (`specVersion`, `schemaVersion`, `transport`, `mvi`, `contextVersion`,
+ *      `strict`, `x-cleo-transport`, …) stamped by the runtime are NOT phantom
+ *      regressions. The semantic payload (`data`/`error`) is still compared by
+ *      full key-union — a missing or extra payload key IS a regression.
+ *   3. {@link computeQuestionHash} — sha256 of the normalized regression
+ *      signature (op coordinates + diff path set) so the SAME regression maps to
+ *      the SAME open DHQ row (the idempotency partial-UNIQUE index in T11889-A).
+ *
+ * `extractFieldFromResult` from `@cleocode/lafs` is reused for targeted-field
+ * asserts where a full structural compare would be too brittle.
+ *
+ * This module is PURE — no DB, no native handle, no `cleo` mutation.
+ * Import-time side-effect-free.
+ *
+ * @module @cleocode/core/selfimprove/envelope-diff
+ * @epic T11889
+ * @task T11912
+ */
+import { createHash } from 'node:crypto';
+import { extractFieldFromResult } from '@cleocode/lafs';
+/**
+ * Volatile envelope-meta field names stripped before diffing.
+ *
+ * Two classes, both non-deterministic per run:
+ *
+ *   - Timing / trace: `timestamp`, `requestId`, `duration_ms` (the runtime
+ *     canonical, snake_case) and `durationMs` (the spec wording — stripped so a
+ *     golden authored either way normalizes identically).
+ *   - Session lineage: `sessionId`, `originSessionId`, `executionSessionId`. The
+ *     live `Dispatcher` stamps these onto `response.meta`
+ *     after defaulting `executionSessionId`/`originSessionId` to a fresh
+ *     `randomUUID()` per request (`ensureRequestSessionLineage`). They are
+ *     per-run UUIDs the hand-authored golden cannot encode; leaving them in would
+ *     make every clean replay emit a phantom regression at
+ *     `meta/executionSessionId` and `meta/originSessionId`, and because the
+ *     regression signature hashes only `opCoord@path` (constant), the resulting
+ *     `question_hash` would be STABLE — a permanent self-firing DHQ. Stripping
+ *     them keeps an identical-but-for-lineage envelope a non-regression.
+ */
+const VOLATILE_META_FIELDS = [
+    'timestamp',
+    'requestId',
+    'duration_ms',
+    'durationMs',
+    'sessionId',
+    'originSessionId',
+    'executionSessionId',
+];
+/**
+ * Meta container keys whose volatile fields are stripped, and whose remaining
+ * keys are compared as a SUBSET (see {@link diffEnvelopes}).
+ *
+ * Runtime envelopes use `meta`; `_meta` is stripped too for defensive parity with
+ * the gateway envelope shape.
+ */
+const META_CONTAINER_KEYS = ['meta', '_meta'];
+/**
+ * Top-level envelope keys whose value is a meta container.
+ *
+ * The structural diff treats these containers as a SUBSET compare (golden-declared
+ * keys only) so deterministic-but-golden-absent infra keys the runtime stamps
+ * (`specVersion`, `schemaVersion`, `transport`, `mvi`, `contextVersion`, `strict`,
+ * `x-cleo-transport`, …) are not phantom regressions. Everything else (`data`,
+ * `error`, …) keeps a full key-union compare.
+ */
+const SUBSET_COMPARE_KEYS = new Set(META_CONTAINER_KEYS);
+/**
+ * Deep-clone a JSON-serializable value via structured round-trip.
+ *
+ * Replay envelopes are JSON-shaped (they round-trip through transports), so a
+ * JSON clone is safe and avoids mutating the caller's object during normalization.
+ *
+ * @param value - The value to clone.
+ * @returns A deep copy.
+ */
+function jsonClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Strip the volatile `meta`/`_meta` fields from an envelope.
+ *
+ * Returns a NEW object; the input is not mutated. The volatile timing/trace fields
+ * AND the per-run session-lineage UUIDs (`sessionId`, `originSessionId`,
+ * `executionSessionId`) are removed — see {@link VOLATILE_META_FIELDS}. The stable
+ * meta remnant (`gateway`, `domain`, `operation`, `source`, …) is preserved so
+ * structural identity (which operation produced the envelope) still compares.
+ *
+ * Note: deterministic-but-golden-absent infra meta keys (`specVersion`,
+ * `transport`, …) are NOT stripped here — they are tolerated by the SUBSET compare
+ * in {@link diffEnvelopes} instead, so the strip set stays exactly the volatile
+ * fields and nothing semantic.
+ *
+ * @param envelope - The replayed envelope to normalize.
+ * @returns The normalized envelope with volatile meta fields removed.
+ *
+ * @example
+ * ```ts
+ * const norm = normalizeEnvelope(envelope);
+ * // norm.meta has no timestamp / requestId / duration_ms / *SessionId
+ * ```
+ */
+export function normalizeEnvelope(envelope) {
+    const cloned = jsonClone(envelope);
+    for (const containerKey of META_CONTAINER_KEYS) {
+        const container = cloned[containerKey];
+        if (container !== null && typeof container === 'object' && !Array.isArray(container)) {
+            const meta = container;
+            for (const field of VOLATILE_META_FIELDS) {
+                delete meta[field];
+            }
+        }
+    }
+    return cloned;
+}
+/**
+ * Recursively collect structural differences between two JSON values.
+ *
+ * Walks both trees in parallel, recording a `{ path, actual, expected }` for each
+ * leaf-level divergence. Object key sets and array lengths are compared; the path
+ * uses `/`-delimited segments.
+ *
+ * Key-set semantics depend on the container:
+ *   - **Subset** (`subset === true`): only the EXPECTED (golden) object's keys are
+ *     compared. Extra keys present in `actual` but absent from the golden are
+ *     ignored. Applied to the `meta` container (see {@link SUBSET_COMPARE_KEYS}) so
+ *     deterministic infra meta keys the runtime stamps but the golden omits are not
+ *     phantom regressions.
+ *   - **Full union** (`subset === false`, the default): keys from BOTH objects are
+ *     compared, so an extra OR missing key is a regression. Applied to the semantic
+ *     payload (`data`/`error`).
+ *
+ * A child whose top-level key is in {@link SUBSET_COMPARE_KEYS} (i.e. `meta`)
+ * switches its subtree into subset mode.
+ *
+ * @param actual - The actual (normalized replay) value.
+ * @param expected - The expected (golden) value.
+ * @param path - Accumulated path prefix.
+ * @param out - Mutable accumulator of `{ path, actual, expected }` tuples.
+ * @param subset - When `true`, compare only the golden-declared keys at this node.
+ */
+function collectStructuralDiffs(actual, expected, path, out, subset = false) {
+    if (actual === expected)
+        return;
+    const bothObjects = actual !== null &&
+        expected !== null &&
+        typeof actual === 'object' &&
+        typeof expected === 'object' &&
+        Array.isArray(actual) === Array.isArray(expected);
+    if (!bothObjects) {
+        out.push({ path, actual, expected });
+        return;
+    }
+    const actualRec = actual;
+    const expectedRec = expected;
+    // Subset mode (meta container): compare ONLY the golden's keys, so extra
+    // deterministic runtime meta keys are not regressions. Full mode: union both
+    // key sets, so an extra OR missing payload key IS a regression.
+    const keys = subset
+        ? new Set(Object.keys(expectedRec))
+        : new Set([...Object.keys(actualRec), ...Object.keys(expectedRec)]);
+    for (const key of keys) {
+        const childPath = path === '' ? key : `${path}/${key}`;
+        // A `meta`/`_meta` container's subtree is compared as a subset; never widen
+        // back to full-union once inside a subset container.
+        const childSubset = subset || SUBSET_COMPARE_KEYS.has(key);
+        collectStructuralDiffs(actualRec[key], expectedRec[key], childPath, out, childSubset);
+    }
+}
+/**
+ * Diff a set of replayed envelopes against the golden envelope set.
+ *
+ * Normalizes each replayed envelope (volatile meta stripped) and structurally
+ * compares it against the positionally-aligned golden entry. The op coordinate
+ * for each `DiffEntry` is taken from `ops[opIndex]`. Callers MUST pass aligned
+ * arrays (`ops.length === replayed.length === golden.length`); the function
+ * diffs up to the shortest length and reports an extra regression for any length
+ * mismatch.
+ *
+ * The `meta` container is compared as a SUBSET (only golden-declared meta keys are
+ * asserted) so deterministic-but-golden-absent infra keys the runtime stamps
+ * (`specVersion`, `transport`, …) are not phantom regressions; the semantic
+ * payload (`data`/`error`) keeps a full key-union compare where an extra or
+ * missing key IS a regression. Together with the volatile-lineage strip in
+ * {@link normalizeEnvelope}, a real live envelope that matches the golden body
+ * yields ZERO regressions.
+ *
+ * @param ops - The scenario ops (for op-coordinate labelling).
+ * @param replayed - The captured envelopes, one per op (replay order).
+ * @param golden - The golden expected entries, positionally aligned with `ops`.
+ * @returns `{ regressions }` — empty when the replay matches the golden.
+ *
+ * @example
+ * ```ts
+ * const { regressions } = diffEnvelopes(scenario.ops, replayed, golden.envelopes);
+ * if (regressions.length === 0) { /* happy path — no DHQ, no PR *\/ }
+ * ```
+ */
+export function diffEnvelopes(ops, replayed, golden) {
+    const regressions = [];
+    const n = Math.min(ops.length, replayed.length, golden.length);
+    for (let i = 0; i < n; i++) {
+        const op = ops[i];
+        const replayEnvelope = replayed[i];
+        const goldenEntry = golden[i];
+        if (op === undefined || replayEnvelope === undefined || goldenEntry === undefined)
+            continue;
+        const opCoord = `${op.domain}.${op.operation}`;
+        const normalized = normalizeEnvelope(replayEnvelope);
+        const leafDiffs = [];
+        collectStructuralDiffs(normalized, goldenEntry, '', leafDiffs);
+        for (const d of leafDiffs) {
+            regressions.push({
+                opIndex: i,
+                opCoord,
+                path: d.path,
+                actual: d.actual,
+                expected: d.expected,
+            });
+        }
+    }
+    if (replayed.length !== golden.length) {
+        regressions.push({
+            opIndex: -1,
+            opCoord: '<count>',
+            path: 'envelopes/length',
+            actual: replayed.length,
+            expected: golden.length,
+        });
+    }
+    return { regressions };
+}
+/**
+ * Extract a targeted field from a normalized envelope's `data` payload.
+ *
+ * Reuses the LAFS `--field` extractor (`extractFieldFromResult`) for cases where
+ * a full structural diff is too brittle and only a specific field's value matters
+ * (e.g. assert `data.tasks[0].id` without comparing the whole envelope).
+ *
+ * @param normalized - A normalized envelope (from {@link normalizeEnvelope}).
+ * @param field - The field name to extract from the envelope's `data` payload.
+ * @returns The extracted value, or `undefined` when absent.
+ *
+ * @example
+ * ```ts
+ * const id = extractTargetedField(normalizeEnvelope(env), 'id');
+ * ```
+ */
+export function extractTargetedField(normalized, field) {
+    const data = normalized.data;
+    if (data === undefined || data === null)
+        return undefined;
+    // The LAFS extractor operates on a result value (object | array | null); the
+    // dispatch envelope's `data` is the equivalent payload.
+    if (typeof data !== 'object')
+        return undefined;
+    return extractFieldFromResult(data, field);
+}
+/**
+ * Build the deterministic regression signature for a diff result.
+ *
+ * The signature is the SORTED set of `{ opCoord, path }` pairs from the
+ * regressions — NOT the values. Two runs that diverge at the same op coordinates
+ * on the same paths produce the same signature (and thus the same
+ * {@link computeQuestionHash}), so a repeated regression maps to ONE open DHQ row
+ * rather than spamming duplicates. Actual/expected values are intentionally
+ * excluded so transient value noise does not fork the hash.
+ *
+ * @param regressions - The diff regressions.
+ * @returns A stable, sorted signature string.
+ */
+function regressionSignature(regressions) {
+    const pairs = regressions.map((r) => `${r.opCoord}@${r.path}`);
+    pairs.sort();
+    return pairs.join('\n');
+}
+/**
+ * Compute the sha256 `question_hash` of a diff result's normalized signature.
+ *
+ * The hash is over the {@link regressionSignature} (op coordinates + diff path
+ * set), so it is stable across runs of the SAME regression and feeds the
+ * idempotency partial-UNIQUE index (`ux_selfimprove_dhq_open`, T11889-A): one
+ * open DHQ row per `question_hash`. An empty regression set hashes the empty
+ * signature deterministically (callers should not persist on the happy path).
+ *
+ * @param result - The diff result whose regressions are hashed.
+ * @returns The lowercase hex sha256 of the regression signature.
+ *
+ * @example
+ * ```ts
+ * const hash = computeQuestionHash(diffEnvelopes(ops, replayed, golden));
+ * ```
+ */
+export function computeQuestionHash(result) {
+    const signature = regressionSignature(result.regressions);
+    return createHash('sha256').update(signature, 'utf-8').digest('hex');
+}
+//# sourceMappingURL=envelope-diff.js.map

package/dist/selfimprove/envelope-diff.js.map

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