@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/domains/session/task-board.ts

@@ -1,4 +1,10 @@
-import type { SessionEntry, TaskLedgerGoal, TaskLedgerStatus, TaskLedgerValidationEvidence } from "./entries.js";
+import { randomUUID } from "node:crypto";
+import {
+	isSessionEntry,
+	type TaskLedgerGoal,
+	type TaskLedgerStatus,
+	type TaskLedgerValidationEvidence,
+} from "./entries.js";
 
 /**
  * The session task board: the live state behind the `tasks` tool, the footer
@@ -15,11 +21,14 @@ import type { SessionEntry, TaskLedgerGoal, TaskLedgerStatus, TaskLedgerValidati
  */
 
 const TASK_BOARD_GOAL_ID = "board";
+export const LEGACY_TASK_BOARD_ID = "legacy";
 
 export interface TaskBoardTask {
 	id: string;
 	title: string;
 	status: TaskLedgerStatus;
+	origin?: "agent" | "user";
+	userTaskId?: string;
 	/** Block or drop reason; empty for pending/active/completed tasks. */
 	reason?: string;
 	/** Evidence note recorded when the task was completed. */
@@ -27,6 +36,8 @@ export interface TaskBoardTask {
 }
 
 export interface TaskBoardSnapshot {
+	/** Stable identity for this plan generation; task display ids are reusable. */
+	boardId: string;
 	title: string;
 	tasks: ReadonlyArray<TaskBoardTask>;
 	/**
@@ -53,6 +64,7 @@ export interface TaskBoardCounts {
 export type TaskBoardMutation =
 	| { op: "plan"; title: string; tasks: ReadonlyArray<string> }
 	| { op: "add"; tasks: ReadonlyArray<string> }
+	| { op: "pick"; title: string; userTaskId: string }
 	| { op: "start"; id: string }
 	| { op: "done"; id: string; evidence: string }
 	| { op: "block"; id: string; reason: string }
@@ -71,6 +83,7 @@ export type TaskBoardMutationResult =
 export interface TaskLedgerEntryFields {
 	kind: "taskLedger";
 	parentTurnId: null;
+	boardId: string;
 	goals: TaskLedgerGoal[];
 	subgoals: TaskLedgerGoal[];
 	activeRunIds: string[];
@@ -88,18 +101,48 @@ export interface TaskBoardStoreDeps {
 	readEntries?: () => ReadonlyArray<unknown>;
 	/** Persist one full-snapshot taskLedger entry. Absent means in-memory only. */
 	appendEntry?: (entry: TaskLedgerEntryFields) => void;
+	/** Stable board-id source; injectable for deterministic contract tests. */
+	createBoardId?: () => string;
 	now?: () => Date;
 }
 
+export interface SessionTaskHistoryBoard {
+	boardId: string;
+	title: string;
+	tasks: ReadonlyArray<TaskBoardTask>;
+	lastSnapshotAt: string;
+}
+
 export interface TaskBoardStore {
 	/** Current board, refolded from the session ledger after a session switch. */
 	snapshot(): TaskBoardSnapshot | null;
+	/**
+	 * Current in-memory projection only. Unlike snapshot(), this never reads or
+	 * folds the session ledger and returns null rather than leaking a stale board
+	 * when the session id changed or invalidate() has marked the cache dirty.
+	 */
+	cachedSnapshot(): TaskBoardSnapshot | null;
+	/** Durable board generations on the active session path, newest first. */
+	historySnapshot(): ReadonlyArray<SessionTaskHistoryBoard>;
 	/** Apply one mutation, persist the resulting snapshot, and return it. */
 	apply(mutation: TaskBoardMutation): TaskBoardMutationResult;
 	/** Link an in-flight dispatch run to the board; a no-op without a board. */
 	attachRun(runId: string): void;
 	/** Unlink a finished dispatch run; a no-op when it was never attached. */
 	detachRun(runId: string): void;
+	/**
+	 * Force the next read to refold from the ledger even if `getSessionId()`
+	 * reports the same id it did last time. A `/tree` switch moves the active
+	 * append point without changing which session is open, so the id-keyed
+	 * cache alone never noticed the branch change and kept showing the
+	 * abandoned branch's board (issue #94). Callers invalidate on the bus
+	 * signal that switch emits.
+	 */
+	invalidate(): void;
+}
+
+function isOpenUserTask(task: TaskBoardTask): boolean {
+	return task.origin === "user" && (task.status === "pending" || task.status === "active");
 }
 
 export function taskBoardCounts(board: Pick<TaskBoardSnapshot, "tasks">): TaskBoardCounts {
@@ -150,12 +193,15 @@ export function toTaskLedgerEntryFields(board: TaskBoardSnapshot, now: Date): Ta
 			status: task.status,
 			parentGoalId: TASK_BOARD_GOAL_ID,
 		};
+		if (task.origin) goal.origin = task.origin;
+		if (task.userTaskId) goal.userTaskId = task.userTaskId;
 		if (task.reason) goal.description = task.reason;
 		return goal;
 	});
 	return {
 		kind: "taskLedger",
 		parentTurnId: null,
+		boardId: board.boardId,
 		goals: [{ id: TASK_BOARD_GOAL_ID, title: board.title, status: boardStatus(board.tasks) }],
 		subgoals,
 		activeRunIds: [...board.activeRunIds],
@@ -165,13 +211,13 @@ export function toTaskLedgerEntryFields(board: TaskBoardSnapshot, now: Date): Ta
 
 function isTaskLedgerShaped(value: unknown): value is {
 	kind: "taskLedger";
+	boardId?: string;
+	timestamp?: string;
 	goals: TaskLedgerGoal[];
 	subgoals: TaskLedgerGoal[];
 	requiredValidationEvidence: TaskLedgerValidationEvidence[];
 } {
-	if (!value || typeof value !== "object") return false;
-	const entry = value as Partial<SessionEntry>;
-	return entry.kind === "taskLedger" && Array.isArray((entry as { goals?: unknown }).goals);
+	return isSessionEntry(value) && value.kind === "taskLedger";
 }
 
 /**
@@ -186,7 +232,60 @@ export function foldTaskBoard(entries: ReadonlyArray<unknown>): TaskBoardSnapsho
 	return last;
 }
 
+/**
+ * Fold every safely identifiable board generation in a session. New ledgers
+ * key generations by boardId; pre-boardId ledgers collapse to the newest
+ * legacy snapshot because reusable tN ids cannot safely distinguish their
+ * older plan generations.
+ */
+export function foldSessionTaskHistory(entries: ReadonlyArray<unknown>): SessionTaskHistoryBoard[] {
+	type MutableHistoryBoard = {
+		boardId: string;
+		title: string;
+		tasks: Map<string, TaskBoardTask>;
+		lastSnapshotAt: string;
+		lastIndex: number;
+	};
+	const boards = new Map<string, MutableHistoryBoard>();
+	for (const [index, raw] of entries.entries()) {
+		if (!isTaskLedgerShaped(raw)) continue;
+		const view = toEntryView(raw);
+		if (!view) continue;
+		const boardId = typeof raw.boardId === "string" && raw.boardId.length > 0 ? raw.boardId : LEGACY_TASK_BOARD_ID;
+		const timestamp = typeof raw.timestamp === "string" ? raw.timestamp : "";
+		if (boardId === LEGACY_TASK_BOARD_ID) {
+			boards.set(boardId, {
+				boardId,
+				title: view.title,
+				tasks: new Map(view.tasks.map((task) => [task.id, task])),
+				lastSnapshotAt: timestamp,
+				lastIndex: index,
+			});
+			continue;
+		}
+		const existing = boards.get(boardId);
+		if (!existing) {
+			boards.set(boardId, {
+				boardId,
+				title: view.title,
+				tasks: new Map(view.tasks.map((task) => [task.id, task])),
+				lastSnapshotAt: timestamp,
+				lastIndex: index,
+			});
+			continue;
+		}
+		existing.title = view.title;
+		for (const task of view.tasks) existing.tasks.set(task.id, task);
+		existing.lastSnapshotAt = timestamp;
+		existing.lastIndex = index;
+	}
+	return [...boards.values()]
+		.sort((left, right) => right.lastIndex - left.lastIndex)
+		.map(({ lastIndex: _lastIndex, tasks, ...board }) => ({ ...board, tasks: [...tasks.values()] }));
+}
+
 function toEntryView(entry: {
+	boardId?: string;
 	goals: TaskLedgerGoal[];
 	subgoals: TaskLedgerGoal[];
 	requiredValidationEvidence: TaskLedgerValidationEvidence[];
@@ -199,9 +298,16 @@ function toEntryView(entry: {
 		evidenceByTask.set(taskId, item.description);
 	}
 	return {
+		boardId: entry.boardId ?? LEGACY_TASK_BOARD_ID,
 		title: boardGoal.title,
 		tasks: entry.subgoals.map((goal) => {
-			const task: TaskBoardTask = { id: goal.id, title: goal.title, status: goal.status };
+			const task: TaskBoardTask = {
+				id: goal.id,
+				title: goal.title,
+				status: goal.status,
+				origin: goal.origin ?? "agent",
+			};
+			if (goal.userTaskId) task.userTaskId = goal.userTaskId;
 			if (goal.description) task.reason = goal.description;
 			const evidence = evidenceByTask.get(goal.id);
 			if (evidence) task.evidence = evidence;
@@ -235,14 +341,27 @@ function applyMutation(
 		const titles = normalizeTitles(mutation.tasks);
 		if (mutation.title.trim().length === 0) return { error: "plan requires a non-empty title" };
 		if (titles.length === 0) return { error: "plan requires at least one task" };
+		const retained = board?.tasks.filter(isOpenUserTask) ?? [];
 		const notes: string[] = [];
-		if (board && taskBoardCounts(board).open > 0) {
-			notes.push(`replaced board "${board.title}" with ${taskBoardCounts(board).open} task(s) still open`);
+		const replacedOpen = board ? taskBoardCounts(board).open - retained.length : 0;
+		if (board && replacedOpen > 0) {
+			notes.push(`replaced board "${board.title}" with ${replacedOpen} agent task(s) still open`);
 		}
+		if (retained.length > 0) notes.push(`preserved ${retained.length} open operator task(s)`);
+		const start = nextTaskId(retained);
 		return {
 			board: {
+				boardId: "",
 				title: mutation.title.trim(),
-				tasks: titles.map((title, index) => ({ id: `t${index + 1}`, title, status: "pending" as const })),
+				tasks: [
+					...retained,
+					...titles.map((title, index) => ({
+						id: `t${start + index}`,
+						title,
+						status: "pending" as const,
+						origin: "agent" as const,
+					})),
+				],
 				// Runs in flight outlive a board swap: they belong to the session,
 				// so the fresh board inherits the linkage until the runs finish.
 				activeRunIds: board?.activeRunIds ?? [],
@@ -250,12 +369,48 @@ function applyMutation(
 			notes,
 		};
 	}
+	if (mutation.op === "pick") {
+		const title = mutation.title.trim();
+		if (title.length === 0) return { error: "pick requires a non-empty operator task title" };
+		if (!/^u[1-9]\d*$/.test(mutation.userTaskId)) return { error: "pick requires an operator task id like u3" };
+		if (
+			board?.tasks.some(
+				(task) =>
+					task.userTaskId === mutation.userTaskId &&
+					(task.status === "pending" || task.status === "active" || task.status === "completed"),
+			)
+		) {
+			return { error: `operator task ${mutation.userTaskId} is already linked to durable board work` };
+		}
+		const tasks = board?.tasks ?? [];
+		const picked: TaskBoardTask = {
+			id: `t${nextTaskId(tasks)}`,
+			title,
+			status: "pending",
+			origin: "user",
+			userTaskId: mutation.userTaskId,
+		};
+		return {
+			board: {
+				boardId: board?.boardId ?? "",
+				title: board?.title ?? "Operator tasks",
+				tasks: [...tasks, picked],
+				activeRunIds: board?.activeRunIds ?? [],
+			},
+			notes: [],
+		};
+	}
 	if (board === null) return { error: 'no task board yet; declare one with action="plan" first' };
 	if (mutation.op === "add") {
 		const titles = normalizeTitles(mutation.tasks);
 		if (titles.length === 0) return { error: "add requires at least one task" };
 		const start = nextTaskId(board.tasks);
-		const added = titles.map((title, index) => ({ id: `t${start + index}`, title, status: "pending" as const }));
+		const added = titles.map((title, index) => ({
+			id: `t${start + index}`,
+			title,
+			status: "pending" as const,
+			origin: "agent" as const,
+		}));
 		return { board: { ...board, tasks: [...board.tasks, ...added] }, notes: [] };
 	}
 	const target = board.tasks.find((task) => task.id === mutation.id);
@@ -323,11 +478,13 @@ function applyStatusMutation(
 
 export function createTaskBoardStore(deps: TaskBoardStoreDeps = {}): TaskBoardStore {
 	let cachedSessionId: string | null | undefined;
+	let dirty = true;
 	let board: TaskBoardSnapshot | null = null;
 
 	const syncToSession = (): void => {
 		const sessionId = deps.getSessionId?.() ?? null;
-		if (cachedSessionId === sessionId) return;
+		if (!dirty && cachedSessionId === sessionId) return;
+		dirty = false;
 		cachedSessionId = sessionId;
 		try {
 			board = deps.readEntries ? foldTaskBoard(deps.readEntries()) : null;
@@ -345,18 +502,52 @@ export function createTaskBoardStore(deps: TaskBoardStoreDeps = {}): TaskBoardSt
 		}
 	};
 
+	const mutationRequiresAcknowledgement = (current: TaskBoardSnapshot | null, mutation: TaskBoardMutation): boolean => {
+		if (mutation.op === "pick") return true;
+		if (mutation.op === "plan") return current?.tasks.some(isOpenUserTask) ?? false;
+		if (mutation.op !== "done") return false;
+		return current?.tasks.some((task) => task.id === mutation.id && task.origin === "user") ?? false;
+	};
+
 	return {
 		snapshot(): TaskBoardSnapshot | null {
 			syncToSession();
 			return board;
 		},
+		cachedSnapshot(): TaskBoardSnapshot | null {
+			const sessionId = deps.getSessionId?.() ?? null;
+			return !dirty && cachedSessionId === sessionId ? board : null;
+		},
+		historySnapshot(): ReadonlyArray<SessionTaskHistoryBoard> {
+			syncToSession();
+			try {
+				return deps.readEntries ? foldSessionTaskHistory(deps.readEntries()) : [];
+			} catch {
+				return [];
+			}
+		},
 		apply(mutation: TaskBoardMutation): TaskBoardMutationResult {
 			syncToSession();
 			const result = applyMutation(board, mutation);
 			if ("error" in result) return { ok: false, message: result.error };
-			board = result.board;
-			persist(result.board);
-			return { ok: true, board: result.board, notes: result.notes };
+			const needsBoardId = mutation.op === "plan" || result.board.boardId.length === 0;
+			const nextBoard = needsBoardId ? { ...result.board, boardId: deps.createBoardId?.() ?? randomUUID() } : result.board;
+			if (mutationRequiresAcknowledgement(board, mutation)) {
+				if (!deps.appendEntry) {
+					return { ok: false, message: "durable task-ledger persistence is unavailable for operator-linked work" };
+				}
+				try {
+					deps.appendEntry(toTaskLedgerEntryFields(nextBoard, deps.now?.() ?? new Date()));
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return { ok: false, message: `could not persist operator-linked task board: ${message}` };
+				}
+				board = nextBoard;
+				return { ok: true, board: nextBoard, notes: result.notes };
+			}
+			board = nextBoard;
+			persist(nextBoard);
+			return { ok: true, board: nextBoard, notes: result.notes };
 		},
 		attachRun(runId: string): void {
 			syncToSession();
@@ -371,5 +562,8 @@ export function createTaskBoardStore(deps: TaskBoardStoreDeps = {}): TaskBoardSt
 			board = { ...board, activeRunIds: board.activeRunIds.filter((id) => id !== runId) };
 			persist(board);
 		},
+		invalidate(): void {
+			dirty = true;
+		},
 	};
 }

package/src/domains/session/tree/active-path.ts

@@ -12,8 +12,14 @@ import type { MessageEntry, SessionEntry } from "../entries.js";
  *   - message entries on the active path,
  *   - sidecar entries anchored to a path turn (parentTurnId or targetTurnId),
  *   - compaction summaries whose firstKeptTurnId or parent lands on the path,
- *   - unanchored sidecars (parentTurnId null), which cannot be attributed to
- *     a branch and keep their historical always-included behavior.
+ *   - unanchored sidecars (parentTurnId null) written at or before the leaf's
+ *     position in the file. `fork.ts` shares this same rule (`entryBelongsToPath`
+ *     below) for the same reason: an unanchored sidecar records state as of
+ *     the moment it was written, and a sidecar written after the turn a
+ *     reconstruction stands at was not visible then, on any branch. Before
+ *     issue #94 this filter kept every unanchored sidecar regardless of
+ *     position while fork applied the positional cut, so the same turn
+ *     reached by /tree switch versus /fork saw two different task boards.
  *
  * A plain chain is returned unchanged unless a live caller explicitly pins an
  * earlier leaf. That preserves historical linear replay (including old parent
@@ -47,7 +53,8 @@ export function filterEntriesToActivePath(entries: ReadonlyArray<SessionEntry>,
 		// as the root rather than failing the whole replay.
 		current = messagesById.get(current.parentTurnId);
 	}
-	return entries.filter((entry) => entryOnActivePath(entry, pathIds));
+	const leafIndex = entries.findIndex((entry) => entry.kind === "message" && entry.turnId === leaf.turnId);
+	return entries.filter((entry, index) => entryBelongsToPath(entry, pathIds, leafIndex >= 0 && index <= leafIndex));
 }
 
 /**
@@ -87,12 +94,44 @@ function hasBranch(messages: ReadonlyArray<MessageEntry>): boolean {
 	return false;
 }
 
-function entryOnActivePath(entry: SessionEntry, pathIds: ReadonlySet<string>): boolean {
+/**
+ * Shared verdict for whether a session entry belongs to a reconstruction
+ * standing at the turn `pathIds` traces back to. Used by both live
+ * `/tree`-switch replay (above) and `/fork` (`fork.ts`), so the two surfaces
+ * agree on the one thing that was inconsistent between them: an unanchored
+ * sidecar (`parentTurnId === null`, e.g. `taskLedger`, a routing notice, a
+ * leafless `workerRun`) carries no turn pointer, so file position is the only
+ * signal available for it. `atOrBeforeLeaf` is that positional verdict,
+ * computed by the caller: was the entry written at or before the leaf's
+ * position in the file. A sidecar written after the leaf's position was not
+ * visible when a reconstruction standing at that leaf would have looked, on
+ * any branch, so it is excluded (issue #94; before this fix, live replay kept
+ * every unanchored sidecar regardless of position while fork dropped anything
+ * after the fork point, so the same turn reached the two ways produced two
+ * different task boards).
+ *
+ * `compactionSummary` is deliberately not given the same positional
+ * treatment here: a compaction anchored to a turn on the path is ordinarily
+ * appended after that turn's own message (compaction runs on top of a
+ * finished conversation, not before it), so gating it by leaf position would
+ * drop the compaction that legitimately covers the leaf itself. `fork.ts`
+ * layers its own, stricter compaction gate on top of this function, because
+ * a fork represents a snapshot frozen at one moment and a compaction written
+ * after that moment did not exist at the fork point even when its anchor
+ * turn is an ancestor. A `sessionInfo` entry with no `targetTurnId` is a
+ * session-wide fact (e.g. a rename), not scoped to any branch or moment, so
+ * it is always kept.
+ */
+export function entryBelongsToPath(
+	entry: SessionEntry,
+	pathIds: ReadonlySet<string>,
+	atOrBeforeLeaf: boolean,
+): boolean {
 	if (entry.kind === "message") return pathIds.has(entry.turnId);
 	if (entry.kind === "label") return pathIds.has(entry.targetTurnId);
 	if (entry.kind === "sessionInfo") return entry.targetTurnId === undefined || pathIds.has(entry.targetTurnId);
 	if (entry.kind === "compactionSummary" && entry.firstKeptTurnId.length > 0 && pathIds.has(entry.firstKeptTurnId)) {
 		return true;
 	}
-	return entry.parentTurnId === null || pathIds.has(entry.parentTurnId);
+	return entry.parentTurnId === null ? atOrBeforeLeaf : pathIds.has(entry.parentTurnId);
 }

package/src/domains/session/tree/fork.ts

@@ -4,6 +4,7 @@ import type { SessionMeta } from "../contract.js";
 import { isSessionHeader, type SessionEntry } from "../entries.js";
 import { enrichForkMeta } from "../history.js";
 import { type SessionManagerState, startSession } from "../manager.js";
+import { entryBelongsToPath } from "./active-path.js";
 
 /**
  * Single-point fork-from-parent-turn orchestration. Closes the caller's
@@ -80,32 +81,21 @@ function treeFromLinearPath(path: ReadonlyArray<LinkedRecord>): SessionTreeNode[
 }
 
 /**
- * Unanchored sidecars (parentTurnId null) carry no turn pointer, so file
- * position is the only branch signal: anything written after the fork-point
- * turn belongs to the timeline that diverged from it, not to the fork.
- * `atOrBeforeForkPoint` is that positional verdict, computed by the caller.
+ * Fork-specific tightening of the shared `entryBelongsToPath` verdict. A fork
+ * is a snapshot frozen at `parentTurnId`: a compaction summary written after
+ * that point did not exist at the fork moment even when its `firstKeptTurnId`
+ * names an ancestor turn, so it must not ride along just because that turn
+ * happens to be on the path. Live `/tree`-switch replay does not need this
+ * extra gate (see the comment on the shared function for why), which is the
+ * one place fork and live replay still deliberately disagree.
  */
 function sessionEntryBelongsToPath(
 	entry: SessionEntry,
 	pathIds: ReadonlySet<string>,
 	atOrBeforeForkPoint: boolean,
 ): boolean {
-	if (entry.kind === "message") return pathIds.has(entry.turnId);
-	if (entry.kind === "label") return pathIds.has(entry.targetTurnId);
-	if (entry.kind === "sessionInfo") return entry.targetTurnId ? pathIds.has(entry.targetTurnId) : false;
-	if (entry.kind === "compactionSummary") {
-		// A summary describes history as of its write position. One written
-		// after the fork point did not exist when the forked timeline split,
-		// even when its firstKeptTurnId lands on the fork path; copying it
-		// would open the fork at the summary boundary and hide the transcript.
-		if (!atOrBeforeForkPoint) return false;
-		if (entry.firstKeptTurnId.length > 0 && pathIds.has(entry.firstKeptTurnId)) return true;
-	}
-	return entry.parentTurnId === null ? atOrBeforeForkPoint : pathIds.has(entry.parentTurnId);
-}
-
-function entryBelongsToPath(entry: SessionEntry, pathIds: ReadonlySet<string>, atOrBeforeForkPoint: boolean): boolean {
-	return sessionEntryBelongsToPath(entry, pathIds, atOrBeforeForkPoint);
+	if (entry.kind === "compactionSummary" && !atOrBeforeForkPoint) return false;
+	return entryBelongsToPath(entry, pathIds, atOrBeforeForkPoint);
 }
 
 function branchEntriesFromParent(
@@ -124,7 +114,7 @@ function branchEntriesFromParent(
 	const pathIds = new Set(path.map((record) => record.id));
 	const forkPointIndex = parsed.findIndex((entry) => linkedRecordFromEntry(entry).id === leafTurnId);
 	const entries = parsed.filter((entry, index) =>
-		entryBelongsToPath(entry, pathIds, forkPointIndex >= 0 && index <= forkPointIndex),
+		sessionEntryBelongsToPath(entry, pathIds, forkPointIndex >= 0 && index <= forkPointIndex),
 	);
 	return {
 		parentCurrentPath,
@@ -134,15 +124,21 @@ function branchEntriesFromParent(
 }
 
 /**
- * Fork the given state into a new session. Closes the prior writer
- * best-effort so the on-disk endedAt marker is written; the caller is
- * responsible for replacing its own state pointer with `result.next`.
+ * Fork the given state into a new session. Closes the prior writer once the
+ * child session is known good, so the on-disk endedAt marker on the parent is
+ * never written for a fork that failed; the caller is responsible for
+ * replacing its own state pointer with `result.next`.
  */
 export function forkFromState(input: ForkInput): ForkResult {
 	const parentMeta = input.from.meta;
-	// close() only performs synchronous filesystem work before resolving, so
-	// the following read sees a fully flushed parent transcript.
-	void input.from.writer.close();
+	// Appends are already synchronous writes (writeSync in the engine writer),
+	// so the read below already sees everything appended in this process
+	// without closing first; flushAppends only fsyncs for durability. Reading
+	// (and traceAncestry inside branchEntriesFromParent, which throws on an
+	// unknown or broken parent chain) happens before the parent writer is
+	// touched, so a broken fork point leaves the parent open and un-ended
+	// instead of orphaning the caller (issue #93).
+	input.from.writer.flushAppends();
 	const branch = branchEntriesFromParent(parentMeta, input.parentTurnId);
 
 	const cwd = input.cwd ?? parentMeta.cwd;
@@ -156,5 +152,8 @@ export function forkFromState(input: ForkInput): ForkResult {
 		parentTurnId: input.parentTurnId,
 	});
 	enrichForkMeta(next.meta, parentMeta.id, input.parentTurnId);
+	// Only now is the child known good: created, seeded, and stamped with its
+	// parent pointers. Close (and stamp endedAt on) the parent last.
+	void input.from.writer.close();
 	return { next, parentMeta, nodes: branch.tree };
 }

package/src/domains/session/tree/preview.ts

@@ -21,10 +21,10 @@ import { stripTokenizerSentinels } from "../../../engine/strip-tokenizer-sentine
  * and optional label suffix. Callers that need a tighter budget can clamp
  * the output further.
  */
-export const TURN_PREVIEW_MAX_CHARS = 60;
+const TURN_PREVIEW_MAX_CHARS = 60;
 
 /** Minimal turn shape buildTurnPreview accepts. */
-export type TurnPreviewInput = Pick<ClioTurnRecord, "kind" | "payload">;
+type TurnPreviewInput = Pick<ClioTurnRecord, "kind" | "payload">;
 
 /**
  * Strip ANSI escape sequences. Tool outputs sometimes carry colour codes

package/src/domains/session/workspace/git-probe.ts

@@ -104,27 +104,31 @@ function remoteFrom(raw: string | null): string | null {
 export function probeGit(cwd: string): GitProbeResult {
 	const inside = gitOk(cwd, ["rev-parse", "--is-inside-work-tree"]);
 	if (inside !== "true") return EMPTY_PROBE;
+	const ignored = gitOk(cwd, ["check-ignore", "--quiet", "--", "."]);
+	if (ignored !== null) return EMPTY_PROBE;
 	const branch = branchFrom(gitOk(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]));
-	const dirty = dirtyFrom(gitOk(cwd, ["status", "--porcelain"]));
+	const dirty = dirtyFrom(gitOk(cwd, ["status", "--porcelain", "--", "."]));
 	const { ahead, behind } = aheadBehindFrom(gitOk(cwd, ["rev-list", "--left-right", "--count", "HEAD...@{u}"]));
-	const recentCommits = recentCommitsFrom(gitOk(cwd, ["log", "-5", "--format=%H%x09%s"]));
+	const recentCommits = recentCommitsFrom(gitOk(cwd, ["log", "-5", "--format=%H%x09%s", "--", "."]));
 	const remoteUrl = remoteFrom(gitOk(cwd, ["remote", "get-url", "origin"]));
 	return { isGit: true, branch, dirty, ahead, behind, recentCommits, remoteUrl };
 }
 
 /**
- * The full probe without blocking the event loop. Six subprocesses cost 63-100 ms
- * of blocked loop on a large repository; the five that follow the work-tree gate
- * are independent, so they run concurrently and the caller waits on none of them.
+ * The full probe without blocking the event loop. Once Git confirms the exact
+ * workspace is both inside a work tree and not ignored, the remaining five
+ * subprocesses are independent and run concurrently.
  */
 export async function probeGitAsync(cwd: string): Promise<GitProbeResult> {
 	const inside = await gitOkAsync(cwd, ["rev-parse", "--is-inside-work-tree"]);
 	if (inside !== "true") return EMPTY_PROBE;
+	const ignored = await gitOkAsync(cwd, ["check-ignore", "--quiet", "--", "."]);
+	if (ignored !== null) return EMPTY_PROBE;
 	const [branchRaw, status, aheadBehindRaw, log, remoteRaw] = await Promise.all([
 		gitOkAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
-		gitOkAsync(cwd, ["status", "--porcelain"]),
+		gitOkAsync(cwd, ["status", "--porcelain", "--", "."]),
 		gitOkAsync(cwd, ["rev-list", "--left-right", "--count", "HEAD...@{u}"]),
-		gitOkAsync(cwd, ["log", "-5", "--format=%H%x09%s"]),
+		gitOkAsync(cwd, ["log", "-5", "--format=%H%x09%s", "--", "."]),
 		gitOkAsync(cwd, ["remote", "get-url", "origin"]),
 	]);
 	const { ahead, behind } = aheadBehindFrom(aheadBehindRaw);
@@ -140,16 +144,18 @@ export async function probeGitAsync(cwd: string): Promise<GitProbeResult> {
 }
 
 /**
- * Branch, dirty flag, and remote only: four subprocesses instead of six, run
- * concurrently and off the loop. This is what the interactive footer polls on
- * its ticker and re-reads at the end of every turn.
+ * Branch, dirty flag, and remote only. After the work-tree and ignored-workspace
+ * gates, the three fact probes run concurrently and off the loop. This is what
+ * the interactive footer polls and re-reads at the end of every turn.
  */
 export async function probeGitStatusAsync(cwd: string): Promise<GitStatusProbeResult> {
 	const inside = await gitOkAsync(cwd, ["rev-parse", "--is-inside-work-tree"]);
 	if (inside !== "true") return EMPTY_STATUS_PROBE;
+	const ignored = await gitOkAsync(cwd, ["check-ignore", "--quiet", "--", "."]);
+	if (ignored !== null) return EMPTY_STATUS_PROBE;
 	const [branchRaw, status, remoteRaw] = await Promise.all([
 		gitOkAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
-		gitOkAsync(cwd, ["status", "--porcelain"]),
+		gitOkAsync(cwd, ["status", "--porcelain", "--", "."]),
 		gitOkAsync(cwd, ["remote", "get-url", "origin"]),
 	]);
 	return {