smol-symphony 0.1.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/src/core/reconcile/pr-decide.js

@@ -0,0 +1,180 @@
+// FCIS rewrite — pure PR-autopilot decision core (issue 70 / issue 105).
+//
+// 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
+// observation and calls `decidePr` again; the function looks at
+// `summaryResolved` / `viewResolved` to decide whether the next observation
+// step has run yet. The loop terminates when `decidePr` returns `[]`.
+//
+// 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
+ * (with new IO outcomes folded in) and calls `decidePr` again. The loop ends
+ * when the result is empty.
+ */
+export function decidePr(obs) {
+    const { intent, cache } = obs;
+    const id = intent.identifier;
+    if (obs.halt)
+        return [];
+    if (cache.completed)
+        return [];
+    if (!obs.summaryResolved) {
+        return [{ kind: 'observe_summary', identifier: id, branch: intent.branch }];
+    }
+    if (intent.kind === 'close')
+        return decideClose(obs);
+    // merge intent below
+    if (obs.summary === null)
+        return [];
+    if (!obs.viewResolved) {
+        return [{ kind: 'observe_view', identifier: id, prNumber: obs.summary.number }];
+    }
+    if (obs.view === null)
+        return [];
+    const view = obs.view;
+    if (view.state === 'MERGED' || view.state === 'CLOSED') {
+        return [
+            { kind: 'delete_remote_branch', identifier: id, branch: intent.branch },
+            { kind: 'cleanup_workspace', identifier: id },
+            { kind: 'mark_completed', identifier: id },
+        ];
+    }
+    // CONFLICTING → route the issue back to the implementing state so the
+    // dispatched agent rebases onto a freshly-fetched `origin/<base>` as part
+    // of its normal work. The autopilot no longer drives a rebase from the
+    // workspace; "is my branch mergeable?" is the agent's responsibility now.
+    if (view.mergeable === 'CONFLICTING')
+        return decideConflict(obs);
+    // UNKNOWN: GitHub is still computing mergeability — defer until the next
+    // pass. Arming on UNKNOWN works (auto-merge waits for the computed state)
+    // but produces noisier ledgers; the per-PR poll TTL means UNKNOWN
+    // typically resolves within one tick.
+    if (view.mergeable === 'UNKNOWN') {
+        // Pin the observed head SHA so the next pass can detect concurrent
+        // pushes if the agent has pushed in the meantime.
+        if (cache.lastObservedHeadSha !== view.head_ref_oid) {
+            return [{ kind: 'update_observed_head', identifier: id, sha: view.head_ref_oid }];
+        }
+        return [];
+    }
+    // MERGEABLE: arm `gh pr merge --auto` once. GitHub handles the wait-for-
+    // checks-and-reviews part on its own; we just keep the auto-merge armed.
+    if (!cache.armed) {
+        return [
+            {
+                kind: 'arm_auto_merge',
+                identifier: id,
+                prNumber: view.number,
+                strategy: obs.config.strategy,
+            },
+        ];
+    }
+    // Armed but BEHIND: branch protection's "require branches up to date" rule
+    // blocks the auto-merge until the branch catches up to base. The diffs
+    // don't textually conflict (mergeable=MERGEABLE), so the CONFLICTING route
+    // never fires — without an explicit nudge the PR sits armed-and-stuck
+    // forever. Advance the branch via `gh pr update-branch`; once the head
+    // moves, head_ref_oid changes (update_observed_head absorbs it) and the
+    // status leaves BEHIND, so the effect stops firing. See issue 105.
+    if (view.merge_state_status === 'BEHIND') {
+        return [{ kind: 'update_branch', identifier: id, prNumber: view.number }];
+    }
+    return [];
+}
+function decideClose(obs) {
+    const id = obs.intent.identifier;
+    if (obs.summary === null)
+        return [{ kind: 'mark_completed', identifier: id }];
+    if (!obs.viewResolved) {
+        return [{ kind: 'observe_view', identifier: id, prNumber: obs.summary.number }];
+    }
+    if (obs.view === null)
+        return [];
+    const view = obs.view;
+    if (view.state === 'MERGED' || view.state === 'CLOSED') {
+        return [
+            { kind: 'delete_remote_branch', identifier: id, branch: obs.intent.branch },
+            { kind: 'mark_completed', identifier: id },
+        ];
+    }
+    // Open PR: close first, then gate branch deletion on close success. A
+    // failed close leaves the PR open on origin, so deleting the remote branch
+    // would orphan it — matching main's `runClosePr` which returned early on
+    // failure. The completion latch still fires (same as main) so a transient
+    // gh outage doesn't leave the close intent looping every pass.
+    if (!obs.closeAttempted) {
+        return [{ kind: 'close_pr', identifier: id, prNumber: view.number }];
+    }
+    if (obs.closeOutcome !== null && obs.closeOutcome.ok) {
+        return [
+            { kind: 'delete_remote_branch', identifier: id, branch: obs.intent.branch },
+            { kind: 'mark_completed', identifier: id },
+        ];
+    }
+    return [{ kind: 'mark_completed', identifier: id }];
+}
+/**
+ * Conflict routing: append a notes block and move the issue back to the
+ * implementing state. No counter, no circuit breaker — the dispatched agent
+ * rebases onto a freshly-fetched `origin/<base>` and resolves the conflict
+ * as part of its normal Todo flow. Each round the PR flips back to
+ * MERGEABLE on the agent's force-push, the next reconcile pass arms
+ * auto-merge, and merging happens once checks pass.
+ */
+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 [
+        {
+            kind: 'route_conflict',
+            identifier: id,
+            fromState: obs.intent.state,
+            toState: obs.config.conflictRouteTo,
+            notes: buildConflictNotes({ intent: obs.intent, view }),
+        },
+        { kind: 'reset_transient', identifier: id },
+    ];
+}
+/**
+ * Structured notes block appended to the issue file when a conflict route
+ * fires. Pure: every input is part of the observation. Lives here (not in the
+ * shell) so the route effect carries its rendered notes as data.
+ */
+export function buildConflictNotes(args) {
+    const { intent, view } = args;
+    const lines = [
+        'pr autopilot — PR is not mergeable against base',
+        '',
+        `GitHub reports PR #${view.number} (${view.url}) as \`mergeable: ${view.mergeable}\` against \`origin/${intent.base_branch}\`.`,
+        '',
+        `Routing the issue back to \`${intent.state}\` → implementing state. The next dispatch will fetch \`origin/${intent.base_branch}\` afresh into the workspace; the agent rebases \`${intent.branch}\` onto it as the first step of its normal Todo flow, resolves any conflicts in-tree, re-runs typecheck/tests, and hands back off to the reviewer. Once the rebased branch is force-pushed, this PR flips back to MERGEABLE and auto-merge is armed on the next reconcile pass.`,
+    ];
+    return lines.join('\n');
+}
+//# sourceMappingURL=pr-decide.js.map

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