@indigoai-us/hq-cli 5.345.117 → 5.345.119

package/dist/commands/core-pipeline-driver-native.js

@@ -0,0 +1,843 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { inflateRawSync } from "node:zlib";
+import { isPipelineDriverProcess } from "./core-pipeline-driver-process.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function scanDriverState(stateDir, maxFails, hqBin, run = spawnSync) {
+    const S = stateDir, MAX = maxFails, HQ = hqBin;
+    const TERMINAL = ['passed', 'failed', 'blocked'];
+    const EARLY = 'engine_exited_early';
+    const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+    const isNum = (v) => typeof v === 'number';
+    const truthy = (v) => !(v === null || v === undefined || v === false || v === 0 || v === '' ||
+        (Array.isArray(v) && !v.length) || (isObj(v) && !Object.keys(v).length));
+    const str = (v) => v === undefined || v === null ? 'None' : v === true ? 'True' : v === false ? 'False'
+        : typeof v === 'string' ? v : JSON.stringify(v);
+    const get = (o, k, d = undefined) => (isObj(o) && Object.prototype.hasOwnProperty.call(o, k) ? o[k] : d);
+    const byteSort = (a) => a.sort((x, y) => Buffer.compare(Buffer.from(x), Buffer.from(y)));
+    function load(p) {
+        try {
+            return JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    // whole seconds since the epoch of "YYYY-MM-DDTHH:MM:SS" (first 19 chars); null when unparseable
+    function epoch(ts) {
+        const m = /^(\d{4})-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})$/.exec(String(ts).slice(0, 19));
+        if (!m)
+            return null;
+        const [y, mo, d, h, mi, s] = m.slice(1).map(Number);
+        if (mo < 1 || mo > 12 || h > 23 || mi > 59 || s > 61)
+            return null;
+        const ms = Date.UTC(y, mo - 1, d, h, mi, s);
+        if (d < 1 || new Date(Date.UTC(y, mo - 1, d)).getUTCDate() !== d)
+            return null;
+        return Math.floor(ms / 1000);
+    }
+    const now = () => Date.now() / 1000;
+    const isoNow = () => new Date().toISOString().slice(0, 19) + 'Z';
+    const collapse = (s) => Array.from(s.split(/\s+/).filter(Boolean).join(' ')).slice(0, 300).join('');
+    let lanes = null;
+    function laneRows() {
+        if (lanes === null) {
+            lanes = new Map();
+            try {
+                const owned = load(path.join(S, 'lanes.json')) || {};
+                const r = run(HQ, ['lanes', 'list', '--json'], { encoding: 'utf8', timeout: 30000 });
+                if (!r.error) {
+                    const text = String(r.stdout || ''), starts = [text.indexOf('['), text.indexOf('{')].filter((n) => n >= 0);
+                    const parsed = JSON.parse(starts.length ? text.slice(Math.min(...starts)) : text);
+                    const rows = Array.isArray(parsed) ? parsed : (isObj(parsed) && Array.isArray(parsed.lanes) ? parsed.lanes : []);
+                    for (const x of rows)
+                        if (isObj(x) && Object.values(owned).includes(get(x, 'lane_id', null)))
+                            lanes.set(get(x, 'lane_id', null), x);
+                }
+            }
+            catch (e) { /* no lanes */ }
+        }
+        return lanes;
+    }
+    function laneRow(worker) {
+        const owned = load(path.join(S, 'lanes.json')) || {};
+        return laneRows().get(owned[worker]) || null;
+    }
+    function laneStopped(worker, since) {
+        const row = laneRow(worker);
+        return !!row && get(get(row, 'loop', {}), 'state') === 'stopped';
+    }
+    function phaseExit(worker, sid, ph, since) {
+        // the lane's last phase-exit event for this phase written after it was routed
+        const row = laneRow(worker);
+        if (!row)
+            return null;
+        const state = get(get(row, 'loop', {}), 'state');
+        if (state === 'parked')
+            return { reason: 'loop_stalled', phase: ph, story_id: sid };
+        return state === 'failed' ? { reason: state, phase: ph, story_id: sid } : null;
+    }
+    function mtime(p) {
+        try {
+            return fs.statSync(p).mtimeMs / 1000;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    const out = [];
+    let active = 0;
+    const sd = path.join(S, 'stories');
+    for (const n of byteSort(fs.readdirSync(sd))) {
+        if (!n.endsWith('.json'))
+            continue;
+        const st = load(path.join(sd, n));
+        if (!isObj(st) || !('id' in st))
+            continue;
+        const sid = st.id, state = get(st, 'state', null);
+        if (['queued', 'in_flight', 'held', 'awaiting_recheck', 'interrupted'].includes(state))
+            active++;
+        const it = get(st, 'interrupted', null);
+        if (isObj(it) && truthy(it.phase) && !truthy(it.routed))
+            out.push(['INTERRUPTED', sid, str(it.phase), str(get(it, 'at', ''))]);
+        const phases = truthy(st.phases) ? st.phases : [];
+        const cur = get(st, 'current', 0);
+        if (!(Number.isInteger(cur) && cur >= 0 && cur < phases.length))
+            continue;
+        const ph = phases[cur].phase;
+        const worker = phases[cur].worker;
+        const h = path.join(S, 'handoffs', `${sid}-${ph}.json`);
+        if (state === 'queued' || state === 'held') {
+            if (fs.existsSync(h))
+                out.push(['ARCHIVE', sid, ph, h]);
+            // count attempts whose handoff said failed; blocked ones are the owner's, not a retry
+            const hd = path.join(S, 'handoffs');
+            // a retry by the owner starts the count over: archives up to fail_ack are acknowledged
+            const fa = get(st, 'fail_ack', null);
+            const ack = isObj(fa) ? Math.trunc(Number(get(fa, ph, 0) || 0)) : 0;
+            const pre = `${sid}-${ph}.failed.`;
+            const tried = fs.readdirSync(hd).filter((f) => {
+                if (!f.startsWith(pre) || !f.endsWith('.json'))
+                    return false;
+                const mid = f.slice(pre.length, -5);
+                return /^\d+$/.test(mid) && parseInt(mid, 10) > ack;
+            }).map((f) => path.join(hd, f));
+            if (fs.existsSync(h))
+                tried.push(h);
+            const hs = tried.map((f) => { const x = load(f); return isObj(x) ? x : {}; });
+            const fails = hs.filter((x) => x.status === 'failed').length;
+            const early = hs.filter((x) => x.status === 'failed' && x.exit_reason === EARLY).length;
+            if (early >= 2)
+                out.push(['FAILCAP', sid, ph, String(early), EARLY]);
+            else if (fails >= MAX)
+                out.push(['FAILCAP', sid, ph, String(fails), 'failed']);
+            if (state === 'held') {
+                const dp = path.join(S, 'decisions', `${sid}-${get(st, 'held_for', worker)}.md`);
+                out.push(['HELD', sid, dp]);
+            }
+        }
+        else if (state === 'in_flight') {
+            const hd = load(h);
+            let since = get(st, 'routed_at', null);
+            if (!isNum(since))
+                since = mtime(path.join(S, 'envelopes', `${sid}-${ph}.json`));
+            const mine = isObj(hd) && hd.phase === ph;
+            const hstat = mine ? get(hd, 'status', null) : null;
+            let ev = null;
+            if (mine && TERMINAL.includes(hstat) && get(hd, 'exit_reason', null) !== EARLY) {
+                out.push(['ACCEPT', sid, ph, h]);
+            }
+            else if (mine && get(hd, 'exit_reason', null) === EARLY) {
+                let secs = get(hd, 'elapsed_s', null);
+                if (!isNum(secs))
+                    secs = since !== null ? Math.trunc(now() - since) : 0;
+                const why = collapse(str(truthy(hd.notes) ? hd.notes : truthy(hd.summary) ? hd.summary : 'no reason given'));
+                out.push(['EARLY', sid, ph, String(Math.trunc(secs)), why]);
+            }
+            else if ((!mine || !TERMINAL.includes(hstat)) && (ev = phaseExit(worker, sid, ph, since)) !== null) {
+                let secs = get(ev, 'elapsed_s', null);
+                if (!isNum(secs))
+                    secs = since !== null ? Math.trunc(now() - since) : 0;
+                const why = collapse(str(truthy(ev.reason) ? ev.reason : 'no reason given'));
+                if (get(ev, 'reason', null) === 'loop_stalled')
+                    out.push(['LANE_STALLED', sid, ph, worker]);
+                else
+                    out.push(['EARLY', sid, ph, String(Math.trunc(secs)), why]);
+            }
+            else if (laneStopped(worker, since)) {
+                out.push(['LANE_STOPPED', sid, ph]);
+            }
+            else {
+                const env = load(path.join(S, 'envelopes', `${sid}-${ph}.json`));
+                const dl = get(env, 'deadline', null);
+                if (typeof dl === 'string' && isoNow() > dl)
+                    out.push(['DEADLINE', sid, ph, dl]);
+                if (since !== null)
+                    out.push(['INFLIGHT', sid, ph, String(Math.max(0, Math.trunc(now() - since)))]);
+            }
+        }
+        else if (state === 'awaiting_go') {
+            out.push(['AWAITING_GO', sid, path.join(S, 'decisions', `${sid}-go.md`)]);
+        }
+        else if (state === 'blocked_needs_owner') {
+            out.push(['BLOCKED', sid, ph, path.join(S, 'decisions', `${sid}-blocked-${ph}.md`)]);
+        }
+        else if (state === 'awaiting_recheck') {
+            out.push(['RECHECK', sid]);
+        }
+    }
+    out.push(['ACTIVE', String(active)]);
+    return out.map((r) => r.join('\t') + '\n').join('');
+}
+export function checkDriverStall(stateDir, stallWindow, hqBin, run = spawnSync) {
+    const S = stateDir, W = stallWindow, HQ = hqBin;
+    const SF = path.join(S, 'driver', 'stall.json');
+    const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+    const truthy = (v) => !(v === null || v === undefined || v === false || v === 0 || v === '' ||
+        (Array.isArray(v) && !v.length) || (isObj(v) && !Object.keys(v).length));
+    const get = (o, k, d = undefined) => (isObj(o) && Object.prototype.hasOwnProperty.call(o, k) ? o[k] : d);
+    const byteSort = (a) => a.sort((x, y) => Buffer.compare(Buffer.from(x), Buffer.from(y)));
+    const cmp = (x, y) => (x < y ? -1 : x > y ? 1 : 0);
+    function load(p) {
+        try {
+            return JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    function epoch(iso) {
+        const m = /^(\d{4})-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})$/.exec(String(iso).slice(0, 19));
+        if (!m)
+            return null;
+        const [y, mo, d, h, mi, s] = m.slice(1).map(Number);
+        if (mo < 1 || mo > 12 || h > 23 || mi > 59 || s > 61)
+            return null;
+        if (d < 1 || new Date(Date.UTC(y, mo - 1, d)).getUTCDate() !== d)
+            return null;
+        return Math.floor(Date.UTC(y, mo - 1, d, h, mi, s) / 1000);
+    }
+    const now = () => Date.now() / 1000;
+    const iso = (secs) => new Date(Math.floor(secs) * 1000).toISOString().slice(0, 19) + 'Z';
+    // Python json.dumps default output: ", " / ": " separators, non-ASCII escaped
+    function dumps(v) {
+        if (v === null || v === undefined)
+            return 'null';
+        if (v === true)
+            return 'true';
+        if (v === false)
+            return 'false';
+        if (typeof v === 'number') {
+            let s = String(v);
+            const m = /^(-?)(\d)(?:\.(\d+))?e([+-])(\d+)$/.exec(s);
+            if (m)
+                s = m[1] + m[2] + (m[3] ? '.' + m[3] : '') + 'e' + m[4] + m[5].padStart(2, '0');
+            return s;
+        }
+        if (typeof v === 'string')
+            return JSON.stringify(v).replace(/[\u0080-￿]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'));
+        if (Array.isArray(v))
+            return '[' + v.map(dumps).join(', ') + ']';
+        return '{' + Object.keys(v).map((k) => dumps(k) + ': ' + dumps(v[k])).join(', ') + '}';
+    }
+    let rows = [];
+    try {
+        const owned = load(path.join(S, 'lanes.json')) || {};
+        const r = run(HQ, ['lanes', 'list', '--json'], { encoding: 'utf8', timeout: 30000 });
+        const text = String(r.stdout || ''), starts = [text.indexOf('['), text.indexOf('{')].filter((n) => n >= 0);
+        const parsed = JSON.parse(starts.length ? text.slice(Math.min(...starts)) : text);
+        const listed = Array.isArray(parsed) ? parsed : (isObj(parsed) && Array.isArray(parsed.lanes) ? parsed.lanes : []);
+        rows = listed.filter((row) => isObj(row) && Object.values(owned).includes(get(row, 'lane_id', null)));
+    }
+    catch (e) {
+        return '';
+    }
+    const inflight = [];
+    const sd = path.join(S, 'stories');
+    for (const n of byteSort(fs.readdirSync(sd))) {
+        const st = n.endsWith('.json') ? load(path.join(sd, n)) : null;
+        if (!isObj(st) || st.state !== 'in_flight')
+            continue;
+        const phases = truthy(st.phases) ? st.phases : [];
+        const cur = get(st, 'current', 0);
+        if (!(Number.isInteger(cur) && cur >= 0 && cur < phases.length))
+            continue;
+        let since = get(st, 'routed_at', null);
+        if (typeof since !== 'number') {
+            try {
+                since = fs.statSync(path.join(S, 'envelopes', `${st.id}-${phases[cur].phase}.json`)).mtimeMs / 1000;
+            }
+            catch (e) {
+                since = now();
+            }
+        }
+        inflight.push([st.id, phases[cur].worker, since]);
+    }
+    const live = rows.filter((r) => isObj(r) && isObj(r.loop));
+    let cond = false, stories = [], lanes = [], since = null;
+    if (inflight.length && live.length && live.every((r) => r.loop.state === 'waiting' && r.loop.queue_depth === 0)) {
+        cond = true;
+        stories = inflight.map((x) => x[0]);
+        lanes = live.map((r) => get(r, 'lane_id', null)).sort(cmp);
+        const changed = live.filter((r) => truthy(r.loop.updated_at)).map((r) => epoch(r.loop.updated_at));
+        since = Math.max(Math.min(...inflight.map((x) => x[2])), ...changed.filter((c) => c !== null));
+    }
+    else {
+        // a routed phase sits in its lane queue and the lane has nothing active
+        const owned = load(path.join(S, 'lanes.json')) || {};
+        const byWorker = new Map();
+        for (const r of live)
+            for (const [worker, lane] of Object.entries(owned))
+                if (lane === get(r, 'lane_id', null))
+                    byWorker.set(worker, r);
+        for (const [sid, worker, s] of inflight) {
+            const r = byWorker.get(worker);
+            if (r && get(r.loop, 'queue_depth', 0) > 0 && !truthy(get(r.loop, 'active_envelope_id', null))) {
+                cond = true;
+                stories.push(sid);
+                lanes.push(get(r, 'lane_id', worker));
+                since = since === null ? s : Math.min(since, s);
+            }
+        }
+    }
+    const prev = load(SF);
+    if (!cond) {
+        if (isObj(prev) && !truthy(prev.fired))
+            fs.unlinkSync(SF);
+        return '';
+    }
+    if (isObj(prev)) {
+        if (truthy(prev.fired))
+            return '';
+        since = get(prev, 'since_epoch', since);
+    }
+    const sinceEpoch = Number(since);
+    const sinceIso = iso(sinceEpoch);
+    const rec = { since_epoch: since, since: sinceIso, stories, lanes: [...new Set(lanes)].sort(cmp), fired: false };
+    if (now() - sinceEpoch >= W) {
+        rec.fired = true;
+        fs.appendFileSync(path.join(S, 'events.jsonl'), dumps({ event: 'stall', stories, lanes: rec.lanes, since: sinceIso,
+            at: iso(now()) }) + '\n');
+        rec.fireLine = 'FIRE ' + sinceIso + ' stories=' + stories.join(',') + ' lanes=' + rec.lanes.join(',');
+    }
+    const fireLine = rec.fireLine || '';
+    delete rec.fireLine;
+    fs.writeFileSync(SF + '.tmp', dumps(rec));
+    fs.renameSync(SF + '.tmp', SF);
+    return fireLine;
+}
+export function acquirePipelineDriverLock(driverDir, pid) {
+    const lock = path.join(driverDir, "lock");
+    try {
+        fs.mkdirSync(lock);
+        fs.writeFileSync(path.join(lock, "pid"), `${pid}\n`);
+        return { acquired: true };
+    }
+    catch {
+        let holder = "";
+        try {
+            holder = fs.readFileSync(path.join(lock, "pid"), "utf8").trim();
+        }
+        catch { /* stale or incomplete lock */ }
+        const holderPid = Number.parseInt(holder, 10);
+        if (isPipelineDriverProcess(holderPid))
+            return { acquired: false };
+        fs.rmSync(lock, { recursive: true, force: true });
+        try {
+            fs.mkdirSync(lock);
+            fs.writeFileSync(path.join(lock, "pid"), `${pid}\n`);
+            return { acquired: true, stalePid: holder || "none" };
+        }
+        catch {
+            return { acquired: false };
+        }
+    }
+}
+export function releasePipelineDriverLock(driverDir) {
+    fs.rmSync(path.join(driverDir, "lock"), { recursive: true, force: true });
+}
+// Exact `usage()` output from the pinned pipeline-driver.sh companion.
+const DRIVER_USAGE = inflateRawSync(Buffer.from("lVptcxu3Ef7OX7FDfjDZ4VG2kiYppWom4yiNWtd2bCdNJ82Q0N1ShwgHnAFQFCfNf+/sLnB3pCRPyi+27w6Lxb48++zCE2h1i0ZbLCqv79AvQg0FxBqhwqjKGiswzrVwjbW2FZz4rS1a737FMkJR5MWL0WQ0ga/BKItQKmtdhFvEFhSUtTYVKKPvEFoVIugYwO0soL3R/LUxcwiO9+StYq3iaAKNu8MAqlMQNs7vlK+gchiAdmCZ2oLifRfwoaYtPNoIAUPQzkKIyscwmkCsdYBQet1GiLV325sa6o+FHJIOrWwFyje0407piB6cBR0XcBWhUbe8ZdJ5NGGtwwIuVVnTqQLouBxNAODFolM8RGUQamUrt9mA24ACj8XHLW6xgrZWAUEFXSFM0zfh5FxXF8U5v7tYbJQ2WC3O7cXi1+DsbM4bnC5AlSW2MbDFsngltmMH7LyLCNGBx7A1cdWqWJP1QNk9aFtsjL6pI0sDSJpMuzgona22ZXQcCrJV2vqzBfitDeCxrLG8ZZF4h34PITq/B0WG0/YGdJQFny8g6vJWNO3ksmZuSyrWCBbvY9LBefFX/5zlkizyDt5T6OxqtPxB8rQOYBErrGg5PfdbSw8dBXMKy2yknY41bRG3AdZi3jV9y9pUoG6UtrC1URvZgbWqVQD5djSBomjUfcEvCnoYIOoGw+KpTa6NK2/TLpZslfaiI9FuyyPT1M5UgTMg2zRAkrGiY4aV21n0bI+d15ECbTSBCkvN8a4jNnN+yynMKc2ZKIck5ww9xht1+VRhi5ZU6yNfbH76gn1NIpMyab2zZi8esS7WLN0ERgDOArH/D0HdoGTHY2BTtL6C89ZXHOUXUBRkPITzSvuLHKTHv5+LYuf8bfSYPoT/wvCRx9Zd/FXeLBaLXz4hh09SXHtlyxrDL/QoqmuDcM5/LGK4u+Cn2kb0d8rAeUDyWLj4lNjjODm3IoVQwRQ7bSu3+2OSlDFuV9CJQnfCX9iyj79jQMLQwVx0nIVLUEMTbW1F0UgrT0ATRLpYo9/pgOBxsw1YPQUKeN8apS3l4n4m0cZBr6ME12gCaO/QuBZzapFohIjGCBiQGshIgJXuEZlehRqNoWRWbWv2BF5lvUjH7bSnpMUWlXhKCyIceH3jfLMEJIBmDz8Lks8BbhxExyVB9GCBbiObp09J0lPHr1y5bdDGALXbCeRgSwJZqeDMHVYzqUbXynPdaiCgT+XMJ2s5KwsXcByDo8kTLoQpLQpRcQrK59CiT9mobYioKjoLfbdBFbeeqtXgS9pxRlsmy3XYvNG+wapzDL/tDHDSpcLsjA4an1BwDrtalzVVCOcrqorkG7+1nNs9MHX2FDfYFHGhLw0qoe+udqELF4JiS1/sSKyOMCV8gtMv4RqN280kTF6pLZ12uvGu4d2++x68c3EmGHStQg2l83gidCCcHPCAojDuZqMp/xmHLk4Eq07SJ8bdQFHAf1LCHsv6vxBONoBjLONTfKsNhpSlR5rIOdIGra4AhN7IEwp0XZEjyL+RSzYvCNG1rAHpTcUjooXrPawfD3P6fA1TxX/pEnr+EKh+G99qW42XY/pwPF8sFr/Pzob1x6OSWMCOLlEg0OeiGdWUkyyuRnOk/RmRKQZKKF27l8oZhCYE1XBGRIRK+4fKDQJLuEUKmc9nsLUGQ2JRzpCdyYaoqqF5yd1AUIS2KqjczTm3uOpH1bTEj4mcUm6pMmpneTVvkn/j89JVeEH4pCgAxp31neUv5115FVLzLCQOypFwSbJIQhDH018BGlSWCu4f/g04E6Uci3rOb4aMYKOtDsT6p3fo9UZjNU/sZ0XQ4eOcjUoOlX8vmgq+vXr99auB7YU1YrVqlY9aMZq3yt9iNTsbLKN07pee8tItkQVA753/Y8fa6HvMINY0yor3TvlkRLhvfGoFbihGyMNbfFIY01vyRwawNa16qjb/kZ9Q8DVJ7HoRIELF6vW8LbPYJTcOjOZBUkGIexKmqpCasyHhG5q+bb27U+asQ1CPcest1QuhbvNuB7I/qJD4uRBLZ0uc95ghP+u6QjnnytyrmDn/6sYJvPOP5DVUuClCk1/mBwIfYYtnqZYeekyC7wzcMLkfnE2+eoqeQ2f9ASwNxE270p8KohXTP06+Bwu5kGdfpPYtrejauKaaic85wJXtO7B0CC6lFffFHW0iGGJcAW61RG9q7kTUZ9nIfefQeuKnFQTXoBh3a/G+xTKSyzmbJHx6YDswaC+Jetu+4wE4/VwUZ36YMV0ZkraXjOkBmZpsBmMAg4oYj2A4QZUI+7MEctSegl0MTxtKS2ndDjbap4yWN/QrBrriHWFY3xGefiWSv6CX3ABXbmeXgJZ7bdi4LfX2ENE32irTd8pnrIphvpC2tKpJxx5GctuSQXeKrOdaAv3MZCRqQlT7kEKCqcqz0O8yDHzp/nOkUzXgHXv/HuNHYkePR+/plyk7aeUyZwVVj8f4Ei1mT1YJRLzbzSGffqDkU2wwkcZU3OXkSUkV5agHqg5EioE+efq0V/oNT/lVkmCM+H7Zlctd7QzCUVMl5SxFOy8ITHvMPCXToV6esoZNr6XssqspsZUFbNq4F70F3boY4SXhCNdzMnVYoi1IrgtuPkj+ZyEHWcqr6ZDUGDMM+4wNgYKe+W9gJZ4lw4rSGVqh7+spoSRHZwdFOuo7XHTkcmgpuMGDE/025rfM8ZQx4zlxPa8xjJc/U3s9H7M1un8FbUscL891cBe/ixP/AomCUvY4iumPWwwRponU9uyUebv8Pg3bnyKus+NE4tykZNIRdoq6tzQgayROX3z2/OTF558BcJvvt8Rf4CSDBv3j0d+jGo4mcDWQIn3nktleplotTLsTz+H91d8+XL77J//l6vWH2QF7llr8xGE7bdep2dV2lQKsC8KGqResBydbjyYSLv2cixFNN9xNJ+9yQRu0bgclirJFx7ryakdksuu2OJVSQMpkSB61mrtWHWHbUluRuWGem+kAt9hGUHTaxyeigwP0Y1GavfWzT4YiqgsSZdK9DAcS0lnkFCVI73JU5l4w/dVtPdWJNYktKmdxDWpDI2EBNe5Q53SwpOaMTXwwt+vSeKf2MgvggWbyqbQiLIdOOwy5ZHpK2hDncI0b5wktXYuWz0Sgo6T50cdBdpY07E5bKs/SJNCrFR9j1a1bQvQJ2VqvnV91Q0zynOJBxKGX8F6HGBbw4erlP7jzkV7uqBdgiByqN5p0B+vmq3ug6chw9ir9+6XyZp+vB8iVy6RO7+ZnYXh9IBT5gBJKbLpt5ENsAxewdIZ5H6Z5hJr548EMl7ZeSZkaTWAsG64ktlZISo7l1gDWwjjp1TrRk6ksnAMa1RK9S5O+GcGOZnBNYSaIezBB5plHGiFrwXAhibkXo2KSJ7HyAQ2UU9d1lqoX9FolpRIJSBbMYc5gPQCCHWdg8gu3nlubAK6P6De2n9LzaGqAWMbdBLj8+t2rf68uf7r6wOqkeZsM9AeIk83DyMPWTJcbmpCg9wyv6MZLOXF6palvgYZSJbpeVXYyl1SZtkneaQutUSUydKTBAvuTMoeslYeBJCJdAqS5fKY9mYBI05RmCi/mD5gN5+KDuJkt4F8MQ/R5CmRmztqYzJZTm5faAL7CmZ6ezmTMSJRN2RusJGPeMTp0afJYCxXgGku1DSgXUYPxPzVxQuZHE+ib/sG4oGuGHy9BvIf0ubxVnmeOJkDoDUVh6T7qPOJ9vFjD1ElNg7WA2jrNSvsGhIvH4S0IoQOFuFwfMjaCblqDNIgla6XQzSWNd0zh3o2uOtKemnoBinXG1nUOr444cZ1O9yYUKymAsOpqMwdiLgsZo0XnhNx05yadU7r547dnErA6ZounJmqoXppVpOB6PlvAj8k76aaGZ9CEoaRr3n35AIsNIbYkS0M5Nc5Oziqyl6gSZhnjdHGW2fCNWx7GDHfDzI/vW6NLHWmoPs2zhyWM8/PxPF3L0Z1pdjDP1w2SwyqMSI9m3bhjMFDI+nUuJ6M8cLpEz6NXXZKNVEZlgJfaLB0oxSmcBnvl8kRXEkzSugpHcdQ3zRJFXdvSpCjL0HH6Iuc/EyZ77I3Fk1nkct6wP9YcUGykQOB11qHXAGiFlOiYUUA+CGqDcb9MxxiOmCjLe6LWTU3n6WqS3zTYOL9fjCZHSclXfRmcVVerNoNxUIaTnoI6m2/zE34Hl2Rk9zDGZmFxp0tGQgXWFa6dp/ra5R1ddeaZMhEavg72mKoauZXvR7jJEKO874cLy+NGcVrhRhFqffH8ea7Pc4ILeHv19vLV1evL1Tfvrn68fLd6/+HrV69W7y9fvqc7BgC2jXSkif4nRmYU/88BqR80VCacetDypdvvVPJYYHcCLlmp9gvIJ+6d6HEXjCe8v7RMZNZsJZleZwjzGDDybe6HTHrE76Uj87HL1/VH6WYlNYqCZK5ZzpQpl6wgLYTXV9jGOsG2MAuZ2TCmyX2UMuaMJfTuJiQUmC4NKh9Yq9eO1NQbXSoankPt3G0imV2RlfPKGCU42otbdOFusdNhOBF6aqDeBYWPy55Oyn9IiTVqD0ZvsNyXBh+5wkhfdCZJfNXeLR9EzMs3r7/54eWHN++6KFvC44kvFMrx8EyOyFdJszN4+3L13feD9fXH2VnK6rcvV3+CO+U1E9vDSaDoenhBJ5q+ffP+6ie6sppWKtQFuYH6p3f4ccv++/UjTP/+/s3rJIIvaRoeu1Q6hpkgn6tw9D8=", "base64")).toString("utf8");
+function parseDriverArgs(args) {
+    const values = { prd: "", state: "", worktrees: [], storyBranches: false, allowReposWorktree: false,
+        table: "", interval: "15", maxFails: "2", stallWindow: process.env.PIPELINE_DRIVER_STALL_SECS || "600" };
+    for (let index = 0; index < args.length;) {
+        const arg = args[index] ?? "";
+        if (["--prd", "--state", "--worktree", "--interval", "--max-phase-fails", "--stall-window", "--table"].includes(arg)) {
+            if (index + 1 >= args.length)
+                return { error: `pipeline-driver: ${arg} needs a value` };
+            const value = args[index + 1] ?? "";
+            if (arg === "--prd")
+                values.prd = value;
+            else if (arg === "--state")
+                values.state = value;
+            else if (arg === "--worktree")
+                values.worktrees.push(value);
+            else if (arg === "--interval")
+                values.interval = value;
+            else if (arg === "--max-phase-fails")
+                values.maxFails = value;
+            else if (arg === "--stall-window")
+                values.stallWindow = value;
+            else
+                values.table = value;
+            index += 2;
+            continue;
+        }
+        if (arg === "--story-branches")
+            values.storyBranches = true;
+        else if (arg === "--allow-repos-worktree")
+            values.allowReposWorktree = true;
+        else if (arg === "-h" || arg === "--help")
+            return { usage: true };
+        else
+            return { error: `pipeline-driver: unknown argument: ${arg}` };
+        index += 1;
+    }
+    if (!values.prd || !values.state)
+        return { usage: true };
+    if (!/^(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(values.interval) || values.interval === ".")
+        return { error: "pipeline-driver: --interval must be a number of seconds" };
+    if (!/^[0-9]+$/.test(values.maxFails) || values.maxFails === "0")
+        return { error: "pipeline-driver: --max-phase-fails must be a positive integer" };
+    if (!/^[0-9]+$/.test(values.stallWindow) || values.stallWindow === "0")
+        return { error: "pipeline-driver: --stall-window must be a positive number of seconds" };
+    if (!fs.existsSync(values.prd) || !fs.statSync(values.prd).isFile())
+        return { error: `pipeline-driver: no such prd: ${values.prd}` };
+    return { options: { ...values, interval: Number(values.interval), maxFails: Number.parseInt(values.maxFails, 10), stallWindow: Number.parseInt(values.stallWindow, 10) } };
+}
+let driverHqRoot = "";
+export function pipelineDriverChildEnvironment(base, hqRoot = driverHqRoot) {
+    return hqRoot ? { ...base, PC_HQ_ROOT: hqRoot } : base;
+}
+function driverRun(command, args, timeout = 30_000) {
+    const env = pipelineDriverChildEnvironment(process.env);
+    const result = spawnSync(command, args, { encoding: "utf8", timeout, stdio: ["ignore", "pipe", "pipe"], maxBuffer: 1 << 30, env });
+    return {
+        code: result.signal ? 128 + ({ SIGINT: 2, SIGTERM: 15 }[result.signal] ?? 0) : result.status ?? 1,
+        stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? result.error?.message ?? ""),
+    };
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonOutput(text) {
+    const starts = [text.indexOf("["), text.indexOf("{")].filter((n) => n >= 0);
+    return JSON.parse(starts.length ? text.slice(Math.min(...starts)) : text);
+}
+function writeDriverLog(file, message) {
+    fs.appendFileSync(file, `${new Date().toISOString().replace(/\.\d{3}Z$/, "Z")} ${message}\n`);
+}
+function readDriverLines(state, maxFails, hq) {
+    return scanDriverState(state, maxFails, hq).split("\n").filter(Boolean);
+}
+function parseScanLine(line) { return line.split("\t"); }
+export function failcapExplanation(story, phase, attempts, maxFails, earlyExit, reason, decision) {
+    const context = earlyExit
+        ? `phase ${story}/${phase}: engine_exited_early in ${attempts} of ${attempts} attempt(s); the lane was restarted once in place and the engine exited early again`
+        : `phase ${story}/${phase} returned handoff status failed in ${attempts} of ${attempts} attempt(s) (limit ${maxFails})`;
+    return `${context}; reason: ${reason}; held for the owner (decision: ${decision}); the parent decides whether to retry, change the story, or stop`;
+}
+export function stalledLaneContext(state, worker) {
+    const run = readJson(path.join(state, "run.json")) || {};
+    const laneMap = readJson(path.join(state, "lanes.json")) || {};
+    return {
+        lane: typeof laneMap[worker] === "string" ? laneMap[worker] : "",
+        company: typeof run.company_slug === "string" ? run.company_slug : "",
+    };
+}
+export function pendingLaneQuestion(text, lane) {
+    const parsed = parseJsonOutput(text);
+    const rows = Array.isArray(parsed) ? parsed : parsed?.questions;
+    const pending = Array.isArray(rows) ? rows.find((item) => item?.lane_id === lane && item?.status === "pending") : undefined;
+    return pending ? JSON.stringify(pending) : "";
+}
+function nextArchiveName(state, story, phase) {
+    let count = 1;
+    while (fs.existsSync(path.join(state, "handoffs", `${story}-${phase}.failed.${count}.json`)))
+        count += 1;
+    return path.join(state, "handoffs", `${story}-${phase}.failed.${count}.json`);
+}
+export async function sleep(ms, signal) {
+    await new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        let timer;
+        const finish = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", finish);
+            resolve();
+        };
+        timer = setTimeout(finish, ms);
+        signal?.addEventListener("abort", finish, { once: true });
+    });
+}
+function writeEarlyHandoff(state, storyId, phase, seconds, reason) {
+    const story = readJson(path.join(state, "stories", `${storyId}.json`));
+    const storyRecord = story && typeof story === "object" ? story : {};
+    const current = Number.isInteger(storyRecord.current) ? storyRecord.current : 0;
+    const worker = storyRecord.phases?.[current]?.worker ?? "None";
+    const handoffPath = path.join(state, "handoffs", `${storyId}-${phase}.json`);
+    const loaded = readJson(handoffPath);
+    const handoff = loaded && typeof loaded === "object" && loaded.phase === phase ? loaded : {};
+    const elapsed = Number(seconds);
+    const record = {
+        ...handoff,
+        schema: "hq-phase-handoff/v1",
+        story_id: storyId,
+        phase,
+        worker_id: handoff.worker_id || worker,
+        status: "failed",
+        exit_reason: "engine_exited_early",
+        elapsed_s: elapsed < 0 ? Math.ceil(elapsed) : Math.floor(elapsed),
+    };
+    const summary = record.summary === undefined || record.summary === null ? "None" : String(record.summary);
+    if (!summary.startsWith("engine_exited_early"))
+        record.summary = `engine_exited_early after ${seconds}s: ${reason}`;
+    if (!Object.hasOwn(record, "files_changed"))
+        record.files_changed = [];
+    if (!Object.hasOwn(record, "commits"))
+        record.commits = [];
+    if (!Object.hasOwn(record, "back_pressure"))
+        record.back_pressure = { tests: "skip", lint: "skip", typecheck: "skip", build: "skip" };
+    if (!Object.hasOwn(record, "context_for_next"))
+        record.context_for_next = "";
+    if (!Object.hasOwn(record, "notes"))
+        record.notes = reason;
+    fs.writeFileSync(handoffPath, `${JSON.stringify(record)}\n`);
+    return handoffPath;
+}
+function driverTimestamp() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function laneRowsFromHq(hq) {
+    const result = driverRun(hq, ["lanes", "list", "--json"]);
+    if (result.code !== 0)
+        throw new Error(`hq lanes list --json exited ${result.code}: ${result.stderr.trim()}`);
+    return extractLaneRows(result.stdout);
+}
+function extractLaneRows(text) {
+    const parsed = parseJsonOutput(text);
+    if (Array.isArray(parsed))
+        return parsed;
+    if (parsed && Array.isArray(parsed.lanes))
+        return parsed.lanes;
+    throw new Error("hq lanes list --json returned an unexpected JSON shape");
+}
+export async function stopDriverLanes(state, hq, logFile, options = {}) {
+    const laneFile = path.join(state, "lanes.json");
+    if (!fs.existsSync(laneFile))
+        return true;
+    const owned = readJson(laneFile) || {};
+    const laneIds = Object.values(owned).filter((lane) => typeof lane === "string" && lane.length > 0);
+    for (const lane of laneIds)
+        (options.stop ?? ((id) => { driverRun(hq, ["lanes", "stop", id]); }))(lane);
+    const deadline = Date.now() + (options.timeoutMs ?? 60_000);
+    while (Date.now() < deadline) {
+        let rows;
+        try {
+            rows = options.query ? options.query() : laneRowsFromHq(hq);
+        }
+        catch (error) {
+            writeDriverLog(logFile, `LANE_LIST_FAILED ${error instanceof Error ? error.message : String(error)}; retaining lane mappings`);
+            await sleep(options.pollMs ?? 2000);
+            continue;
+        }
+        const allStopped = laneIds.every((lane) => {
+            const row = rows.find((item) => item?.lane_id === lane);
+            return !row || row.loop?.state === "stopped";
+        });
+        if (allStopped) {
+            fs.writeFileSync(laneFile, "{}\n");
+            return true;
+        }
+        await sleep(options.pollMs ?? 2000);
+    }
+    writeDriverLog(logFile, "LANE_STOP_TIMEOUT unable to confirm all mapped lanes stopped or absent within 60s");
+    return false;
+}
+export async function runPipelineDriverNative(args, hqRoot = "") {
+    const parsed = parseDriverArgs(args);
+    if (parsed.usage) {
+        process.stderr.write(DRIVER_USAGE);
+        return 2;
+    }
+    if (parsed.error) {
+        process.stderr.write(`${parsed.error}\n`);
+        return 2;
+    }
+    const opts = parsed.options;
+    driverHqRoot = hqRoot;
+    const hq = process.env.PC_HQ || "hq";
+    const stateInput = path.resolve(opts.state);
+    fs.mkdirSync(stateInput, { recursive: true });
+    for (const name of ["stories", "handoffs", "envelopes", "driver"])
+        fs.mkdirSync(path.join(stateInput, name), { recursive: true });
+    const state = fs.realpathSync(stateInput);
+    const driverDir = path.join(state, "driver");
+    const logFile = path.join(driverDir, "driver.log");
+    process.title = "pipeline-driver";
+    const lockResult = acquirePipelineDriverLock(driverDir, process.pid);
+    if (!lockResult.acquired) {
+        let holder = "";
+        try {
+            holder = fs.readFileSync(path.join(driverDir, "lock", "pid"), "utf8").trim();
+        }
+        catch { /* report empty holder */ }
+        process.stderr.write(`pipeline-driver: another driver (pid ${holder}) runs against ${state}\n`);
+        writeDriverLog(logFile, `REFUSED second copy pid=${process.pid} holder=${holder}`);
+        return 24;
+    }
+    if (lockResult.stalePid !== undefined)
+        writeDriverLog(logFile, `STALE_LOCK pid=${lockResult.stalePid}; taking it over`);
+    fs.writeFileSync(path.join(driverDir, "driver.pid"), `${process.pid}\n`);
+    fs.rmSync(path.join(driverDir, "exit"), { force: true });
+    const finish = (code, reason) => {
+        fs.writeFileSync(path.join(driverDir, "exit"), `${code} ${reason}\n`);
+        writeDriverLog(logFile, `EXIT ${code} ${reason}`);
+        releasePipelineDriverLock(driverDir);
+        fs.rmSync(path.join(driverDir, "driver.pid"), { force: true });
+        return code;
+    };
+    const runPc = (pcArgs) => driverRun(hq, ["core", "pipeline", "conductor", ...pcArgs]);
+    const runTick = () => {
+        const pcArgs = ["tick", "--prd", opts.prd, "--state", state];
+        if (opts.storyBranches)
+            pcArgs.push("--story-branches");
+        if (opts.allowReposWorktree)
+            pcArgs.push("--allow-repos-worktree");
+        if (opts.table)
+            pcArgs.push("--table", opts.table);
+        for (const worktree of opts.worktrees)
+            pcArgs.push("--worktree", worktree);
+        return runPc(pcArgs);
+    };
+    let stopSignal = "";
+    const stopWait = new AbortController();
+    const onTerm = () => { stopSignal = "terminated"; stopWait.abort(); };
+    const onInt = () => { stopSignal = "interrupted"; stopWait.abort(); };
+    process.on("SIGTERM", onTerm);
+    process.on("SIGINT", onInt);
+    const removeHandlers = () => { process.off("SIGTERM", onTerm); process.off("SIGINT", onInt); };
+    const stop = async (code, reason) => {
+        const result = runPc(["interrupt", "--state", state, "--note", reason]);
+        writeDriverLog(logFile, `INTERRUPT rc=${result.code}: ${result.stdout.replace(/[\r\n]+/g, " ")}`);
+        await stopDriverLanes(state, hq, logFile);
+        fs.rmSync(path.join(driverDir, "stop.json"), { force: true });
+        removeHandlers();
+        return finish(code, reason);
+    };
+    writeDriverLog(logFile, `START pid=${process.pid} prd=${opts.prd} interval=${opts.interval}s max_phase_fails=${opts.maxFails} stall_window=${opts.stallWindow}s`);
+    const stopFile = path.join(driverDir, "stop.json");
+    if (fs.existsSync(stopFile)) {
+        writeDriverLog(logFile, "STALE_STOP removed driver/stop.json left from an earlier stop");
+        fs.rmSync(stopFile, { force: true });
+    }
+    try {
+        let goLast = "";
+        for (;;) {
+            if (stopSignal) {
+                const signal = stopSignal;
+                return await stop(signal === "terminated" ? 143 : 130, signal);
+            }
+            if (fs.existsSync(stopFile)) {
+                const stopText = fs.readFileSync(stopFile, "utf8").replace(/[\r\n]+/g, " ");
+                return await stop(29, `stopped on request: ${stopText}`);
+            }
+            let acted = 0;
+            let active = "";
+            let held = "";
+            let gateDue = false;
+            let blockedItems = "";
+            let goItems = "";
+            let interruptedItems = "";
+            for (let scanCount = 0; scanCount < 100; scanCount += 1) {
+                acted = 0;
+                active = "";
+                for (const line of readDriverLines(state, opts.maxFails, hq)) {
+                    const [action, a = "", b = "", c = "", d = "", e = ""] = parseScanLine(line);
+                    if (action === "ACTIVE")
+                        active = a;
+                    else if (action === "ARCHIVE") {
+                        const target = nextArchiveName(state, a, b);
+                        fs.renameSync(c, target);
+                        writeDriverLog(logFile, `ARCHIVE ${a} ${b} -> ${path.basename(target)}`);
+                        acted = 1;
+                    }
+                    else if (action === "FAILCAP") {
+                        const result = runPc(["failcap", "--state", state, "--story", a]);
+                        writeDriverLog(logFile, `FAILCAP_HOLD ${a} ${b} rc=${result.code}: ${result.stdout.trim()}`);
+                        if (!(result.code === 10 && (/^PHASE_FAILCAP/.test(result.stdout) || /ALREADY/.test(result.stdout)))) {
+                            return finish(23, `failcap ${a} ${b}: unexpected (rc=${result.code}): ${result.stdout} ${result.stderr}`);
+                        }
+                        const story = readJson(path.join(state, "stories", `${a}.json`));
+                        const reason = String(story?.blocked?.text ?? "").replace(/[\r\n\t]+/g, " ");
+                        return finish(21, failcapExplanation(a, b, c, opts.maxFails, e === "engine_exited_early", reason, result.stdout.split(/\s+/).at(-1) ?? ""));
+                    }
+                    else if (action === "EARLY") {
+                        writeDriverLog(logFile, `TICK: EARLY_EXIT ${a}/${b} after ${c}s: engine_exited_early (${d})`);
+                        const handoff = writeEarlyHandoff(state, a, b, c, d);
+                        fs.rmSync(path.join(driverDir, "stall.json"), { force: true });
+                        const result = runPc(["accept", "--state", state, "--story", a, "--handoff", handoff]);
+                        writeDriverLog(logFile, `ACCEPT ${a} ${b} rc=${result.code}: ${result.stdout.trim()}`);
+                        if (!(result.code === 1 && result.stdout.startsWith("PHASE_FAILED")))
+                            return finish(23, `accept early exit ${a} ${b}: unexpected (rc=${result.code}): ${result.stdout} ${result.stderr}`);
+                        acted = 1;
+                    }
+                    else if (action === "ACCEPT") {
+                        fs.rmSync(path.join(driverDir, "stall.json"), { force: true });
+                        writeDriverLog(logFile, `ACCEPTING ${a} ${b} ${c}`);
+                        const result = runPc(["accept", "--state", state, "--story", a, "--handoff", c]);
+                        writeDriverLog(logFile, `ACCEPT ${a} ${b} rc=${result.code}: ${result.stdout.trim()}`);
+                        if (!((result.code === 0 && (/^(NEXT|RECHECK)/.test(result.stdout))) || (result.code === 1 && /^PHASE_/.test(result.stdout)) || (result.code === 10 && /^PHASE_BLOCKED/.test(result.stdout)))) {
+                            return finish(23, `accept ${a} ${b}: unexpected (rc=${result.code}): ${result.stdout} ${result.stderr}`);
+                        }
+                        acted = 1;
+                    }
+                    else if (action === "RECHECK") {
+                        writeDriverLog(logFile, `RECHECKING ${a}`);
+                        const result = runPc(["recheck", "--prd", opts.prd, "--state", state, "--story", a]);
+                        writeDriverLog(logFile, `RECHECK ${a} rc=${result.code}: ${result.stdout.replace(/[\r\n]+/g, " ")}`);
+                        if (result.code === 0 && result.stdout.startsWith("VERIFIED")) {
+                            acted = 1;
+                            gateDue ||= result.stdout.includes("RUN_GATE");
+                        }
+                        else if (result.code === 1 && (/^ROUTED_BACK/.test(result.stdout) || /^FAILED/.test(result.stdout)))
+                            acted = 1;
+                        else
+                            return finish(23, `recheck ${a}: unexpected (rc=${result.code}): ${result.stdout} ${result.stderr}`);
+                    }
+                    else if (action === "DEADLINE")
+                        return finish(22, `phase ${a}/${b} passed its deadline ${c} with no handoff`);
+                    else if (action === "HELD")
+                        held = `${a} ${b}`;
+                    else if (action === "BLOCKED")
+                        blockedItems += `${blockedItems ? "; " : ""}${a}/${b} (decision: ${c})`;
+                    else if (action === "AWAITING_GO")
+                        goItems += `${goItems ? ", " : ""}${a} (decision: ${b})`;
+                    else if (action === "INTERRUPTED")
+                        interruptedItems += `${interruptedItems ? ", " : ""}${a} at ${b} (${c})`;
+                    else if (action === "LANE_STOPPED") {
+                        const result = runPc(["interrupt", "--state", state, "--story", a, "--note", `the ${b} lane exited on a stop envelope`]);
+                        writeDriverLog(logFile, `LANE_STOPPED ${a} ${b} rc=${result.code}: ${result.stdout.trim()}`);
+                        acted = 1;
+                    }
+                    else if (action === "INFLIGHT") { /* wait for this phase */ }
+                    else if (action === "LANE_STALLED") {
+                        const worker = c;
+                        const { lane, company } = stalledLaneContext(state, worker);
+                        const listed = lane && company
+                            ? driverRun(hq, ["lanes", "questions", "list", "--company", company, "--json"])
+                            : { code: 1, stdout: "", stderr: "" };
+                        let question = "";
+                        if (listed.code === 0) {
+                            try {
+                                question = pendingLaneQuestion(listed.stdout, lane);
+                            }
+                            catch { /* The shell reports no pending question for invalid JSON too. */ }
+                        }
+                        const detail = question || "no pending question returned";
+                        writeDriverLog(logFile, `LANE_QUESTION story=${a} phase=${b} lane=${lane} question=${detail}`);
+                        return finish(28, `loop lane ${lane} parked after repeated stalls for ${a}/${b}; answer its pending question with hq lanes questions answer, then restart the driver: ${detail}`);
+                    }
+                    else
+                        return finish(23, `scan printed an unknown line: ${action}`);
+                }
+                if (!active)
+                    return finish(23, `could not read the state dir ${state}`);
+                if (gateDue)
+                    return finish(20, "regression gate due");
+                if (!acted)
+                    break;
+                if (scanCount === 99)
+                    return finish(23, "state did not settle after 100 scans");
+            }
+            if (held)
+                return finish(21, `story held for approval: ${held}`);
+            const fire = checkDriverStall(state, opts.stallWindow, hq);
+            if (fire) {
+                const parts = fire.split(" ");
+                writeDriverLog(logFile, `STALL since ${parts[1]} ${parts[2]} ${parts[3]}: no phase accepted for the whole ${opts.stallWindow}s stall window; event in ${path.join(state, "events.jsonl")}`);
+                return finish(28, `stall: since ${parts[1]}, ${parts[2]} ${parts[3]}, no phase accepted for ${opts.stallWindow}s and no lane is working on them (event: ${path.join(state, "events.jsonl")}); check the lanes, then restart the driver`);
+            }
+            if (fs.existsSync(stopFile))
+                return await stop(29, `stopped on request: ${fs.readFileSync(stopFile, "utf8").replace(/[\r\n]+/g, " ")}`);
+            const tick = runTick();
+            const goNow = readDriverLines(state, opts.maxFails, hq).filter((line) => line.startsWith("AWAITING_GO\t")).map((line) => parseScanLine(line)[1]).join(" ");
+            if (tick.stdout || goNow !== goLast || interruptedItems)
+                writeDriverLog(logFile, `TICK: ${tick.stdout.replace(/[\r\n]+/g, " ")}${goNow ? `| awaiting go: ${goNow}` : ""}${interruptedItems ? `| interrupted, routing first: ${interruptedItems}` : ""}`);
+            goLast = goNow;
+            if (![0, 3, 11, 12].includes(tick.code))
+                return finish(23, `tick failed (rc=${tick.code}): ${tick.stderr}`);
+            let gate = "";
+            let laneDown = "";
+            let noLane = "";
+            held = "";
+            for (const line of tick.stdout.split(/\r?\n/).filter(Boolean)) {
+                if (["", "RUN_GATE", "GATE_FAILED"].includes(line)) {
+                    if (line)
+                        gate = line;
+                    continue;
+                }
+                if (/^(ROUTED|RETRY|PARKED_DEPENDENCY|RELEASED_DEPENDENCY|CUT|REUSED|EXISTS|MAX_STORIES|BLOCKED_OWNER|AWAITING_GO)\b/.test(line))
+                    continue;
+                if (line.startsWith("HELD ")) {
+                    held ||= line.slice(5);
+                    continue;
+                }
+                if (line.startsWith("LANE_DOWN ")) {
+                    laneDown ||= line.slice(10);
+                    continue;
+                }
+                if (line.startsWith("NO_LANE ")) {
+                    noLane ||= line.slice(8);
+                    continue;
+                }
+                return finish(23, `tick printed an unexpected line: ${line}`);
+            }
+            if (laneDown)
+                return finish(26, `lane down: ${laneDown}; relaunch the named loop lane, then restart the driver`);
+            if (noLane)
+                return finish(27, `no lane: ${noLane}; add the row, launch the named loop lane, then restart the driver`);
+            if (gate === "RUN_GATE")
+                return finish(20, "regression gate due");
+            if (gate === "GATE_FAILED")
+                return finish(21, `regression gate failed; record a failed gate result for the story, then restart the driver`);
+            if (held)
+                return finish(21, `story held for approval: ${held}`);
+            if (!tick.stdout) {
+                const afterTick = readDriverLines(state, opts.maxFails, hq);
+                const currentActive = afterTick.map(parseScanLine).find((row) => row[0] === "ACTIVE")?.[1];
+                if (currentActive === "0") {
+                    const next = runPc(["next", "--prd", opts.prd, "--state", state]);
+                    if (next.code === 0 && !next.stdout) {
+                        const report = runPc(["report", "final", "--state", state]);
+                        writeDriverLog(logFile, `REPORT ${report.stdout.trim()}`);
+                        if (blockedItems || goItems)
+                            return finish(21, `decision needed, nothing else can move:${blockedItems ? ` blocked by its worker: ${blockedItems}` : ""}${goItems ? `; awaiting go: ${goItems}; release with pipeline-conductor.sh go --state ${state} --story <id>` : ""}`);
+                        if (!await stopDriverLanes(state, hq, logFile))
+                            return finish(23, "could not confirm every loop lane stopped; see LANE_STOP_TIMEOUT");
+                        return finish(0, `all stories finished: ${report.stdout.trim()}`);
+                    }
+                }
+            }
+            await sleep(opts.interval * 1000, stopWait.signal);
+        }
+    }
+    catch (error) {
+        return finish(23, `driver failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        removeHandlers();
+        driverHqRoot = "";
+    }
+}
+//# sourceMappingURL=core-pipeline-driver-native.js.map