@iowarp/clio-coder 0.3.1 → 0.3.3

package/src/interactive/turn-persistence.ts

@@ -9,7 +9,8 @@ import type { ClioSettings } from "../core/config.js";
 import type { MiddlewareToolChoiceControl } from "../domains/middleware/index.js";
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import type { SessionTurnUsage } from "../domains/observability/trace-store.js";
-import type { SessionContract } from "../domains/session/contract.js";
+import type { SessionContract, TurnInput } from "../domains/session/contract.js";
+import type { ClioTurnRecord } from "../engine/session.js";
 import type { AgentEvent, AgentMessage, Usage } from "../engine/types.js";
 import {
 	type AssistantCallTiming,
@@ -98,6 +99,28 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 	const { state } = deps;
 	const persistedAssistantMessages = new WeakSet<object>();
 
+	// --- ledger appends -------------------------------------------------------
+	// Every turn this loop writes parents onto `state.lastTurnId`, the loop's own
+	// copy of the session leaf. session.append refuses a parent that is not the
+	// session's current leaf, and a refusal used to leave that copy stale, so
+	// every later submit failed the same way until the operator ran /resume.
+	// A stale copy has one known producer: a caller of resetForSession that
+	// passed a leaf captured before another turn landed. Whatever produced it,
+	// the right parent is the session's real leaf, so re-sync to it and append
+	// once more; a second refusal is a genuine session fault and propagates.
+	const appendTurn = (session: SessionContract, turn: Omit<TurnInput, "parentId">): ClioTurnRecord => {
+		try {
+			return session.append({ ...turn, parentId: state.lastTurnId } as TurnInput);
+		} catch (err) {
+			const current = session.current();
+			if (!current) throw err;
+			const leaf = session.tree(current.id).leafId;
+			if (leaf === state.lastTurnId) throw err;
+			state.lastTurnId = leaf;
+			return session.append({ ...turn, parentId: leaf } as TurnInput);
+		}
+	};
+
 	// --- trace mirror ---------------------------------------------------------
 	// One open runs/phases pair per operator turn, opened by the user row that
 	// starts the turn and closed by the assistant row that ends it. Every helper
@@ -227,9 +250,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			return;
 		}
 		if (message && typeof message === "object") persistedAssistantMessages.add(message as object);
-		const turn = deps.session.append({
+		const turn = appendTurn(deps.session, {
 			kind: "assistant",
-			parentId: state.lastTurnId,
 			payload,
 		});
 		state.lastTurnId = turn.id;
@@ -268,9 +290,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 				if (settings.orchestrator.model) input.model = settings.orchestrator.model;
 				deps.session.create(input);
 			}
-			const userTurn = deps.session.append({
+			const userTurn = appendTurn(deps.session, {
 				kind: "user",
-				parentId: state.lastTurnId,
 				payload: { text },
 			});
 			state.lastTurnId = userTurn.id;
@@ -282,9 +303,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 
 		appendToolCallTurn(event): void {
 			if (!deps.session) return;
-			const turn = deps.session.append({
+			const turn = appendTurn(deps.session, {
 				kind: "tool_call",
-				parentId: state.lastTurnId,
 				payload: {
 					toolCallId: event.toolCallId,
 					name: event.toolName,
@@ -318,9 +338,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			// instead of re-deriving it from result text.
 			if (event.outcome !== undefined) payload.outcome = event.outcome;
 			if (event.blockReason !== undefined) payload.blockReason = event.blockReason;
-			const turn = deps.session.append({
+			const turn = appendTurn(deps.session, {
 				kind: "tool_result",
-				parentId: state.lastTurnId,
 				payload,
 			});
 			state.lastTurnId = turn.id;
@@ -350,9 +369,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 
 		appendTerminalToolAssistantTurn(terminal): void {
 			if (!deps.session) return;
-			const turn = deps.session.append({
+			const turn = appendTurn(deps.session, {
 				kind: "assistant",
-				parentId: state.lastTurnId,
 				payload: {
 					text: "",
 					stopReason: "stop",
@@ -385,9 +403,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 				payload.synthetic = true;
 				payload.source = "middleware_request_continuation";
 			}
-			const userTurn = deps.session.append({
+			const userTurn = appendTurn(deps.session, {
 				kind: "user",
-				parentId: state.lastTurnId,
 				payload,
 			});
 			state.lastTurnId = userTurn.id;

package/src/interactive/turn-queues.ts

@@ -10,8 +10,20 @@
 import type { AgentMessage } from "../engine/types.js";
 import type { ChatTurnState } from "./turn-state.js";
 
+/** Which engine queue a queued message rides: the steering queue or the follow-up queue. */
 export type QueuedMessageKind = "steer" | "follow-up";
 
+/**
+ * Operator-chosen delivery point for a message submitted while a run is
+ * active. `next-slot` rides the steering queue and lands between tool batches,
+ * mid-run. `end-of-turn` rides the follow-up queue and lands when the whole run
+ * settles and the agent would hand control back. `interrupt` cancels the
+ * in-flight work and delivers now; it never enters a queue.
+ */
+export type SteeringMode = "interrupt" | "next-slot" | "end-of-turn";
+
+export const DEFAULT_STEERING_MODE: SteeringMode = "next-slot";
+
 export interface QueuedChatMessage {
 	text: string;
 	kind: QueuedMessageKind;

package/src/interactive/turn-recovery.ts

@@ -79,9 +79,10 @@ export interface TurnRecovery {
  * that landed in the same window wins: `activeInterruptReason` is set only by
  * `ChatLoop.cancel`, so the stall reason is dropped rather than retried.
  *
- * The failure's assistant message is rewritten in place because it is the same
- * object the ledger persists and the transcript renders; without it the turn
- * would read "[aborted] Request was aborted." instead of naming the stall.
+ * The runtime event seam calls `rewriteStallAbortMessage` before publishing or
+ * persisting `message_end`, so the provider's one terminal message becomes the
+ * corrected ledger row. This post-settlement pass covers engines that settle
+ * without emitting that event and consumes the watchdog reason in either case.
  */
 export function reclassifyStallAbort(
 	state: ChatTurnState,
@@ -90,14 +91,30 @@ export function reclassifyStallAbort(
 	const reason = state.streamStallReason;
 	state.streamStallReason = null;
 	if (reason === null || failure.stopReason !== "aborted" || state.activeInterruptReason !== null) return failure;
-	if (failure.message) {
-		const message = failure.message as { stopReason?: unknown; errorMessage?: unknown };
-		message.stopReason = "error";
-		message.errorMessage = reason;
-	}
+	if (failure.message) rewriteStallAbortMessage(state, failure.message, reason);
 	return { ...failure, stopReason: "error", errorMessage: reason };
 }
 
+/** Rewrite the provider's terminal abort object before its event is emitted and persisted. */
+export function rewriteStallAbortMessage(
+	state: ChatTurnState,
+	message: AgentMessage,
+	reason = state.streamStallReason,
+): boolean {
+	if (
+		reason === null ||
+		state.activeInterruptReason !== null ||
+		message.role !== "assistant" ||
+		(message as { stopReason?: unknown }).stopReason !== "aborted"
+	) {
+		return false;
+	}
+	const failure = message as { stopReason?: unknown; errorMessage?: unknown };
+	failure.stopReason = "error";
+	failure.errorMessage = reason;
+	return true;
+}
+
 export function createTurnRecovery(deps: TurnRecoveryDeps): TurnRecovery {
 	const { state, persistence, context } = deps;
 	let retryCountdown: RetryCountdownHandle | null = null;

package/src/interactive/turn-runtime.ts

@@ -11,7 +11,6 @@ import type { MiddlewareToolChoiceControl } from "../domains/middleware/index.js
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import {
 	applyModelCapabilityPatch,
-	firstRuntimeResolutionError,
 	modelResidencyForStatus,
 	type ProvidersContract,
 	refineRuntimeTargetWithModelHints,
@@ -35,6 +34,7 @@ import {
 	type AssistantCallTiming,
 	type BackendCacheVerdict,
 	backendCacheVerdict,
+	estimatedUsageForInterruptedTurn,
 	extractText,
 	extractThinking,
 	fallbackIdentityPrompt,
@@ -52,6 +52,22 @@ import type { AgentRuntime, ChatLoopTarget, ChatTurnState } from "./turn-state.j
 
 const LOCAL_API_KEY_FALLBACK = "clio-local-target";
 
+/**
+ * A turn that never started, with a machine-readable reason attached. The
+ * operator-facing message is unchanged prose; `reason` exists because the ACP
+ * server has to tell a client *why* Clio refused to admit the prompt, and
+ * parsing that out of the prose would bind a wire contract to a sentence.
+ */
+export class TurnAdmissionError extends Error {
+	constructor(
+		message: string,
+		readonly reason: string,
+	) {
+		super(message);
+		this.name = "TurnAdmissionError";
+	}
+}
+
 /**
  * Say that the first request will pay for a load, before it does.
  *
@@ -177,8 +193,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			requireOutputBudget: true,
 		});
 		if (!resolved.ok) {
-			const message = firstRuntimeResolutionError(resolved.diagnostics) ?? resolved.diagnostics[0]?.message;
-			throw new Error(`[Clio Coder] ${message ?? "orchestrator target resolution failed"}`);
+			const failure = resolved.diagnostics.find((entry) => entry.severity === "error") ?? resolved.diagnostics[0];
+			throw new TurnAdmissionError(
+				`[Clio Coder] ${failure?.message ?? "orchestrator target resolution failed"}`,
+				failure?.code ?? "admission-failed",
+			);
 		}
 		for (const message of runtimeResolutionWarnings(resolved.diagnostics)) {
 			const key = `${targetId}|${wireModelId}|${message}`;
@@ -331,8 +350,9 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		if (!target) return null;
 		context.emitContextWindowWarningTransition(target.runtimeResolution?.contextWindowDetails?.warning ?? null);
 		if (!deps.knownTargets().has(target.target.id)) {
-			throw new Error(
+			throw new TurnAdmissionError(
 				`[Clio Coder] orchestrator target=${target.target.id} unknown. Run \`clio-coder targets\` to see configured targets.`,
+				"target-unknown",
 			);
 		}
 		if (
@@ -400,6 +420,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			state.runtime.agent.abort();
 			cleanupSessionResources(state.runtime.agent.sessionId);
 		}
+		let getCurrentAgentSignal: () => AbortSignal | undefined = () => undefined;
 		const handle = deps.createAgent({
 			initialState: {
 				systemPrompt: fallbackIdentityPrompt(),
@@ -428,10 +449,16 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				if (!targetRequiresAuth(target.target, target.runtime)) {
 					return LOCAL_API_KEY_FALLBACK;
 				}
-				const resolved = await deps.providers.auth.resolveForTarget(target.target, target.runtime);
+				const signal = getCurrentAgentSignal();
+				const resolved = await deps.providers.auth.resolveForTarget(
+					target.target,
+					target.runtime,
+					signal ? { signal } : undefined,
+				);
 				return resolved.apiKey;
 			},
 		});
+		getCurrentAgentSignal = () => handle.agent.signal;
 
 		// Build the runtime object before subscribing so the callback closes
 		// over the same heap object the hot-swap path mutates. Reading
@@ -543,6 +570,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		// message of the run (prompts, assistant, tool results) via message_end,
 		// so the slice from here is the run's real message window.
 		let runStartMessageCount = 0;
+		// Estimated spend of each cancelled call, keyed by the engine's message
+		// object: message_end publishes it, agent_end re-reports it on the same
+		// object from agent state, and a suppressed hollow abort hands it to the
+		// closing turn. Weak so a settled run's messages are not retained.
+		const interruptedUsageByMessage = new WeakMap<object, Record<string, unknown>>();
 
 		handle.agent.subscribe(async (event) => {
 			// Wall anchor for the one field a human reads back (`recordedAt`);
@@ -608,7 +640,36 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 					enrichedEvent = { ...event, lockedSynthesisSanitized: true } as typeof event;
 				}
 			}
-			const publicEvent = enrichedEvent;
+			let publicEvent = enrichedEvent;
+			if (enrichedEvent.type === "message_end" && enrichedEvent.message?.role === "assistant") {
+				const interruptedUsage = estimatedUsageForInterruptedTurn(enrichedEvent.message, context.promptSideTokens());
+				if (interruptedUsage !== null) {
+					// Persistence records the same estimate, but it does so after the
+					// public event has already fed status. Copy it onto the public event
+					// only: the raw engine message and observability/cost path must remain
+					// provider-reported. Remember it by message identity so the public
+					// agent_end window below reports the same figure.
+					interruptedUsageByMessage.set(enrichedEvent.message as object, interruptedUsage);
+					publicEvent = {
+						...enrichedEvent,
+						message: { ...enrichedEvent.message, usage: interruptedUsage as unknown as Usage },
+					} as typeof enrichedEvent;
+				}
+			}
+			if (enrichedEvent.type === "agent_end") {
+				// The aborted message in the run window still carries the provider's
+				// untouched zeros. The footer's settled summary and the transcript's
+				// `turn · in/out` receipt both rebuild from this window, so give them
+				// the estimate the message_end published; the raw window feeds
+				// observability and the cache summary below unchanged.
+				const reported = enrichedEvent.messages.map((message) => {
+					const estimate = interruptedUsageByMessage.get(message as object);
+					return estimate === undefined ? message : ({ ...message, usage: estimate as unknown as Usage } as typeof message);
+				});
+				if (reported.some((message, index) => message !== enrichedEvent.messages[index])) {
+					publicEvent = { ...enrichedEvent, messages: reported } as typeof enrichedEvent;
+				}
+			}
 			if (publicEvent?.type === "agent_start") {
 				runStartMessageCount = localRuntime.agent.state.messages.length;
 				streamStartedAt = eventClock;
@@ -644,11 +705,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				if (hasDelta && firstAssistantDeltaAt === null) firstAssistantDeltaAt = eventClock;
 				if (hasDelta && apiCallFirstDeltaAt === null) apiCallFirstDeltaAt = eventClock;
 			}
-			if (publicEvent?.type === "agent_end") {
-				context.noteRunCacheSummary(publicEvent.messages, runFirstCallVerdict);
+			if (enrichedEvent.type === "agent_end") {
+				context.noteRunCacheSummary(enrichedEvent.messages, runFirstCallVerdict);
 			}
-			if (publicEvent?.type === "agent_end" && deps.observability) {
-				const summary = sumRunUsage(publicEvent.messages);
+			if (enrichedEvent.type === "agent_end" && deps.observability) {
+				const summary = sumRunUsage(enrichedEvent.messages);
 				if (summary.hadUsage && (summary.tokens > 0 || summary.costUsd > 0)) {
 					deps.observability.recordTokens(
 						localRuntime.targetId,
@@ -687,9 +748,15 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 			// persistence does.
 			if (
 				state.activeInterruptReason !== null &&
-				publicEvent?.type === "message_end" &&
-				isEmptyAbortedAssistantMessage(publicEvent.message)
+				enrichedEvent.type === "message_end" &&
+				isEmptyAbortedAssistantMessage(enrichedEvent.message)
 			) {
+				// The ledger drops this message too, so the spend the cancelled call
+				// streamed as thinking would otherwise vanish from the durable record.
+				// Hand it to the closing turn the interrupt persists when the run
+				// settles; the public agent_end window above still feeds status.
+				const estimate = interruptedUsageByMessage.get(enrichedEvent.message as object);
+				if (estimate !== undefined) state.interruptedUsage = estimate;
 				return;
 			}
 			if (publicEvent) deps.emit(publicEvent);

package/src/interactive/turn-state.ts

@@ -39,6 +39,7 @@ export interface AgentRuntime {
 
 export interface ChatLoopRunSnapshot {
 	targetId: string;
+	targetUrl: string | null;
 	runtimeId: string;
 	runtimeKind: RuntimeDescriptor["kind"];
 	wireModelId: string;
@@ -74,6 +75,14 @@ export interface ChatTurnState {
 	 * start of each submit.
 	 */
 	activeInterruptReason: string | null;
+	/**
+	 * Estimated spend of the cancelled call whose hollow aborted message the
+	 * interrupt suppressed (thinking streamed, no text). The message never reaches
+	 * the ledger, so the closing turn persisted in submit's finally carries this
+	 * instead of an estimate derived from its own notice text. Cleared with
+	 * `activeInterruptReason`.
+	 */
+	interruptedUsage: Record<string, unknown> | null;
 	/**
 	 * Loop-guard synthesis lockout: once the guard locks a turn, the remaining
 	 * model rounds are forced text-only at the request level (tool_choice none
@@ -108,6 +117,7 @@ export function createTurnState(initialThinkingLevel: ThinkingLevel): ChatTurnSt
 		replayedContextMessages: [],
 		activeUserTurnId: null,
 		activeInterruptReason: null,
+		interruptedUsage: null,
 		synthesisToolLock: false,
 		toolProseAbortReason: null,
 		streamStallReason: null,

package/src/interactive/view/artifacts.ts

@@ -1,6 +1,6 @@
 import { createReadStream, readFileSync, statSync } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import type { DispatchContract } from "../../domains/dispatch/contract.js";
 import {
 	isReceiptIntegrity,
@@ -31,6 +31,8 @@ import {
 	readPromptCompileManifest,
 	type SessionPromptCompileRecord,
 } from "../../domains/session/prompt-manifest.js";
+import { foldSessionArtifacts, resolveSessionArtifactPath } from "../../domains/session/session-artifacts.js";
+import { filterEntriesToActivePath } from "../../domains/session/tree/active-path.js";
 import { formatUsd } from "../footer/widgets.js";
 import { formatFooterTokens } from "../footer-panel.js";
 import { clockLocal } from "../format-time.js";
@@ -42,6 +44,7 @@ export type ViewArtifactCategory =
 	| "receipt"
 	| "dispatch"
 	| "task-ledger"
+	| "workspace"
 	| "tool-output"
 	| "protected-artifact"
 	| "compaction"
@@ -91,6 +94,7 @@ export const VIEW_ARTIFACT_CATEGORIES: readonly ViewArtifactCategory[] = [
 	"receipt",
 	"dispatch",
 	"task-ledger",
+	"workspace",
 	"tool-output",
 	"protected-artifact",
 	"compaction",
@@ -815,6 +819,8 @@ function renderTaskLedgerGoals(lines: string[], heading: string, goals: Readonly
 	for (const goal of goals) {
 		const parent = goal.parentGoalId ? ` parent ${goal.parentGoalId}` : "";
 		lines.push(`- [${goal.status}] ${goal.id} ${goal.title}${parent}`);
+		if (goal.origin) lines.push(`  - origin: ${goal.origin}`);
+		if (goal.userTaskId) lines.push(`  - operator task: ${goal.userTaskId}`);
 		if (goal.description) lines.push(`  - description: ${goal.description}`);
 	}
 }
@@ -842,6 +848,7 @@ function renderTaskLedgerMarkdown(entry: TaskLedgerEntry): string[] {
 		`- timestamp: ${entry.timestamp}`,
 		`- status: ${taskLedgerStatusSummary(entry)}`,
 	];
+	if (entry.boardId) lines.push(`- board id: ${entry.boardId}`);
 	renderTaskLedgerGoals(lines, "## Board Goals", entry.goals);
 	renderTaskLedgerGoals(lines, "## Subgoals", entry.subgoals);
 	lines.push("", "## Active Runs");
@@ -873,9 +880,24 @@ export class TaskLedgerArtifactProvider implements ArtifactProvider {
 				...(path ? { path } : {}),
 				searchText: [
 					entry.turnId,
+					entry.boardId ?? "",
 					...entry.activeRunIds,
-					...entry.goals.flatMap((goal) => [goal.id, goal.title, goal.description ?? "", goal.parentGoalId ?? ""]),
-					...entry.subgoals.flatMap((goal) => [goal.id, goal.title, goal.description ?? "", goal.parentGoalId ?? ""]),
+					...entry.goals.flatMap((goal) => [
+						goal.id,
+						goal.title,
+						goal.description ?? "",
+						goal.parentGoalId ?? "",
+						goal.origin ?? "agent",
+						goal.userTaskId ?? "",
+					]),
+					...entry.subgoals.flatMap((goal) => [
+						goal.id,
+						goal.title,
+						goal.description ?? "",
+						goal.parentGoalId ?? "",
+						goal.origin ?? "agent",
+						goal.userTaskId ?? "",
+					]),
 					...entry.requiredValidationEvidence.flatMap((item) => [
 						item.id,
 						item.description,
@@ -892,6 +914,93 @@ export class TaskLedgerArtifactProvider implements ArtifactProvider {
 	}
 }
 
+function workspaceArtifactFormat(path: string): ViewArtifactFormat {
+	const lower = path.toLowerCase();
+	return lower.endsWith(".md") || lower.endsWith(".markdown") ? "markdown" : "text";
+}
+
+class WorkspaceArtifactContainmentError extends Error {}
+
+async function canonicalWorkspaceArtifactPath(path: string, workspace: string): Promise<string> {
+	// Resolve both sides from the live filesystem for every load. The artifact
+	// row is durable, but neither an earlier lexical check nor an earlier realpath
+	// result is authority after a symlink has changed.
+	const canonicalWorkspace = await realpath(workspace);
+	const canonicalTarget = await realpath(path);
+	const rel = relative(canonicalWorkspace, canonicalTarget);
+	if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+		throw new WorkspaceArtifactContainmentError("canonical target is outside the recorded workspace");
+	}
+	return canonicalTarget;
+}
+
+async function loadWorkspaceArtifact(
+	path: string,
+	workspace: string,
+	recordedAt: string,
+): Promise<ViewArtifactLoadResult> {
+	try {
+		const canonicalPath = await canonicalWorkspaceArtifactPath(path, workspace);
+		const { lines } = await readTextFileLinesCapped(canonicalPath);
+		return { lines, format: workspaceArtifactFormat(path) };
+	} catch (error) {
+		const err = error as NodeJS.ErrnoException;
+		if (err.code === "ENOENT") {
+			return { lines: [`file no longer on disk (recorded at ${recordedAt})`], format: "text" };
+		}
+		if (error instanceof WorkspaceArtifactContainmentError) {
+			return { lines: [`refusing to read ${path}: ${error.message}`], format: "text" };
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		return { lines: [`unable to read ${path}: ${message}`], format: "text" };
+	}
+}
+
+/** Files successfully produced by artifact/write/edit on the active session branch. */
+export class WorkspaceArtifactProvider implements ArtifactProvider {
+	readonly category = "workspace" as const;
+	private readonly entries: ReadonlyArray<SessionEntry>;
+
+	constructor(private readonly deps: ArtifactProviderDeps) {
+		const entries = [...sessionEntries(deps)];
+		this.entries = filterEntriesToActivePath(entries, deps.sessionMeta?.pinnedLeafTurnId ?? undefined);
+	}
+
+	async list(): Promise<ViewArtifact[]> {
+		const workspace = this.deps.sessionMeta?.cwd;
+		if (!workspace) return [];
+		return foldSessionArtifacts(this.entries, { workspace }).flatMap((artifact) => {
+			const path = resolveSessionArtifactPath(artifact.path, workspace);
+			if (path === null) return [];
+			const kind = artifact.artifactKind ? ` · ${artifact.artifactKind}` : "";
+			const overwriteLabel = `${artifact.overwrites} overwrite${artifact.overwrites === 1 ? "" : "s"}`;
+			return [
+				{
+					id: `workspace:${path}`,
+					category: this.category,
+					title: safeTitle(`${artifact.path} · ${artifact.tool}${kind}`, artifact.path),
+					timestamp: parseTime(artifact.timestamp),
+					sizeBytes: maybeSizeBytes(path),
+					path,
+					description: `${artifact.tool}${kind} · ${overwriteLabel}`,
+					toolName: artifact.tool,
+					searchText: [
+						artifact.path,
+						path,
+						basename(path),
+						artifact.tool,
+						artifact.artifactKind ?? "",
+						overwriteLabel,
+						String(artifact.overwrites),
+						artifact.turnId,
+					].filter(isNonEmptyString),
+					load: () => loadWorkspaceArtifact(path, workspace, artifact.timestamp),
+				},
+			];
+		});
+	}
+}
+
 export class ToolOutputArtifactProvider implements ArtifactProvider {
 	readonly category = "tool-output" as const;
 
@@ -1310,6 +1419,7 @@ export function createDefaultArtifactProviders(deps: ArtifactProviderDeps): Arti
 		new ReceiptArtifactProvider(deps),
 		new DispatchArtifactProvider(deps),
 		new TaskLedgerArtifactProvider(deps),
+		new WorkspaceArtifactProvider(deps),
 		new ToolOutputArtifactProvider(deps),
 		new ProtectedArtifactProvider(deps),
 		new CompactionArtifactProvider(deps),

package/src/interactive/view/view-overlay.ts

@@ -109,6 +109,8 @@ function categoryLabel(category: ViewArtifactCategory): string {
 			return "Dispatch outputs";
 		case "task-ledger":
 			return "Task ledgers";
+		case "workspace":
+			return "Workspace outputs";
 		case "tool-output":
 			return "Tool outputs";
 		case "protected-artifact":
@@ -125,6 +127,7 @@ function categoryLabel(category: ViewArtifactCategory): string {
 const VIEW_ARTIFACT_CATEGORY_SET = new Set<ViewArtifactCategory>(VIEW_ARTIFACT_CATEGORIES);
 const BARE_CATEGORY_FILTERS = new Set<ViewArtifactCategory>([
 	"task-ledger",
+	"workspace",
 	"protected-artifact",
 	"compaction",
 	"prompt-manifest",

package/src/interactive/welcome-dashboard.ts

@@ -2,17 +2,16 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { ClioSettings } from "../core/config.js";
 import { readClioVersion } from "../core/package-root.js";
-import { EXPERIMENTAL_RELEASE_WARNING } from "../core/release.js";
+import { loadProjectClioMd } from "../domains/context/clio-md.js";
+import { readCodewiki, readCodewikiAsync } from "../domains/context/codewiki/artifact.js";
+import { renderCodewikiDigest } from "../domains/context/codewiki/digest.js";
+import { listWikiPages } from "../domains/context/wiki/layout.js";
 import {
-	listWikiPages,
-	readCodewiki,
-	readCodewikiAsync,
-	renderCodewikiDigest,
 	type WikiStaleness,
 	wikiCompleteness,
 	wikiStaleness,
 	wikiStalenessAsync,
-} from "../domains/context/index.js";
+} from "../domains/context/wiki/staleness.js";
 import type { TaskMemoryOperatorStatus } from "../domains/memory/index.js";
 import type { ObservabilityContract } from "../domains/observability/index.js";
 import {
@@ -172,7 +171,9 @@ function entryPointExcerpt(codewikiDigest: string): string[] {
 const NO_WIKI_STATUS = "no wiki; run clio-coder context wiki";
 
 function clioMdStatusFor(cwd: string): string {
-	return existsSync(join(cwd, "CLIO-CODER.md")) ? "ok" : "none";
+	const loaded = loadProjectClioMd(cwd);
+	if (loaded.errors.length > 0) return "malformed";
+	return loaded.files.length > 0 ? "ok" : "none";
 }
 
 /** Shape the wiki rows from a staleness verdict the caller already paid for. */
@@ -370,7 +371,10 @@ function nextValue(stats: WelcomeDashboardStats): string {
 /**
  * The launchpad has one fixed row per decision the operator needs to make.
  * Repository facts may replace text inside NEXT, never rows. After submission,
- * the session header is exactly one line for every width and fact state.
+ * the session header is exactly one line for every width and fact state, and
+ * it carries the same three facts in order: where Clio is working, which
+ * route answers, and what the context is ready for. Maturity caveats belong
+ * in the README, not in a line the operator reads on every turn.
  */
 export function buildWelcomeDashboardLines(
 	stats: WelcomeDashboardStats,
@@ -380,21 +384,18 @@ export function buildWelcomeDashboardLines(
 	const theme = clioTheme();
 	const safeWidth = Math.max(1, width);
 	const title = `${brandMark(theme)} ${theme.style("title", "Clio Coder", { bold: true })} ${theme.fg("dim", `v${readClioVersion()}`)}`;
-	const experimental = theme.style("warning", EXPERIMENTAL_RELEASE_WARNING, { bold: true });
 	const tag = (label: string): string => sectionTag(theme, "accentDeep", label, 9);
 	const row = (label: string, value: string): string => `  ${tag(label)}  ${value}`;
+	const workspace = theme.fg("muted", workspaceValue(stats));
+	const route = theme.fg(stats.currentAvailable ? "success" : "warning", routeValue(stats));
+	const next = theme.fg(stats.clioMdStatus === "ok" && !stats.factsPending ? "success" : "warning", nextValue(stats));
 
 	if (mode === "session") {
-		const header = `${title} · ${experimental} · ${theme.fg("muted", nextValue(stats))}`;
+		const header = [title, workspace, route, theme.fg("muted", nextValue(stats))].join(" · ");
 		return [truncateToWidth(header, safeWidth, GLYPH.ellipsis, true)];
 	}
 
-	const body = [
-		`  ${experimental}`,
-		row("WORKSPACE", theme.fg("muted", workspaceValue(stats))),
-		row("ROUTE", theme.fg(stats.currentAvailable ? "success" : "warning", routeValue(stats))),
-		row("NEXT", theme.fg(stats.clioMdStatus === "ok" && !stats.factsPending ? "success" : "warning", nextValue(stats))),
-	];
+	const body = [row("WORKSPACE", workspace), row("ROUTE", route), row("NEXT", next)];
 	if (safeWidth >= MID_MIN) return frame(theme, title, body, safeWidth);
 	return [title, ...body].map((line) => truncateToWidth(line, safeWidth, GLYPH.ellipsis, true));
 }