@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/chrome-extension/driver-plan.js

@@ -0,0 +1,41 @@
+// Which watched sessions the Driver tab visits this cycle (#1332). Shared by the service worker,
+// which decides, and the offline harness, which pins the rule; loaded as a plain script in both.
+//
+// The rule exists because claude.ai's list statuses are sticky: an in-app visit clears neither
+// "Awaiting input" nor "Unread response" (measured 2026-08-25), so visiting every stopped session
+// on every cycle would mean 50 visits every half minute for 50 agents. A session is visited when
+// its status changed to awaiting, unread or idle since the last read; an awaiting one also when it
+// has not been visited for a while — a question asked in prose carries no block, so the list's
+// word is the only signal and a re-read is what catches it (#1707); and any session always when
+// the dashboard queued an answer for it — that is the one thing the list cannot know.
+
+/** How long a session the list keeps calling awaiting waits before being looked at again. */
+const REVISIT_MS = 5 * 60_000
+
+/** The list statuses that mean the session stopped: for its user, after a turn, or for good. */
+const ON_CHANGE = new Set(['awaiting', 'unread', 'idle'])
+
+/** The one status also revisited on age: the session may be asking without a block. */
+const ON_AGE = new Set(['awaiting'])
+
+/**
+ * `statuses`: what the list said, `[{sessionId, status}]`. `answers`: a map of session id to the
+ * queued answer. `seen`: a map of session id to `{status, visitedAt}` from earlier cycles. Returns
+ * the visits in list order, each `{id, status, answer?}`.
+ */
+function planVisits(statuses, answers, seen, now, revisitMs = REVISIT_MS) {
+  const visits = []
+  for (const { sessionId, status } of statuses) {
+    const answer = answers.get(sessionId)
+    const last = seen.get(sessionId)
+    const changed = !last || last.status !== status
+    const stale = !last || now - (last.visitedAt ?? 0) >= revisitMs
+    const due = (ON_CHANGE.has(status) && changed) || (ON_AGE.has(status) && stale)
+    if (answer || due) visits.push({ id: sessionId, status, ...(answer ? { answer } : {}) })
+  }
+  return visits
+}
+
+// The worker loads this with importScripts, where a top-level function is already global; jsdom
+// evaluates it the same way. Nothing else to export.
+if (typeof globalThis !== 'undefined') globalThis.__tfPlanVisits = planVisits

package/dist/chrome-extension/fingerprint.js

@@ -0,0 +1,43 @@
+// Whether the extension's own files changed on disk (#1711). Shared by the service worker, which
+// reloads the extension when they did, and the offline harness, which pins the rule; loaded as a
+// plain script in both.
+//
+// This exists because the extension is unpacked and edited in place, and Chrome re-reads an
+// unpacked extension's files only on a reload — which used to be a human click on
+// chrome://extensions after every change. The worker can read its own files as they are on disk
+// right now (measured 2026-08-26: a fetch of the extension's own URL returns the current file,
+// not a cached copy), so it fingerprints them at start, again every beat, and reloads itself on
+// a difference.
+
+/** Every file Chrome loads for this extension: the manifest, the worker and what it imports, the content script, and the options page and its script. */
+const WATCHED_FILES = ['manifest.json', 'background.js', 'driver-plan.js', 'fingerprint.js', 'content.js', 'options.html', 'options.js']
+
+/** FNV-1a over the text, as eight hex digits. Enough to tell an edit; nobody is attacking it. */
+function hashText(text) {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return hash.toString(16).padStart(8, '0')
+}
+
+/**
+ * The hash of each watched file, read through `readText(file)`. A file that cannot be read fails
+ * the whole fingerprint rather than standing in as a change: a reload on a read that merely
+ * failed this once would loop.
+ */
+async function fingerprint(readText) {
+  const hashes = {}
+  for (const file of WATCHED_FILES) hashes[file] = hashText(await readText(file))
+  return hashes
+}
+
+/** The watched files whose hash differs between two fingerprints, in watched order. */
+function changedFiles(before, after) {
+  return WATCHED_FILES.filter(file => before[file] !== after[file])
+}
+
+// The worker loads this with importScripts, where a top-level binding is already global; jsdom
+// evaluates it the same way. Nothing else to export.
+if (typeof globalThis !== 'undefined') globalThis.__tfFingerprint = { WATCHED_FILES, fingerprint, changedFiles }

package/dist/chrome-extension/manifest.json

@@ -0,0 +1,31 @@
+{
+  "manifest_version": 3,
+  "name": "The Framework: Claude web bridge",
+  "version": "0.12.0",
+  "description": "Drives one pinned claude.ai tab through your Claude Code cloud sessions: the question a session is parked on shows up in your local The Framework dashboard, and the answer you pick there is typed back into the session.",
+  "permissions": [
+    "storage",
+    "tabs",
+    "alarms"
+  ],
+  "host_permissions": [
+    "http://localhost/*",
+    "http://127.0.0.1/*"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "options_page": "options.html",
+  "content_scripts": [
+    {
+      "matches": [
+        "https://claude.ai/*"
+      ],
+      "js": [
+        "content.js"
+      ],
+      "run_at": "document_idle",
+      "all_frames": true
+    }
+  ]
+}

package/dist/chrome-extension/options.html

@@ -0,0 +1,48 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>The Framework bridge</title>
+    <style>
+      body { font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; margin: 24px; max-width: 560px; color: #1f2430; }
+      h1 { font-size: 17px; margin: 0 0 4px; }
+      p { color: #5b6472; margin: 0 0 16px; }
+      label { display: block; font-weight: 600; margin: 14px 0 4px; }
+      input { width: 100%; padding: 7px 9px; border: 1px solid #c9cfd8; border-radius: 6px; font: inherit; box-sizing: border-box; }
+      button { margin-top: 16px; padding: 7px 14px; border: 0; border-radius: 6px; background: #2d3441; color: #fff; font: inherit; cursor: pointer; }
+      code { background: #eef1f5; padding: 1px 5px; border-radius: 4px; }
+      #status { margin-top: 12px; min-height: 20px; color: #2f7a3f; }
+      #status.error { color: #b3261e; }
+    </style>
+  </head>
+  <body>
+    <h1>The Framework bridge</h1>
+    <p>
+      Reports the question a Claude Code cloud session is parked on to your local dashboard. Turn the
+      bridge on in The Framework first, then paste its token here.
+    </p>
+
+    <label for="daemon">Dashboard URL</label>
+    <input id="daemon" type="url" placeholder="http://localhost:4200" />
+
+    <label for="token">Bridge token</label>
+    <input id="token" type="password" placeholder="paste the token from The Framework" autocomplete="off" />
+
+    <label style="font-weight:600;margin-top:18px;display:flex;align-items:center;gap:8px">
+      <input id="autoOpen" type="checkbox" style="width:auto" />
+      Run the Driver tab
+    </label>
+    <p style="margin:4px 0 0;font-size:12px">
+      One pinned background tab that reads claude.ai's session list, visits the cloud sessions
+      waiting on you, and types your answers. Without it the bridge does nothing. Closing the tab
+      pauses it; the button below reopens it.
+    </p>
+
+    <button id="save">Save and test</button>
+    <button id="openNow" style="background:#4a5566;margin-left:8px">Open the Driver tab now</button>
+    <div id="status" role="status"></div>
+    <p id="lastCycle" style="margin:10px 0 0;font-size:12px"></p>
+
+    <script src="options.js"></script>
+  </body>
+</html>

package/dist/chrome-extension/options.js

@@ -0,0 +1,122 @@
+// Where the token is set. It lives in extension storage rather than in the page, so nothing on
+// claude.ai can read the secret that talks to the daemon.
+
+const DEFAULT_DAEMON = 'http://localhost:4200'
+const daemonEl = document.getElementById('daemon')
+const tokenEl = document.getElementById('token')
+const statusEl = document.getElementById('status')
+const autoOpenEl = document.getElementById('autoOpen')
+const lastCycleEl = document.getElementById('lastCycle')
+
+void chrome.storage.local.get(['daemonUrl', 'token', 'autoOpen']).then(({ daemonUrl, token, autoOpen }) => {
+  daemonEl.value = daemonUrl || DEFAULT_DAEMON
+  tokenEl.value = token || ''
+  // Default on once configured, but stored explicitly so the worker never has to guess.
+  autoOpenEl.checked = autoOpen !== false
+})
+
+/**
+ * What the worker's last cycle did, as it recorded it: this page is the one place to read why
+ * the bridge is doing nothing — or that the worker just reloaded the extension because its files
+ * changed on disk — without opening a service worker console. Kept live while the page is open:
+ * the worker records every cycle, and each record re-renders the line.
+ */
+function showLastCycle(lastCycle) {
+  if (!lastCycle) {
+    lastCycleEl.textContent = 'No cycle has run yet.'
+    return
+  }
+  const at = lastCycle.at ? ` at ${new Date(lastCycle.at).toLocaleTimeString()}` : ''
+  lastCycleEl.textContent = `Last cycle${at}: ${lastCycle.ok ? '' : 'failed — '}${lastCycle.reason ?? 'no reason recorded'}`
+}
+void chrome.storage.local.get('lastCycle').then(({ lastCycle }) => showLastCycle(lastCycle))
+chrome.storage.onChanged.addListener((changes, area) => {
+  if (area === 'local' && changes.lastCycle) showLastCycle(changes.lastCycle.newValue)
+})
+
+function say(message, isError) {
+  statusEl.textContent = message
+  statusEl.className = isError ? 'error' : ''
+}
+
+/**
+ * Are the host permissions actually granted?
+ *
+ * Declaring them in the manifest is not the same as holding them: Chrome lists each site under
+ * "Site access" with its own toggle, and for an unpacked extension they can sit off. The daemon
+ * sends no CORS headers by design, so without the localhost grant the worker's fetch is blocked
+ * before it leaves the browser and the daemon sees nothing at all. That looked like every other
+ * failure and cost an evening, so it is checked first now.
+ */
+async function missingHosts(daemonUrl) {
+  const wanted = [`${daemonUrl}/`, 'https://claude.ai/']
+  const missing = []
+  for (const origin of wanted) {
+    const ok = await chrome.permissions.contains({ origins: [`${origin}*`] }).catch(() => false)
+    if (!ok) missing.push(origin)
+  }
+  return missing
+}
+
+document.getElementById('save').addEventListener('click', async () => {
+  const daemonUrl = (daemonEl.value || DEFAULT_DAEMON).replace(/\/+$/, '')
+  const token = tokenEl.value.trim()
+  if (!token) return say('Paste the bridge token first.', true)
+  await chrome.storage.local.set({ daemonUrl, token, autoOpen: autoOpenEl.checked })
+
+  // Save then prove it: a token that is merely stored tells the user nothing, and the two ways
+  // this goes wrong (bridge off, wrong token) are worth telling apart before they need it.
+  say('Saved. Testing…')
+  const missing = await missingHosts(daemonUrl)
+  if (missing.length) {
+    return say(
+      `Chrome has not granted access to ${missing.join(' and ')}. Open chrome://extensions, find this extension, and switch those on under Site access.`,
+      true,
+    )
+  }
+  try {
+    const version = { 'x-tf-extension-version': chrome.runtime.getManifest().version }
+    const res = await fetch(`${daemonUrl}/_bridge/ping`, { headers: { authorization: `Bearer ${token}`, ...version } })
+    if (res.status === 401) return say('The dashboard is reachable but rejected the token.', true)
+    if (res.status === 404) return say('Reached the dashboard, but the bridge is off. Turn it on in The Framework.', true)
+    // The daemon refuses a version-skewed extension on every route (#1519); its answer names
+    // both versions and the way out, so hand it over verbatim.
+    if (res.status === 426) return say(await res.text(), true)
+    if (!res.ok) return say(`The dashboard answered ${res.status}.`, true)
+    // A 200 is not enough. The dashboard serves its single-page app for any path it does not
+    // recognise, so a build with no bridge route answers 200 and a page of HTML, and treating
+    // that as success would report "connected" to someone whose bridge does not exist.
+    const body = (await res.text()).trim()
+    if (body !== 'ok') return say('That dashboard has no bridge route. Update The Framework, then try again.', true)
+
+    // Prove the read path too, not just auth. "Connected" on its own leaves the next question
+    // unanswered: does the daemon actually have anything for us to watch?
+    let watching = ''
+    try {
+      const list = await fetch(`${daemonUrl}/_bridge/sessions`, { headers: { authorization: `Bearer ${token}`, ...version } })
+      const sessions = list.ok ? ((await list.json())?.sessions ?? []) : []
+      watching = sessions.length
+        ? ` Watching ${sessions.length} recent cloud session${sessions.length === 1 ? '' : 's'}${autoOpenEl.checked ? ', the Driver tab serves them.' : ' (the Driver tab is off).'}`
+        : ' No recent cloud sessions to watch yet.'
+    } catch {
+      watching = ' Could not list sessions.'
+    }
+    say(`Connected. The bridge is on and the token works.${watching}`)
+  } catch {
+    say(`Could not reach ${daemonUrl}. Is the dashboard running?`, true)
+  }
+})
+
+
+// Run a Driver cycle on demand. The alarm fires twice a minute, which is a long time to sit
+// wondering whether anything is wrong, and every reason it might do nothing is reported. This
+// also resumes a Driver the user paused by closing its tab.
+document.getElementById('openNow').addEventListener('click', () => {
+  say('Driving…')
+  chrome.runtime.sendMessage({ type: 'tf-open-now' }, result => {
+    if (chrome.runtime.lastError) return say(chrome.runtime.lastError.message ?? 'the worker did not answer', true)
+    if (!result) return say('The worker did not answer. Try reloading the extension.', true)
+    if (!result.ok) return say(`Did nothing: ${result.reason}`, true)
+    say(`Driver cycle done: ${result.reason}.`)
+  })
+})

package/dist/ci-watch.d.ts

@@ -0,0 +1,123 @@
+import { type AgentMeta } from './store/index.js';
+import { type HandoffResult, type PrAgent } from './dashboard/agent-handoff.js';
+import { type LinkedPr, type PrCiStatus } from './dashboard/gh.js';
+import type { Cached } from './dashboard/cache.js';
+import { type ProjectPass, type ProjectsSource } from './project-pass.js';
+/**
+ * How long an agent's watched PR stays on the sweep's list: long enough to survive a weekend of the
+ * daemon being off, short enough that the sweep's `gh` spend cannot grow with the archive. A PR
+ * older than this is a human's to land — it has been red or unmergeable for a week.
+ */
+export declare const CI_WATCH_WINDOW_MS: number;
+/**
+ * How old a check-less PR must be before "no checks" is believed to mean "this repo has no CI"
+ * rather than "the suite has not attached yet" — GitHub takes seconds to attach one after a push,
+ * and merging inside that window is the stale-check hazard (#1406) wearing a different face.
+ */
+export declare const NO_CHECKS_GRACE_MS: number;
+/**
+ * The marker a CI-fix agent's prompt opens with, so attempts are discoverable from agent metas. The
+ * `@` is always there, sha or not: it is what stops "PR #12" reading as a prefix of "PR #123"
+ * when the metas are scanned for prior attempts.
+ */
+export declare function ciFixMarker(number: number, headSha?: string): string;
+/** What the fix agent needs to know, distilled from the PR and its checks read. */
+export interface CiFixRequest {
+    number: number;
+    title: string;
+    url: string;
+    branch: string;
+    headSha: string;
+    failed: string[];
+}
+/**
+ * The prompt a CI-fix session runs (#1418). Explicit about the git mechanics because the agent gets
+ * an ordinary session worktree on its own scratch branch: the PR's branch may be checked out in a
+ * retained worktree elsewhere, so `push origin HEAD:<branch>` is the one spelling that always
+ * lands the fix without fighting over who holds the branch.
+ */
+export declare function ciFixPrompt(fix: CiFixRequest): string;
+/** One PR the sweep merged. */
+export interface CiMerged {
+    agentId: string;
+    number: number;
+    url?: string;
+}
+/** One fix session the sweep started, or why it stood down. */
+export interface CiFixOutcome {
+    number: number;
+    /** The started session, when one was. */
+    agentId?: string;
+    /** Why no session was started: the wiring declined (gate/quota), or the attempts cap is spent. */
+    reason?: 'declined' | 'attempts-exhausted';
+}
+/** What one project's sweep did. */
+export interface CiSweepResult {
+    merged: CiMerged[];
+    /** Merges that should have happened and did not, with the refusal. */
+    failed: {
+        agentId: string;
+        number: number;
+        error: string;
+    }[];
+    fixes: CiFixOutcome[];
+}
+/** Injectable seams so the sweep is unit-testable off disk and off `gh`. */
+export interface CiSweepDeps {
+    /** Every agent meta worth scanning — live and archived (default: both stores). */
+    agents?: (cwd: string) => Promise<AgentMeta[]>;
+    /** The PR that belongs to an agent (default {@link resolveAgentPr}, which rides the PR-lookup cache (#1028)). */
+    pr?: (cwd: string, agent: PrAgent) => Promise<Cached<LinkedPr | undefined>>;
+    /** A PR's combined check state (default {@link ghPrCiStatus}). */
+    ci?: (cwd: string, number: number) => Promise<PrCiStatus>;
+    /** Merge an agent's open PR (default {@link mergeAgentPr}, which also forgets the PR caches). */
+    merge?: (cwd: string, agent: PrAgent) => Promise<HandoffResult>;
+    /**
+     * Start a CI-fix session for a red PR (#1418's fix half), resolving the agent id or undefined
+     * when the wiring declined (preference off, no quota headroom, start failed). Absent = the fix
+     * half is off and red PRs are only left for the merge half to keep ignoring.
+     */
+    fix?: (cwd: string, request: CiFixRequest) => Promise<string | undefined>;
+    /**
+     * Merge attempts that already failed (`<cwd>\0<number>\0<headSha>`), fed and consulted by the
+     * sweep so a persistently refused merge (branch protection demanding a review, say) costs one
+     * `gh` write per head, not one per tick for a week. The head sha is part of the key (#1484):
+     * a push that changes the head — a conflict resolved, say — re-arms exactly one more attempt,
+     * the same re-arm rule the CI-fix half applies. Before, a PR that arrived unmergeable was
+     * skipped for the daemon's lifetime even after its branch was fixed and its checks went green.
+     * In-memory on purpose: a daemon restart retries once.
+     */
+    attemptedMerges?: Set<string>;
+    now?: () => number;
+}
+/**
+ * Sweep one project's watched PRs (#1418): merge the green ones the repo could not arm GitHub
+ * auto-merge for, and start a fix session for the red ones.
+ *
+ * Conservative wherever the answer is unclear: a PR that is not OPEN is done (merged or a
+ * human's rejection — neither is this sweep's to touch), `pending` checks wait for the next
+ * tick, and a check-less PR only counts as green once it has been check-less for longer than a
+ * suite takes to attach ({@link NO_CHECKS_GRACE_MS}). An `auto-armed` PR is never merged here —
+ * GitHub holds that promise — but its checks going red still starts a fix.
+ */
+export declare function sweepProjectCi(cwd: string, deps?: CiSweepDeps): Promise<CiSweepResult>;
+/** What {@link startCiWatch} needs from the daemon. */
+export interface CiWatchOptions {
+    /** The registered projects to sweep. */
+    projects: ProjectsSource;
+    log: (message: string) => void;
+    /** The per-project sweep's seams, {@link CiSweepDeps.fix} included — the daemon wires the gates. */
+    deps?: CiSweepDeps;
+    /** The per-project sweep (default {@link sweepProjectCi}). */
+    sweep?: (cwd: string, deps: CiSweepDeps) => Promise<CiSweepResult>;
+}
+/**
+ * Watch every registered project's armed PRs on a timer (#1418).
+ *
+ * Same lifecycle contract as the merged-worktree sweep: an immediate start-up tick (the case is a
+ * daemon that was off while checks went green), overlapping ticks join the sweep in flight, the
+ * timer is unref'd, and everything it does is logged — a PR merging with no line explaining why
+ * reads as a bug even when it is the feature.
+ */
+export declare function startCiWatch(opts: CiWatchOptions): ProjectPass;
+//# sourceMappingURL=ci-watch.d.ts.map

package/dist/ci-watch.d.ts.map

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

package/dist/ci-watch.js

@@ -0,0 +1,228 @@
+import { listAgents, readLiveMetas } from './store/index.js';
+import { mergeAgentPr, resolveAgentPr } from './dashboard/agent-handoff.js';
+import { ghPrCiStatus } from './dashboard/gh.js';
+import { startProjectPass } from './project-pass.js';
+// Watch the PRs the framework is waiting to land, and act on what their CI says (#1418).
+//
+// The merge half (#1417's ask): a session armed for auto-merge on a repo without GitHub's native
+// auto-merge used to get the direct fallback — merged seconds after opening, before its first
+// check ran (#1406). Since #1418 that path answers `watched` instead, and this sweep is the other
+// half of the promise: poll the watched PR's checks (~1 min, the latency agreed on the issue) and
+// merge it once they pass. The repo setting stops mattering: merge-on-green works everywhere.
+//
+// The fix half (#1418's first use case): a watched or auto-armed PR whose checks go *red* is work
+// the framework produced and then abandoned to a human. The sweep starts one unattended fix
+// session per failing head commit, told to land its fix on the PR's own branch — the checks rerun,
+// and the merge half finishes the job if they come back green.
+//
+// Polling rather than webhooks on purpose: a local daemon has no public URL for GitHub to call.
+// Every decision this sweep takes starts from what `gh` answers, so a hosted deployment can later
+// feed the same handlers from a webhook receiver and only the trigger changes.
+/**
+ * How long an agent's watched PR stays on the sweep's list: long enough to survive a weekend of the
+ * daemon being off, short enough that the sweep's `gh` spend cannot grow with the archive. A PR
+ * older than this is a human's to land — it has been red or unmergeable for a week.
+ */
+export const CI_WATCH_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * How old a check-less PR must be before "no checks" is believed to mean "this repo has no CI"
+ * rather than "the suite has not attached yet" — GitHub takes seconds to attach one after a push,
+ * and merging inside that window is the stale-check hazard (#1406) wearing a different face.
+ */
+export const NO_CHECKS_GRACE_MS = 3 * 60 * 1000;
+/**
+ * How many fix sessions one PR may consume before the sweep stands down. Each attempt only
+ * re-arms on a new head commit, so two attempts means: the original failure, and one more after
+ * a fix that did not take. Past that the failure is evidently not agent-shaped.
+ */
+const MAX_CI_FIX_ATTEMPTS = 2;
+/**
+ * The marker a CI-fix agent's prompt opens with, so attempts are discoverable from agent metas. The
+ * `@` is always there, sha or not: it is what stops "PR #12" reading as a prefix of "PR #123"
+ * when the metas are scanned for prior attempts.
+ */
+export function ciFixMarker(number, headSha = '') {
+    return `[ci-fix] PR #${number} @${headSha}`;
+}
+/**
+ * The prompt a CI-fix session runs (#1418). Explicit about the git mechanics because the agent gets
+ * an ordinary session worktree on its own scratch branch: the PR's branch may be checked out in a
+ * retained worktree elsewhere, so `push origin HEAD:<branch>` is the one spelling that always
+ * lands the fix without fighting over who holds the branch.
+ */
+export function ciFixPrompt(fix) {
+    return [
+        ciFixMarker(fix.number, fix.headSha),
+        '',
+        `CI is red on PR #${fix.number} ("${fix.title}"): ${fix.failed.join(', ') || 'checks failed'}.`,
+        `The PR's branch is \`${fix.branch}\` and its failing head commit is ${fix.headSha}.`,
+        '',
+        'Fix the failure so the checks go green:',
+        `1. \`git fetch origin ${fix.branch}\` and put your worktree on that exact state: \`git reset --hard origin/${fix.branch}\` (your worktree’s own branch is scratch — nothing on it is worth keeping).`,
+        `2. Read the failing checks (\`gh pr checks ${fix.number}\`, then \`gh run view --log-failed <run-id>\` for the failed workflow runs) and diagnose the failure.`,
+        '3. Fix it, and run the relevant tests/build locally to confirm.',
+        `4. Push the fix back onto the PR: \`git push origin HEAD:${fix.branch}\`.`,
+        '',
+        `Do NOT open a new PR and do not merge anything: the fix belongs on PR #${fix.number} (${fix.url}), and the merge happens elsewhere once the checks pass.`,
+    ].join('\n');
+}
+/** Both stores' metas: the live agents (their conversation is still going) and the archive. */
+async function allAgentMetas(cwd) {
+    const [live, archived] = await Promise.all([
+        readLiveMetas(cwd).catch(() => []),
+        listAgents(cwd).catch(() => []),
+    ]);
+    return [...live, ...archived];
+}
+/** Whether a meta is one of this sweep's candidates: an ended agent with a merge the CI decides. */
+function watchable(meta, now) {
+    if (meta.status === 'running')
+        return false;
+    if (meta.mergeOutcome !== 'watched' && meta.mergeOutcome !== 'auto-armed')
+        return false;
+    const updated = Date.parse(meta.updatedAt ?? '');
+    return Number.isFinite(updated) && now - updated <= CI_WATCH_WINDOW_MS;
+}
+/**
+ * Sweep one project's watched PRs (#1418): merge the green ones the repo could not arm GitHub
+ * auto-merge for, and start a fix session for the red ones.
+ *
+ * Conservative wherever the answer is unclear: a PR that is not OPEN is done (merged or a
+ * human's rejection — neither is this sweep's to touch), `pending` checks wait for the next
+ * tick, and a check-less PR only counts as green once it has been check-less for longer than a
+ * suite takes to attach ({@link NO_CHECKS_GRACE_MS}). An `auto-armed` PR is never merged here —
+ * GitHub holds that promise — but its checks going red still starts a fix.
+ */
+export async function sweepProjectCi(cwd, deps = {}) {
+    const agents = deps.agents ?? allAgentMetas;
+    const pr = deps.pr ?? resolveAgentPr;
+    const ci = deps.ci ?? ghPrCiStatus;
+    const merge = deps.merge ?? mergeAgentPr;
+    const now = deps.now ?? Date.now;
+    const result = { merged: [], failed: [], fixes: [] };
+    const metas = await agents(cwd).catch(() => []);
+    const candidates = metas.filter(meta => watchable(meta, now()));
+    if (candidates.length === 0)
+        return result;
+    const seen = new Set();
+    for (const meta of candidates) {
+        const read = await pr(cwd, meta).catch(() => ({ value: undefined, pending: false }));
+        // A cache still warming answers `pending`, and the value standing in for the state it has not
+        // read yet is a synthetic OPEN (agent-handoff.ts). Acting on that guess re-merges PRs that
+        // already landed and starts fix sessions on branches a human closed; the next tick knows.
+        if (read.pending)
+            continue;
+        const linked = read.value;
+        // No PR, or one that is no longer open: nothing left to watch. CLOSED stays closed on
+        // purpose — an unmerged close is a human's rejection of the work.
+        if (!linked || linked.state !== 'OPEN' || seen.has(linked.number))
+            continue;
+        seen.add(linked.number);
+        const status = await ci(cwd, linked.number).catch(() => ({ checks: 'none', failed: [] }));
+        if (status.checks === 'pending')
+            continue;
+        if (status.checks === 'failing') {
+            const fix = await requestFix(cwd, metas, linked, status, deps);
+            if (fix)
+                result.fixes.push(fix);
+            continue;
+        }
+        // Green — but the merge is only ours where GitHub could not take it (#1418): an auto-armed
+        // PR lands by GitHub's own hand, and a check-less one must outlive the attach window first.
+        if (meta.mergeOutcome !== 'watched')
+            continue;
+        if (status.checks === 'none') {
+            // "No checks" means "this repo has no CI" only when `gh` actually answered: an unreadable
+            // status reads `none` too (gh.ts), and acting on one must never merge anything. A read that
+            // succeeded always carries the head commit, so its presence is what tells the two apart.
+            if (!status.headSha)
+                continue;
+            if (!pastNoChecksGrace(linked, now()))
+                continue;
+        }
+        const attemptKey = `${cwd}\u0000${linked.number}\u0000${status.headSha ?? ''}`;
+        if (deps.attemptedMerges?.has(attemptKey))
+            continue;
+        const outcome = await merge(cwd, meta);
+        if (outcome.ok)
+            result.merged.push({ agentId: meta.id, number: linked.number, ...(outcome.url ? { url: outcome.url } : {}) });
+        else {
+            deps.attemptedMerges?.add(attemptKey);
+            result.failed.push({ agentId: meta.id, number: linked.number, error: outcome.error });
+        }
+    }
+    return result;
+}
+/** Whether a check-less PR has been open longer than a check suite takes to attach. */
+function pastNoChecksGrace(pr, now) {
+    const created = Date.parse(pr.createdAt ?? '');
+    // No creation time on the record: age unknowable, so never merge on its absence.
+    return Number.isFinite(created) && now - created > NO_CHECKS_GRACE_MS;
+}
+/**
+ * The fix half's own restraint (#1418), applied before the wiring's gates: one session per
+ * failing head commit — the marker in the prompt is the durable record, scanned off the same
+ * metas — at most one in flight per PR, and {@link MAX_CI_FIX_ATTEMPTS} per PR ever.
+ */
+async function requestFix(cwd, metas, pr, status, deps) {
+    if (!deps.fix)
+        return undefined;
+    // No head to pin the attempt to (or no branch to land it on): a retry could not be told from a
+    // loop, so stand down rather than guess.
+    if (!status.headSha || !status.branch)
+        return undefined;
+    const attempts = metas.filter(meta => meta.intent?.startsWith(ciFixMarker(pr.number)));
+    if (attempts.some(meta => meta.intent?.startsWith(ciFixMarker(pr.number, status.headSha))))
+        return undefined;
+    if (attempts.some(meta => meta.status === 'running'))
+        return undefined;
+    if (attempts.length >= MAX_CI_FIX_ATTEMPTS)
+        return { number: pr.number, reason: 'attempts-exhausted' };
+    const agentId = await deps.fix(cwd, {
+        number: pr.number,
+        title: pr.title,
+        url: pr.url,
+        branch: status.branch,
+        headSha: status.headSha,
+        failed: status.failed,
+    });
+    return agentId ? { number: pr.number, agentId } : { number: pr.number, reason: 'declined' };
+}
+/**
+ * Watch every registered project's armed PRs on a timer (#1418).
+ *
+ * Same lifecycle contract as the merged-worktree sweep: an immediate start-up tick (the case is a
+ * daemon that was off while checks went green), overlapping ticks join the sweep in flight, the
+ * timer is unref'd, and everything it does is logged — a PR merging with no line explaining why
+ * reads as a bug even when it is the feature.
+ */
+export function startCiWatch(opts) {
+    const sweep = opts.sweep ?? sweepProjectCi;
+    const deps = { attemptedMerges: new Set(), ...opts.deps };
+    // A red or unmergeable PR stays a candidate for a week, and its line does not get truer with
+    // repetition: each distinct line is said once per daemon lifetime.
+    const said = new Set();
+    const sayOnce = (line) => {
+        if (said.has(line))
+            return;
+        said.add(line);
+        opts.log(line);
+    };
+    // No timer of its own (E4): the daemon's one clock calls `tick`.
+    return startProjectPass(opts.projects, async (cwd) => {
+        const result = await sweep(cwd, deps).catch(() => ({ merged: [], failed: [], fixes: [] }));
+        for (const item of result.merged) {
+            opts.log(`[framework] CI watch: checks passed on PR #${item.number}, merged it${item.url ? ` (${item.url})` : ''} (session ${item.agentId})`);
+        }
+        for (const item of result.failed) {
+            sayOnce(`[framework] CI watch: could not merge PR #${item.number}: ${item.error}`);
+        }
+        for (const item of result.fixes) {
+            if (item.agentId)
+                opts.log(`[framework] CI watch: checks failed on PR #${item.number}, started fix session ${item.agentId}`);
+            else if (item.reason === 'attempts-exhausted')
+                sayOnce(`[framework] CI watch: PR #${item.number} is still red after ${MAX_CI_FIX_ATTEMPTS} fix sessions; leaving it for a human`);
+        }
+    });
+}
+//# sourceMappingURL=ci-watch.js.map