@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/domains/session/extension.ts

@@ -6,7 +6,7 @@ import {
 import type { DomainBundle, DomainContext, DomainExtension } from "../../core/domain-loader.js";
 import { performCheckpoint } from "./checkpoint.js";
 import type { DeleteSessionOptions, SessionContract, SessionEntryInput, SessionMeta, TurnInput } from "./contract.js";
-import type { LabelEntry, SessionEntry } from "./entries.js";
+import type { LabelEntry, SessionEntry, SessionInfoEntry } from "./entries.js";
 import { listSessionsForCwd } from "./history.js";
 import {
 	appendEntry,
@@ -48,6 +48,26 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 		context.bus.emit(BusChannels.SessionResumed, { sessionId, via, at: Date.now() });
 	}
 
+	function emitTurnSwitched(sessionId: string, turnId: string): void {
+		context.bus.emit(BusChannels.SessionTurnSwitched, { sessionId, turnId, at: Date.now() });
+	}
+
+	/**
+	 * The leaf to resume onto: the persisted `/tree` pin when it still names a
+	 * real turn in this session's tree, otherwise the inferred newest-node leaf.
+	 * A pin surviving here is what makes a `/tree` switch made without a
+	 * follow-up message survive quit + resume instead of silently reverting to
+	 * the abandoned tip (issue #94).
+	 */
+	function resolveLeafOnOpen(resumed: {
+		state: SessionManagerState;
+		nodes: ReadonlyArray<TreeInputNode>;
+	}): string | null {
+		const pinned = resumed.state.meta.pinnedLeafTurnId;
+		if (pinned && resumed.nodes.some((node) => node.id === pinned)) return pinned;
+		return computeLeafId(resumed.nodes);
+	}
+
 	async function closeCurrent(reason: ParkReason = "close"): Promise<void> {
 		if (!state) return;
 		const s = state;
@@ -118,6 +138,10 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 			// to a previewless snapshot. The overlay handles missing previews
 			// gracefully via its kind-label fallback.
 		}
+		const persistedLeaf =
+			bundle.meta.pinnedLeafTurnId && bundle.nodes.some((node) => node.id === bundle.meta.pinnedLeafTurnId)
+				? bundle.meta.pinnedLeafTurnId
+				: computeLeafId(bundle.nodes);
 		return buildTreeSnapshot({
 			meta,
 			nodes: [...bundle.nodes, ...structural],
@@ -126,7 +150,7 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 			// The leaf is the next append point, so it is computed over turn nodes
 			// only: a structural node marks a moment in the timeline, never a place
 			// the session continues from.
-			leafId: state?.meta.id === sessionId ? currentTurnId : computeLeafId(bundle.nodes),
+			leafId: state?.meta.id === sessionId ? currentTurnId : persistedLeaf,
 		});
 	}
 
@@ -156,8 +180,28 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 		},
 		append(turn: TurnInput) {
 			if (!state) throw new Error("session.append: no current session");
+			// Invariant: a turn can only extend this session's own current leaf.
+			// The interactive layer tracks its own copy of "the last turn id"
+			// (turn-persistence.ts) and normally keeps it in lockstep with
+			// currentTurnId via chat.resetForSession after every switch; when a
+			// failed resume/fork/switchBranch left that copy pointing at a turn
+			// from a session that was never actually opened here, this is the
+			// one place that catches it before a foreign parent id reaches disk.
+			if (turn.parentId !== currentTurnId) {
+				throw new Error(
+					`session.append: turn parentId ${turn.parentId ?? "null"} is not this session's current leaf (expected ${currentTurnId ?? "null"}); refusing to parent a turn onto another session's turn`,
+				);
+			}
 			const record = appendTurn(state, turn);
 			currentTurnId = record.id;
+			// A fresh append moves the leaf past whatever /tree pinned earlier
+			// (or this append could not have been made: see the invariant above),
+			// so the persisted pin is stale and must not outlive it. Once cleared,
+			// resolveLeafOnOpen's timestamp inference is trustworthy again.
+			if (state.meta.pinnedLeafTurnId !== undefined && state.meta.pinnedLeafTurnId !== null) {
+				state.meta.pinnedLeafTurnId = null;
+				persistSessionMeta(state);
+			}
 			return record;
 		},
 		appendEntry(entry: SessionEntryInput) {
@@ -190,29 +234,37 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 		},
 		resume(sessionId) {
 			if (state && state.meta.id === sessionId) return state.meta;
+			// Open the target before touching the current session: resumeSessionState
+			// reads and migrates the target's meta.json and can throw (unsupported
+			// format version, unreadable entries, missing files). Closing or nulling
+			// the prior session ahead of that risk is how a failed switch used to
+			// orphan the operator with no current session (issue #93); on success,
+			// the prior is parked and closed only now that the successor is known good.
+			const resumed = resumeSessionState(sessionId);
 			if (state) {
-				// best-effort close of prior session before switching
 				const prior = state;
 				emitPark(prior.meta.id, "resume_other");
-				state = null;
 				void prior.writer.close();
 			}
-			const resumed = resumeSessionState(sessionId);
 			state = resumed.state;
-			currentTurnId = computeLeafId(resumed.nodes);
+			currentTurnId = resolveLeafOnOpen(resumed);
 			emitResume(resumed.state.meta.id, "resume");
 			return resumed.state.meta;
 		},
 		fork(parentTurnId, input) {
 			if (!state) throw new Error("session.fork: no current session to fork from");
 			const prior = state;
-			emitPark(prior.meta.id, "fork");
-			state = null;
+			// forkFromState reads and validates the parent's own ancestry chain
+			// and can throw (unknown or broken parent turn) before it ever creates
+			// the child session; it closes `prior.writer` itself, and only once the
+			// child is known good (see tree/fork.ts). Do not null or park `state`
+			// until forkFromState returns, for the same reason as resume() above.
 			const { next, nodes } = forkFromState({
 				from: prior,
 				parentTurnId,
 				...(input?.cwd !== undefined ? { cwd: input.cwd } : {}),
 			});
+			emitPark(prior.meta.id, "fork");
 			state = next;
 			currentTurnId = computeLeafId(nodes);
 			return next.meta;
@@ -232,17 +284,17 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 		switchBranch(sessionId) {
 			// /tree-driven branch switch currently delegates to resume. Kept as a
 			// distinct contract method so later slices can layer telemetry or
-			// chat-loop rewiring without changing resume's semantics.
+			// chat-loop rewiring without changing resume's semantics. Same
+			// open-before-close ordering as resume() above and for the same reason.
 			if (state?.meta.id === sessionId) return state.meta;
+			const resumed = resumeSessionState(sessionId);
 			if (state) {
 				const prior = state;
 				emitPark(prior.meta.id, "switch_branch");
-				state = null;
 				void prior.writer.close();
 			}
-			const resumed = resumeSessionState(sessionId);
 			state = resumed.state;
-			currentTurnId = computeLeafId(resumed.nodes);
+			currentTurnId = resolveLeafOnOpen(resumed);
 			emitResume(resumed.state.meta.id, "switch_branch");
 			return resumed.state.meta;
 		},
@@ -254,6 +306,13 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 				throw new Error(`session.switchTurn: turn not found: ${turnId}`);
 			}
 			currentTurnId = turnId;
+			// Persist the pin immediately, not just in memory: without this, a
+			// switch made without a follow-up message was silently lost on quit
+			// because resume() had nothing but timestamp inference to fall back
+			// on and always landed back on the abandoned tip (issue #94).
+			state.meta.pinnedLeafTurnId = turnId;
+			persistSessionMeta(state);
+			emitTurnSwitched(state.meta.id, turnId);
 			return state.meta;
 		},
 		editLabel(turnId, label, sessionId) {
@@ -281,6 +340,28 @@ export function createSessionBundle(context: DomainContext): DomainBundle<Sessio
 			};
 			appendEntryToSessionFile(targetId, entry);
 		},
+		setName(name, sessionId) {
+			const targetId = sessionId ?? state?.meta.id;
+			if (!targetId) throw new Error("session.setName: no sessionId provided and no current session");
+			// A name is session-wide metadata rather than a turn label. Keep it
+			// unanchored and let history's last-wins SessionInfoEntry fold resolve it.
+			if (state && state.meta.id === targetId) {
+				appendEntry(state, {
+					kind: "sessionInfo",
+					parentTurnId: null,
+					name,
+				} as SessionEntryInput);
+				return;
+			}
+			const entry: SessionInfoEntry = {
+				kind: "sessionInfo",
+				turnId: newTurnId(),
+				parentTurnId: null,
+				timestamp: new Date().toISOString(),
+				name,
+			};
+			appendEntryToSessionFile(targetId, entry);
+		},
 		deleteSession(id, opts) {
 			if (state?.meta.id === id) {
 				throw new Error("session.deleteSession: refusing to delete the currently open session; close() first");

package/src/domains/session/retry.ts

@@ -10,16 +10,17 @@
  *
  * This module is the pure building block for the Clio equivalent. It:
  *   1. Declares the RetrySettings shape and sensible defaults.
- *   2. Exposes a deterministic heuristic (`isRetryableErrorMessage`) that
- *      matches the transient error strings pi-ai providers actually emit.
+ *   2. Routes generic provider classification through pi-ai 0.84's
+ *      `isRetryableAssistantError`, retaining only Clio's local-model delta.
  *   3. Computes the backoff delay for a given attempt (`computeRetryDelayMs`)
  *      with the cap the settings declare; callers schedule the wait.
  *   4. Provides `createRetryCountdown` so the TUI can show seconds remaining
  *      and cancel a pending retry on `Esc` without coupling to a specific
  *      timer abstraction.
  *
- * No I/O, no pi-agent-core/pi-ai imports. The chat-loop wiring (which decides
- * whether an agent_end with stopReason "error" triggers a retry) lives in
+ * No I/O. The only engine dependency is the classifier re-exported by
+ * `src/engine/ai.ts`. The chat-loop wiring (which decides whether an
+ * agent_end with stopReason "error" triggers a retry) lives in
  * `src/interactive/chat-loop.ts` and consumes this module; keeping the two
  * split so the countdown can be exercised in unit tests without spinning up a
  * runtime.
@@ -27,6 +28,7 @@
 
 import { performance } from "node:perf_hooks";
 import type { RetrySettings } from "../../core/defaults.js";
+import { isEngineRetryableAssistantError } from "../../engine/ai.js";
 
 export type { RetrySettings } from "../../core/defaults.js";
 
@@ -42,16 +44,6 @@ export const DEFAULT_RETRY_SETTINGS: RetrySettings = {
 	streamStallMs: 180000,
 };
 
-/**
- * Pattern list built from pi-mono's `_isRetryableError` regex (agent-session.ts).
- * Kept as a plain RegExp so the check is `O(1)` per assistant error message.
- * The match is case-insensitive: providers phrase the same error in mixed
- * case (Anthropic: "Overloaded", OpenRouter: "rate limited", Fireworks:
- * "connection error"), and we want all of them classified as transient.
- */
-const RETRYABLE_PATTERN =
-	/overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|timed? out|timeout|terminated|retry delay/i;
-
 /**
  * A self-hosted server refusing a request because the model is not resident.
  *
@@ -61,7 +53,7 @@ const RETRYABLE_PATTERN =
  * llama-swap and Ollama phrase the same condition differently, so the pattern
  * covers the family rather than one vendor's wording.
  *
- * Deliberately not folded into {@link RETRYABLE_PATTERN}: this is transient in
+ * Deliberately kept outside pi's generic classifier: this is transient in
  * a different unit. A rate limit clears in a second or two; a 35B model loads
  * off disk in twenty to sixty, and retrying it on a rate limit's backoff burns
  * every attempt before the server is ready. `clio-coder run --target node-a --model
@@ -95,7 +87,7 @@ export function isModelLoadingErrorMessage(errorMessage: string | null | undefin
  */
 export function isRetryableErrorMessage(errorMessage: string | null | undefined): boolean {
 	if (!errorMessage || errorMessage.length === 0) return false;
-	return RETRYABLE_PATTERN.test(errorMessage) || MODEL_LOADING_PATTERN.test(errorMessage);
+	return isEngineRetryableAssistantError(errorMessage) || MODEL_LOADING_PATTERN.test(errorMessage);
 }
 
 /**
@@ -125,7 +117,7 @@ export function computeRetryDelayMs(
  * initial delay; `done` flips true when the deadline is reached; `cancelled`
  * flips true when a caller aborts via `cancel()` before the deadline.
  */
-export interface RetryCountdownState {
+interface RetryCountdownState {
 	attempt: number;
 	maxAttempts: number;
 	seconds: number;
@@ -133,7 +125,7 @@ export interface RetryCountdownState {
 	cancelled: boolean;
 }
 
-export interface RetryCountdownOptions {
+interface RetryCountdownOptions {
 	/** 1-indexed attempt id displayed to the user, e.g. "Retrying (1/3)". */
 	attempt: number;
 	/** Upper bound displayed alongside `attempt`. */

package/src/domains/session/session-artifacts.ts

@@ -0,0 +1,107 @@
+import { isAbsolute, relative, resolve } from "node:path";
+
+export type SessionArtifactTool = "artifact" | "write" | "edit";
+export type SessionArtifactKind = "plan" | "review" | "report";
+
+export interface SessionArtifact {
+	/** Path exactly as the successful tool result recorded it. */
+	path: string;
+	tool: SessionArtifactTool;
+	artifactKind?: SessionArtifactKind;
+	turnId: string;
+	timestamp: string;
+	/** Number of earlier successful writes to this normalized path. */
+	overwrites: number;
+}
+
+export interface FoldSessionArtifactsOptions {
+	/** Recorded session cwd. Paths outside this root are rejected. */
+	workspace?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSessionArtifactTool(value: unknown): value is SessionArtifactTool {
+	return value === "artifact" || value === "write" || value === "edit";
+}
+
+function isSessionArtifactKind(value: unknown): value is SessionArtifactKind {
+	return value === "plan" || value === "review" || value === "report";
+}
+
+function normalizedWorkspacePath(path: string, workspace: string): string | null {
+	const root = resolve(workspace);
+	const target = isAbsolute(path) ? resolve(path) : resolve(root, path);
+	const rel = relative(root, target);
+	if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) return target;
+	return null;
+}
+
+interface IndexedArtifact extends SessionArtifact {
+	index: number;
+}
+
+/**
+ * Fold durable tool-result facts into the files produced in one active-path
+ * session. This function never stats or reads a path; missing files remain
+ * visible facts and are handled by the `/view workspace` loader.
+ */
+export function foldSessionArtifacts(
+	entries: ReadonlyArray<unknown>,
+	options: FoldSessionArtifactsOptions = {},
+): SessionArtifact[] {
+	const workspace = resolve(options.workspace ?? process.cwd());
+	const lastByPath = new Map<string, IndexedArtifact>();
+	const writeCounts = new Map<string, number>();
+	let writeIndex = 0;
+
+	for (const raw of entries) {
+		if (!isRecord(raw) || raw.kind !== "message" || raw.role !== "tool_result") continue;
+		if (typeof raw.turnId !== "string" || typeof raw.timestamp !== "string") continue;
+		const payload = raw.payload;
+		if (!isRecord(payload) || !isSessionArtifactTool(payload.toolName)) continue;
+		if (
+			payload.isError === true ||
+			payload.outcome === "error" ||
+			payload.outcome === "blocked" ||
+			payload.outcome === "aborted" ||
+			payload.outcome === "orphaned"
+		) {
+			continue;
+		}
+		const result = payload.result;
+		if (!isRecord(result) || !isRecord(result.details) || !Array.isArray(result.details.paths)) continue;
+		const artifactKind =
+			payload.toolName === "artifact" && isSessionArtifactKind(result.details.kind) ? result.details.kind : undefined;
+		const pathsSeenInResult = new Set<string>();
+		for (const recordedPath of result.details.paths) {
+			if (typeof recordedPath !== "string" || recordedPath.trim().length === 0) continue;
+			const normalized = normalizedWorkspacePath(recordedPath, workspace);
+			if (normalized === null || pathsSeenInResult.has(normalized)) continue;
+			pathsSeenInResult.add(normalized);
+			const priorWrites = writeCounts.get(normalized) ?? 0;
+			writeCounts.set(normalized, priorWrites + 1);
+			writeIndex += 1;
+			lastByPath.set(normalized, {
+				path: recordedPath,
+				tool: payload.toolName,
+				...(artifactKind ? { artifactKind } : {}),
+				turnId: raw.turnId,
+				timestamp: raw.timestamp,
+				overwrites: priorWrites,
+				index: writeIndex,
+			});
+		}
+	}
+
+	return [...lastByPath.values()]
+		.sort((left, right) => right.index - left.index)
+		.map(({ index: _index, ...artifact }) => artifact);
+}
+
+/** Resolve a recorded, already-validated artifact path for loading. */
+export function resolveSessionArtifactPath(path: string, workspace: string): string | null {
+	return normalizedWorkspacePath(path, workspace);
+}