@zhuxixi/pi-agent-board 0.4.3 → 0.5.1

package/src/core/host-crash.mjs

@@ -0,0 +1,39 @@
+/**
+ * Crash-time finalization for PTY hosts (used by pty-runner's uncaughtException
+ * handler). Pure enough to unit-test: writes a failed host.json + a diagnostic.
+ * Never throws — this runs on the crash path.
+ */
+import { appendDiagnostic } from "./diagnostics.mjs";
+import { writeHost } from "./store.mjs";
+
+/**
+ * @param {string} root
+ * @param {string} viewId
+ * @param {object|null} host
+ * @param {unknown} error
+ * @returns {object}
+ */
+export function finalizeHostCrash(root, viewId, host, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	const failed = {
+		...(host ?? { version: 1, viewId, mode: "pty", socketPath: null, startedAt: Date.now() }),
+		state: "failed",
+		endedAt: Date.now(),
+		lastSeenAt: Date.now(),
+		exitCode: 1,
+		error: message,
+	};
+	try {
+		writeHost(root, failed);
+	} catch { /* best effort */ }
+	try {
+		appendDiagnostic(root, viewId, {
+			source: "runner",
+			level: "error",
+			code: "host_crashed",
+			message: `PTY host crashed: ${message}`,
+			details: { error: message },
+		});
+	} catch { /* best effort */ }
+	return failed;
+}

package/src/core/launch.mjs

@@ -33,6 +33,9 @@ export function launchRun(root, config, opts) {
 		detached: true,
 		stdio: "ignore",
 		env: process.env,
+		// Windows: detached children get their own console window unless
+		// suppressed (CREATE_NO_WINDOW; no-op on POSIX) — issue #49.
+		windowsHide: true,
 	});
 	child.unref();
 
@@ -61,6 +64,7 @@ export function launchHost(root, config, opts) {
 		detached: true,
 		stdio: "ignore",
 		env: process.env,
+		windowsHide: true,
 	});
 	child.unref();
 
@@ -85,6 +89,7 @@ export function launchTitle(root, config, opts) {
 		detached: true,
 		stdio: "ignore",
 		env: process.env,
+		windowsHide: true,
 	});
 	child.unref();
 
@@ -109,6 +114,7 @@ export function launchAutoState(root, config, opts) {
 		detached: true,
 		stdio: "ignore",
 		env: process.env,
+		windowsHide: true,
 	});
 	child.unref();
 

package/src/core/paths.mjs

@@ -23,6 +23,8 @@ export const launchPrefsPath = (root) => path.join(root, "launch-prefs.json");
 export const gcHistoryPath = (root) => path.join(root, "gc-history.jsonl");
 /** @param {string} root */
 export const cwdStatsPath = (root) => path.join(root, "cwd-stats.json");
+/** @param {string} root */
+export const providersPath = (root) => path.join(root, "providers.json");
 
 /** @param {string} root */
 export const viewsDir = (root) => path.join(root, "views");
@@ -40,8 +42,27 @@ export const hostConfigPath = (root, viewId) => path.join(viewDir(root, viewId),
 export const titleConfigPath = (root, viewId) => path.join(viewDir(root, viewId), "title-config.json");
 /** @param {string} root @param {string} viewId */
 export const autoStateConfigPath = (root, viewId) => path.join(viewDir(root, viewId), "auto-state-config.json");
+/**
+ * Named pipe used for the host control socket on Windows. Named pipes are kernel
+ * objects, not filesystem entries, so existsSync/unlink never apply to them; they
+ * vanish automatically when the owning process exits. Names must be ≤ 256 chars.
+ * @param {string} viewId
+ */
+export const controlPipeName = (viewId) => `\\\\.\\pipe\\pi-agent-board-${viewId}`;
+/**
+ * Control socket address for a view, platform-aware. On Windows plain filesystem
+ * paths cannot be bound by node's net module (EACCES) — only `\\.\pipe\`-style
+ * names work (see libuv#458, nodejs/node#55979).
+ * @param {"win32"|"linux"|"darwin"} platform
+ * @param {string} root
+ * @param {string} viewId
+ */
+export function controlSocketPathFor(platform, root, viewId) {
+	if (platform === "win32") return controlPipeName(viewId);
+	return path.join(viewDir(root, viewId), "control.sock");
+}
 /** @param {string} root @param {string} viewId */
-export const controlSocketPath = (root, viewId) => path.join(viewDir(root, viewId), "control.sock");
+export const controlSocketPath = (root, viewId) => controlSocketPathFor(process.platform, root, viewId);
 /** @param {string} root @param {string} viewId */
 export const screenLogPath = (root, viewId) => path.join(viewDir(root, viewId), "screen.log");
 /** @param {string} root @param {string} viewId */
@@ -65,6 +86,8 @@ export const diagnosticsPath = (root, viewId) => path.join(viewDir(root, viewId)
 /** @param {string} root @param {string} viewId */
 export const evidencePath = (root, viewId) => path.join(viewDir(root, viewId), "evidence.json");
 /** @param {string} root @param {string} viewId */
+export const codeRefsPath = (root, viewId) => path.join(viewDir(root, viewId), "github.json");
+/** @param {string} root @param {string} viewId */
 export const viewEvidencePath = evidencePath;
 /** @param {string} root @param {string} viewId */
 export const followUpQueuePath = (root, viewId) => path.join(viewDir(root, viewId), "queue.json");

package/src/core/pty-attach-jiggle-controller.mjs

@@ -2,10 +2,12 @@
  * Injectable orchestration for the attach shrink-and-hold jiggle protocol.
  *
  * Replaces the pulse-pair jiggle (shrink → 200ms → restore) with a
- * shrink-and-hold protocol: on connect we resize the child PTY down one
- * column/row and KEEP it there until the child's own rendering proves it
- * observed the width change (a full clear, \x1b[2J, which pi-tui emits from
- * fullRender(true) whenever widthChanged fires). Because there is no
+ * shrink-and-hold protocol: on connect we resize the child PTY to a safe
+ * alternate size and KEEP it there until the child's own rendering proves it
+ * observed the size change (a full clear, \x1b[2J, which pi-tui emits from
+ * fullRender(true) whenever widthChanged fires). At normal sizes the alternate
+ * size is one column/row smaller; near the minimum it changes only a safe
+ * dimension, and at 20x5 no jiggle is attempted. Because there is no
  * "restore" that can cancel the shrink before a clear is seen, event-loop
  * coalescing on either side (outer dashboard timers or the child's
  * SIGWINCH/render throttle) can no longer collapse a jiggle into a
@@ -27,10 +29,19 @@
  *   G4 notifyExternalResize() — a real user resize cancels the hold and
  *      adopts the new size.
  *   G5 start() restores any previous hold before arming a new one (reconnect).
+ *   G6 post-restore verify (issue #42): the frameStart fast path restores the
+ *      hold on the FIRST frame, which may predate the shrink — if the restore
+ *      then collapses both resizes into a net-zero change at the child, the
+ *      child renders nothing and never clears. While a frame has been seen
+ *      and no clear followed, each backoff tick re-arms the shrink (which
+ *      lands alone and cannot collapse), bounded by the same retry budget.
  *
  * If pi-tui ever drops the 2026h sequence, re-arm degrades to G1: the PTY
- * is restored within 6s — still better than the pre-#10 behavior.
+ * is restored within 6s — still better than the pre-#10 behavior. At the
+ * minimum supported PTY size (20x5), jiggle is disabled because the runner's
+ * clamp leaves no valid alternate size.
  */
+import { resizeJiggleSize } from "./pty-scroll.mjs";
 import {
 	advanceRetry,
 	createJiggleRetryState,
@@ -41,6 +52,13 @@ import {
 
 /** Restore the held (shrunk) child PTY when no TUI frame arrives this long. */
 const NO_FRAME_RESTORE_MS = 6000;
+/**
+ * Grace window after the frameStart fast-path restore before the chain may
+ * re-poke (issue #42). A healthy child proves the restore landed with a
+ * fullRender clear within a few hundred ms even on large screens; without the
+ * grace a slow-but-healthy clear would trigger a pointless re-shrink flicker.
+ */
+const POST_RESTORE_VERIFY_MS = 900;
 
 /**
  * @typedef {Object} JiggleRetryControllerDeps
@@ -64,6 +82,8 @@ export function createJiggleRetryController(deps) {
 	/** @type {[number, number]} */
 	let originalCols = 0;
 	let originalRows = 0;
+	/** The safe alternate size used while a jiggle hold is active, or null when unsupported. */
+	let holdSize = null;
 	/** @type {unknown | null} */
 	let chainTimer = null;
 	/** @type {unknown | null} */
@@ -98,10 +118,31 @@ export function createJiggleRetryController(deps) {
 	}
 
 	/**
-	 * Backoff chain is a pure countdown under the hold protocol: firing a
-	 * retry schedules the next backoff (no pulse is sent — the shrink is
-	 * already held). When the budget runs out, G2 restores the size.
+	 * One chain tick: advance the backoff budget, then re-arm the hold if the
+	 * child has a renderer (a TUI frame was seen) but no clear ever proved the
+	 * last size delta landed and the hold is currently inactive (issue #42:
+	 * the frameStart fast-path restore can race the shrink into a net-zero
+	 * size change at the child — its throttled renderer reads back the
+	 * original size and stays silent forever — so a clear-less restore must
+	 * be followed by a fresh shrink, which lands alone and cannot collapse).
+	 * Children that never rendered a frame (shells, cold boots) keep the old
+	 * pure-countdown behavior and are handled by G1/G2 only.
 	 */
+	function tickChain() {
+		chainTimer = null;
+		state = advanceRetry(state);
+		ensureHold();
+		if (state.clearDetected || state.stopped) return;
+		scheduleNextRetry();
+	}
+
+	function ensureHold() {
+		if (!tuiFrameSeen || held || state.clearDetected || state.stopped || !holdSize) return;
+		sendResize(holdSize.cols, holdSize.rows);
+		held = true;
+		restored = false;
+	}
+
 	function scheduleNextRetry() {
 		const delay = nextRetryDelay(state);
 		if (delay === null) {
@@ -109,11 +150,7 @@ export function createJiggleRetryController(deps) {
 			restoreIfHeld(); // G2
 			return;
 		}
-		chainTimer = setTimeoutFn(() => {
-			chainTimer = null;
-			state = advanceRetry(state);
-			scheduleNextRetry();
-		}, delay);
+		chainTimer = setTimeoutFn(tickChain, delay);
 	}
 
 	function armG1() {
@@ -142,8 +179,18 @@ export function createJiggleRetryController(deps) {
 		tuiFrameSeen = false;
 		originalCols = cols;
 		originalRows = rows;
+		holdSize = resizeJiggleSize(cols, rows);
 		sendResize(cols, rows);
-		sendResize(cols - 1, rows - 1);
+		if (!holdSize) {
+			// The runner clamps below 20x5, so a smaller request would be a
+			// net-zero resize and cannot trigger a redraw. Leave the child at the
+			// requested original size and disable this attach's jiggle chain.
+			state = stopRetry(state);
+			held = false;
+			restored = true;
+			return;
+		}
+		sendResize(holdSize.cols, holdSize.rows);
 		held = true;
 		restored = false;
 		armG1();
@@ -176,14 +223,20 @@ export function createJiggleRetryController(deps) {
 			clearG1Timer();
 			if (held) {
 				restoreIfHeld(); // fast path: child is rendering, width delta now lands
+				// …unless that frame was in flight BEFORE the shrink and the restore
+				// collapses both into a net-zero change at the child (issue #42).
+				// Restart the chain on the post-restore grace window: no clear within
+				// POST_RESTORE_VERIFY_MS → tickChain re-arms the hold (ensureHold).
+				clearChainTimer();
+				chainTimer = setTimeoutFn(tickChain, POST_RESTORE_VERIFY_MS);
 			} else {
 				// Slow boot: G1 released the hold before the TUI came up, so the
 				// child baselined at the original size. Re-arm a fresh hold — its
 				// next frame then sees a width delta and fullRenders. Guards: the
 				// clear path (primary) and G2 budget exhaustion (chain still
 				// ticking). G1 is NOT re-armed: frames are now flowing.
-				sendResize(originalCols - 1, originalRows - 1);
-				held = true;
+				if (holdSize) sendResize(holdSize.cols, holdSize.rows);
+				held = holdSize !== null;
 				restored = false;
 			}
 		}
@@ -212,6 +265,7 @@ export function createJiggleRetryController(deps) {
 		restored = false;
 		originalCols = cols;
 		originalRows = rows;
+		holdSize = null;
 		state = stopRetry(state);
 	}
 
@@ -220,6 +274,6 @@ export function createJiggleRetryController(deps) {
 		feed,
 		restoreAndStop,
 		notifyExternalResize,
-		getState: () => ({ ...state, held, tuiFrameSeen, originalCols, originalRows }),
+		getState: () => ({ ...state, held, tuiFrameSeen, originalCols, originalRows, holdSize }),
 	};
 }

package/src/core/pty-attach-reconnect.mjs

@@ -0,0 +1,43 @@
+/**
+ * Attach reconnect policy (issue #48). The pty-runner can die without sending
+ * an exit message (uncaught crash), which previously left the attach view in a
+ * 150 ms reconnect loop forever with no way out. Two regimes:
+ *  - ever connected: a crashed host is unrecoverable quickly — give up after a
+ *    short window and report "host exited";
+ *  - never connected: the host may still be cold-starting (service launches it
+ *    right before attach) — allow a long window before declaring it unreachable.
+ */
+
+/** Give-up delay after a previously-established connection drops (ms). */
+export const ATTACH_RECONNECT_TIMEOUT_MS = 15_000;
+/** Give-up delay while waiting for the initial host connection (ms). */
+export const ATTACH_HOST_START_TIMEOUT_MS = 120_000;
+
+/**
+ * @param {{ everConnected: boolean, disconnectedAt: number|null, connectStartedAt: number, now: number }} input
+ * @returns {{ giveUp: boolean, status: string | null }}
+ */
+export function evaluateAttachReconnect({ everConnected, disconnectedAt, connectStartedAt, now }) {
+	if (everConnected && disconnectedAt !== null) {
+		const elapsed = now - disconnectedAt;
+		return elapsed >= ATTACH_RECONNECT_TIMEOUT_MS
+			? { giveUp: true, status: "host exited" }
+			: { giveUp: false, status: null };
+	}
+	const elapsed = now - connectStartedAt;
+	return elapsed >= ATTACH_HOST_START_TIMEOUT_MS
+		? { giveUp: true, status: "host not reachable" }
+		: { giveUp: false, status: null };
+}
+
+/**
+ * Detach-key policy: while the socket is down a key can never reach the child,
+ * so treat ← / ctrl+] as "leave the view" unconditionally; otherwise keep the
+ * existing empty-input-line gate (issue #48 comment 1).
+ * @param {boolean} connected
+ * @param {boolean} childInputLooksEmpty
+ * @returns {boolean}
+ */
+export function shouldEscapeAttach(connected, childInputLooksEmpty) {
+	return !connected || childInputLooksEmpty;
+}

package/src/core/pty-scroll.mjs

@@ -141,9 +141,10 @@ export function selectionDragScrollLines(row, bodyHeight) {
 }
 
 /**
- * Return a one-frame alternate PTY size that will force a hosted TUI to receive a
- * SIGWINCH/redraw before restoring the real size. This mirrors the user-visible
- * terminal zoom workaround without leaving the child at the wrong dimensions.
+ * Return a safe temporary PTY size for an attach jiggle hold. The attach controller
+ * keeps the child at this size until a clear or guard restores the original size;
+ * near the minimum supported dimensions, only one safe dimension is changed, and
+ * at 20x5 there is no valid alternate size.
  */
 export function resizeJiggleSize(cols, rows) {
 	const c = Math.max(1, Math.floor(cols));

package/src/core/repo.mjs

@@ -1,5 +1,6 @@
 /** Git repository identity. Pure node (shells out to `git`); returns null off-repo. */
 import { execFileSync } from "node:child_process";
+import { parseRemoteHost } from "./code-refs.mjs";
 
 /**
  * Resolve the git repo root containing `cwd`, or null if not in a repo.
@@ -11,6 +12,7 @@ export function gitRepoRoot(cwd) {
 		const out = execFileSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
 			encoding: "utf8",
 			stdio: ["ignore", "pipe", "ignore"],
+			windowsHide: true,
 		});
 		const root = out.trim();
 		return root || null;
@@ -39,9 +41,63 @@ export function isDirty(repoRoot) {
 		const out = execFileSync("git", ["-C", repoRoot, "status", "--porcelain"], {
 			encoding: "utf8",
 			stdio: ["ignore", "pipe", "ignore"],
+			windowsHide: true,
 		});
 		return out.trim().length > 0;
 	} catch {
 		return false;
 	}
 }
+
+/**
+ * Cached origin-remote URL per repo root. Failures are cached as null so each
+ * repo root is only ever queried once per process.
+ * @type {Map<string, string|null>}
+ */
+const remoteUrlCache = new Map();
+
+/**
+ * Raw URL of the `origin` remote of `repoRoot`, or null when the repo has no
+ * origin remote or is not a repo. The result (including misses) is cached per
+ * repoRoot.
+ * @param {string} repoRoot
+ * @returns {string|null}
+ */
+export function gitRemoteUrl(repoRoot) {
+	const cached = remoteUrlCache.get(repoRoot);
+	if (cached !== undefined) return cached;
+	let url = null;
+	try {
+		const out = execFileSync("git", ["-C", repoRoot, "remote", "get-url", "origin"], {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+			timeout: 2000,
+			windowsHide: true,
+		});
+		url = out.trim() || null;
+	} catch {
+		// not a repo or no origin remote
+	}
+	remoteUrlCache.set(repoRoot, url);
+	return url;
+}
+
+/**
+ * Host of the `origin` remote of `repoRoot`, lowercased and without port, or
+ * null when the repo has no origin remote or is not a repo. Supports
+ * `https://host/owner/repo(.git)` and `git@host:owner/repo(.git)`; parsed from
+ * the cached raw remote URL.
+ * @param {string} repoRoot
+ * @returns {string|null}
+ */
+export function gitRemoteHost(repoRoot) {
+	return parseRemoteHost(gitRemoteUrl(repoRoot));
+}
+
+/**
+ * Clear the gitRemoteHost cache. Test-only helper.
+ * @returns {void}
+ */
+export function clearRemoteHostCacheForTests() {
+	remoteUrlCache.clear();
+}

package/src/core/rows.mjs

@@ -10,6 +10,13 @@ import { GROUP_LABELS, GROUP_ORDER, SEMANTIC_STATES } from "./types.mjs";
 /** @typedef {import("./store.mjs").Row} Row */
 /** @typedef {import("./types.mjs").SemanticState} SemanticState */
 
+/**
+ * Host heartbeat staleness threshold (ms). The pty-runner writes host.json on a
+ * 1 Hz heartbeat; when a crashed runner leaves host.json stuck on "alive", the
+ * heartbeat goes stale within seconds (issue #48 L4).
+ */
+const STALE_HOST_MS = 10_000;
+
 /**
  * @typedef {Object} RowView
  * @property {string} id
@@ -24,6 +31,8 @@ import { GROUP_LABELS, GROUP_ORDER, SEMANTIC_STATES } from "./types.mjs";
  * @property {SemanticState} state
  * @property {boolean} alive
  * @property {boolean} hostAlive
+ * @property {boolean} staleHost True when host.json claims alive but the runner
+ *   process is gone and the heartbeat is stale (display-only crash marker).
  * @property {boolean} needsInput
  * @property {boolean} hasError
  * @property {boolean} worktree
@@ -35,6 +44,9 @@ import { GROUP_LABELS, GROUP_ORDER, SEMANTIC_STATES } from "./types.mjs";
  * @property {number} followUpCount
  * @property {string|null} followUpPreview
  * @property {string} steeringState
+ * @property {string} refsBadge Inline issue/PR badge (e.g. "#40 ▸#45"); "" when there are no refs.
+ * @property {boolean} refsLowConfidence True when the winning issue or pr confidence is "low".
+ * @property {import("./types.mjs").CodeRefsSummary|null} codeRefs Compact ref summary the peek view consumes.
  * @property {number} lastActivityAt
  * @property {number} createdAt
  */
@@ -115,6 +127,19 @@ export function rowView(row, now) {
 	const place = folderName;
 	const lastVisitedAt = row.state?.lastVisitedAt ?? null;
 	const lastAgentActivityAt = row.state?.lastAgentActivityAt ?? null;
+	const refs = codeRefsBadge(row.codeRefs);
+	// Host-lost display marker (issue #48 L4): host.json still claims "alive"
+	// but the runner process is gone and the 1 Hz heartbeat went stale — the
+	// crash path leaves exactly this fingerprint (no exit message, no
+	// reconcile). Display-only; state.json is deliberately untouched.
+	const host = row.host;
+	const staleHost = Boolean(
+		host &&
+			host.state === "alive" &&
+			!row.hostAlive &&
+			typeof host.lastSeenAt === "number" &&
+			now - host.lastSeenAt > STALE_HOST_MS,
+	);
 	return {
 		id: row.meta.id,
 		name: row.meta.name,
@@ -128,6 +153,7 @@ export function rowView(row, now) {
 		state,
 		alive: Boolean(row.alive),
 		hostAlive: Boolean(row.hostAlive),
+		staleHost,
 		needsInput: state === "needs_input",
 		hasError: state === "failed",
 		worktree,
@@ -139,11 +165,35 @@ export function rowView(row, now) {
 		followUpCount: row.state?.followUps?.queuedCount ?? 0,
 		followUpPreview: row.state?.followUps?.lastQueuedPreview ?? null,
 		steeringState: row.state?.steering?.status ?? "none",
+		refsBadge: refs.refsBadge,
+		refsLowConfidence: refs.refsLowConfidence,
+		codeRefs: row.codeRefs ?? null,
 		lastActivityAt,
 		createdAt: row.meta.createdAt ?? 0,
 	};
 }
 
+/**
+ * Map a CodeRefsSummary to the inline badge strings shown on dashboard rows:
+ * the winning issue and pr joined by a space, each prefixed with the provider
+ * prefix stored on the summary; plus the low-confidence flag that makes the
+ * dashboard dim the badge. Missing/garbage summaries yield an empty badge.
+ * @param {import("./types.mjs").CodeRefsSummary|null|undefined} summary
+ * @returns {{ refsBadge: string, refsLowConfidence: boolean }}
+ */
+function codeRefsBadge(summary) {
+	if (!summary) return { refsBadge: "", refsLowConfidence: false };
+	const issue = summary.issue;
+	const pr = summary.pr;
+	const parts = [];
+	if (issue && Number.isFinite(issue.number)) parts.push(`${summary.issuePrefix ?? "#"}${issue.number}`);
+	if (pr && Number.isFinite(pr.number)) parts.push(`${summary.prPrefix ?? "▸#"}${pr.number}`);
+	return {
+		refsBadge: parts.join(" "),
+		refsLowConfidence: issue?.confidence === "low" || pr?.confidence === "low",
+	};
+}
+
 /** @param {string} text */
 function oneLine(text) {
 	return String(text || "").replace(/\s+/g, " ").trim() || "—";

package/src/core/store.mjs

@@ -7,6 +7,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { atomicWriteJson, ensureDir, readJson } from "./atomic.mjs";
 import * as P from "./paths.mjs";
 import { isAlive } from "./pid.mjs";
+import { readCodeRefs, summarizeCodeRefs } from "./code-refs-store.mjs";
 import { readDiagnosticSummary } from "./diagnostics.mjs";
 import { readEvidence, summarizeEvidence } from "./evidence.mjs";
 import { readFollowUpQueue, summarizeFollowUpQueue } from "./follow-up-queue.mjs";
@@ -181,6 +182,7 @@ function mtime(dir) {
  * @property {import("./types.mjs").DiagnosticSummary} [diagnostics]
  * @property {import("./types.mjs").FollowUpSummary} [followUps]
  * @property {import("./types.mjs").SteeringSummary} [steering]
+ * @property {import("./types.mjs").CodeRefsSummary} [codeRefs]
  */
 
 /** @param {string} root @param {string} viewId @returns {Row|null} */
@@ -211,7 +213,8 @@ export function readViewArtifactSummaries(root, viewId) {
 	const diagnostics = readDiagnosticSummary(root, viewId);
 	const followUps = summarizeFollowUpQueue(readFollowUpQueue(root, viewId));
 	const steering = summarizeSteering(readSteering(root, viewId));
-	return { review, diagnostics, followUps, steering };
+	const codeRefs = summarizeCodeRefs(readCodeRefs(root, viewId));
+	return { review, diagnostics, followUps, steering, codeRefs };
 }
 
 /**

package/src/core/types.mjs

@@ -118,6 +118,7 @@ export const GROUP_LABELS = {
  * @property {DiagnosticSummary} [diagnostics] Compact diagnostics summary.
  * @property {FollowUpSummary} [followUps] Compact queued follow-up summary.
  * @property {SteeringSummary} [steering] Compact plan/approval steering summary.
+ * @property {CodeRefsSummary} [codeRefs] Compact issue/PR reference summary.
  * @property {AutoStateClassification|null} [autoState] Latest automatic terminal-state classification.
  */
 
@@ -364,6 +365,17 @@ export const GROUP_LABELS = {
 
 /** @typedef {{ status:SteeringModeState, awaitingApproval:boolean, planPreview:string|null, updatedAt:number|null, question:string|null }} SteeringSummary */
 
+/**
+ * Compact issue/PR reference summary for a view (`github.json`).
+ * @typedef {Object} CodeRefsSummary
+ * @property {string|null} provider Resolved provider name (e.g. "github"); always non-null after a successful extraction (falls back to "generic"), null only before any extraction has run.
+ * @property {string} issuePrefix Issue-number prefix resolved from the matched provider at write time (default "#").
+ * @property {string} prPrefix PR/MR-number prefix resolved from the matched provider at write time (default "▸#"; "!" for gitlab).
+ * @property {import("./code-refs.mjs").Ref|null} issue
+ * @property {import("./code-refs.mjs").Ref|null} pr
+ * @property {import("./code-refs.mjs").Ref[]} allRefs Distinct refs for the peek view (max 10).
+ */
+
 /** Roster index (`roster.json`). @typedef {Object} Roster @property {number} version @property {string[]} views */
 
 /**

package/src/core/worktree.mjs

@@ -15,6 +15,7 @@ function git(repoRoot, args) {
 		const stdout = execFileSync("git", ["-C", repoRoot, ...args], {
 			encoding: "utf8",
 			stdio: ["ignore", "pipe", "pipe"],
+			windowsHide: true,
 		});
 		return { ok: true, stdout: stdout.trim(), error: null };
 	} catch (err) {

package/src/runtime/service.mjs

@@ -13,6 +13,7 @@ import { appendLine } from "../core/atomic.mjs";
 import { finalizeRun, projectViewState, reduceEvent } from "../core/events.mjs";
 import { clearDiagnostics, appendDiagnostic, tailDiagnostics } from "../core/diagnostics.mjs";
 import { emptyEvidenceSnapshot, finalizeEvidence, readEvidence, reduceEvidence, summarizeEvidence, writeEvidence } from "../core/evidence.mjs";
+import { updateCodeRefsFromEvidence } from "../core/code-refs-store.mjs";
 import { claimNextFollowUp, completeFollowUp, enqueueFollowUp, readFollowUpQueue, releaseFollowUp, summarizeFollowUpQueue, clearQueuedFollowUps, removeLastFollowUp } from "../core/follow-up-queue.mjs";
 import { approvePlan as approvePlanState, markExecutingApprovedPlan, readSteering, recordPlanReady, requestPlan as requestPlanState, requestPlanChanges as requestPlanChangesState, summarizeSteering } from "../core/steering.mjs";
 import { buildApprovePlanPrompt, buildPlanChangesPrompt, buildPlanRequestPrompt } from "../core/steering-prompts.mjs";
@@ -517,6 +518,7 @@ export function createService(opts) {
 		try {
 			reduceEvidence(evidence, event, now);
 			writeEvidence(root, evidence);
+			updateCodeRefsFromEvidence(root, row.meta.id, evidence, row.meta);
 		} catch (err) {
 			appendDiagnostic(root, row.meta.id, { source: "evidence", level: "warn", code: "evidence_reduce_failed", message: "Could not reduce hosted evidence", details: { error: err instanceof Error ? err.message : String(err) } });
 		}
@@ -548,6 +550,7 @@ export function createService(opts) {
 			}
 			status.evidenceSummary = summarizeEvidence(evidence);
 			writeEvidence(root, evidence);
+			updateCodeRefsFromEvidence(root, row.meta.id, evidence, row.meta);
 			writeForegroundState(row, status);
 			pruneWarmHosts({ keepViewId: row.meta.id });
 			drainNextFollowUp(row.meta.id);
@@ -1142,7 +1145,10 @@ function compactSummary(text) {
 function sendHostMessage(row, message) {
 	const socketPath = row.host?.socketPath;
 	if (!socketPath) return { ok: false, error: "No host socket" };
-	if (!existsSync(socketPath)) return { ok: false, error: "Host socket is not ready" };
+	// On Windows the control socket is a named pipe, which never exists as a
+	// filesystem entry, so existsSync can't be used as a readiness probe there.
+	// A missing pipe surfaces as a connection error on the socket below.
+	if (process.platform !== "win32" && !existsSync(socketPath)) return { ok: false, error: "Host socket is not ready" };
 	try {
 		const socket = createConnection(socketPath);
 		socket.on("connect", () => {