one-code-extension 0.4.1 → 0.6.0

package/extensions/effort/index.ts

@@ -1,6 +1,10 @@
 /**
  * effort extension — Claude Code's `/effort`, including the `ultracode` stop.
  *
+ * Interactive low/medium/high/xhigh choices persist per model in pi's own
+ * settings (`modelThinkingLevels`); max and ultracode stay session-only. pi
+ * restores the saved level natively, so launch overrides and resume still win.
+ *
  * Reasoning effort is pi's thinking level under another name, and shift+tab
  * already cycles it. pi reserves that key (`app.thinking.cycle` is on its
  * RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS list, so `registerShortcut` on
@@ -17,10 +21,14 @@
  * same shape the permissions extension uses for plan mode.
  */
 
+import os from "node:os";
+import { join } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { effortSetMessage, isPersistedEffort, type PersistedEffort } from "./settings.ts";
+import { REMINDER_CHANNEL, RENDER_CHANNEL, type RenderRequest, stickyFact, toldBlockFact } from "../lib/reminders.ts";
+import { readState, recordState } from "../lib/ledger/state.ts";
 import { dimRightAlignedWidget, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
 import {
 	acceptedEffortArgs,
@@ -43,6 +51,9 @@ import {
 	ULTRACODE_STATUS_KEY,
 } from "./slider.ts";
 import { registerLocalCommand } from "../lib/local-command.ts";
+import { readWorkflowSettings } from "../lib/one-code-settings.ts";
+import { panelUi } from "../lib/panel-focus.ts";
+import { extendingCompletions } from "../lib/argument-hints.ts";
 
 /** The levels pi says the active model can reach; the full ladder when unknown. */
 function supportedLevels(ctx: ExtensionContext): ThinkingLevel[] {
@@ -70,6 +81,28 @@ const ULTRACODE_STANDING_REMINDER =
 	"Token cost is not the constraint here; the most exhaustive correct answer is. " +
 	"Work solo only on conversational turns and trivial mechanical edits.";
 
+/**
+ * Said once when ultracode is off while the model has read its standing block:
+ * the earlier messages keep the block in the record, so without this the model
+ * reads the opt-in as standing (lifecycle-grid-hunt round 3, R3-M21).
+ */
+const ULTRACODE_OFF_REMINDER =
+	"Ultracode mode is off now: the user's standing opt-in to multi-agent orchestration has ended. Run a workflow only when the task calls for one or the user asks.";
+/**
+ * The told key of the standing block: a request that carries its first
+ * delivery records the block's hash under it (system-reminder).
+ */
+const STANDING_TOLD_KEY = stickyFact({ key: REMINDER_KEY, text: "", since: 0 }).key;
+/**
+ * What the off notice tells, under the same key: the model last read "off".
+ * The standing block switched on again is then a first delivery once more,
+ * and a later off is told again only after that delivery.
+ */
+const OFF_TOLD = toldBlockFact(STANDING_TOLD_KEY, ULTRACODE_OFF_REMINDER);
+
+/** The `one-code:state` key ultracode is recorded under on the branch. */
+const ULTRACODE_STATE = "ultracode";
+
 export default function effortExtension(pi: ExtensionAPI) {
 	let ultracodeActive = false;
 	/**
@@ -109,15 +142,22 @@ export default function effortExtension(pi: ExtensionAPI) {
 	pi.on("session_start", cancelEffortNote);
 	pi.on("session_shutdown", cancelEffortNote);
 
-	const setUltracode = (on: boolean, level?: ThinkingLevel) => {
-		const changed = ultracodeActive !== on;
+	/** Whether workflows are on for this session, read with workflow's own settings at session start. */
+	let workflowsOn = true;
+	/** `record` false when the state comes from the branch itself (a resume, a /tree switch). */
+	const setUltracode = (on: boolean, level?: ThinkingLevel, { record = true }: { record?: boolean } = {}) => {
+		const changed = ultracodeActive !== on || (on && ultracodeLevel !== level);
 		ultracodeActive = on;
 		ultracodeLevel = on ? level : undefined;
 		if (changed) pi.events.emit(ULTRACODE_MODE_CHANNEL, { active: on });
-		if (on) {
+		// Ultracode follows the branch: recorded on every change.
+		if (changed && record) recordState(pi, ULTRACODE_STATE, on ? { on, level } : { on });
+		// With workflows turned off (enableWorkflows/disableWorkflows) the block's
+		// "run a workflow for every task" would steer to a tool the session does
+		// not offer, so ultracode is only its reasoning level there (R3-M21).
+		if (on && workflowsOn) {
 			pi.events.emit(REMINDER_CHANNEL, {
 				text: ULTRACODE_STANDING_REMINDER,
-				scope: "every-turn",
 				key: REMINDER_KEY,
 				placement: "sticky-append",
 			});
@@ -126,8 +166,40 @@ export default function effortExtension(pi: ExtensionAPI) {
 		}
 	};
 
+	// The off notice derives from what the epoch told, when a request goes out:
+	// only a model that read the standing block hears it ended, a switch off and
+	// on again before the request says nothing, and the notice's own told fact
+	// keeps a /reload or a resume from saying it twice.
+	pi.events.on(RENDER_CHANNEL, (data) => {
+		const request = data as RenderRequest;
+		if (request.epoch || ultracodeActive) return;
+		const told = request.toldBlocks.get(STANDING_TOLD_KEY);
+		if (told === undefined || told === OFF_TOLD.hash) return;
+		request.blocks.push({ text: ULTRACODE_OFF_REMINDER, facts: [OFF_TOLD] });
+	});
+
+	const canPersist = (ctx: ExtensionContext) => ctx.hasUI && (ctx.mode === "tui" || ctx.mode === "rpc") && !!ctx.model;
+	/** Through pi's own settings writer: its key format, file lock and merge of changed fields. */
+	const persist = async (ctx: ExtensionContext, level: PersistedEffort | undefined): Promise<string | undefined> => {
+		const settings = SettingsManager.create(ctx.cwd, getAgentDir());
+		const loadError = settings.drainErrors().find((entry) => entry.scope === "global");
+		// An unreadable file would be rewritten from empty settings; leave it for the user.
+		if (loadError) return `Failed to set effort level: ${loadError.error.message}`;
+		if (level === undefined) settings.removeModelThinkingLevel(ctx.model!.provider, ctx.model!.id);
+		else settings.setModelThinkingLevel(ctx.model!.provider, ctx.model!.id, level);
+		await settings.flush();
+		const writeError = settings.drainErrors()[0];
+		if (writeError) return `Failed to set effort level: ${writeError.error.message}`;
+	};
+	const report = (ctx: ExtensionContext, message: string, error = false) => {
+		ctx.ui.notify(message, error ? "error" : "info");
+		return message;
+	};
+
 	/** Apply a chosen stop and report what actually took effect. */
-	const applyChoice = (choice: EffortChoice, ctx: ExtensionContext) => {
+	const applyChoice = async (choice: EffortChoice, ctx: ExtensionContext, asDefault = true): Promise<string> => {
+		const wasUltracode = ultracodeActive;
+		const previous = pi.getThinkingLevel();
 		const wanted = thinkingLevelFor(choice);
 		pi.setThinkingLevel(wanted);
 		const actual = pi.getThinkingLevel();
@@ -144,13 +216,25 @@ export default function effortExtension(pi: ExtensionAPI) {
 		const cappedDown = ar >= 0 && wr >= 0 && ar < wr;
 		const note = cappedDown ? ` (${modelLabel(ctx)} tops out at ${actual})` : "";
 		if (choice === ULTRACODE) {
-			ctx.ui.notify(`Effort: ultracode — ${actual} reasoning, workflows armed every turn${note}`, "info");
-		} else {
-			ctx.ui.notify(`Effort: ${actual}${note}`, "info");
+			return report(ctx, `Effort: ultracode — ${actual} reasoning, workflows armed every turn${note}`);
+		}
+		const saved = asDefault && canPersist(ctx) && isPersistedEffort(choice) && actual === wanted;
+		if (saved) {
+			const error = await persist(ctx, choice);
+			if (error) {
+				// Claude Code changes nothing when the save fails.
+				pi.setThinkingLevel(previous);
+				setUltracode(wasUltracode, previous);
+				applyStatus(ctx);
+				showEffortNote(ctx, previous);
+				return report(ctx, error, true);
+			}
 		}
+		if (isPersistedEffort(actual) || actual === "max") return report(ctx, `${effortSetMessage(actual, saved)}${wasUltracode ? " · Ultracode off" : ""}`);
+		return report(ctx, `Effort: ${actual}${note}`);
 	};
 
-	const showSlider = async (ctx: ExtensionContext): Promise<void> => {
+	const showSlider = async (ctx: ExtensionContext): Promise<string | void> => {
 		const supported = supportedLevels(ctx);
 		if (!supported.some((level) => level !== "off")) {
 			ctx.ui.notify(`${modelLabel(ctx)} doesn't support reasoning effort.`, "info");
@@ -165,7 +249,7 @@ export default function effortExtension(pi: ExtensionAPI) {
 		index = nearestEnabled(index, enabled);
 
 		const label = modelLabel(ctx);
-		const chosen = await ctx.ui.custom<EffortChoice | null>((tui, theme, _keybindings, done) => {
+		const chosen = await panelUi(pi.events, ctx.ui).custom<{ choice: EffortChoice; asDefault: boolean } | null>((tui, theme, _keybindings, done) => {
 			const paint = safeThemePaint(theme);
 			return {
 				// The slider's own layout is column-safe for its ASCII labels, but this
@@ -180,8 +264,8 @@ export default function effortExtension(pi: ExtensionAPI) {
 						done(null);
 						return;
 					}
-					if (key === "confirm") {
-						done(EFFORT_CHOICES[index]);
+					if (key === "confirm" || key === "session") {
+						done({ choice: EFFORT_CHOICES[index], asDefault: key === "confirm" });
 						return;
 					}
 					index = moveIndex(index, key, enabled);
@@ -191,18 +275,32 @@ export default function effortExtension(pi: ExtensionAPI) {
 			};
 		});
 
-		if (chosen) applyChoice(chosen, ctx);
+		if (!chosen) return "Cancelled";
+		return applyChoice(chosen.choice, ctx, chosen.asDefault);
 	};
 
 	registerLocalCommand(pi, "effort", {
-		description: `Set reasoning effort (shift+tab cycles the plain levels): /effort [${EFFORT_CHOICES.join("|")}] — ultracode is ${ULTRACODE_LEVEL} + workflows`,
-		getArgumentCompletions: (prefix) => {
-			const matches = acceptedEffortArgs().filter((value) => value.startsWith(prefix.trim().toLowerCase()));
-			return matches.length ? matches.map((value) => ({ value, label: value })) : null;
-		},
+		description: `Set reasoning effort (shift+tab cycles the plain levels): /effort [${EFFORT_CHOICES.join("|")}|auto] — ultracode is ${ULTRACODE_LEVEL} + workflows`,
+		argumentHint: `[${EFFORT_CHOICES.join("|")}|auto]`,
+		reportsResult: true,
+		getArgumentCompletions: (prefix) => extendingCompletions(prefix, [...acceptedEffortArgs(), "auto", "unset"].map((value) => ({ value, label: value }))),
 		handler: async (args, ctx) => {
 			const typed = args.trim();
 			if (typed) {
+				if (typed.toLowerCase() === "auto" || typed.toLowerCase() === "unset") {
+					// Clear the saved level first: a failed save changes nothing.
+					const saved = canPersist(ctx);
+					if (saved) {
+						const error = await persist(ctx, undefined);
+						if (error) return report(ctx, error, true);
+					}
+					// getSettings arrived in pi 1.0.1; a 1.0.0 install falls back to pi's default.
+					pi.setThinkingLevel(pi.getSettings?.().defaultThinkingLevel ?? "medium");
+					setUltracode(false);
+					applyStatus(ctx);
+					showEffortNote(ctx, pi.getThinkingLevel());
+					return report(ctx, `Effort level set to auto${saved ? "" : " (this session only)"}`);
+				}
 				const parsed = parseEffortArg(typed);
 				if (!parsed) {
 					ctx.ui.notify(`Unknown effort "${typed}". Use one of: ${acceptedEffortArgs().join(", ")}`, "error");
@@ -220,20 +318,19 @@ export default function effortExtension(pi: ExtensionAPI) {
 						return;
 					}
 				}
-				applyChoice(parsed, ctx);
-				return;
+				return applyChoice(parsed, ctx);
 			}
 
 			// The picker needs focus and a terminal; elsewhere say what to type.
 			if (!ctx.hasUI || ctx.mode !== "tui") {
 				ctx.ui.notify(
 					`Current effort: ${ultracodeActive ? `ultracode (${pi.getThinkingLevel()} + workflows)` : pi.getThinkingLevel()}. ` +
-						`Set one with /effort <${acceptedEffortArgs().join("|")}>.`,
+						`Set one with /effort <${acceptedEffortArgs().join("|")}|auto>.`,
 					"info",
 				);
 				return;
 			}
-			await showSlider(ctx);
+			return await showSlider(ctx);
 		},
 	});
 
@@ -248,7 +345,26 @@ export default function effortExtension(pi: ExtensionAPI) {
 		showEffortNote(ctx, event.level);
 	});
 
-	pi.on("session_start", (_event, ctx) => {
+	/**
+	 * Take the branch's ultracode state (a resume, /reload, a fork, a /tree
+	 * switch). At a session start it is on only while pi's reasoning level,
+	 * which pi restores from the branch itself, is still the level ultracode
+	 * settled on (a launch `--thinking` flag wins). pi restores no level at a
+	 * /tree switch, so there the branch's level is put back with the mode.
+	 * When the branch's model read it on and it resolves off, the next request
+	 * tells it (the RENDER_CHANNEL listener above).
+	 */
+	const followBranch = (ctx: ExtensionContext, tree: boolean) => {
+		const stored = readState(ctx, ULTRACODE_STATE) as { on?: unknown; level?: unknown } | undefined;
+		const storedOn = stored?.on === true && typeof stored.level === "string";
+		const on = storedOn && (tree || stored.level === pi.getThinkingLevel());
+		setUltracode(on, on ? (stored?.level as ThinkingLevel) : undefined, { record: false });
+		if (on && tree && pi.getThinkingLevel() !== stored?.level) pi.setThinkingLevel(stored?.level as ThinkingLevel);
 		applyStatus(ctx);
+	};
+	pi.on("session_start", (_event, ctx) => {
+		workflowsOn = readWorkflowSettings(ctx.cwd, os.homedir()).enabled;
+		followBranch(ctx, false);
 	});
+	pi.on("session_tree", (_event, ctx) => followBranch(ctx, true));
 }

package/extensions/effort/settings.ts

@@ -0,0 +1,21 @@
+/** Which effort levels are saved, and the result text (pure, no pi imports). */
+
+const PERSISTED_LEVELS = ["low", "medium", "high", "xhigh"] as const;
+export type PersistedEffort = (typeof PERSISTED_LEVELS)[number];
+
+export function isPersistedEffort(level: string): level is PersistedEffort {
+	return (PERSISTED_LEVELS as readonly string[]).includes(level);
+}
+
+const DESCRIPTIONS: Record<string, string> = {
+	low: "Quick, straightforward implementation with minimal overhead",
+	medium: "Balanced approach with standard implementation and testing",
+	high: "Comprehensive implementation with extensive testing and documentation",
+	xhigh: "Deeper reasoning than high, just below maximum (on supported models)",
+	max: "Maximum capability with deepest reasoning. May use excessive tokens resulting in long response times or overthinking. Use sparingly for the hardest tasks.",
+};
+
+/** The ordinary local response, without organization or environment overrides. */
+export function effortSetMessage(level: PersistedEffort | "max", saved: boolean): string {
+	return `Set effort level to ${level} (${saved ? "saved as your default for new sessions" : "this session only"}): ${DESCRIPTIONS[level]}`;
+}

package/extensions/effort/slider.ts

@@ -18,6 +18,7 @@
  */
 
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { keyId, keyText } from "../lib/key-input.ts";
 
 /** The final stop on the track: top reasoning + workflows armed every turn. */
 export const ULTRACODE = "ultracode";
@@ -73,35 +74,38 @@ export function choiceForState(level: ThinkingLevel | undefined, ultracodeActive
 	return "medium";
 }
 
-export type SliderKey = "left" | "right" | "first" | "last" | "confirm" | "cancel";
+export type SliderKey = "left" | "right" | "first" | "last" | "confirm" | "session" | "cancel";
 
 /**
  * Decode a raw terminal chunk. `Component.handleInput` hands over bytes, not key
- * names, so the sequences are matched directly: CSI C/D for arrows (plus the
- * older SS3 form some terminals still send), CR/LF to confirm, ESC to cancel.
+ * names; `lib/key-input.ts` names them, so every terminal encoding of a key
+ * (legacy, kitty, modifyOtherKeys) decodes alike.
  */
 export function decodeKey(data: string): SliderKey | undefined {
-	switch (data) {
-		case "\x1b[C":
-		case "\x1bOC":
-		case "l":
+	switch (keyId(data)) {
+		case "right":
 			return "right";
-		case "\x1b[D":
-		case "\x1bOD":
-		case "h":
+		case "left":
 			return "left";
-		case "\x1b[H":
-		case "\x1b[1~":
+		case "home":
 			return "first";
-		case "\x1b[F":
-		case "\x1b[4~":
+		case "end":
 			return "last";
-		case "\r":
-		case "\n":
+		case "enter":
 			return "confirm";
-		case "\x1b":
-		case "\x03": // ctrl+c — same intent as escape while a picker is focused
+		case "escape":
+		case "ctrl+c": // same intent as escape while a picker is focused
 			return "cancel";
+		default:
+			break;
+	}
+	switch (keyText(data)) {
+		case "s":
+			return "session";
+		case "l":
+			return "right";
+		case "h":
+			return "left";
 		default:
 			return undefined;
 	}
@@ -178,10 +182,10 @@ export interface SliderView {
 }
 
 const TITLE = "Effort";
-const HINTS = "←/→ or h/l adjust · Enter confirm · Esc cancel · shift+tab cycles the plain levels";
+const HINTS = "←/→ or h/l adjust · Enter confirm · s for this session only · Esc cancel · shift+tab cycles the plain levels";
 /** Anthropic's cache hierarchy: a thinking/effort change invalidates the message cache once (CACHE-REVIEW-2026-09-04 M4). */
 const CACHE_NOTE = "changing effort re-caches the conversation (one uncached request)";
-const SHORT_HINTS = "←/→ h/l · Enter · Esc";
+const SHORT_HINTS = "←/→ h/l · Enter · s · Esc";
 const ULTRACODE_SUBTITLE = `${ULTRACODE_LEVEL} + workflows`;
 
 /**

package/extensions/exit/index.ts

@@ -1,5 +1,5 @@
 /**
- * exit extension — Claude Code's `/exit`.
+ * exit extension — Claude Code's `/exit` and one-shot failure status.
  *
  * pi's built-in quit command is `/quit`; Claude Code's is `/exit` (with `quit`
  * shown as an alias). A user coming from Claude Code types `/exit` out of habit
@@ -17,8 +17,39 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { ONE_SHOT_COMMAND_FAILED_CHANNEL, type RunOutcome, RunOutcomeLatch, TURN_FAILED_CHANNEL } from "../lib/interrupt.ts";
 
 export default function exitExtension(pi: ExtensionAPI) {
+	const outcome = new RunOutcomeLatch();
+	let settled: RunOutcome | undefined;
+	// The harness stopped the turn in progress: its run ends "aborted", which
+	// must not read as a user cancel when the turn settles.
+	let turnFailed = false;
+	pi.on("agent_end", (event, ctx) => {
+		outcome.record(event.messages, ctx.signal?.aborted);
+	});
+	pi.on("agent_settled", () => {
+		const run = outcome.take();
+		settled = turnFailed ? "error" : run ?? settled;
+		turnFailed = false;
+	});
+	pi.events.on(ONE_SHOT_COMMAND_FAILED_CHANNEL, () => {
+		settled = "error";
+	});
+	pi.events.on(TURN_FAILED_CHANNEL, () => {
+		turnFailed = true;
+	});
+	pi.on("session_shutdown", (event, ctx) => {
+		if (ctx.mode !== "print" && ctx.mode !== "json") return;
+		if (event.reason !== "quit" || (settled !== "error" && !turnFailed)) return;
+		// pi 1.0.1 checks provider errors for text output, but not JSON. A print
+		// run may submit several prompts or replace the session (/clear), so a
+		// settled turn is not yet the process's final outcome. Commit only at
+		// final disposal, after retries/compaction and every prompt. main preserves
+		// this code when runPrintMode returns zero; never clear another failure.
+		if (process.exitCode === undefined || Number(process.exitCode) === 0) process.exitCode = 1;
+	});
+
 	pi.registerCommand("exit", {
 		description: "Quit One Code (same as /quit)",
 		handler: async (_args, ctx) => {