@zhuxixi/pi-agent-board 0.3.0 → 0.3.1

package/src/core/auto-state.mjs

@@ -40,6 +40,18 @@ function isOff(value) {
 	return typeof value === "string" && /^(0|false|off|no)$/i.test(value.trim());
 }
 
+/**
+ * Whether automatic `done` classification is disabled.
+ * Default (env unset): disabled — completed is only ever set by the user.
+ * Set AGENT_BOARD_AUTO_STATE_NO_DONE to 0/false/off/no to restore auto-done.
+ * @param {NodeJS.ProcessEnv|Record<string,string|undefined>} [env]
+ */
+export function autoStateDoneDisabled(env = process.env) {
+	const raw = env.AGENT_BOARD_AUTO_STATE_NO_DONE;
+	if (typeof raw !== "string" || !raw.trim()) return true;
+	return !isOff(raw);
+}
+
 /** @param {AutoStateKind} kind @returns {SemanticState} */
 export function semanticStateForAutoKind(kind) {
 	switch (kind) {
@@ -55,22 +67,35 @@ export function semanticStateForAutoKind(kind) {
 /**
  * Prompt used by runners for the cheap classifier pass.
  * @param {string} latestAssistantText
+ * @param {NodeJS.ProcessEnv|Record<string,string|undefined>} [env]
  */
-export function buildAutoStatePrompt(latestAssistantText) {
+export function buildAutoStatePrompt(latestAssistantText, env = process.env) {
 	const text = truncate(String(latestAssistantText || "").trim(), 6000);
-	return `Classify the LAST assistant response for a coding-agent dashboard.\n\nChoose exactly one state:\n- needs_input: the assistant asks the user for a decision, clarification, approval, credentials, or is blocked waiting for the user.\n- in_progress: work is partial, next steps remain, verification is pending/failed, or the assistant says it will continue later.\n- done: the requested work is complete, final answer given, no user input required.\n\nReturn ONLY minified JSON with this shape:\n{"state":"needs_input|in_progress|done","confidence":"high|medium|low","reason":"short reason <=18 words","question":"user-facing question or null"}\n\nLast assistant response:\n${text}`;
+	const doneLine = autoStateDoneDisabled(env)
+		? ""
+		: "- done: the requested work is complete, final answer given, no user input required.\n";
+	const doneNote = autoStateDoneDisabled(env)
+		? "The user marks completed manually in the dashboard, so completion signals (done/completed/finished) must be classified as in_progress.\n"
+		: "";
+	const states = autoStateDoneDisabled(env) ? "needs_input|in_progress" : "needs_input|in_progress|done";
+	return `Classify the LAST assistant response for a coding-agent dashboard.\n\nChoose exactly one state:\n- needs_input: the assistant asks the user for a decision, clarification, approval, credentials, or is blocked waiting for the user.\n- in_progress: work is partial, next steps remain, verification is pending/failed, or the assistant says it will continue later.\n${doneLine}${doneNote}\nReturn ONLY minified JSON with this shape:\n{"state":"${states}","confidence":"high|medium|low","reason":"short reason <=18 words","question":"user-facing question or null"}\n\nLast assistant response:\n${text}`;
 }
 
 /**
  * Parse and normalize model JSON. Returns null if the response is unusable.
  * @param {string} raw
- * @param {{ latestAssistantText?: string, now?: number, lastAgentActivityAt?: number|null }} [opts]
+ * @param {{ latestAssistantText?: string, now?: number, lastAgentActivityAt?: number|null, env?: NodeJS.ProcessEnv|Record<string,string|undefined> }} [opts]
  */
 export function parseAutoStateModelOutput(raw, opts = {}) {
 	const obj = extractJsonObject(raw);
 	if (!obj) return null;
-	const kind = normalizeKind(obj.state ?? obj.kind ?? obj.status);
+	let kind = normalizeKind(obj.state ?? obj.kind ?? obj.status);
 	if (!kind) return null;
+	let downgraded = false;
+	if (kind === "done" && autoStateDoneDisabled(opts.env ?? process.env)) {
+		kind = "in_progress";
+		downgraded = true;
+	}
 	const confidence = normalizeConfidence(obj.confidence);
 	const latest = opts.latestAssistantText ?? "";
 	const nb = detectNeedsInput(latest);
@@ -78,7 +103,9 @@ export function parseAutoStateModelOutput(raw, opts = {}) {
 	return makeClassification(kind, {
 		source: "model",
 		confidence,
-		reason: cleanReason(obj.reason) || defaultReason(kind),
+		reason: downgraded
+			? "Model reported done but auto-done is disabled"
+			: cleanReason(obj.reason) || defaultReason(kind),
 		question,
 		now: opts.now,
 		lastAgentActivityAt: opts.lastAgentActivityAt ?? null,
@@ -90,7 +117,7 @@ export function parseAutoStateModelOutput(raw, opts = {}) {
  * Conservative fallback classifier. It should be useful, but never clever enough to
  * overrule strong question/error signals.
  * @param {string} latestAssistantText
- * @param {{ now?: number, lastAgentActivityAt?: number|null }} [opts]
+ * @param {{ now?: number, lastAgentActivityAt?: number|null, env?: NodeJS.ProcessEnv|Record<string,string|undefined> }} [opts]
  */
 export function heuristicAutoState(latestAssistantText, opts = {}) {
 	const text = String(latestAssistantText || "").trim();
@@ -110,7 +137,8 @@ export function heuristicAutoState(latestAssistantText, opts = {}) {
 	const lower = text.toLowerCase();
 	const pending = hasPendingSignal(lower);
 	const done = hasDoneSignal(lower);
-	if (done && !pending) {
+	const env = opts.env ?? process.env;
+	if (done && !pending && !autoStateDoneDisabled(env)) {
 		return makeClassification("done", {
 			source: "heuristic",
 			confidence: hasStrongDoneSignal(lower) ? "high" : "medium",
@@ -120,6 +148,18 @@ export function heuristicAutoState(latestAssistantText, opts = {}) {
 			latestAssistantText: text,
 		});
 	}
+	if (done && !pending) {
+		// Auto-done disabled: completion signals stay out of the completed bucket;
+		// the user marks completed manually from the dashboard.
+		return makeClassification("in_progress", {
+			source: "heuristic",
+			confidence: hasStrongDoneSignal(lower) ? "medium" : "low",
+			reason: "Assistant reported completion but auto-done is disabled",
+			now: opts.now,
+			lastAgentActivityAt: opts.lastAgentActivityAt ?? null,
+			latestAssistantText: text,
+		});
+	}
 	if (pending) {
 		return makeClassification("in_progress", {
 			source: "heuristic",
@@ -150,6 +190,17 @@ export function autoStateFromModelOrHeuristic(modelOutput, latestAssistantText,
 	return parseAutoStateModelOutput(modelOutput, { latestAssistantText, ...opts }) ?? heuristicAutoState(latestAssistantText, opts);
 }
 
+/**
+ * Whether a row/status shows a manual completion. completeView clears autoState on
+ * both state.json and status.json when the user marks done, so `autoState == null`
+ * combined with `completed` is the manual-completion signal. Auto-classified
+ * completed rows keep autoState and stay refinable by a later model pass.
+ * @param {{ semanticState?: string, autoState?: unknown|null }|null|undefined} state
+ */
+export function isManualCompletion(state) {
+	return Boolean(state && state.semanticState === "completed" && state.autoState == null);
+}
+
 /**
  * Mutate a RunStatus with a classification. Returns true if state/metadata changed.
  * @param {import("./types.mjs").RunStatus} status
@@ -159,6 +210,8 @@ export function autoStateFromModelOrHeuristic(modelOutput, latestAssistantText,
 export function applyAutoStateToStatus(status, classification, now = Date.now()) {
 	if (!classification || status.processState === "alive") return false;
 	if (status.semanticState === "failed" || status.semanticState === "stopped") return false;
+	// Manual completions are user verdicts and must never be overwritten.
+	if (isManualCompletion(status)) return false;
 	const nextState = semanticStateForAutoKind(classification.kind);
 	const before = `${status.semanticState}|${status.question ?? ""}|${status.summary ?? ""}|${status.autoState?.source ?? ""}|${status.autoState?.textHash ?? ""}`;
 	status.semanticState = nextState;
@@ -182,6 +235,8 @@ export function applyAutoStateToStatus(status, classification, now = Date.now())
 export function applyAutoStateToViewState(state, classification, now = Date.now()) {
 	if (!classification || state.processState === "alive") return false;
 	if (state.semanticState === "failed" || state.semanticState === "stopped") return false;
+	// Manual completions are user verdicts and must never be overwritten.
+	if (isManualCompletion(state)) return false;
 	const nextState = semanticStateForAutoKind(classification.kind);
 	const before = `${state.semanticState}|${state.question ?? ""}|${state.summary ?? ""}|${state.autoState?.source ?? ""}|${state.autoState?.textHash ?? ""}`;
 	state.semanticState = nextState;

package/src/core/derive.mjs

@@ -16,8 +16,8 @@ import { firstSentence, truncate } from "./heuristics.mjs";
 const GENERIC_STATUS_TEXT = {
 	queued: new Set(["Queued"]),
 	working: new Set(["Working", "Working…", "Running", "Running…"]),
-	needs_input: new Set(["Needs input"]),
-	idle: new Set(["Idle", "In Progress"]),
+	needs_input: new Set(["Needs input", "Needs answer"]),
+	idle: new Set(["Idle", "In Progress", "Needs instructions"]),
 	completed: new Set(["Completed", "Done"]),
 	failed: new Set(["Failed"]),
 	stopped: new Set(["Stopped"]),
@@ -50,9 +50,9 @@ export function fallbackStatusText(state) {
 		case "working":
 			return "Running…";
 		case "needs_input":
-			return "Needs input";
+			return "Needs answer";
 		case "idle":
-			return "In Progress";
+			return "Needs instructions";
 		case "completed":
 			return "Done";
 		case "failed":

package/src/core/events.mjs

@@ -122,14 +122,15 @@ export function reduceEvent(status, event, now, opts = {}) {
 				if (msg.errorMessage) status.error = msg.errorMessage;
 				else if (msg.stopReason === "stop") status.error = null;
 				const text = assistantText(msg);
+				let nb = { needsInput: false, question: null };
 				if (text) {
 					// Store the full latest text (truncated) so peek shows meaningful output;
 					// deriveSummary() condenses it to a first sentence for the row.
 					status.latestAssistantPreview = truncate(text, PREVIEW_MAX);
-					const nb = detectNeedsInput(text);
+					nb = detectNeedsInput(text);
 					status.question = nb.question;
 				}
-				status.semanticState = "working";
+				status.semanticState = nb.needsInput ? "needs_input" : "working";
 				preservePendingQuestion(status);
 				status.lastActivityAt = now;
 				status.lastAgentActivityAt = now;

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

@@ -0,0 +1,112 @@
+/**
+ * Injectable orchestration for the attach jiggle-retry chain.
+ *
+ * Owns the retry state machine, backoff timers, cross-chunk scanning, and the
+ * one-shot re-arm on the child TUI's first frame (\x1b[?2026h). The attach
+ * component (and the cold-start E2E) drive it through injected callbacks, so
+ * the whole choreography is testable without a TUI or socket.
+ *
+ * Cold-start design (issue #10): the chain starts at socket connect, but a cold
+ * child pi-tui installs its SIGWINCH listener only ~5s in — every early jiggle
+ * is lost. When the first TUI frame arrives we re-arm once with a fresh budget,
+ * so the next jiggle lands on a live TUI and its fullRender emits \x1b[2J,
+ * which stops the chain. If pi-tui ever drops the 2026h sequence, this degrades
+ * to the plain connect-time chain (still better than the old one-shot).
+ */
+import {
+	advanceRetry,
+	createJiggleRetryState,
+	feedOutput,
+	nextRetryDelay,
+	stopRetry,
+} from "./pty-attach-jiggle-retry.mjs";
+
+/**
+ * @typedef {Object} JiggleRetryControllerDeps
+ * @property {() => void} sendJiggle - Fire one resize jiggle at the child.
+ * @property {(fn: () => void, ms: number) => unknown} setTimeoutFn - Timer factory.
+ * @property {(timer: unknown) => void} clearTimeoutFn - Timer canceller.
+ * @property {() => boolean} [shouldFire] - Guard on retry fire; false stops the chain without firing.
+ */
+
+/**
+ * @param {JiggleRetryControllerDeps} deps
+ */
+export function createJiggleRetryController(deps) {
+	const { sendJiggle, setTimeoutFn, clearTimeoutFn, shouldFire } = deps;
+	let state = createJiggleRetryState();
+	let carry = "";
+	let tuiFrameSeen = false;
+	/** @type {unknown | null} */
+	let timer = null;
+
+	function clearTimer() {
+		if (timer === null) return;
+		clearTimeoutFn(timer);
+		timer = null;
+	}
+
+	function scheduleNext() {
+		const delay = nextRetryDelay(state);
+		if (delay === null) {
+			state = stopRetry(state);
+			return;
+		}
+		timer = setTimeoutFn(() => {
+			timer = null;
+			if (shouldFire && !shouldFire()) {
+				state = stopRetry(state);
+				return;
+			}
+			sendJiggle();
+			state = advanceRetry(state);
+			scheduleNext();
+		}, delay);
+	}
+
+	/** Reset everything (fresh connection) and schedule the first retry. */
+	function start() {
+		clearTimer();
+		state = createJiggleRetryState();
+		carry = "";
+		tuiFrameSeen = false;
+		scheduleNext();
+	}
+
+	/**
+	 * Feed one socket output chunk. Clear detection wins over re-arm when both
+	 * sequences appear in one chunk (a hot attach's first frame is often the
+	 * fullRender we were waiting for). Re-arm fires at most once per start().
+	 * @param {string} data
+	 */
+	function feed(data) {
+		if (state.clearDetected) return; // chain done; nothing left to detect
+		const result = feedOutput(state, data, carry);
+		state = result.state;
+		carry = result.carry;
+		if (result.clearFound) {
+			clearTimer();
+			state = stopRetry({ ...state, clearDetected: true });
+			return;
+		}
+		if (result.frameStartFound && !tuiFrameSeen && !state.clearDetected) {
+			tuiFrameSeen = true;
+			clearTimer();
+			state = createJiggleRetryState();
+			scheduleNext();
+		}
+	}
+
+	/** Stop the chain (component closed, etc.). */
+	function stop() {
+		clearTimer();
+		state = stopRetry(state);
+	}
+
+	return {
+		start,
+		feed,
+		stop,
+		getState: () => ({ ...state, tuiFrameSeen }),
+	};
+}

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

@@ -1,6 +1,6 @@
 /** Pure logic for attach jiggle-retry: detect full-clear, schedule backoff retries. */
 
-export const BACKOFF_MS = Object.freeze([120, 500, 1500, 3000]);
+export const BACKOFF_MS = Object.freeze([120, 500, 1500, 3000, 6000, 10000, 15000, 20000]);
 export const MAX_RETRIES = BACKOFF_MS.length;
 
 // Verified empirically in issue #2: a resize jiggle makes the child pi-tui run
@@ -10,8 +10,12 @@ export const MAX_RETRIES = BACKOFF_MS.length;
 // signal. If pi-tui ever changes fullRender to skip the clear, the detector
 // silently degrades to the old one-shot behavior after MAX_RETRIES.
 const FULL_CLEAR = "\x1b[2J";
-/** Carry enough bytes to catch a split escape sequence at chunk boundary. */
-const CARRY_LEN = FULL_CLEAR.length - 1; // 3 bytes: \x1b, \x1b[, \x1b[2
+// pi-tui begins every frame (including differential frames) with a synchronized
+// output start sequence; boot-time extension output never contains it, so the
+// first occurrence marks "child TUI has started rendering" (issue #10).
+const TUI_FRAME_START = "\x1b[?2026h";
+/** Carry enough bytes to catch either target sequence split at a chunk boundary. */
+const CARRY_LEN = TUI_FRAME_START.length - 1; // 7 bytes
 
 /**
  * @typedef {Object} JiggleRetryState
@@ -27,18 +31,22 @@ export function createJiggleRetryState() {
 
 /**
  * Feed PTY output data into the state machine.
- * Returns new state, updated carry buffer, and whether a clear was found.
+ * Returns new state, updated carry buffer, and which target sequences were found.
  * @param {JiggleRetryState} state
  * @param {string} data - New output data chunk.
  * @param {string} carry - Leftover partial escape sequence from previous chunk.
- * @returns {{ state: JiggleRetryState, carry: string, clearFound: boolean }}
+ * @returns {{ state: JiggleRetryState, carry: string, clearFound: boolean, frameStartFound: boolean }}
  */
 export function feedOutput(state, data, carry) {
 	const combined = carry + data;
 	const clearFound = hasFullClearSequence(combined);
-	const newCarry = clearFound ? "" : tailCarry(combined);
+	const frameStartFound = hasTuiFrameStart(combined);
+	// Always keep the tail carry: a clear hit stops the chain (carry irrelevant), and
+	// a frame-start hit must still preserve a trailing half-sequence so an immediately
+	// following clear split across the next chunk is not missed.
+	const newCarry = tailCarry(combined);
 	const newState = clearFound ? { ...state, clearDetected: true } : state;
-	return { state: newState, carry: newCarry, clearFound };
+	return { state: newState, carry: newCarry, clearFound, frameStartFound };
 }
 
 /**
@@ -79,12 +87,23 @@ export function hasFullClearSequence(data) {
 	return data.includes(FULL_CLEAR);
 }
 
+/**
+ * Check if data contains the TUI frame-start (synchronized output) sequence.
+ * pi-tui begins every frame with \x1b[?2026h; boot-time extension output never
+ * contains it, so the first occurrence marks "child TUI has started rendering".
+ * @param {string} data
+ * @returns {boolean}
+ */
+export function hasTuiFrameStart(data) {
+	return data.includes(TUI_FRAME_START);
+}
+
 /** Extract the tail carry for cross-chunk boundary detection. */
 function tailCarry(data) {
-	// We only need to carry up to CARRY_LEN bytes to catch a split \x1b[2J.
+	// We only need to carry up to CARRY_LEN bytes to catch a split \x1b[2J or
+	// \x1b[?2026h. Find the last \x1b in the tail — everything before it can't be
+	// part of a split escape sequence.
 	const tail = data.slice(-CARRY_LEN);
-	// Find the last \x1b in the tail — everything before it can't be part of
-	// a split escape sequence.
 	const escIdx = tail.lastIndexOf("\x1b");
 	return escIdx >= 0 ? tail.slice(escIdx) : "";
 }

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

@@ -22,6 +22,27 @@ export function shouldScheduleAttachRenderForMessage(type) {
 
 export const ATTACH_OUTPUT_RENDER_INTERVAL_MS = 40;
 
+/**
+ * Resolve the PTY cursor to an ABSOLUTE buffer row for the projected window
+ * [start, start + height). xterm's buffer cursorY is relative to baseY (the child
+ * terminal's viewport top when scrolled to bottom), so the absolute row is
+ * baseY + cursorY. Returns null when the cursor is outside the projected window
+ * (e.g. the user scrolled up into history).
+ *
+ * The returned row must stay absolute: projection loops pass absolute buffer
+ * indices (buf.getLine(i) for i in [start, end)) and mouse selection points are
+ * absolute too. Returning a start-relative row only matches while start === 0;
+ * once scrollback exists the cursor cell never matches, which silently drops the
+ * visible PTY-cursor block AND the CURSOR_MARKER used to position the hardware
+ * cursor for IME candidate windows.
+ */
+export function projectPtyCursor(buf, start, height) {
+	if (typeof buf.cursorX !== "number" || typeof buf.cursorY !== "number" || buf.cursorX < 0 || buf.cursorY < 0) return null;
+	const row = buf.baseY + buf.cursorY;
+	if (row < start || row >= start + height) return null;
+	return { row, col: buf.cursorX };
+}
+
 /**
  * Coalesce PTY parser callbacks into a bounded stream of repaint requests.
  *

package/src/core/rows.mjs

@@ -36,6 +36,7 @@ import { GROUP_LABELS, GROUP_ORDER, SEMANTIC_STATES } from "./types.mjs";
  * @property {string|null} followUpPreview
  * @property {string} steeringState
  * @property {number} lastActivityAt
+ * @property {number} createdAt
  */
 
 /** @param {Row} row @returns {SemanticState} */
@@ -139,6 +140,7 @@ export function rowView(row, now) {
 		followUpPreview: row.state?.followUps?.lastQueuedPreview ?? null,
 		steeringState: row.state?.steering?.status ?? "none",
 		lastActivityAt,
+		createdAt: row.meta.createdAt ?? 0,
 	};
 }
 
@@ -148,8 +150,9 @@ function oneLine(text) {
 }
 
 /**
- * Group rows by semantic state in GROUP_ORDER. Within a group: pinned first, then most
- * recently active first. Empty groups are omitted.
+ * Group rows by semantic state in GROUP_ORDER. Within a group: pinned first, then
+ * creation order (oldest first) — the order is stable and never reshuffles on activity.
+ * Empty groups are omitted.
  * @param {Row[]} rows
  * @param {number} now
  * @returns {Array<{ state: SemanticState, label: string, rows: RowView[] }>}
@@ -171,7 +174,7 @@ export function groupRows(rows, now) {
  * a single folder renders as a flat list (no redundant folder header).
  * @param {Row[]} rows
  * @param {number} now
- * @returns {Array<{ state: SemanticState, label: string, rowCount: number, showFolders: boolean, folders: Array<{ key: string, name: string, path: string, rows: RowView[], lastActivityAt: number, pinned: boolean }> }>}
+ * @returns {Array<{ state: SemanticState, label: string, rowCount: number, showFolders: boolean, folders: Array<{ key: string, name: string, path: string, rows: RowView[], createdAt: number, pinned: boolean }> }>}
  */
 export function groupRowsByFolder(rows, now) {
 	const views = rows.map((r) => rowView(r, now));
@@ -184,23 +187,35 @@ export function groupRowsByFolder(rows, now) {
 			const key = view.folderKey;
 			const existing = byFolder.get(key);
 			if (existing) existing.rows.push(view);
-			else byFolder.set(key, { key, name: view.folderName, path: view.folderPath, rows: [view], lastActivityAt: view.lastActivityAt, pinned: view.pinned });
+			else byFolder.set(key, { key, name: view.folderName, path: view.folderPath, rows: [view], createdAt: view.createdAt, pinned: view.pinned });
 		}
 		const folders = [...byFolder.values()].map((folder) => {
 			folder.rows = sortRowViews(folder.rows);
-			folder.lastActivityAt = Math.max(...folder.rows.map((r) => r.lastActivityAt));
+			// Folder creation time = its first-created row, so folders keep a stable,
+			// creation-ordered position and don't jump when any row inside gets busy.
+			folder.createdAt = Math.min(...folder.rows.map((r) => r.createdAt));
 			folder.pinned = folder.rows.some((r) => r.pinned);
 			return folder;
-		}).sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.lastActivityAt - a.lastActivityAt || a.name.localeCompare(b.name));
+		}).sort((a, b) => Number(b.pinned) - Number(a.pinned) || a.createdAt - b.createdAt || a.name.localeCompare(b.name));
 		const showFolders = folders.length > 1;
 		groups.push({ state, label: GROUP_LABELS[state], rowCount: inState.length, showFolders, folders });
 	}
 	return groups;
 }
 
-/** @param {RowView[]} views */
+/**
+ * Stable row order: pinned first, then creation order (oldest first), then id.
+ * Activity time deliberately does not participate, so rows never reshuffle while
+ * sessions are running.
+ * @param {RowView[]} views
+ */
 function sortRowViews(views) {
-	return views.sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.lastActivityAt - a.lastActivityAt);
+	return views.sort(
+		(a, b) =>
+			Number(b.pinned) - Number(a.pinned) ||
+			a.createdAt - b.createdAt ||
+			a.id.localeCompare(b.id),
+	);
 }
 
 /** @param {string} path */

package/src/core/types.mjs

@@ -62,12 +62,12 @@ export const GROUP_ORDER = /** @type {const} */ ([
 
 /** Human labels for group headers. @type {Record<SemanticState,string>} */
 export const GROUP_LABELS = {
-	needs_input: "Needs input",
+	needs_input: "Needs answer",
 	working: "Running",
 	queued: "Queued",
 	failed: "Failed",
 	completed: "Done",
-	idle: "In Progress",
+	idle: "Needs instructions",
 	stopped: "Stopped",
 };
 

package/src/runtime/service.mjs

@@ -36,6 +36,7 @@ import {
 	writeLaunchPrefs,
 	writeMeta,
 	writeState,
+	writeStatus,
 } from "../core/store.mjs";
 import { diagnoseNodePtyFailure, ensureNodePtySpawnHelperExecutable, nodePtyFallbackMessage, probeNodePtyEnvironment } from "../core/pty-support.mjs";
 import { normalizeScreenLogMaxBytes, pruneScreenLogs } from "../core/screen-log-gc.mjs";
@@ -270,6 +271,15 @@ export function createService(opts) {
 		state.summary = completionSummary(state);
 		state.lastActivityAt = Date.now();
 		state.updatedAt = Date.now();
+		// Also clear autoState in the run status so in-flight model passes
+		// (job-runner / state-runner) see the manual completion and skip refinement.
+		if (state.currentRunId) {
+			const status = readStatus(root, viewId, state.currentRunId);
+			if (status) {
+				status.autoState = null;
+				writeStatus(root, status);
+			}
+		}
 		writeState(root, state);
 		return { ok: true };
 	}
@@ -958,7 +968,7 @@ export function createService(opts) {
 						s.question = null;
 						s.pendingQuestions = [];
 						s.error = failed ? (s.error ?? row.host.error ?? "PTY host exited unexpectedly") : null;
-						s.summary = failed ? "Failed (PTY host exited)" : "In Progress";
+						s.summary = failed ? "Failed (PTY host exited)" : "Needs instructions";
 						s.updatedAt = now;
 						writeState(root, s);
 						appendDiagnostic(root, row.meta.id, { source: "service", level: failed ? "error" : "info", code: "host_reconciled", message: failed ? "PTY host exited before final event" : "PTY host finalized without final event", details: { hostState: row.host.state, exitCode: row.host.exitCode } });

package/src/ui/dashboard.ts

@@ -923,7 +923,7 @@ export class DashboardComponent implements Component {
 			currentRunId: null,
 			semanticState: "idle",
 			processState: "exited",
-			summary: "In Progress",
+			summary: "Needs instructions",
 			lastActivityAt: Date.now(),
 			updatedAt: Date.now(),
 			needsInput: false,
@@ -1754,7 +1754,7 @@ function headerTextRows(
 function headerStageSummary(theme: ThemeLike, counts: HeaderCounts, filterQuery: string, compact: boolean): string {
 	const joiner = theme.fg("dim", " · ");
 	const parts = [
-		headerStagePart(theme, "needs_input", counts.needs, compact ? "awaiting" : "awaiting input"),
+		headerStagePart(theme, "needs_input", counts.needs, compact ? "answer" : "needs answer"),
 		headerStagePart(theme, "working", counts.working, "running"),
 		headerUnreadPart(theme, counts.unread),
 		headerStagePart(theme, "completed", counts.completed, "done"),