smol-symphony 0.1.0 → 0.3.0

package/dist/src/core/reconcile/pr-notes.js

@@ -0,0 +1,35 @@
+// FCIS rewrite — pure per-PR cache TTL freshness predicates.
+//
+// Extracted from the original `src/reconciler/pr.ts` (`PrResource.lookupPrSummary`
+// + `PrResource.fetchPrView`), which tangled these freshness checks into the same
+// async methods that shelled out to `gh pr list`/`gh pr view` and mutated state.
+// Here it is ONLY the decision: given an injected `now` plus the prior
+// `lastLookupAt`/`lastViewAt` and the cached payloads, reuse or re-poll/re-fetch.
+//
+// Two INDEPENDENT predicates (issue 70 "sticky cache" mustFix):
+//   1. Summary (sticky): once a PR is FOUND it is reused forever — PR numbers
+//      don't change and a found PR moving OPEN→MERGED/CLOSED must keep its cached
+//      number so the autopilot can observe the terminal state. `lastLookupAt`
+//      governs ONLY the cache-MISS (null) re-poll.
+//   2. View (TTL): plain time-to-live on the detailed view, keyed solely on its
+//      own `lastViewAt` — never coupled to the summary re-poll.
+//
+// `pollIntervalMs === 0` disables caching on both paths: the strict `<` makes any
+// elapsed (>= 0) fall outside the window. Pure + synchronous: `now` is injected.
+/** Mirrors the head of `PrResource.lookupPrSummary`: sticky short-circuit, then null-result TTL guard. */
+export function decidePrSummaryFreshness(input) {
+    if (input.summary)
+        return { kind: 'reuse', summary: input.summary };
+    if (input.summary === null && input.now - input.lastLookupAt < input.pollIntervalMs) {
+        return { kind: 'defer' };
+    }
+    return { kind: 'repoll' };
+}
+/** Mirrors the head of `PrResource.fetchPrView`: reuse while inside the TTL, else re-fetch (strict `<`). */
+export function decidePrViewFreshness(input) {
+    if (input.view !== null && input.now - input.lastViewAt < input.pollIntervalMs) {
+        return { kind: 'reuse', view: input.view };
+    }
+    return { kind: 'refetch' };
+}
+//# sourceMappingURL=pr-notes.js.map

package/dist/src/core/reconcile/pr-notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pr-notes.js","sourceRoot":"","sources":["../../../../src/core/reconcile/pr-notes.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,EAAE;AACF,mFAAmF;AACnF,kFAAkF;AAClF,iFAAiF;AACjF,uEAAuE;AACvE,kFAAkF;AAClF,EAAE;AACF,gEAAgE;AAChE,8EAA8E;AAC9E,kFAAkF;AAClF,8EAA8E;AAC9E,mDAAmD;AACnD,gFAAgF;AAChF,gEAAgE;AAChE,EAAE;AACF,kFAAkF;AAClF,iFAAiF;AAsBjF,0GAA0G;AAC1G,MAAM,UAAU,wBAAwB,CAAC,KAA8B;IACrE,IAAI,KAAK,CAAC,OAAO;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACpE,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC;QACpF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAmBD,4GAA4G;AAC5G,MAAM,UAAU,qBAAqB,CAAC,KAA2B;IAC/D,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC;QAC/E,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7C,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AAC7B,CAAC"}

package/dist/src/core/reconcile/vm-decide.js

@@ -0,0 +1,70 @@
+// FCIS rewrite — pure VM-reaper decision core (issue 33 / reconciler stage 2;
+// Gondolin migration Phase 4).
+//
+// Verbatim port of the original `src/reconciler/vm.ts:decideVm`. The original
+// module mixed the pure decision (`decideVm`) with the imperative reaper loop
+// (`VmResource`, gc / listSessions / process.kill / setTimeout). This rewrite
+// extracts ONLY the pure decision; the SIGTERM→grace→SIGKILL escalation, the
+// Gondolin gc, the session enumeration, and the ledger all live in the shell.
+//
+// The decision: given the observed live Gondolin session set, the orchestrator's
+// intended label set, and the reaper's own pid, return one `kill_session`
+// effect per session that is a LIVE orphan — a `symphony-`-prefixed session that
+// the orchestrator does NOT intend to keep alive AND whose host pid is safe to
+// signal (a sane positive integer that is not the reaper itself).
+//
+// Pid safety (verbatim from the original): a host signal is only ever emitted
+// for a `pid` that is a safe positive integer and is NOT the reaper's own pid.
+// The shell delivers the signal with `process.kill(pid, sig)`, which signals the
+// whole PROCESS GROUP for `pid <= 0` and would target the orchestrator itself
+// for `pid === selfPid`. A session carrying a `0`/`NaN`/negative/self pid is a
+// registry anomaly, never a legitimate orphan, so it is left untouched here.
+//
+// Namespace safety (verbatim): anything outside the symphony-prefixed namespace
+// — a session with no label, or a label that doesn't start with the prefix — is
+// left untouched (operator VMs, sibling tools' sessions). STALE/dead-pid
+// sessions and orphan sockets are NOT this function's concern; Gondolin's
+// `gc()` collects them in the shell before the live session set reaches here.
+//
+// HARD CONSTRAINTS (gate-enforced): 100% synchronous; no async/await/Promise; no
+// IO, node: imports, process, clock, or randomness. Imports ONLY from
+// src/types. Every side effect is RETURNED as a `KillSessionAction[]`; the
+// shell executes it.
+/**
+ * Domain constant. Every VM the orchestrator creates is labelled with this
+ * prefix (the runner mints `sessionLabel = symphony-<identifier>`); the reaper
+ * only acts on labels that match. The vm-port adapter in the shell mirrors the
+ * same value — keep them in sync.
+ */
+export const SYMPHONY_VM_PREFIX = 'symphony-';
+/**
+ * Pure decision: given the observed Gondolin session state, return the
+ * `kill_session` effects the shell should apply. No IO, no clock reads, no
+ * logging.
+ *
+ * Effect rule:
+ *   • Session has a `label` that starts with SYMPHONY_VM_PREFIX and isn't
+ *     intended, AND a sane, non-self host pid → `kill_session` (the shell
+ *     SIGTERM→SIGKILLs its host pid).
+ */
+export function decideVm(state) {
+    const out = [];
+    for (const s of state.sessions) {
+        const label = s.label;
+        if (label === undefined)
+            continue;
+        if (!label.startsWith(SYMPHONY_VM_PREFIX))
+            continue;
+        if (state.intendedLabels.has(label))
+            continue;
+        // Pid safety: skip anomalous pids (0/NaN/negative — process-group / invalid)
+        // and never signal the reaper's own process.
+        if (!Number.isSafeInteger(s.pid) || s.pid <= 0)
+            continue;
+        if (s.pid === state.selfPid)
+            continue;
+        out.push({ kind: 'kill_session', pid: s.pid, label });
+    }
+    return out;
+}
+//# sourceMappingURL=vm-decide.js.map

package/dist/src/core/reconcile/vm-decide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm-decide.js","sourceRoot":"","sources":["../../../../src/core/reconcile/vm-decide.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+BAA+B;AAC/B,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,8EAA8E;AAC9E,EAAE;AACF,iFAAiF;AACjF,0EAA0E;AAC1E,iFAAiF;AACjF,+EAA+E;AAC/E,kEAAkE;AAClE,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,iFAAiF;AACjF,8EAA8E;AAC9E,+EAA+E;AAC/E,6EAA6E;AAC7E,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAChF,yEAAyE;AACzE,0EAA0E;AAC1E,8EAA8E;AAC9E,EAAE;AACF,iFAAiF;AACjF,sEAAsE;AACtE,2EAA2E;AAC3E,qBAAqB;AAIrB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAsB;IAC7C,MAAM,GAAG,GAAwB,EAAE,CAAC;IACpC,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;QACtB,IAAI,KAAK,KAAK,SAAS;YAAE,SAAS;QAClC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,kBAAkB,CAAC;YAAE,SAAS;QACpD,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,SAAS;QAC9C,6EAA6E;QAC7E,6CAA6C;QAC7C,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;YAAE,SAAS;QACzD,IAAI,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,OAAO;YAAE,SAAS;QACtC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/src/core/reconcile/vm-reap.js

@@ -0,0 +1,207 @@
+// FCIS rewrite — pure VM-reaper KILL state machine (the per-session
+// SIGTERM → grace → probe → SIGKILL escalation).
+//
+// Ported faithfully from the reference `VmResource.killSession`
+// (REF: src/reconciler/vm.ts). The reference was a single async method that
+// interleaved IO (`process.kill`, an inline `setTimeout` grace) with ledger
+// bookkeeping. Under FCIS that method splits into two halves:
+//
+//   • the SHELL drives the loop and performs the IO — it sends each host signal
+//     (a `process.kill`-backed `ProcessEffect`), sleeps the grace window (a
+//     `TimerEffect`), and probes liveness (signal-0). After each it hands the
+//     observed `KillStepResult` back here.
+//   • this CORE owns every DECISION as a pure fold: given the current `KillStep`
+//     (which signal/probe is in flight) and the `KillStepResult` the shell just
+//     observed, it returns the NEXT `KillStep` (wrapped as a `ReaperEffect` +,
+//     for `wait_grace`, the matching `TimerEffect`) PLUS the ledger transition
+//     to record. No IO, no clock, no `process`.
+//
+// The escalation, branch-for-branch with the reference:
+//
+//   ① SIGTERM (start key, send SIGTERM).
+//        gone(ESRCH)  → already dead → ledger done.            (ref: ESRCH→done)
+//        no_perm(EPERM)→ can't signal → ledger error.          (ref: throw→error)
+//        signalled    → enter the grace window (wait_grace).   (ref: await sleep)
+//   ② wait_grace (sleep killGraceMs), then probe.
+//        signalled    → grace elapsed → probe liveness.
+//   ③ probe (signal 0 — liveness test).
+//        gone(ESRCH)  → exited during grace → ledger done.     (ref: !alive→done)
+//        no_perm(EPERM)→ alive but unreachable → ledger error. (ref: code!==ESRCH→error)
+//        alive(signal0 ok) → still running → escalate to SIGKILL.
+//   ④ SIGKILL.
+//        gone(ESRCH)  → raced to exit → ledger done.           (ref: ESRCH→done)
+//        signalled    → killed → ledger done.                  (ref: success→done)
+//        no_perm(EPERM)→ unkillable → ledger error.            (ref: throw→error)
+//
+// Pid safety (the keystone): the host signal is delivered by `process.kill`,
+// which signals the whole PROCESS GROUP for `pid <= 0` and would target the
+// orchestrator itself for `pid === selfPid`. `decideVm` already excludes those,
+// but the reference re-guards once more before any signal leaves the shell
+// ("belt-and-suspenders"). That guard is reproduced PURELY here in
+// {@link beginKill}: an unsafe pid never yields a `signal` step — it yields an
+// immediate terminal error decision, so the shell has no path to call
+// `process.kill` on a bad pid.
+//
+// 100% SYNCHRONOUS. No async / await / Promise. No IO, no node: imports, no
+// wall clock or randomness. Imports ONLY from src/types. (NodeNext ESM → .js
+// extensions on relative imports.)
+/**
+ * SIGTERM-to-SIGKILL grace period (ms). A session runner that ignores SIGTERM is
+ * SIGKILL'd after this delay. Mirrors the reference `DEFAULT_KILL_GRACE_MS`.
+ * Tests pass a small value so the grace path is observable in fast suites; the
+ * value is injected into {@link beginKill} (core never reads a config or a clock).
+ */
+export const DEFAULT_KILL_GRACE_MS = 3_000;
+/** The ledger key for one session's kill action — `kill_session:<pid>` (ref). */
+export function killKey(pid) {
+    return `kill_session:${pid}`;
+}
+/** Wrap a `KillStep` as the `reaper` Effect the shell's interpreter drains. */
+function reaperEffect(step) {
+    return { family: 'reaper', step };
+}
+/** The `timer.sleep` effect backing the grace window. */
+function sleepEffect(ms) {
+    return { family: 'timer', kind: 'sleep', ms };
+}
+/** Whether a pid is safe to signal: a positive safe integer that isn't us. */
+export function isSafeKillPid(pid, selfPid) {
+    // `process.kill(pid, sig)` signals the whole process group for `pid <= 0`
+    // and the orchestrator itself for `pid === selfPid` — both catastrophic.
+    return Number.isSafeInteger(pid) && pid > 0 && pid !== selfPid;
+}
+/**
+ * Begin the escalation for one `kill_session` action. Reproduces the reference
+ * belt-and-suspenders guard PURELY: an unsafe pid (self / `<= 0` / non-finite)
+ * never produces a `signal` step — it returns a terminal `done` state carrying
+ * an `error` ledger op, so the shell has no path to `process.kill` a bad pid.
+ *
+ * A safe pid yields the opening step: `start` the ledger row and emit the
+ * SIGTERM signal (the shell sends it, then folds the observed result via
+ * {@link foldKillStep}).
+ *
+ * @param graceMs Injected grace window (the shell read it from config). Carried
+ *                into the eventual `wait_grace` step's sleep effect.
+ */
+export function beginKill(action, selfPid) {
+    const key = killKey(action.pid);
+    if (!isSafeKillPid(action.pid, selfPid)) {
+        // Reference: `start(key)` then `error(key, msg)` — surfaced as a row so the
+        // dashboard shows the refusal — and NO signal is ever emitted.
+        return {
+            next: { kind: 'done', pid: action.pid },
+            effects: [],
+            ledger: { op: 'error', key, message: `refused to signal unsafe pid ${action.pid}` },
+        };
+    }
+    return {
+        next: { kind: 'signal', pid: action.pid, signal: 'SIGTERM' },
+        effects: [reaperEffect({ kind: 'signal', pid: action.pid, signal: 'SIGTERM' })],
+        ledger: { op: 'start', key },
+    };
+}
+/**
+ * The core fold: given the `step` whose effect was just executed and the
+ * `result` the shell observed, return the NEXT step + effects + ledger op.
+ *
+ * `graceMs` is the injected grace window (only consulted when transitioning into
+ * `wait_grace`). Every branch returns a fresh decision; nothing is mutated.
+ *
+ * Terminal states return `{ kind: 'done' }` with NO effects — the shell stops
+ * driving and applies the `ledger` op. Intermediate states return the next
+ * `reaper` step (and, for the grace window, the `timer.sleep`) and the loop
+ * continues.
+ */
+export function foldKillStep(step, result, graceMs = DEFAULT_KILL_GRACE_MS) {
+    const pid = step.pid;
+    const key = killKey(pid);
+    const terminalDone = { kind: 'done', pid };
+    switch (step.kind) {
+        // ── ① SIGTERM / ④ SIGKILL share the same signal-result table. ──────────
+        case 'signal': {
+            switch (result.kind) {
+                case 'gone':
+                    // ESRCH: already gone — treat as success (ref: ESRCH → done).
+                    return { next: terminalDone, effects: [], ledger: { op: 'done', key } };
+                case 'no_perm': {
+                    // EPERM: can't deliver the signal — surface as an error and stop.
+                    const phase = step.signal === 'SIGTERM' ? 'SIGTERM' : 'SIGKILL';
+                    return {
+                        next: terminalDone,
+                        effects: [],
+                        ledger: { op: 'error', key, message: `${phase} failed: EPERM` },
+                    };
+                }
+                case 'signalled':
+                    if (step.signal === 'SIGTERM') {
+                        // Reference: `await sleep(graceMs)` then probe. Emit the grace
+                        // window's sleep AND the next reaper step (wait_grace) so the shell
+                        // sleeps before probing.
+                        const next = { kind: 'wait_grace', pid, ms: graceMs };
+                        return {
+                            next,
+                            effects: [sleepEffect(graceMs), reaperEffect(next)],
+                            ledger: { op: 'none' },
+                        };
+                    }
+                    // SIGKILL succeeded → terminal done (ref: success → done).
+                    return { next: terminalDone, effects: [], ledger: { op: 'done', key } };
+                case 'alive':
+                    // A `signal`/`SIGKILL` reporting "still alive" is not a normal result
+                    // path (the shell maps signal-send success to `signalled`); treat a
+                    // surviving SIGKILL target as terminal success to avoid a kill loop,
+                    // matching the reference (post-SIGKILL it always lands in done).
+                    return { next: terminalDone, effects: [], ledger: { op: 'done', key } };
+            }
+            // Exhaustive; unreachable.
+            return { next: terminalDone, effects: [], ledger: { op: 'none' } };
+        }
+        // ── ② grace window elapsed → probe liveness. ────────────────────────────
+        case 'wait_grace': {
+            // Reference: after the sleep, probe with signal 0. The sleep already ran
+            // (shell applied the timer.sleep); regardless of the observed result we
+            // advance to the probe step. No ledger change here.
+            const next = { kind: 'probe', pid };
+            return { next, effects: [reaperEffect(next)], ledger: { op: 'none' } };
+        }
+        // ── ③ probe (signal 0) → done / error / escalate to SIGKILL. ────────────
+        case 'probe': {
+            switch (result.kind) {
+                case 'gone':
+                    // ESRCH from the probe: the process exited during the grace window
+                    // (ref: `!alive` → done).
+                    return { next: terminalDone, effects: [], ledger: { op: 'done', key } };
+                case 'no_perm':
+                    // EPERM: alive but unreachable — surface as error (ref: code !== ESRCH
+                    // → error, "assume alive but unkillable").
+                    return {
+                        next: terminalDone,
+                        effects: [],
+                        ledger: { op: 'error', key, message: 'alive-probe failed: EPERM' },
+                    };
+                case 'alive':
+                case 'signalled': {
+                    // Still alive after the grace → escalate to SIGKILL (ref: `alive` →
+                    // SIGKILL). `signalled` from a signal-0 probe is treated the same as
+                    // `alive` (the process accepted the no-op signal ⇒ it exists).
+                    const next = { kind: 'signal', pid, signal: 'SIGKILL' };
+                    return { next, effects: [reaperEffect(next)], ledger: { op: 'none' } };
+                }
+            }
+            // Exhaustive; unreachable.
+            return { next: terminalDone, effects: [], ledger: { op: 'none' } };
+        }
+        // ── terminal ─────────────────────────────────────────────────────────────
+        case 'done':
+            // No further work; a result observed against a terminal step is a no-op.
+            return { next: step, effects: [], ledger: { op: 'none' } };
+    }
+}
+/**
+ * Whether a `KillStep` is terminal (the shell stops driving the per-session
+ * escalation when it reaches this).
+ */
+export function isKillTerminal(step) {
+    return step.kind === 'done';
+}
+//# sourceMappingURL=vm-reap.js.map

package/dist/src/core/reconcile/vm-reap.js.map

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

package/dist/src/core/reconcile/workspace-decide.js

@@ -0,0 +1,162 @@
+// FCIS rewrite — pure workspace-janitor decision core.
+//
+// Functional-core port of the diff half of the original
+// `src/reconciler/workspace.ts:WorkspaceResource.reconcile`. The original was an
+// async class method that interleaved IO (tracker read, dir listing, base-ref
+// lookup, per-dir git inspection, rm, create) with the diff logic and recorded
+// every step into a `ResourceActionLedger`. In the FCIS layout ALL of that IO
+// moves OUT into the shell:
+//
+//   - The desired set (active non-terminal + in-flight identifiers with their
+//     current state) is SUPPLIED here as plain data (`WorkspaceObservedState.
+//     desired`). The shell does the (fail-closed) tracker read; if it throws,
+//     the shell never calls this decider — exactly matching the original's
+//     "bail and leave existing workspaces untouched" rule.
+//   - The dir listing, the source-repo base SHA, and the per-dir git inspection
+//     are SUPPLIED as plain data (`observed`, `baseRefSha`, `inspections`). When
+//     `baseRefSha` is null the shell couldn't resolve base → this decider skips
+//     drift detection entirely (orphan removal still fires), mirroring the
+//     original `if (baseRef === null) continue;`.
+//   - The merge-state guard the original applied INSIDE its create callback
+//     (`WorkspaceManager.ensureFor` skips eager recreation while the owning
+//     issue sits in the PR/merge state) is applied here as data: a desired
+//     entry whose `state === prMergeState` does NOT get a `create_workspace`.
+//
+// The decider RETURNS:
+//   - `actions`: `create_workspace` / `remove_workspace` `ReconcilerAction[]`
+//     the shell executes (each maps to a `workspace.ensure` / `workspace.remove`
+//     Effect). `remove` carries the sanitized dir name; `create` carries the raw
+//     operator-visible identifier (the shell's `ensure` re-sanitizes).
+//   - `marks`: non-destructive `mark_stale` / `mark_stuck` drift annotations the
+//     shell records into the ledger (the original never auto-removes for drift
+//     in v1 — it only annotates so the dashboard renders a badge).
+//   - `logs`: `LogEffect[]` so the shell can re-emit the same structured lines
+//     the original logged at each branch.
+//
+// Pure + synchronous: (data) -> data + Effect[]. Imports ONLY from src/types.
+//
+// HARD CONSTRAINTS (gate-enforced):
+//   - 100% SYNCHRONOUS. No async/await/Promise anywhere.
+//   - No IO, no node: imports, no process/fetch, no wall clock, no randomness.
+//   - Imports ONLY from src/types/**.
+import { sanitizeWorkspaceKey } from '../workspace-key.js';
+function log(level, message, fields) {
+    return fields === undefined
+        ? { family: 'log', kind: 'emit', level, message }
+        : { family: 'log', kind: 'emit', level, message, fields };
+}
+/**
+ * Pure janitor diff. Given the desired set (active + in-flight identifiers with
+ * state), the observed dirs on disk, the source repo's current base SHA, and the
+ * per-dir git inspections, return the create/remove actions, the drift marks,
+ * and the log effects.
+ *
+ * Branch parity with the original `WorkspaceResource.reconcile`:
+ *   1. Build `wanted`: sanitize in-flight ids first, then active ids (active
+ *      wins on overlap so the tracker's authoritative state beats an in-flight
+ *      target_state). Keyed by sanitized dir name → { identifier, state }.
+ *   2. For each observed dir: not in `wanted` ⇒ `remove_workspace` (stale_issue),
+ *      UNLESS it carries a handoff-pending marker (`obs.handoffPending`) — a
+ *      terminal issue whose push handoff failed, RETAINED so the only commit copy
+ *      survives for recovery (234). Else mark present; if a base SHA is present,
+ *      fold the inspection for drift (mark_stuck when there's agent work to lose,
+ *      else mark_stale).
+ *   3. For each wanted id with no dir on disk ⇒ `create_workspace`, UNLESS the
+ *      merge-state guard fires (its state === prMergeState).
+ */
+export function decideWorkspace(obs) {
+    const actions = [];
+    const marks = [];
+    const logs = [];
+    let staleCount = 0;
+    let stuckCount = 0;
+    let createdCount = 0;
+    let lastError = null;
+    // Step 1 — build the desired map keyed by sanitized dir name. The original
+    // iterated in-flight first then active so active (the tracker's authoritative
+    // state) overwrites any overlapping in-flight entry. `obs.desired` here is the
+    // already-merged sequence the shell hands us in that same precedence order;
+    // we sanitize and last-write-wins to reproduce the overlap rule even if a
+    // caller supplies raw (in-flight, active) pairs in order.
+    const wanted = new Map();
+    for (const entry of obs.desired) {
+        wanted.set(sanitizeWorkspaceKey(entry.identifier), {
+            identifier: entry.identifier,
+            state: entry.state,
+        });
+    }
+    // Step 2 — reap orphans + annotate drift on the dirs that survive.
+    const present = new Set();
+    for (const { name } of obs.observed) {
+        if (!wanted.has(name)) {
+            // A terminal issue whose phase-8 handoff push FAILED left a marker: the only
+            // copy of its completed commit lives in this dir, so RETAIN it (skip the reap)
+            // until it's pushed/recovered — reaping it would be unrecoverable loss (234).
+            if (obs.handoffPending.has(name)) {
+                logs.push(log('warn', 'workspace reconcile: retained (handoff pending)', { identifier: name, reason: 'handoff_pending' }));
+                continue;
+            }
+            actions.push({ kind: 'remove_workspace', identifier: name });
+            logs.push(log('info', 'workspace reconcile: removed', { identifier: name, reason: 'stale_issue' }));
+            continue;
+        }
+        present.add(name);
+        // In the desired set. Drift detection needs a base SHA to compare against;
+        // null means the shell couldn't resolve base this pass — skip (workspace ok).
+        if (obs.baseRefSha === null)
+            continue;
+        const inspection = obs.inspections[name];
+        // No inspection supplied (shell skipped or the inspect call failed) — treat
+        // as ok, matching the original's `catch { continue; }` around inspect.
+        if (inspection === undefined)
+            continue;
+        if (inspection.head === null)
+            continue;
+        // Workspace has no local copy of the base branch — operator likely deleted
+        // it. Skip drift detection rather than guess.
+        if (inspection.workspaceBaseSha === null)
+            continue;
+        // Drift = workspace's frozen base SHA disagrees with source's current base
+        // SHA. Any disagreement counts (fast-forward, divergence, rewind all surface
+        // as "the operator's base moved out from under us").
+        if (inspection.workspaceBaseSha === obs.baseRefSha)
+            continue;
+        // Drift detected. v1 never auto-removes for drift; annotate and move on.
+        if (inspection.hasUncommitted || inspection.commitsAheadOfBase > 0) {
+            stuckCount += 1;
+            const reason = inspection.hasUncommitted
+                ? 'uncommitted changes present'
+                : `${inspection.commitsAheadOfBase} commit(s) ahead of base`;
+            lastError = `workspace ${name} stuck: base advanced and ${reason}`;
+            marks.push({ status: 'stuck', identifier: name, reason });
+            logs.push(log('warn', 'workspace reconcile: stuck (drift, agent work present)', { identifier: name, reason }));
+            continue;
+        }
+        staleCount += 1;
+        const staleReason = 'base advanced past workspace HEAD; re-clone is opt-in';
+        lastError = `workspace ${name} stale: ${staleReason}`;
+        marks.push({ status: 'stale', identifier: name, reason: staleReason });
+        logs.push(log('info', 'workspace reconcile: stale (drift, no agent work to lose)', { identifier: name, reason: staleReason }));
+    }
+    // Step 3 — create any desired identifier with no dir on disk, modulo the
+    // merge-state guard. The original deferred to `WorkspaceManager.ensureFor`,
+    // which is idempotent; the guard (skip while the owning issue sits in the
+    // PR/merge state) was applied inside that create callback. Here it's data:
+    // `state === prMergeState` ⇒ no create_workspace.
+    for (const [key, { identifier, state }] of wanted) {
+        if (present.has(key))
+            continue;
+        if (obs.prMergeState !== null && state === obs.prMergeState) {
+            logs.push(log('debug', 'workspace reconcile: create skipped (merge-state guard)', {
+                identifier,
+                state,
+            }));
+            continue;
+        }
+        actions.push({ kind: 'create_workspace', identifier });
+        createdCount += 1;
+        logs.push(log('info', 'workspace reconcile: created', { identifier, state }));
+    }
+    return { actions, marks, logs, staleCount, stuckCount, createdCount, lastError };
+}
+//# sourceMappingURL=workspace-decide.js.map

package/dist/src/core/reconcile/workspace-decide.js.map

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