smol-symphony 0.2.0 → 0.3.0

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

@@ -0,0 +1,48 @@
+// FCIS rewrite — pure image-readiness decision core (issue 206).
+//
+// The auto-convert-on-reconcile gate: given the shell's image-readiness
+// projection (gondolin.oci_image set? a cached asset present? a build in flight?
+// did the last build fail?), decide whether the poll tick must HOLD VM dispatch
+// this round, and whether to EMIT an `ensure_image` effect to kick off the
+// one-time conversion. The shell does all the docker/filesystem IO (resolve the
+// OCI digest, look the asset up in the local gondolin store, run `buildAssets`);
+// this function only folds the resulting flags into a decision so the gate is
+// unit-testable without docker.
+//
+// HARD CONSTRAINTS (mirror the sibling reconcile deciders): 100% synchronous; no
+// async/await/Promise; no IO, node: imports, process, clock, or randomness. The
+// side effect is RETURNED as an Effect[]; the loop executes it.
+/**
+ * Fold the image-readiness projection into the poll tick's hold/build decision.
+ *
+ *   - `gondolin.image` escape hatch set → it WINS the runtime selector
+ *     (`resolveImagePath`, mirrored by `checkGondolinImage`), so the `oci_image`
+ *     auto-convert path is irrelevant: never hold dispatch on its readiness and
+ *     never require the one-time conversion. The escape hatch takes precedence
+ *     REGARDLESS of whether `oci_image` is set / converted / failing.
+ *   - oci_image unset (or no ref) → auto-convert path inactive: never hold, never
+ *     build (dispatch runs against the `gondolin.image` escape hatch).
+ *   - cached asset present (`ready`) → proceed: never hold, never build.
+ *   - configured but not ready → HOLD dispatch, and emit `ensure_image` UNLESS a
+ *     build is already in flight (`building`) or the last build for this ref failed
+ *     (`failed`, so we don't hammer a broken ref every poll — the dashboard banner
+ *     + doctor surface the error and the operator fixes the ref / restarts).
+ *
+ * `escapeHatchConfigured` is whether `gondolin.image` is a non-empty selector,
+ * computed by the poll reducer the same way `resolveImagePath` tests it (so the
+ * gate, doctor, and the runtime selector can never disagree on which source wins).
+ */
+export function decideImageReadiness(image, escapeHatchConfigured) {
+    if (escapeHatchConfigured)
+        return { holdDispatch: false, effects: [] };
+    if (!image || !image.ociConfigured || image.ref === null) {
+        return { holdDispatch: false, effects: [] };
+    }
+    if (image.ready)
+        return { holdDispatch: false, effects: [] };
+    const effects = image.building || image.failed
+        ? []
+        : [{ family: 'image', kind: 'ensure', ref: image.ref }];
+    return { holdDispatch: true, effects };
+}
+//# sourceMappingURL=image-decide.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image-decide.js","sourceRoot":"","sources":["../../../../src/core/reconcile/image-decide.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,EAAE;AACF,wEAAwE;AACxE,iFAAiF;AACjF,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,iFAAiF;AACjF,8EAA8E;AAC9E,gCAAgC;AAChC,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,gEAAgE;AAShE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAiC,EACjC,qBAA8B;IAE9B,IAAI,qBAAqB;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACvE,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,EAAE,CAAC;QACzD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAC9C,CAAC;IACD,IAAI,KAAK,CAAC,KAAK;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAC7D,MAAM,OAAO,GACX,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM;QAC5B,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;IAC5D,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AACzC,CAAC"}

package/dist/src/core/reconcile/ledger.js

@@ -0,0 +1,142 @@
+// FCIS rewrite — the ONE pure ResourceActionLedger reducer shared by every
+// reconciler resource (vm / workspace / pr / actions). Each carries a
+// most-recent-first buffer of `ActionStatus` rows ("what is this resource doing
+// / what did it just try") for the dashboard. The original (REF:
+// src/reconciler/ledger.ts) was a stateful CLASS that read `Date.now()` and
+// mutated in place; here every transition is a PURE function returning a new
+// immutable `LedgerState` with the wall clock INJECTED as an ISO string (`at`).
+// The original async `run(action, fn)` helper stays in the shell, composed from
+// start → (done | error). Per-function behavior is documented inline below; the
+// buffer keeps a `maxHistory * 2` lookback so a late done/error still finds its
+// `in_progress` row after a flood of newer actions, while `snapshot()` slices
+// the freshest `maxHistory`.
+/**
+ * Snapshot slice cap. Matches what each resource exposed as its private
+ * `MAX_ACTION_HISTORY` before the refactor: bake = 8, vm = 32, workspace = 32,
+ * pr = 64. Each call site passes its prior cap so snapshot payloads are
+ * unchanged.
+ */
+export const DEFAULT_MAX_HISTORY = 32;
+/** Construct an empty ledger for `resource`. `maxHistory` defaults to 32. */
+export function createLedger(resource, maxHistory = DEFAULT_MAX_HISTORY) {
+    return { resource, maxHistory, buf: [] };
+}
+/**
+ * Prepend `status` and evict beyond the `maxHistory * 2` lookback window.
+ * Pure: returns a new state, leaves `state.buf` untouched.
+ */
+function push(state, status) {
+    const next = [status, ...state.buf];
+    const cap = state.maxHistory * 2;
+    return { ...state, buf: next.length > cap ? next.slice(0, cap) : next };
+}
+/** Index of the most-recent `in_progress` row for `action`, or -1. */
+function findInProgress(state, action) {
+    return state.buf.findIndex((a) => a.action === action && a.state === 'in_progress');
+}
+/** Replace the row at `idx` with `next`, returning a new state. */
+function replaceAt(state, idx, next) {
+    const buf = state.buf.slice();
+    buf[idx] = next;
+    return { ...state, buf };
+}
+/** Prepend an `in_progress` row started at `at` (injected ISO clock reading). */
+export function start(state, action, at) {
+    return push(state, {
+        resource: state.resource,
+        action,
+        state: 'in_progress',
+        started_at: at,
+        finished_at: null,
+        error: null,
+    });
+}
+/**
+ * Flip the most-recent matching `in_progress` row to `done` (finished at `at`).
+ * Idempotent: with no matching row this returns the SAME state value.
+ */
+export function done(state, action, at) {
+    const idx = findInProgress(state, action);
+    if (idx < 0)
+        return state;
+    return replaceAt(state, idx, { ...state.buf[idx], state: 'done', finished_at: at });
+}
+/**
+ * Flip the matching `in_progress` row to `error` (finished at `at`); when no
+ * in-progress row exists, prepend a fresh orphan-error row with
+ * `started_at === finished_at`.
+ */
+export function error(state, action, msg, at) {
+    const idx = findInProgress(state, action);
+    if (idx >= 0) {
+        return replaceAt(state, idx, {
+            ...state.buf[idx],
+            state: 'error',
+            finished_at: at,
+            error: msg,
+        });
+    }
+    return push(state, {
+        resource: state.resource,
+        action,
+        state: 'error',
+        started_at: at,
+        finished_at: at,
+        error: msg,
+    });
+}
+/**
+ * One-shot terminal annotation. The action is prepended already-finished;
+ * `started_at === finished_at`. Used for state that has no meaningful
+ * in-progress phase (workspace drift annotations, vm kill_session errors).
+ */
+export function record(state, action, outcome, at, msg = null) {
+    return push(state, {
+        resource: state.resource,
+        action,
+        state: outcome,
+        started_at: at,
+        finished_at: at,
+        error: msg,
+    });
+}
+/** Most-recent-first slice of action statuses, capped at `maxItems` (default `maxHistory`). */
+export function snapshot(state, maxItems) {
+    return state.buf.slice(0, maxItems ?? state.maxHistory);
+}
+/**
+ * The newest error message in the buffer, or null. Surfaced as `last_error` in
+ * both the ResourceSnapshot and ActionsSnapshot projections. (buf is
+ * most-recent-first, so the first error row is the freshest.)
+ */
+function lastError(state) {
+    const row = state.buf.find((a) => a.state === 'error' && a.error !== null);
+    return row ? row.error : null;
+}
+/**
+ * Project a `ResourceSnapshot` for the dashboard. The ledger does not own the
+ * desired/actual convergence verdict, so the caller supplies `ready`,
+ * `desired_hash`, and (optionally) overrides `id` / `last_error`.
+ */
+export function resourceSnapshot(state, opts) {
+    return {
+        id: opts.id ?? state.resource,
+        ready: opts.ready,
+        desired_hash: opts.desired_hash ?? null,
+        last_error: opts.last_error !== undefined ? opts.last_error : lastError(state),
+        actions: snapshot(state, opts.maxItems),
+    };
+}
+/**
+ * Project an `ActionsSnapshot` (the orchestrator drains this from the actions
+ * executor between attempts). `id` is conventionally `actions:<state>`.
+ */
+export function actionsSnapshot(state, opts) {
+    return {
+        id: opts.id,
+        ready: opts.ready,
+        last_error: opts.last_error !== undefined ? opts.last_error : lastError(state),
+        actions: snapshot(state, opts.maxItems),
+    };
+}
+//# sourceMappingURL=ledger.js.map

package/dist/src/core/reconcile/ledger.js.map

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

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

@@ -0,0 +1,62 @@
+// FCIS rewrite — pure PR-intent classifier.
+//
+// Functional-core port of the original `src/orchestrator-decisions.ts:
+// classifyPrIntent`. Maps a tracker issue + the configured merge/close state
+// names + the base branch into a `PrIntent` (the unit of work the PR autopilot
+// reconciles) or `null` when the issue's state matches neither configured PR
+// state.
+//
+// The original is already pure-ish (no IO of its own), but it took the
+// merge-workspace path as a precomputed string — workspace pathing is an
+// adapter concern (it depends on the workspace root + key scheme), so the
+// SHELL still supplies `mergeWorkspacePath` here, exactly as before. Close
+// intents drop the workspace path (terminal cleanup owns that directory), so
+// the shell may pass anything for it on a pure-close issue.
+//
+// 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/**.
+//
+// Behavior ported faithfully:
+//   - State matching is CASE-INSENSITIVE (both sides lower-cased) — the tracker
+//     stores the human-facing state label (e.g. "In Review") while the workflow
+//     config may declare it differently-cased.
+//   - `closeState === null` means "no close state configured" → never a close
+//     intent.
+//   - The emitted `state` field preserves the issue's ORIGINAL casing (the
+//     case-insensitive compare is only for matching, not for what we echo back).
+//   - Branch fallback: an empty / missing `branch_name` derives `agent/<id>`.
+/**
+ * Classify a tracker issue into a PR autopilot intent or `null`.
+ *
+ * Returns `null` when the issue's state matches neither the configured merge
+ * state nor (if any) the configured close state. Otherwise returns a fully
+ * populated {@link PrIntent}:
+ *   - `kind: 'merge'` when the state matches `mergeState` (merge takes
+ *     precedence if — pathologically — both names coincide), with
+ *     `workspace_path` set to the shell-supplied `mergeWorkspacePath`.
+ *   - `kind: 'close'` otherwise, with `workspace_path: null`.
+ *
+ * Pure + synchronous: (data) -> data | null. No Effects: this is a pure
+ * classification, so the only "output" is the decision object itself.
+ */
+export function classifyPrIntent(input) {
+    const stateLower = input.issue.state.toLowerCase();
+    const isMerge = stateLower === input.mergeState.toLowerCase();
+    const isClose = input.closeState !== null && stateLower === input.closeState.toLowerCase();
+    if (!isMerge && !isClose)
+        return null;
+    const branch = input.issue.branch_name && input.issue.branch_name.length > 0
+        ? input.issue.branch_name
+        : `agent/${input.issue.identifier}`;
+    return {
+        identifier: input.issue.identifier,
+        kind: isMerge ? 'merge' : 'close',
+        state: input.issue.state,
+        workspace_path: isMerge ? input.mergeWorkspacePath : null,
+        branch,
+        base_branch: input.baseBranch,
+    };
+}
+//# sourceMappingURL=pr-classify.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pr-classify.js","sourceRoot":"","sources":["../../../../src/core/reconcile/pr-classify.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,uEAAuE;AACvE,6EAA6E;AAC7E,+EAA+E;AAC/E,6EAA6E;AAC7E,SAAS;AACT,EAAE;AACF,uEAAuE;AACvE,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,6EAA6E;AAC7E,4DAA4D;AAC5D,EAAE;AACF,oCAAoC;AACpC,yDAAyD;AACzD,+EAA+E;AAC/E,sCAAsC;AACtC,EAAE;AACF,8BAA8B;AAC9B,gFAAgF;AAChF,gFAAgF;AAChF,+CAA+C;AAC/C,8EAA8E;AAC9E,cAAc;AACd,2EAA2E;AAC3E,iFAAiF;AACjF,8EAA8E;AAsB9E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA4B;IAC3D,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IACnD,MAAM,OAAO,GAAG,UAAU,KAAK,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;IAC9D,MAAM,OAAO,GACX,KAAK,CAAC,UAAU,KAAK,IAAI,IAAI,UAAU,KAAK,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;IAC7E,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAEtC,MAAM,MAAM,GACV,KAAK,CAAC,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC;QAC3D,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW;QACzB,CAAC,CAAC,SAAS,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;IAExC,OAAO;QACL,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU;QAClC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO;QACjC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK;QACxB,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI;QACzD,MAAM;QACN,WAAW,EAAE,KAAK,CAAC,UAAU;KAC9B,CAAC;AACJ,CAAC"}

package/dist/{reconciler → src/core/reconcile}/pr-decide.js

@@ -1,12 +1,20 @@
-// Pure decision logic for the PR autopilot (issue 70). `decidePr(observed) →
-// PrEffect[]` is the heart of the resource: every routing, arm, cleanup, and
-// reroute branch lives here as a deterministic function of an observation
-// snapshot. `pr.ts` is then the imperative shell that builds the observation,
-// applies effects in order through the injected ports, folds outcomes back
-// into the next observation, and re-decides until the decision list is empty.
+// FCIS rewrite — pure PR-autopilot decision core (issue 70 / issue 105).
 //
-// Effects-as-data lets the branch table be tested as a plain function over
-// input objects — and the shell shrinks to one effect-application switch.
+// Verbatim port of the original `src/reconciler/pr-decide.ts`:
+//   decidePr, buildConflictNotes, and the two private deciders decideClose /
+//   decideConflict. The original module was already a pure, synchronous
+//   (data) -> data function — it declared `No IO imports. No clock. No
+//   randomness. Domain-only.` at the top. The only change in this rewrite is
+//   structural: the type vocabulary (PrEffect, PrObservation, PrIntent, PrView,
+//   …) now lives in `src/types/reconcile.ts` and is imported here rather than
+//   declared inline. The branch logic is unchanged.
+//
+// `decidePr(observation) → PrEffect[]` is the heart of the resource: every
+// routing, arm, cleanup, and reroute branch lives here as a deterministic
+// function of an observation snapshot. The imperative shell builds the
+// observation, applies the returned effects in order through injected ports,
+// folds outcomes back into the next observation, and re-decides until the
+// decision list is empty.
 //
 // Multi-pass semantics: outcomes of IO effects (summary lookup, view fetch)
 // drive subsequent decisions. The shell records each outcome into the
@@ -14,10 +22,10 @@
 // `summaryResolved` / `viewResolved` to decide whether the next observation
 // step has run yet. The loop terminates when `decidePr` returns `[]`.
 //
-// Action ledger / log lines are handled inside the effect handlers in
-// `pr.ts` — this module only emits the data describing what should happen.
-//
-// No IO imports. No clock. No randomness. Domain-only.
+// 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/**.
 /**
  * Pure decision: given an observation, return the next batch of effects the
  * shell should apply. After applying, the shell rebuilds the observation
@@ -136,6 +144,11 @@ function decideClose(obs) {
  */
 function decideConflict(obs) {
     const id = obs.intent.identifier;
+    // `decideConflict` is only reached from the MERGEABLE-branch guard in
+    // `decidePr` after `obs.view === null` has been ruled out, so the view is
+    // always present here. The original asserted this with a non-null assertion
+    // (`obs.view!`); we narrow explicitly instead to keep the module free of
+    // `!` and still hand a defined `PrView` to `buildConflictNotes`.
     const view = obs.view;
     return [
         {

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

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

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

@@ -0,0 +1,161 @@
+// FCIS rewrite — pure multi-pass driver of `decidePr` (the PR autopilot's
+// per-intent decide → apply → re-decide loop).
+//
+// Ported faithfully from the reference `src/reconciler/pr.ts`
+// (`processIntent` + `applyEffect`). The reference was an async driver that:
+//
+//   • built a fresh `PrObservation` from live `PerIssueState`,
+//   • looped up to 12 times calling the pure `decidePr(obs)`,
+//   • AWAITED each emitted `PrEffect` against injected `gh` / tracker / cleanup
+//     ports (IO), and
+//   • folded each effect's OUTCOME back into the next observation
+//     (`summaryResolved`/`summary`, `viewResolved`/`view`, `closeAttempted`/
+//     `closeOutcome`, `halt`, and the sticky per-issue cache view: `armed` /
+//     `lastObservedHeadSha` / `completed`).
+//
+// In the functional core all the IO disappears. This module is JUST the fold:
+//
+//   • The shell APPLIES each `PrEffect` (running the matching gh/tracker/fs
+//     port) and hands the result back as a `PrEffectOutcome` — the exact data
+//     the reference's `applyEffect` derived from its awaited IO call.
+//   • `foldPrEffectOutcome(obs, effect, outcome)` reproduces the reference's
+//     `applyEffect` switch as a pure `(obs, effect, outcome) -> obs` reducer:
+//     it threads the next observation (including the sticky cache view) without
+//     touching any port.
+//   • `decidePrPass(obs, decide)` runs ONE `decidePr` call and returns the
+//     emitted effects (or `[]` to stop) — `decide` is the pure `decidePr`
+//     injected as a plain parameter so this driver stays import-clean and
+//     independently testable.
+//   • `MAX_PR_DECIDE_ITERATIONS` is the reference's defensive 12-pass cap; the
+//     shell drives the outer loop and emits an `iteration_cap_reached` log when
+//     `driveStartState`/the loop signals it.
+//
+// The reference's sticky-cache mutations (`PerIssueState.armed` /
+// `lastObservedHeadSha` / `completed`, and the `resetTransient` wipe) lived in
+// the live `PerIssueState` map; here they ride in the `PrCacheView` carried by
+// the observation. The shell folds the returned `obs.cache` back into its
+// per-issue state after each pass.
+//
+// 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.)
+/**
+ * Defensive iteration cap, mirroring the reference's `for (let i = 0; i < 12;`
+ * loop in `processIntent`. `decidePr` strictly reduces work on every iteration
+ * (a `*_resolved` flag flips, a cache latch lands, or `halt` is set), so the
+ * loop terminates well inside this bound; the cap only guards against a future
+ * decide-table regression looping forever.
+ */
+export const MAX_PR_DECIDE_ITERATIONS = 12;
+/**
+ * Run one `decidePr` pass over the current observation. Returns the effects the
+ * shell should apply (in order), or `[]` to terminate the per-intent loop.
+ *
+ * Mirrors the reference's `const effects = decidePr(obs); if (effects.length
+ * === 0) return;`. Kept as a one-liner seam so the shell never imports
+ * `decidePr` directly and the cap loop below has a single decide entry point.
+ */
+export function decidePrPass(obs, decide) {
+    return decide(obs);
+}
+/**
+ * Fold one applied `PrEffect`'s outcome back into the next observation. Pure
+ * reproduction of the reference `applyEffect` switch (`src/reconciler/pr.ts`):
+ * the shell runs the IO for `effect`, hands back the matching `PrEffectOutcome`,
+ * and this returns the observation the next `decidePr` call should see.
+ *
+ * Every branch returns a NEW observation object (never mutates the input),
+ * matching the reference's `{ ...obs, ... }` spreads.
+ */
+export function foldPrEffectOutcome(obs, effect, outcome) {
+    switch (effect.kind) {
+        case 'observe_summary': {
+            // Reference: `{ ...obs, summaryResolved: true, summary, cache }`.
+            const summary = outcome.kind === 'summary' ? outcome.summary : null;
+            const cache = outcome.kind === 'summary' ? outcome.cache : obs.cache;
+            return { ...obs, summaryResolved: true, summary, cache };
+        }
+        case 'observe_view': {
+            // Reference: `{ ...obs, viewResolved: true, view, cache }` — the shell's
+            // `fetchPrView` also folds `armed` / `lastObservedHeadSha` from the view
+            // into the cache, which arrives here in `outcome.cache`.
+            const view = outcome.kind === 'view' ? outcome.view : null;
+            const cache = outcome.kind === 'view' ? outcome.cache : obs.cache;
+            return { ...obs, viewResolved: true, view, cache };
+        }
+        case 'arm_auto_merge': {
+            // Reference: sets `st.armed = true`, returns `{ ...obs, cache }`.
+            const cache = outcome.kind === 'cache' ? outcome.cache : obs.cache;
+            return { ...obs, cache };
+        }
+        case 'update_branch':
+            // Reference: `{ ...obs, halt: true }`. The cached view still reads BEHIND;
+            // halting prevents re-emitting `update_branch` every iteration.
+            return { ...obs, halt: true };
+        case 'close_pr': {
+            // Reference: `{ ...obs, closeAttempted: true, closeOutcome: { ok } }`.
+            const ok = outcome.kind === 'close' ? outcome.ok : false;
+            return { ...obs, closeAttempted: true, closeOutcome: { ok } };
+        }
+        case 'delete_remote_branch':
+        case 'cleanup_workspace':
+            // Reference: returns `obs` unchanged (fire-and-forget, best-effort).
+            return obs;
+        case 'route_conflict':
+            // Reference: `{ ...obs, halt: true }`. Terminal for this pass; the paired
+            // `reset_transient` effect carries the cache wipe.
+            return { ...obs, halt: true };
+        case 'update_observed_head': {
+            // Reference: sets `st.lastObservedHeadSha = eff.sha`, returns `{ ...obs, cache }`.
+            const cache = outcome.kind === 'cache' ? outcome.cache : obs.cache;
+            return { ...obs, cache };
+        }
+        case 'mark_completed': {
+            // Reference: sets `st.completed = true`, returns `{ ...obs, cache }`.
+            const cache = outcome.kind === 'cache' ? outcome.cache : obs.cache;
+            return { ...obs, cache };
+        }
+        case 'reset_transient': {
+            // Reference: `resetTransient(st)` then `{ ...obs, cache, halt: true }`.
+            // Always paired with `route_conflict`; terminal for this pass. The shell
+            // hands back the wiped cache view (or the EMPTY cache if the per-issue
+            // state had already been dropped).
+            const cache = outcome.kind === 'cache' ? outcome.cache : obs.cache;
+            return { ...obs, cache, halt: true };
+        }
+    }
+}
+/**
+ * Pure multi-pass driver: the functional-core form of the reference
+ * `processIntent`. Repeatedly runs `decide(obs)`; if it emits no effects the
+ * loop ends; otherwise it folds each effect's applied outcome (via `apply`)
+ * back into the observation and re-decides — capped at
+ * {@link MAX_PR_DECIDE_ITERATIONS} passes.
+ *
+ * `apply` is synchronous on purpose: in production the shell drives the loop
+ * directly (awaiting IO between folds); this helper exists for pure tests and
+ * for shells that can resolve every effect synchronously. The fold reducer
+ * ({@link foldPrEffectOutcome}) and the pass seam ({@link decidePrPass}) are the
+ * load-bearing pure pieces — `drivePr` just sequences them, exactly like the
+ * reference loop, with no IO of its own.
+ */
+export function drivePr(initial, decide, apply) {
+    let obs = initial;
+    const steps = [];
+    for (let i = 0; i < MAX_PR_DECIDE_ITERATIONS; i += 1) {
+        const effects = decidePrPass(obs, decide);
+        if (effects.length === 0) {
+            return { observation: obs, steps, stop: 'idle' };
+        }
+        for (const effect of effects) {
+            const outcome = apply(effect, obs);
+            obs = foldPrEffectOutcome(obs, effect, outcome);
+        }
+        steps.push({ effects, observation: obs });
+        // A halt set by this pass means decidePr will return [] next iteration; we
+        // let the loop spin once more so the terminating `[]` is observed (matching
+        // the reference, where the next `decidePr` short-circuits on `obs.halt`).
+    }
+    return { observation: obs, steps, stop: 'iteration_cap' };
+}
+//# sourceMappingURL=pr-loop.js.map

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

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

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"}