@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/interactive/welcome-dashboard.ts

@@ -4,7 +4,7 @@ import type { ContextState } from "../domains/context/index.js";
 import type { ProvidersContract, TargetStatus } from "../domains/providers/index.js";
 import { sanitizeCallTargetText } from "../domains/safety/call-target.js";
 import type { WorkspaceSnapshot } from "../domains/session/workspace/index.js";
-import { type Component, truncateToWidth, visibleWidth } from "../engine/tui.js";
+import { type Component, type Keybinding, truncateToWidth, visibleWidth } from "../engine/tui.js";
 import {
 	brandMark,
 	type ClioTheme,
@@ -15,6 +15,7 @@ import {
 	GLYPH,
 	padAnsi,
 } from "./theme/index.js";
+import { WELCOME_WORDMARK, WELCOME_WORDMARK_WIDE } from "./welcome-art.js";
 
 /**
  * What the route can honestly be said to be.
@@ -39,6 +40,8 @@ export type WelcomeProjectContextState = "checking" | "ok" | "stale" | "none" |
 
 export interface WelcomeDashboardDeps {
 	providers: Pick<ProvidersContract, "list">;
+	/** In-memory recipe inventory; excludes internal helper agents. */
+	getAgentCount?: () => number;
 	getSettings?: () => Readonly<ClioSettings>;
 	getWorkspaceSnapshot?: () => WorkspaceSnapshot | null;
 	/**
@@ -50,6 +53,8 @@ export interface WelcomeDashboardDeps {
 	getContextState?: (cwd: string) => ContextState;
 	/** Effective label for the submit binding; null when unbound or disabled. */
 	getSubmitKeyLabel?: () => string | null;
+	/** Effective shortcut labels; null hides an unbound action. */
+	getKeyLabel?: (action: Keybinding) => string | null;
 	/** Called when an off-render refresh lands, so the frame owner can ask for one. */
 	onFactsRefreshed?: () => void;
 	/**
@@ -74,6 +79,9 @@ export interface WelcomeDashboardStats {
 	projectContext: WelcomeProjectContextState;
 	/** Null in session mode: the collapsed row prints no key hint. */
 	submitKeyLabel: string | null;
+	autonomy: string;
+	targets: string;
+	fleet: string;
 }
 
 export type WelcomeDashboardMode = "launchpad" | "session";
@@ -299,7 +307,7 @@ function routeGlyph(route: WelcomeRouteState): string {
  * back to the route alone; the action row still names the fault there.
  */
 function routeRow(theme: ClioTheme, stats: WelcomeDashboardStats, room: number): string {
-	const target = plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel));
+	const target = plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel, { abbreviate: false }));
 	if (stats.route === "unset") return theme.fg("warning", truncateToWidth(target, room, GLYPH.ellipsis, false));
 	const token = routeToken(stats.route);
 	// A glyph rather than a word, so the verdicts stay distinct with no color.
@@ -351,37 +359,6 @@ function actionRow(theme: ClioTheme, stats: WelcomeDashboardStats, room: number)
 	return say("dim", ["describe a task", send, "/ for commands"].filter((part) => part !== null).join(" · "));
 }
 
-/**
- * The masthead: identity flush left, workspace flush right, a frame-colored rule
- * between them. Exactly one line at every width. The identity gives up its
- * version before its name, because `Clio Coder` identifies the tool and `v0.4.7`
- * only dates it, and gives up its name before its wordmark.
- */
-function mastheadRow(theme: ClioTheme, stats: WelcomeDashboardStats, version: string, width: number): string {
-	const mark = brandMark(theme);
-	const name = theme.style("title", "Clio Coder", { bold: true });
-	const identities = [`${mark} ${name} ${theme.fg("dim", `v${version}`)}`, `${mark} ${name}`, mark];
-	for (const identity of identities) {
-		const identityWidth = visibleWidth(identity);
-		// one space, at least two fill columns, one space
-		const room = width - identityWidth - 4;
-		if (room < 6) continue;
-		const workspace = workspaceLabel(theme, stats, room);
-		if (workspace.length === 0) continue;
-		const fill = width - identityWidth - visibleWidth(workspace) - 2;
-		if (fill < 2) continue;
-		return `${identity} ${theme.fg("frame", "─".repeat(fill))} ${workspace}`;
-	}
-	// Too narrow to pair them. The wordmark holds column 0 and the workspace takes
-	// what is left; below that, the wordmark alone.
-	const markWidth = visibleWidth(mark);
-	if (width >= markWidth + 3) {
-		const workspace = workspaceLabel(theme, stats, width - markWidth - 1);
-		if (workspace.length > 0) return `${mark} ${workspace}`;
-	}
-	return truncateToWidth(mark, width, "", false);
-}
-
 /**
  * The collapsed session header: one live line naming where Clio is working and
  * which route answers.
@@ -401,7 +378,10 @@ function sessionRow(theme: ClioTheme, stats: WelcomeDashboardStats, version: str
 	const branch = workspaceBranch(stats);
 	const units: Unit[] = [
 		{ text: `${theme.style("title", "Clio Coder", { bold: true })} ${theme.fg("dim", `v${version}`)}`, rank: 3 },
-		{ text: theme.fg("muted", plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel))), rank: 0 },
+		{
+			text: theme.fg("muted", plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel, { abbreviate: false }))),
+			rank: 0,
+		},
 		{ text: theme.fg("muted", fitPathTail(workspacePath(stats), Math.max(8, Math.floor(room * 0.5)))), rank: 1 },
 		...(branch
 			? [
@@ -415,29 +395,165 @@ function sessionRow(theme: ClioTheme, stats: WelcomeDashboardStats, version: str
 	return `${mark} ${fitByPriority(theme, units, room)}`;
 }
 
-/**
- * Three rows in launchpad mode and one in session mode, at every width and in
- * every fact state. The row count never moves, because the banner sits at line 0
- * and a height change there forces pi-tui to clear and repaint the whole buffer
- * once the transcript has scrolled — and because a header that grows a row when
- * a probe lands makes the first seconds of a session jump.
- */
+function shortNames(names: string[]): string {
+	return names.slice(0, 3).map(plainOneLine).join(", ") + (names.length > 3 ? ` +${names.length - 3}` : "");
+}
+
+/** Inventory is configuration plus existing observations; rendering never probes. */
+function inventory(
+	settings: Readonly<ClioSettings> | undefined,
+	statuses?: ReadonlyArray<TargetStatus>,
+	agentCount?: number,
+): { targets: string; fleet: string } {
+	const configured = settings?.targets ?? statuses?.map((status) => status.target) ?? [];
+	const ready = statuses?.filter((status) => status.available && status.health.status === "healthy").length ?? 0;
+	const down = statuses?.filter((status) => !status.available || status.health.status === "down").length ?? 0;
+	const degraded = statuses?.filter((status) => status.available && status.health.status === "degraded").length ?? 0;
+	const targets =
+		configured.length === 0
+			? "None configured · /settings targets"
+			: [
+					`${configured.length} configured`,
+					...(ready ? [`${ready} ready`] : []),
+					...(degraded ? [`${degraded} degraded`] : []),
+					...(down ? [`${down} unavailable`] : []),
+					shortNames(configured.map((target) => target.id)),
+				].join(" · ");
+	const profiles = Object.keys(settings?.fleet?.profiles ?? {});
+	const rosters = Object.keys(settings?.fleet?.rosters ?? {});
+	const fleet =
+		[
+			...(agentCount === undefined ? [] : [`${agentCount} agent recipes`]),
+			...(rosters.length ? [`Rosters: ${shortNames(rosters)}`] : profiles.length ? [`${profiles.length} profiles`] : []),
+		].join(" · ") || "Uses main model · /agents to explore";
+	return { targets, fleet };
+}
+
+const WELCOME_HINT_INTERVAL_MS = 15_000;
+const WELCOME_HINT_MIN_WIDTH = 160;
+
+const WELCOME_HINTS: ReadonlyArray<{
+	title: string;
+	commands: ReadonlyArray<readonly [string, string]>;
+	keys: ReadonlyArray<readonly [Keybinding, string]>;
+}> = [
+	{
+		title: "Make Clio yours",
+		commands: [
+			["/model", "Choose a model and target"],
+			["/library", "Browse skills and extensions"],
+			["/help", "Explore commands and shortcuts"],
+		],
+		keys: [
+			["tui.input.newLine", "New line"],
+			["clio-coder.model.select", "Model picker"],
+			["clio-coder.editor.external", "Open your external editor"],
+		],
+	},
+	{
+		title: "Know your workspace",
+		commands: [
+			["/context", "Inspect the active context"],
+			["/fleet", "Explore your agent fleet"],
+			["/help", "Find a command by name"],
+		],
+		keys: [
+			["clio-coder.files.toggle", "Browse files"],
+			["clio-coder.status.toggle", "Cycle dashboard pages"],
+			["clio-coder.session.tree", "Explore the session tree"],
+		],
+	},
+	{
+		title: "Keep work moving",
+		commands: [
+			["/skills", "See available skills"],
+			["/model", "Switch the active model"],
+			["/help", "Look up a shortcut"],
+		],
+		keys: [
+			["clio-coder.dispatchBoard.toggle", "Open the worker board"],
+			["clio-coder.tasks.open", "Open tasks"],
+			["clio-coder.thinking.cycle", "Cycle thinking effort"],
+		],
+	},
+];
+
+function welcomeHints(theme: ClioTheme, page: number, getKeyLabel?: WelcomeDashboardDeps["getKeyLabel"]): string[] {
+	const hint = WELCOME_HINTS[page % WELCOME_HINTS.length];
+	if (!hint) return [];
+	const keys = hint.keys.flatMap(([action, description]) => {
+		const label = getKeyLabel?.(action);
+		return label ? [`${theme.fg("accent", label)}  ${theme.fg("muted", description)}`] : [];
+	});
+	return [
+		theme.style("accent", hint.title, { bold: true }) +
+			theme.fg("dim", `  ${(page % WELCOME_HINTS.length) + 1}/${WELCOME_HINTS.length}`),
+		"",
+		...hint.commands.map(([command, description]) => `${theme.fg("accent", command)}  ${theme.fg("muted", description)}`),
+		"",
+		...(keys.length ? [theme.fg("dim", "Keyboard shortcuts"), ...keys] : []),
+	];
+}
+
+/** Shared by the instant shell and hydrated UI: one stable, framed welcome. */
 function buildWelcomeDashboardLines(
 	stats: WelcomeDashboardStats,
 	version: string,
 	width: number,
 	mode: WelcomeDashboardMode,
+	hintPage = 0,
+	getKeyLabel?: WelcomeDashboardDeps["getKeyLabel"],
 ): string[] {
 	const theme = clioTheme();
 	const safeWidth = Math.max(1, width);
 	if (mode === "session") return [padAnsi(sessionRow(theme, stats, version, safeWidth), safeWidth)];
-	const indent = safeWidth >= 12 ? "  " : "";
-	const room = Math.max(1, safeWidth - indent.length);
+	const panelWidth = safeWidth;
+	const room = Math.max(1, panelWidth - 4);
+	const frame = (text: string) => theme.fg("frame", text);
+	const row = (text: string) =>
+		`${frame("│")} ${padAnsi(truncateToWidth(text, room, GLYPH.ellipsis, false), room)} ${frame("│")}`;
+	const rule = (left: string, right: string) => frame(`${left}${"─".repeat(Math.max(0, panelWidth - 2))}${right}`);
+	const title = ` Clio Coder v${version} `;
+	const heading = `${frame("╭─")}${theme.fg("muted", title)}${frame(`${"─".repeat(Math.max(0, panelWidth - visibleWidth(title) - 3))}╮`)}`;
+	const wordmark = panelWidth >= 100 ? WELCOME_WORDMARK_WIDE : WELCOME_WORDMARK;
+	const sideBySide = panelWidth >= 76;
+	const artWidth = sideBySide ? visibleWidth(wordmark[0] ?? "") : 0;
+	const showHints = panelWidth >= WELCOME_HINT_MIN_WIDTH;
+	const contentWidth = showHints ? Math.min(132, Math.floor((room - 3) * 0.58)) : room;
+	const hintWidth = room - contentWidth - 3;
+	const hints = showHints ? welcomeHints(theme, hintPage, getKeyLabel) : [];
+	const detailWidth = sideBySide ? contentWidth - artWidth - 3 : contentWidth;
+	const field = (label: string, value: string) => `${theme.fg("dim", `${label}  `)}${value}`;
+	const details = [
+		sideBySide
+			? theme.fg("muted", "Built for the code behind science.")
+			: theme.style("title", "CLIO CODER", { bold: true }),
+		sideBySide ? "" : theme.fg("muted", "Built for the code behind science."),
+		theme.fg("dim", "Model"),
+		routeRow(theme, stats, detailWidth),
+		field("Workspace", workspaceLabel(theme, stats, Math.max(1, detailWidth - 11))),
+		field("Permissions", theme.fg(stats.autonomy === "full-auto" ? "warning" : "muted", stats.autonomy)),
+		theme.fg("dim", "Ask Clio how to use or extend her."),
+		theme.fg("dim", "Targets"),
+		theme.fg("muted", stats.targets),
+		theme.fg("dim", "Fleet"),
+		theme.fg("muted", stats.fleet),
+	];
 	return [
-		mastheadRow(theme, stats, version, safeWidth),
-		`${indent}${routeRow(theme, stats, room)}`,
-		`${indent}${actionRow(theme, stats, room)}`,
-	].map((line) => padAnsi(line, safeWidth));
+		heading,
+		...details.map((detail, index) => {
+			const art = sideBySide ? `${theme.fg("accent", wordmark[index] ?? "")}   ` : "";
+			const content = `${art}${truncateToWidth(detail, detailWidth, GLYPH.ellipsis, false)}`;
+			return row(
+				showHints
+					? `${padAnsi(content, contentWidth)} ${frame("│")} ${truncateToWidth(hints[index] ?? "", hintWidth, GLYPH.ellipsis, false)}`
+					: content,
+			);
+		}),
+		rule("├", "┤"),
+		row(actionRow(theme, stats, room)),
+		rule("╰", "╯"),
+	].map((line) => padAnsi(truncateToWidth(line, safeWidth, GLYPH.ellipsis, false), safeWidth));
 }
 
 /**
@@ -458,6 +574,9 @@ function statsSignature(stats: WelcomeDashboardStats): string {
 		stats.routeReason,
 		stats.projectContext,
 		stats.submitKeyLabel,
+		stats.autonomy,
+		stats.targets,
+		stats.fleet,
 	].join("\0");
 }
 
@@ -481,6 +600,7 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 	private disposed = false;
 	private mode: WelcomeDashboardMode = "launchpad";
 	private readonly now: () => number;
+	private hintStartedAt: number;
 	private readonly schedule: (run: () => void) => void;
 	/**
 	 * Read once, here, rather than inside a frame: resolving it walks up for
@@ -491,6 +611,7 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 
 	constructor(private readonly deps: WelcomeDashboardDeps) {
 		this.now = deps.now ?? ((): number => Date.now());
+		this.hintStartedAt = this.now();
 		this.schedule =
 			deps.scheduleRefresh ??
 			((run: () => void): void => {
@@ -505,10 +626,19 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 
 	render(width: number): string[] {
 		const stats = this.stats();
-		const signature = `${this.mode}\0${statsSignature(stats)}`;
+		// Existing presentation refreshes advance the hints; no extra timer or startup work.
+		const hintPage =
+			this.mode === "launchpad" && width >= WELCOME_HINT_MIN_WIDTH
+				? Math.floor(Math.max(0, this.now() - this.hintStartedAt) / WELCOME_HINT_INTERVAL_MS) % WELCOME_HINTS.length
+				: 0;
+		const shortcutSignature =
+			this.mode === "launchpad" && width >= WELCOME_HINT_MIN_WIDTH
+				? WELCOME_HINTS[hintPage]?.keys.map(([action]) => this.deps.getKeyLabel?.(action)).join("|")
+				: "";
+		const signature = `${this.mode}\0${statsSignature(stats)}\0${hintPage}\0${shortcutSignature}`;
 		const cached = this.cachedRender;
 		if (cached !== null && cached.width === width && cached.signature === signature) return cached.lines;
-		const lines = buildWelcomeDashboardLines(stats, this.version, width, this.mode);
+		const lines = buildWelcomeDashboardLines(stats, this.version, width, this.mode, hintPage, this.deps.getKeyLabel);
 		this.cachedRender = { width, signature, lines };
 		return lines;
 	}
@@ -525,6 +655,7 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 	resetToLaunchpad(): boolean {
 		if (this.mode === "launchpad") return false;
 		this.mode = "launchpad";
+		this.hintStartedAt = this.now();
 		this.cachedRender = null;
 		return true;
 	}
@@ -575,6 +706,8 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 			routeReason,
 			projectContext: launchpad ? this.projectContext(cwd) : "checking",
 			submitKeyLabel: launchpad ? (this.deps.getSubmitKeyLabel?.() ?? null) : null,
+			autonomy: settings?.safety?.autonomy ?? "auto-edit",
+			...inventory(settings, statuses, this.deps.getAgentCount?.()),
 		};
 	}
 
@@ -652,3 +785,30 @@ export class WelcomeDashboard implements WelcomeDashboardComponent {
 export function createWelcomeDashboard(deps: WelcomeDashboardDeps): WelcomeDashboard {
 	return new WelcomeDashboard(deps);
 }
+
+/** Same welcome geometry before hydration, using only the settings already read. */
+export function createBootWelcome(
+	settings: Readonly<ClioSettings>,
+	submitKeyLabel: string | null,
+	getKeyLabel?: WelcomeDashboardDeps["getKeyLabel"],
+): Component {
+	const target = settings.targets.find((entry) => entry.id === settings.chat.target);
+	const model = settings.chat.model ?? target?.defaultModel ?? null;
+	const version = readClioVersion();
+	const stats: WelcomeDashboardStats = {
+		cwd: process.cwd(),
+		workspace: null,
+		targetLabel: settings.chat.target ?? null,
+		modelLabel: model,
+		route: target && model ? "checking" : "unset",
+		routeReason: null,
+		projectContext: "checking",
+		submitKeyLabel,
+		autonomy: settings.safety.autonomy,
+		...inventory(settings),
+	};
+	return {
+		render: (width) => buildWelcomeDashboardLines(stats, version, width, "launchpad", 0, getKeyLabel),
+		invalidate: () => {},
+	};
+}

package/src/interactive/worker-replay.ts

@@ -46,6 +46,8 @@ export function workerRunEntryFields(state: WorkerEntryState): WorkerRunEntryFie
 	const { assignmentId, runId, origin, agentId, runtime, parentToolCallId } = state;
 	return {
 		kind: "workerRun",
+		...(state.helper ? { helper: true as const } : {}),
+		...(state.task !== undefined ? { task: state.task } : {}),
 		assignmentId,
 		runId,
 		origin,
@@ -96,6 +98,8 @@ export function workerEntriesFromRunEntries(
 			assignmentId,
 			runId: last.runId,
 			origin: last.origin,
+			...(last.helper ? { helper: true as const } : {}),
+			...(last.task !== undefined ? { task: last.task } : {}),
 			agentId: last.agentId,
 			runtime: last.runtime,
 			text: bounded.text,

package/src/interactive/worker-stream.ts

@@ -115,7 +115,17 @@ export interface WorkerReceiptFacts extends WorkerReceiptSummary {
 /** Reads `receipts/<runId>.json` and projects it; null when it is absent or unreadable. */
 export type WorkerReceiptReader = (runId: string) => WorkerReceiptFacts | null;
 
+/** Presentation follows the admitted audience, never a recipe name. */
+export function isHelperRun(run: { agentAudience?: DispatchStartedPayload["agentAudience"] }): boolean {
+	return run.agentAudience === "shadow" || run.agentAudience === "internal";
+}
+
 export interface WorkerEntryState {
+	/** Local presentation clock; never restored as a live timer from a receipt. */
+	startedAtMs?: number;
+	/** Compact agent-to-agent presentation, selected from the admitted audience. */
+	helper?: true;
+	task?: string;
 	assignmentId: string;
 	/** Current attempt's run id. */
 	runId: string;
@@ -323,6 +333,7 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 				existing.runId = runId;
 				existing.runtime = runtime;
 				existing.pending = true;
+				existing.startedAtMs = Date.now();
 				delete existing.receipt;
 				existing.attempts.push({ runId, targetLabel: workerTargetLabel(runtime) });
 				assignmentByRun.set(runId, assignmentId);
@@ -333,19 +344,23 @@ export function createWorkerStream(options: WorkerStreamOptions = {}): WorkerStr
 				}
 				return { kind: "updated", entry: existing };
 			}
-			if (payload.requestOrigin !== "user" && payload.requestOrigin !== "agent") return null;
+			const helper = isHelperRun(payload);
+			if (!helper && payload.requestOrigin !== "user" && payload.requestOrigin !== "agent") return null;
 			attemptByAssignment.set(assignmentId, payload.attempt);
 			const progress = createWorkerProgressFold();
 			const entry: WorkerEntryState = {
 				assignmentId,
 				runId,
-				origin: payload.requestOrigin,
+				origin: payload.requestOrigin === "user" ? "user" : "agent",
+				...(helper ? { helper: true as const } : {}),
+				...(payload.task ? { task: payload.task } : {}),
 				agentId: payload.agentId,
 				runtime,
 				text: "",
 				droppedLines: 0,
 				tools: [],
 				progress: progress.snapshot(),
+				startedAtMs: Date.now(),
 				attempts: [{ runId, targetLabel: workerTargetLabel(runtime) }],
 				pending: true,
 				...(payload.council !== undefined ? { council: { ...payload.council } } : {}),

package/src/tools/agent-tools.ts

@@ -21,6 +21,7 @@ import type { TSchema } from "typebox";
 import { type SkillActivation, skillActivationFromToolDetails } from "../core/skill-activation.js";
 import type { ToolName } from "../core/tool-names.js";
 import { ToolNames } from "../core/tool-names.js";
+import { type TurnConstraints, turnAllowsTool } from "../core/turn-constraints.js";
 import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
 import { type CallActionDescriptor, describeCallAction } from "../domains/safety/call-target.js";
 import type { SafetyDecision } from "../domains/safety/contract.js";
@@ -88,6 +89,12 @@ export interface ToolFinishEvent {
 	reason?: string;
 	actionClass?: string;
 	decision?: "allowed" | "blocked" | "permission_requested";
+	/**
+	 * The blocked call had parked for approval and the park was answered without
+	 * one (`RegistryVerdict.deniedPark`). `decision` still says `blocked` for it,
+	 * as it always has; this says the block was a refused ask.
+	 */
+	deniedPark?: true;
 	ruleId?: string;
 	reasonCode?: string;
 	policySource?: string;
@@ -96,6 +103,7 @@ export interface ToolFinishEvent {
 
 export interface ResolveAgentToolsInput {
 	registry: ToolRegistry;
+	turnConstraints?: TurnConstraints;
 	allowedTools?: ReadonlyArray<ToolName>;
 	toolProfile?: ToolProfileName;
 	agentId?: string;
@@ -197,6 +205,7 @@ async function runValidatedToolCall(input: RunValidatedToolCallInput): Promise<W
 			...withCallId,
 			reason: verdict.reason,
 			...(verdict.kind === "blocked" ? { decision: verdict.decision } : {}),
+			...(verdict.kind === "blocked" && verdict.deniedPark === true ? { deniedPark: true } : {}),
 		});
 		// The model sees only this thrown message. The short verdict reason
 		// starves the next turn of the policy's why and how-to-recover, so
@@ -251,6 +260,7 @@ function emitFinish(
 		reason?: string;
 		terminate?: boolean;
 		decision?: SafetyDecision;
+		deniedPark?: true;
 		skillActivation?: SkillActivation;
 		toolCallId?: string;
 	},
@@ -265,6 +275,7 @@ function emitFinish(
 	if (extra?.toolCallId !== undefined) event.toolCallId = extra.toolCallId;
 	if (extra?.reason !== undefined) event.reason = extra.reason;
 	if (extra?.terminate === true) event.terminate = true;
+	if (extra?.deniedPark === true) event.deniedPark = true;
 	if (extra?.decision !== undefined) {
 		event.actionClass = extra.decision.classification.actionClass;
 		const permissionWasRequired =
@@ -387,7 +398,14 @@ export function resolveAgentTools(input: ResolveAgentToolsInput): AgentTool[] {
 		if (spec && toolSpecPlacement(spec) === "direct") specs.push(spec);
 	}
 	specs.sort((a, b) => a.name.localeCompare(b.name));
-	return specs.map((spec) => toAgentTool(spec, input.registry, input.telemetry, input.invokeOptions));
+	// Bind the same immutable ceiling to execution as to schema selection.
+	// Hiding a schema alone does not protect a retained tool handle or nested call.
+	const invokeOptions = () => ({
+		...input.invokeOptions?.(),
+		...(input.turnConstraints ? { turnConstraints: input.turnConstraints } : {}),
+		...(input.allowedTools ? { allowedTools: input.allowedTools } : {}),
+	});
+	return specs.map((spec) => toAgentTool(spec, input.registry, input.telemetry, invokeOptions));
 }
 
 /**
@@ -415,6 +433,7 @@ export function effectiveToolNames(input: Omit<ResolveAgentToolsInput, "telemetr
 	const includeInteractiveTools = input.includeInteractiveTools !== false;
 	const names: ToolName[] = [];
 	for (const name of new Set(toolIds)) {
+		if (!turnAllowsTool(input.turnConstraints, name)) continue;
 		// Orchestrator-only tools. Workers resolve their full surface once at
 		// admission, so neither operator interviews nor self-activation apply.
 		if (!includeInteractiveTools && name === ToolNames.AskUser) continue;
@@ -471,6 +490,8 @@ export function resolveSessionTools(
 ): AgentTool[] {
 	if (!toolRegistry || runtime.runtimeResolution.capabilityDecisions.tools !== true) return [];
 	const input: ResolveAgentToolsInput = { registry: toolRegistry };
+	const constraints = invokeOptions?.().turnConstraints;
+	if (constraints) input.turnConstraints = constraints;
 	input.invokeOptions = () => ({
 		...invokeOptions?.(),
 		supportsImages: runtime.runtimeResolution.capabilityDecisions.vision === true,

package/src/tools/builtin-tool-catalog.ts

@@ -101,7 +101,7 @@ const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 			"Use code_nav with source=workspace (default) for project code and source=clio for Clio's shipped code map; modes: symbol, path, entries, outline, deps, dependents, wiki (workspace only).",
 	},
 	[ToolNames.Context]: {
-		objective: "Return workspace, skill, or recall context.",
+		objective: "Return workspace, effective configuration, skill, or recall context.",
 		uiLabel: "Context",
 		retrySafety: "idempotent",
 		resultSizePolicy: observePolicy(
@@ -111,7 +111,7 @@ const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 		costLatency: "local_fast",
 		promptHint: {
 			session:
-				'On an explicit pending skill request, first load exactly that skill with context(scope="skills", name=<skill>). Follow a [Marketplace] reminder\'s exact ask_user options. Recall needed [evicted ...] content with context(scope="recall", ref=...).',
+				'For questions about your settings or limits, call context(scope="settings") for the live values and UI guidance; never guess from defaults or change permission rules to bypass a denial. On an explicit pending skill request, first load exactly that skill with context(scope="skills", name=<skill>). Follow a [Marketplace] reminder\'s exact ask_user options. Recall needed [evicted ...] content with context(scope="recall", ref=...).',
 			worker:
 				'This worker has no operator skill-activation channel; do not load or suggest skills. Recall needed [evicted ...] content with context(scope="recall", ref=...).',
 			boundWorker:

package/src/tools/codewiki/code-nav.ts

@@ -104,7 +104,7 @@ async function loadNavSource(
 	source: CodeNavSource,
 ): Promise<{ ok: true; loaded: LoadedNavSource } | { ok: false; message: string }> {
 	if (source === "clio") return loadClioCodewikiForTool();
-	const loaded = await loadCodewikiForTool();
+	const loaded = await loadCodewikiForTool(process.cwd(), { readOnly: true });
 	return loaded.ok
 		? { ok: true, loaded: { codewiki: loaded.codewiki, entryRoot: null } }
 		: { ok: false, message: loaded.message };

package/src/tools/codewiki/shared.ts

@@ -1,6 +1,7 @@
 import { statSync } from "node:fs";
+import { resolve } from "node:path";
 import { codewikiPath, readCodewiki } from "../../domains/context/codewiki/artifact.js";
-import { coordinateCodewikiWrite } from "../../domains/context/codewiki/coordinator.js";
+import { coordinateCodewikiWrite, reconcileCodewikiCandidate } from "../../domains/context/codewiki/coordinator.js";
 import type { Codewiki } from "../../domains/context/codewiki/schema.js";
 import { readClioState, writeClioState } from "../../domains/context/state.js";
 
@@ -18,6 +19,15 @@ interface CodewikiArtifactCacheEntry {
 	codewiki: Codewiki;
 }
 
+const transientCodewikis = new Map<
+	string,
+	{
+		codewiki: Codewiki;
+		fingerprint: import("../../domains/context/fingerprint.js").Fingerprint;
+		identity: CodewikiArtifactIdentity | null;
+	}
+>();
+
 const codewikiArtifactCache = new Map<string, CodewikiArtifactCacheEntry>();
 
 function codewikiArtifactIdentity(cwd: string): CodewikiArtifactIdentity | null {
@@ -68,8 +78,36 @@ function readCodewikiForTool(cwd: string): Codewiki | null {
 
 export async function loadCodewikiForTool(
 	cwd: string = process.cwd(),
+	options: { readOnly?: boolean } = {},
 ): Promise<{ ok: true; codewiki: Codewiki } | { ok: false; message: string }> {
 	try {
+		if (options.readOnly) {
+			const workspace = resolve(cwd);
+			const identity = codewikiArtifactIdentity(workspace);
+			const cached = transientCodewikis.get(workspace);
+			const sameDisk =
+				cached &&
+				(identity === null
+					? cached.identity === null
+					: cached.identity !== null && sameArtifactIdentity(identity, cached.identity));
+			const state = readClioState(workspace);
+			const current = sameDisk ? cached.codewiki : readCodewikiForTool(workspace);
+			const language = state?.projectType ?? current?.language;
+			const result = await reconcileCodewikiCandidate({
+				kind: "ensure",
+				cwd: workspace,
+				current,
+				previous: sameDisk ? cached.fingerprint : (state?.fingerprint ?? null),
+				...(language ? { language } : {}),
+			});
+			transientCodewikis.delete(workspace);
+			transientCodewikis.set(workspace, { codewiki: result.codewiki, fingerprint: result.fingerprint, identity });
+			while (transientCodewikis.size > CODEWIKI_ARTIFACT_CACHE_LIMIT) {
+				const oldest = transientCodewikis.keys().next().value;
+				if (oldest !== undefined) transientCodewikis.delete(oldest);
+			}
+			return { ok: true, codewiki: result.codewiki };
+		}
 		const generatedAt = new Date().toISOString();
 		const coordinated = await coordinateCodewikiWrite(
 			cwd,