agent-tempo 1.0.1

package/dist/scripts/258-spotcheck.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * scripts/258-spotcheck.ts — automated #258 "one-delivery-then-silence" probe
+ *
+ * Ops tooling for the v0.26.0-beta.4 burn-in window (issue #258). Replaces
+ * the manual 4-step analysis performed by tempo-researcher on 2026-04-19
+ * at ~T+2h into the burn-in (dump at C:\tmp\wf-conductor-burnin.json). Run
+ * this whenever you want a fresh read on whether the #249 fix is still
+ * holding under real ensemble traffic.
+ *
+ * NOT committed. NOT production code. No tests, no docs. If this script
+ * stops working because the wire protocol evolves, delete and rewrite.
+ *
+ * ── Usage ─────────────────────────────────────────────────────────────
+ *
+ *   npx ts-node --project scripts/tsconfig.json scripts/258-spotcheck.ts
+ *
+ *   Flags (all optional):
+ *     --ensemble <name>    Override ensemble (default: $CLAUDE_TEMPO_ENSEMBLE or 'tempo-impl')
+ *     --conductor <name>   Override conductor player name (default: 'conductor')
+ *     --json               Emit JSON instead of the human table
+ *     --save <path>        Write full report JSON to <path>
+ *
+ * ── Exit codes ────────────────────────────────────────────────────────
+ *     0  pattern-not-detected (healthy)
+ *     1  unexpected error (Temporal unreachable, workflow missing, etc.)
+ *     2  pattern-recurring (hypothesis A or B) — HIGH PRIORITY
+ *     3  inconclusive-too-early (< 30 min window)
+ *
+ * ── Assumptions ───────────────────────────────────────────────────────
+ *   • Temporal server reachable via the canonical getConfig() chain
+ *     (localhost:7233 default; overridable via TEMPORAL_ADDRESS,
+ *     ~/.claude-tempo/config.json, or ~/.config/temporalio/temporal.yaml).
+ *   • Conductor workflow ID = `claude-session-{ensemble}-conductor`
+ *     (src/config.ts::conductorWorkflowId). For non-default ensembles,
+ *     set CLAUDE_TEMPO_ENSEMBLE or pass --ensemble.
+ *   • Reads the *current* run via handle-without-runId. If a CAN has
+ *     occurred, the SDK returns the latest run — which is exactly what
+ *     we want for post-CAN health.
+ *   • Signal / update names are per docs/WIRE-PROTOCOL.md (stable):
+ *     Signals:  'heartbeat', 'markDelivered', 'receiveMessage',
+ *               'playerReport', 'setPaused', 'setPart', 'releaseHeld', ...
+ *     Updates:  'claimAttachment', 'submitOutbox', ...
+ *
+ * ── #258 pattern definitions (from C:\tmp\spike-0d17dc0f-verdict.md) ──
+ *
+ *   • Hypothesis A — adapter process death:
+ *       heartbeats stop mid-window, markDelivered goes silent while
+ *       receiveMessage continues arriving, NO reclaim attempts.
+ *
+ *   • Hypothesis B — delayed fireTerminal('destroy') via reconnect loop:
+ *       same silence signature, PLUS at least one claimAttachment reclaim
+ *       fired after the silence started (adapter tried to recover, then
+ *       a terminal-class error on the pre-check killed the poller).
+ *
+ *   Thresholds used here (conservative; tune if we recalibrate):
+ *       – Heartbeat staleness:  > 180 s since last (3× expected 60 s cadence)
+ *       – Silence skew:         receiveMessage last-ts > markDelivered last-ts + 60 s
+ *       – Too-early window:     total history span < 30 min
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@temporalio/client");
+const fs_1 = require("fs");
+const config_1 = require("../src/config");
+const connection_1 = require("../src/connection");
+// ─── CLI ──────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+function argVal(flag) {
+    const i = args.indexOf(flag);
+    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
+}
+const emitJson = args.includes('--json');
+const savePath = argVal('--save');
+const ensembleOverride = argVal('--ensemble');
+const conductorNameOverride = argVal('--conductor') ?? 'conductor';
+// ─── Helpers ──────────────────────────────────────────────────────────
+function tsIso(t) {
+    // Temporal SDK decodes protobuf Timestamp to { seconds: Long|number|bigint, nanos: number }.
+    // Fall back through a few shapes defensively; the SDK's Long type has .toNumber().
+    if (!t)
+        return '';
+    if (typeof t === 'string')
+        return t;
+    const rawSeconds = t.seconds;
+    let seconds;
+    if (typeof rawSeconds === 'bigint')
+        seconds = Number(rawSeconds);
+    else if (typeof rawSeconds === 'number')
+        seconds = rawSeconds;
+    else if (rawSeconds && typeof rawSeconds.toNumber === 'function')
+        seconds = rawSeconds.toNumber();
+    else
+        seconds = 0;
+    const nanos = typeof t.nanos === 'number' ? t.nanos : 0;
+    return new Date(seconds * 1000 + nanos / 1e6).toISOString();
+}
+function addStat(map, name, ts) {
+    const s = map.get(name) ?? { count: 0 };
+    s.count++;
+    if (!s.first)
+        s.first = ts;
+    s.last = ts;
+    map.set(name, s);
+}
+function isoToMs(iso) {
+    return iso ? new Date(iso).getTime() : 0;
+}
+function fmtDur(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const ss = s % 60;
+    return h ? `${h}h ${m}m ${ss}s` : `${m}m ${ss}s`;
+}
+function fmtSec(ms) {
+    return ms === null ? 'n/a' : `${(ms / 1000).toFixed(1)}s`;
+}
+// ─── Main ─────────────────────────────────────────────────────────────
+async function run() {
+    const config = (0, config_1.getConfig)();
+    const ensemble = ensembleOverride ?? config.ensemble ?? 'tempo-impl';
+    const workflowId = conductorNameOverride === 'conductor'
+        ? (0, config_1.conductorWorkflowId)(ensemble)
+        : `claude-session-${ensemble}-${conductorNameOverride}`;
+    const connection = await (0, connection_1.createTemporalConnection)(config);
+    try {
+        const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+        const handle = client.workflow.getHandle(workflowId);
+        const history = await handle.fetchHistory();
+        const events = history.events ?? [];
+        if (events.length === 0) {
+            throw new Error(`Workflow "${workflowId}" returned no events — is it running? (ensemble="${ensemble}", ns="${config.temporalNamespace}", addr="${config.temporalAddress}")`);
+        }
+        // Run identity (first event is EXECUTION_STARTED; capture its runId).
+        let runId = '(unknown)';
+        const startedAttrs = events[0].workflowExecutionStartedEventAttributes;
+        if (startedAttrs?.originalExecutionRunId)
+            runId = startedAttrs.originalExecutionRunId;
+        const signals = new Map();
+        const updates = new Map();
+        const hbTimes = [];
+        for (const e of events) {
+            const ts = tsIso(e.eventTime);
+            // Presence-of-attribute pattern — matches how src/adapters/base.ts
+            // detects CAN events. Avoids coupling to the numeric eventType enum.
+            if (e.workflowExecutionSignaledEventAttributes) {
+                const name = e.workflowExecutionSignaledEventAttributes.signalName ?? '<unknown>';
+                addStat(signals, name, ts);
+                if (name === 'heartbeat')
+                    hbTimes.push(isoToMs(ts));
+                continue;
+            }
+            if (e.workflowExecutionUpdateAcceptedEventAttributes) {
+                const req = e.workflowExecutionUpdateAcceptedEventAttributes.acceptedRequest;
+                const name = req?.input?.name ?? '<unknown>';
+                addStat(updates, name, ts);
+                continue;
+            }
+        }
+        // Window = first event -> last event
+        const windowStart = tsIso(events[0].eventTime);
+        const windowEnd = tsIso(events[events.length - 1].eventTime);
+        const windowMs = isoToMs(windowEnd) - isoToMs(windowStart);
+        // Heartbeat cadence stats
+        let minGap = null;
+        let maxGap = null;
+        let meanGap = null;
+        if (hbTimes.length >= 2) {
+            const gaps = [];
+            for (let i = 1; i < hbTimes.length; i++)
+                gaps.push(hbTimes[i] - hbTimes[i - 1]);
+            minGap = Math.min(...gaps);
+            maxGap = Math.max(...gaps);
+            meanGap = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+        }
+        const nowMs = Date.now();
+        const STALE_MS = 180000; // 3× 60 s expected cadence
+        const msSinceLast = hbTimes.length ? nowMs - hbTimes[hbTimes.length - 1] : null;
+        const stalled = msSinceLast !== null && msSinceLast > STALE_MS;
+        // Silence-skew detector: markDelivered silent while receiveMessage continues.
+        const receiveLast = signals.get('receiveMessage')?.last;
+        const markLast = signals.get('markDelivered')?.last;
+        const skew = !!receiveLast &&
+            !!markLast &&
+            isoToMs(receiveLast) > isoToMs(markLast) + 60000;
+        // Reclaim-after-silence detector (hypothesis B): a claimAttachment
+        // update fired AFTER markDelivered went quiet.
+        const claimLast = updates.get('claimAttachment')?.last;
+        const reclaimAfterSilence = !!claimLast && !!markLast && isoToMs(claimLast) > isoToMs(markLast) + 60000;
+        // ── Verdict ─────────────────────────────────────────────────────────
+        const TOO_EARLY_MS = 30 * 60 * 1000;
+        let verdict;
+        let verdictReason;
+        if (windowMs < TOO_EARLY_MS) {
+            verdict = 'inconclusive-too-early';
+            verdictReason = `window ${fmtDur(windowMs)} < 30 min minimum — re-run later.`;
+        }
+        else if (stalled && skew && reclaimAfterSilence) {
+            verdict = 'pattern-recurring-hypothesis-B';
+            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)}); markDelivered silent while receiveMessage continued; claimAttachment reclaim fired after silence — consistent with delayed fireTerminal('destroy').`;
+        }
+        else if (stalled && skew) {
+            verdict = 'pattern-recurring-hypothesis-A';
+            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)}); markDelivered silent while receiveMessage continued; no reclaim — consistent with adapter process death.`;
+        }
+        else if (stalled) {
+            verdict = 'pattern-recurring-hypothesis-A';
+            verdictReason = `heartbeats stale (${fmtSec(msSinceLast)} > ${STALE_MS / 1000}s threshold); no inbound-vs-outbound skew detected but cadence is broken.`;
+        }
+        else {
+            verdict = 'pattern-not-detected';
+            const lastPart = msSinceLast !== null ? `last tick ${fmtSec(msSinceLast)} ago` : 'no heartbeats';
+            const maxPart = maxGap !== null ? `max gap ${fmtSec(maxGap)}` : '';
+            verdictReason = `heartbeat cadence healthy (${lastPart}${maxPart ? `, ${maxPart}` : ''}); no signal-flow anomaly.`;
+        }
+        return {
+            workflowId,
+            runId,
+            windowStart,
+            windowEnd,
+            windowMs,
+            eventCount: events.length,
+            signals: Object.fromEntries(signals),
+            updates: Object.fromEntries(updates),
+            heartbeat: {
+                count: hbTimes.length,
+                minGapMs: minGap,
+                maxGapMs: maxGap,
+                meanGapMs: meanGap,
+                staleThresholdMs: STALE_MS,
+                msSinceLast,
+                stalled,
+            },
+            verdict,
+            verdictReason,
+            capturedAt: new Date().toISOString(),
+        };
+    }
+    finally {
+        await connection.close();
+    }
+}
+function printHuman(r) {
+    const sep = '─'.repeat(74);
+    console.log(`\n${sep}`);
+    console.log(`#258 spot-check — ${r.workflowId}`);
+    console.log(sep);
+    console.log(`Run:       ${r.runId}`);
+    console.log(`Window:    ${r.windowStart}  →  ${r.windowEnd}`);
+    console.log(`           ${fmtDur(r.windowMs)}, ${r.eventCount} events`);
+    console.log(`Captured:  ${r.capturedAt}`);
+    console.log();
+    console.log('Signal counts:');
+    const sigRows = Object.entries(r.signals).sort((a, b) => b[1].count - a[1].count);
+    if (sigRows.length === 0)
+        console.log('  (none)');
+    for (const [name, s] of sigRows) {
+        console.log(`  ${name.padEnd(22)} ${String(s.count).padStart(4)}   first=${s.first}   last=${s.last}`);
+    }
+    console.log('\nAccepted-update counts:');
+    const updRows = Object.entries(r.updates).sort((a, b) => b[1].count - a[1].count);
+    if (updRows.length === 0)
+        console.log('  (none)');
+    for (const [name, s] of updRows) {
+        console.log(`  ${name.padEnd(22)} ${String(s.count).padStart(4)}   first=${s.first}   last=${s.last}`);
+    }
+    console.log('\nHeartbeat cadence:');
+    const hb = r.heartbeat;
+    console.log(`  count=${hb.count}   min=${fmtSec(hb.minGapMs)}   max=${fmtSec(hb.maxGapMs)}   mean=${fmtSec(hb.meanGapMs)}`);
+    console.log(`  since last heartbeat: ${fmtSec(hb.msSinceLast)}   stale threshold: ${hb.staleThresholdMs / 1000}s   stalled=${hb.stalled ? 'YES' : 'no'}`);
+    console.log(`\nVerdict: ${r.verdict}`);
+    console.log(`  ${r.verdictReason}`);
+    console.log();
+}
+run()
+    .then((r) => {
+    if (emitJson) {
+        console.log(JSON.stringify(r, null, 2));
+    }
+    else {
+        printHuman(r);
+    }
+    if (savePath) {
+        (0, fs_1.writeFileSync)(savePath, JSON.stringify(r, null, 2));
+        if (!emitJson)
+            console.log(`(saved report JSON to ${savePath})`);
+    }
+    switch (r.verdict) {
+        case 'pattern-not-detected':
+            process.exit(0);
+        case 'inconclusive-too-early':
+            process.exit(3);
+        default:
+            process.exit(2); // hypothesis-A or hypothesis-B — escalate
+    }
+})
+    .catch((err) => {
+    console.error('\n[258-spotcheck] error:', err instanceof Error ? err.message : err);
+    if (err instanceof Error && err.stack)
+        console.error(err.stack);
+    process.exit(1);
+});

package/dist/scripts/check-components-css-sync.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Drift report for `dashboard/src/styles/components.css` — F-LEAD-1
+ * follow-up (PR-B of #454).
+ *
+ * The dashboard's `components.css` is a SELECTIVE port of the canonical
+ * hand-off bundle at `docs/design/dashboard-handoff/project/styles.css`.
+ * The port is re-synced manually each minor release until shadcn lands
+ * (see `docs/design/components-css-port-procedure.md`). This script
+ * surfaces how stale the port is — reads the LAST-SYNC commit out of
+ * the file's header and compares it against the most recent canonical
+ * commit. The number you see is the *line count of canonical drift*,
+ * not the number of impl-side edits required to absorb it.
+ *
+ * Output:
+ *   - 0 added/deleted lines        → exit 0, "in sync"
+ *   - 1..49 lines                  → exit 0, "minor drift"
+ *   - 50..150 lines                → exit 0, prints WARN banner
+ *                                    (CI may treat as warning)
+ *   - 151+ lines                   → exit 1, prints FAIL banner
+ *                                    (CI hard-fails, PR-B-style
+ *                                    re-sync needed)
+ *
+ * Usage:
+ *   npm run build:scripts
+ *   node dist/scripts/check-components-css-sync.js
+ *
+ * Or one-shot via ts-node:
+ *   npx ts-node scripts/check-components-css-sync.ts
+ *
+ * CI integration:
+ *   The `dashboard-build` job in `.github/workflows/...` runs the
+ *   compiled `dist/scripts/check-components-css-sync.js` after the
+ *   dashboard build. Failure mode (>150 lines) blocks merge.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const COMPONENTS_CSS = path.join(REPO_ROOT, 'dashboard', 'src', 'styles', 'components.css');
+const CANONICAL_CSS_REPO = path.join('docs', 'design', 'dashboard-handoff', 'project', 'styles.css');
+const CANONICAL_CSS_FS = path.join(REPO_ROOT, CANONICAL_CSS_REPO);
+const WARN_THRESHOLD = 50;
+const FAIL_THRESHOLD = 150;
+const EXIT_OK = 0;
+const EXIT_FAIL = 1;
+const EXIT_USAGE = 2;
+function fail(msg) {
+    console.error(`[check-components-css-sync] ${msg}`);
+    process.exit(EXIT_USAGE);
+}
+function readLastSyncCommit() {
+    if (!fs.existsSync(COMPONENTS_CSS)) {
+        fail(`components.css not found at ${COMPONENTS_CSS}`);
+    }
+    const head = fs.readFileSync(COMPONENTS_CSS, 'utf8').slice(0, 4000);
+    const match = head.match(/LAST-SYNC COMMIT:\s+([0-9a-f]{7,40})/i);
+    if (!match) {
+        fail('components.css header is missing the "LAST-SYNC COMMIT: <sha>" line. ' +
+            'The drift detector cannot run without a baseline. Re-add the marker per ' +
+            'docs/design/components-css-port-procedure.md.');
+    }
+    return match[1];
+}
+function git(...args) {
+    return (0, child_process_1.execFileSync)('git', args, { cwd: REPO_ROOT, encoding: 'utf8' }).trim();
+}
+function commitExists(sha) {
+    try {
+        git('cat-file', '-e', `${sha}^{commit}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * If the LAST-SYNC commit isn't in the local object DB (typical of
+ * GitHub Actions' default shallow checkout), try to fetch it directly.
+ * Belt-and-braces with the workflow-level `fetch-depth: 0` — if a future
+ * job copies the script without copying that checkout option, the script
+ * still self-heals instead of hard-failing.
+ *
+ * Returns true if the commit is reachable after the attempted fetch.
+ * Stays silent on success; logs the fetch attempt on failure for diagnostics.
+ */
+function tryFetchCommit(sha) {
+    try {
+        // `--no-tags --depth=1` is enough — we only need the commit object
+        // for `git diff`, not its ancestry.
+        (0, child_process_1.execFileSync)('git', ['fetch', '--no-tags', '--depth=1', 'origin', sha], {
+            cwd: REPO_ROOT,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        return commitExists(sha);
+    }
+    catch (err) {
+        console.error(`[check-components-css-sync] git fetch origin ${sha.slice(0, 12)} failed:`);
+        console.error('  ' + (err instanceof Error ? err.message : String(err)).split('\n').join('\n  '));
+        return false;
+    }
+}
+function latestCanonicalCommit() {
+    const sha = git('log', '-1', '--format=%H', '--', CANONICAL_CSS_REPO);
+    if (!sha) {
+        fail(`git log returned no commits for ${CANONICAL_CSS_REPO}. ` +
+            'Either the file path is wrong or the repo has no history yet.');
+    }
+    return sha;
+}
+function diffLineCount(fromSha, toSha) {
+    if (fromSha === toSha)
+        return 0;
+    // `git diff --shortstat` gives "1 file changed, X insertions(+), Y deletions(-)".
+    const out = git('diff', '--shortstat', `${fromSha}..${toSha}`, '--', CANONICAL_CSS_REPO);
+    if (!out)
+        return 0;
+    const ins = /(\d+) insertion/.exec(out);
+    const del = /(\d+) deletion/.exec(out);
+    return (ins ? parseInt(ins[1], 10) : 0) + (del ? parseInt(del[1], 10) : 0);
+}
+function main() {
+    if (!fs.existsSync(CANONICAL_CSS_FS)) {
+        fail(`canonical CSS not found at ${CANONICAL_CSS_FS}`);
+    }
+    const lastSync = readLastSyncCommit();
+    if (!commitExists(lastSync) && !tryFetchCommit(lastSync)) {
+        fail(`LAST-SYNC commit ${lastSync} is not in the local git history and could ` +
+            'not be fetched from origin. Run `git fetch --unshallow` locally, or — ' +
+            'if the commit was rewritten/force-pushed away — update the LAST-SYNC ' +
+            'marker to a reachable commit per ' +
+            'docs/design/components-css-port-procedure.md.');
+    }
+    const head = latestCanonicalCommit();
+    const drift = diffLineCount(lastSync, head);
+    console.log('────────────────────────────────────────────────────');
+    console.log('  components.css canonical-port drift report');
+    console.log('────────────────────────────────────────────────────');
+    console.log(`  LAST-SYNC : ${lastSync}`);
+    console.log(`  HEAD      : ${head}`);
+    console.log(`  drift     : ${drift} lines (insertions + deletions)`);
+    console.log(`  canonical : ${CANONICAL_CSS_REPO}`);
+    console.log('────────────────────────────────────────────────────');
+    if (drift === 0) {
+        console.log('  status    : IN SYNC');
+        return EXIT_OK;
+    }
+    if (drift < WARN_THRESHOLD) {
+        console.log(`  status    : minor drift (<${WARN_THRESHOLD} lines)`);
+        return EXIT_OK;
+    }
+    if (drift <= FAIL_THRESHOLD) {
+        console.log(`  status    : WARN — ${drift} lines drift (>=${WARN_THRESHOLD})`);
+        console.log('  action    : schedule a re-sync PR per');
+        console.log('              docs/design/components-css-port-procedure.md');
+        return EXIT_OK;
+    }
+    console.log(`  status    : FAIL — ${drift} lines drift (>${FAIL_THRESHOLD})`);
+    console.log('  action    : re-sync REQUIRED before merge — see');
+    console.log('              docs/design/components-css-port-procedure.md');
+    return EXIT_FAIL;
+}
+process.exit(main());

package/dist/scripts/run-shard.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Run a Mocha shard per `test/shard-config.json` (#231, design
+ * `docs/design/191-test-parallelization.md` §2).
+ *
+ * Usage:
+ *   node dist/scripts/run-shard.js <1|2>
+ *
+ *   shard-1 — run only the files listed in `shard-config.json` under
+ *     `"shard-1"`. Runs Mocha with `--no-config` so positional args are the
+ *     complete spec; the `require: root-hooks.js` + `timeout` + `exit`
+ *     options from `.mocharc.yml` are forwarded as CLI flags to preserve the
+ *     shared-env teardown hook and the existing 30s-per-test cap.
+ *     Mocha 11's default spec from mocharc unions with CLI args rather than
+ *     replacing, which is why we can't just pass positional args against the
+ *     default config — that would silently run the full suite.
+ *
+ *   shard-2 — run the default `.mocharc.yml` spec minus the shard-1 files,
+ *     via Mocha's `--ignore` flag. Mocharc config stays in charge so
+ *     `root-hooks.js` etc. land via its `require:` key, no CLI duplication.
+ *
+ * The JSON is the single source of truth. Moving a file between shards is a
+ * one-line edit; the rebalance rule lives in `test/README.md` (20% drift
+ * bound). Build/clean is handled by `pretest:shard-*` hooks in
+ * `package.json`, so this script only needs to fan args into Mocha.
+ *
+ * Exits with Mocha's own exit code (0 on success, non-zero on test failure
+ * or spawn error) so `npm run test:shard-*` and CI see identical semantics
+ * to a direct `mocha` invocation.
+ */
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const shard = process.argv[2];
+if (shard !== '1' && shard !== '2') {
+    console.error('Usage: node dist/scripts/run-shard.js <1|2>');
+    process.exit(2);
+}
+const configPath = path.join(__dirname, '..', '..', 'test', 'shard-config.json');
+const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+const shard1Sources = Array.isArray(config['shard-1']) ? config['shard-1'] : [];
+if (shard1Sources.length === 0) {
+    console.error('test/shard-config.json is missing or empty under "shard-1".');
+    process.exit(2);
+}
+// Map each source path to its compiled .js under dist-test. The helper stays
+// here (rather than in the JSON) so the JSON reads as a plain file list — no
+// build-path leakage into a config that engineers edit during rebalance.
+function toCompiled(sourcePath) {
+    return sourcePath
+        .replace(/^test\//, 'dist-test/test/')
+        .replace(/\.ts$/, '.js');
+}
+const shard1Compiled = shard1Sources.map(toCompiled);
+// For shard-1 we bypass `.mocharc.yml` entirely (`--no-config`) because
+// Mocha 11 unions the mocharc `spec:` glob with CLI args rather than
+// letting CLI args override, so a positional-args-only approach would also
+// pull in every file in the default glob. Forwarding `require` + `timeout`
+// + `exit` by hand keeps the shared TestWorkflowEnvironment teardown hook
+// wired up and the per-test timeout identical to a full-suite run.
+const shard1CliMirrorOfMocharc = [
+    '--no-config',
+    '--require',
+    'dist-test/test/root-hooks.js',
+    '--timeout',
+    '30000',
+    '--exit',
+];
+const mochaArgs = shard === '1'
+    ? [...shard1CliMirrorOfMocharc, ...shard1Compiled]
+    : shard1Compiled.flatMap((f) => ['--ignore', f]);
+// Resolve the local `mocha` binary directly rather than relying on PATH / npx
+// wrapping — avoids an extra process on CI and keeps Windows + POSIX behaviour
+// identical. `npm_execpath`-style lookup isn't worth the complexity for one
+// dev-only script.
+const mochaBin = path.join(__dirname, '..', '..', 'node_modules', '.bin', process.platform === 'win32' ? 'mocha.cmd' : 'mocha');
+console.log(`[run-shard] shard-${shard}: ${shard === '1' ? shard1Compiled.length + ' explicit files' : 'full spec minus ' + shard1Compiled.length + ' shard-1 files'}`);
+const result = (0, child_process_1.spawnSync)(mochaBin, mochaArgs, {
+    stdio: 'inherit',
+    shell: process.platform === 'win32', // .cmd on Windows needs a shell
+});
+if (result.error) {
+    console.error('[run-shard] failed to spawn mocha:', result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);