@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/src/session/snapcompact-savings-journal.ts

@@ -0,0 +1,113 @@
+/**
+ * Append-only journal of snapcompact tool-result savings.
+ *
+ * Snapcompact frames are transient — built per provider request in
+ * `transformProviderContext` and never written to session.jsonl — so the tokens
+ * they keep off the wire would otherwise leave no trace. This records one line
+ * the FIRST time a tool result is imaged in a session:
+ *
+ *   {"ts":<epochMs>,"session":<sessionFile>,"provider":..,"model":..,"toolCallId":..,"savedTokens":..}
+ *
+ * Newline-delimited JSON, opened with O_APPEND so concurrent appenders (parallel
+ * agents/subagents) never interleave a partial line. Writes are fire-and-forget;
+ * a failure is logged at debug and never propagates into the request hot path.
+ *
+ * Readers MUST dedup by (session, toolCallId): a session resumed in a fresh
+ * process re-images the same results and may append a second line. The savings
+ * for a given (session, toolCallId) are stable, so any-per-key is correct.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { getStatsDbPath, isEnoent, logger } from "@oh-my-pi/pi-utils";
+
+export interface SnapcompactSavingsRecord {
+	/** Epoch milliseconds when the swap was applied. */
+	ts: number;
+	/** Session file path (matches the stats `messages.session_file` key). */
+	session: string;
+	provider: string;
+	model: string;
+	toolCallId: string;
+	savedTokens: number;
+}
+
+/** `~/.omp/.../snapcompact-savings.jsonl`, colocated with stats.db. */
+export function snapcompactSavingsJournalPath(): string {
+	return path.join(path.dirname(getStatsDbPath()), "snapcompact-savings.jsonl");
+}
+
+/**
+ * Appends savings to the journal, deduped by toolCallId for the recorder's
+ * lifetime (one per session). Returns the in-flight append so callers/tests can
+ * await durability; the production transform leaves it floating (fire-and-forget,
+ * and it never rejects — I/O errors are swallowed to debug). `getSession` is read
+ * at write time so a session file assigned late is still captured; a null session
+ * (in-memory / SDK embedding) or non-positive savings skip the write.
+ */
+export type SnapcompactSavingsRecorder = (
+	savings: ReadonlyArray<{ toolCallId: string; savedTokens: number }>,
+	model: Model,
+) => Promise<void>;
+
+export function createSnapcompactSavingsRecorder(
+	getSession: () => string | null,
+	journalPath: string = snapcompactSavingsJournalPath(),
+): SnapcompactSavingsRecorder {
+	const seen = new Set<string>();
+	let dirEnsured = false;
+	return async (savings, model) => {
+		const session = getSession();
+		if (!session) return;
+		const ts = Date.now();
+		const lines: string[] = [];
+		for (const { toolCallId, savedTokens } of savings) {
+			if (savedTokens <= 0 || seen.has(toolCallId)) continue;
+			seen.add(toolCallId);
+			lines.push(
+				JSON.stringify({
+					ts,
+					session,
+					provider: model.provider,
+					model: model.id,
+					toolCallId,
+					savedTokens,
+				} satisfies SnapcompactSavingsRecord),
+			);
+		}
+		if (lines.length === 0) return;
+		try {
+			if (!dirEnsured) {
+				await fs.mkdir(path.dirname(journalPath), { recursive: true });
+				dirEnsured = true;
+			}
+			await fs.appendFile(journalPath, `${lines.join("\n")}\n`);
+		} catch (err) {
+			logger.debug("snapcompact savings journal append failed", { err: String(err) });
+		}
+	};
+}
+
+/** Read all journal records. Malformed lines are skipped; a missing file is empty. */
+export async function readSnapcompactSavingsJournal(
+	journalPath: string = snapcompactSavingsJournalPath(),
+): Promise<SnapcompactSavingsRecord[]> {
+	let text: string;
+	try {
+		text = await Bun.file(journalPath).text();
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
+	}
+	const records: SnapcompactSavingsRecord[] = [];
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			records.push(JSON.parse(line) as SnapcompactSavingsRecord);
+		} catch {
+			/* skip malformed line */
+		}
+	}
+	return records;
+}

package/src/session/tool-choice-queue.ts

@@ -10,14 +10,14 @@ export interface ResolveInfo {
 export interface RejectInfo {
 	/** The ToolChoice that was yielded but never (or unsuccessfully) served. */
 	choice: ToolChoice;
-	reason: "aborted" | "error" | "cleared" | "removed";
+	reason: "aborted" | "error" | "cleared" | "removed" | "unavailable" | "not_invoked";
 }
 
 /** "requeue" replays the lost yield next turn; "drop" (or void/undefined) discards it. */
 export type RejectOutcome = "requeue" | "drop";
 
 export interface DirectiveCallbacks {
-	/** Fires when the yield was served (LLM call completed). The directive is consumed. */
+	/** Fires when the yield completed; onInvoked directives require the requested tool to run first. */
 	onResolved?: (info: ResolveInfo) => void;
 	/**
 	 * Fires when the yield is being discarded. Return "requeue" to replay the
@@ -62,6 +62,7 @@ export function* onceGen(choice: ToolChoice): Generator<ToolChoice, void, unknow
 interface InFlight {
 	directive: ToolChoiceDirective;
 	yielded: ToolChoice;
+	invoked: boolean;
 }
 
 // ── Queue ───────────────────────────────────────────────────────────────────
@@ -116,7 +117,7 @@ export class ToolChoiceQueue {
 				this.#queue.shift();
 				continue;
 			}
-			this.#inFlight = { directive: head, yielded: result.value };
+			this.#inFlight = { directive: head, yielded: result.value, invoked: false };
 			return result.value;
 		}
 		return undefined;
@@ -125,14 +126,18 @@ export class ToolChoiceQueue {
 	// ── Lifecycle ─────────────────────────────────────────────────────────
 
 	/**
-	 * The in-flight yield was served — the LLM call completed normally.
-	 * Fires onResolved, then clears in-flight state. The directive's generator
-	 * remains in the queue if it has more values to yield.
+	 * The in-flight yield completed normally. Directives with onInvoked are only
+	 * consumed after their requested tool ran; a normal text turn or a different
+	 * tool call requeues/rejects the directive instead.
 	 */
 	resolve(): void {
 		const inFlight = this.#inFlight;
-		this.#inFlight = undefined;
 		if (!inFlight) return;
+		if (inFlight.directive.callbacks.onInvoked && !inFlight.invoked) {
+			this.reject("not_invoked");
+			return;
+		}
+		this.#inFlight = undefined;
 
 		this.#lastResolvedLabel = inFlight.directive.label;
 		inFlight.directive.callbacks.onResolved?.({ choice: inFlight.yielded });
@@ -155,12 +160,13 @@ export class ToolChoiceQueue {
 
 		if (outcome === "requeue") {
 			// Re-queue only the lost yield, not the rest of the sequence. Carry forward
-			// onInvoked and onRejected so the replayed yield still executes correctly
-			// and can requeue itself again if the next turn also aborts.
+			// callbacks so the replayed yield still executes and finalizes correctly,
+			// and can requeue itself again if the next turn also aborts or skips it.
 			this.#queue.unshift({
 				generator: onceGen(inFlight.yielded),
 				label: `${inFlight.directive.label}-requeued`,
 				callbacks: {
+					onResolved: inFlight.directive.callbacks.onResolved,
 					onInvoked: inFlight.directive.callbacks.onInvoked,
 					onRejected: inFlight.directive.callbacks.onRejected,
 				},
@@ -173,9 +179,15 @@ export class ToolChoiceQueue {
 		return this.#inFlight !== undefined;
 	}
 
-	/** Peek the in-flight directive's onInvoked handler, if any. */
+	/** Return the in-flight directive's onInvoked handler and mark it when called. */
 	peekInFlightInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
-		return this.#inFlight?.directive.callbacks.onInvoked;
+		const inFlight = this.#inFlight;
+		const onInvoked = inFlight?.directive.callbacks.onInvoked;
+		if (!inFlight || !onInvoked) return undefined;
+		return (input: unknown): Promise<unknown> | unknown => {
+			inFlight.invoked = true;
+			return onInvoked(input);
+		};
 	}
 
 	// ── Cleanup ───────────────────────────────────────────────────────────

package/src/slash-commands/builtin-registry.ts

@@ -62,6 +62,19 @@ function refreshStatusLine(ctx: InteractiveModeContext): void {
 	ctx.ui.requestRender();
 }
 
+/** `/fast status` label: "off", "on", or scope-qualified "on (… only)". */
+function formatFastModeStatus(session: AgentSession): string {
+	if (!session.isFastModeEnabled()) return "off";
+	switch (session.serviceTier) {
+		case "openai-only":
+			return "on (OpenAI only)";
+		case "claude-only":
+			return "on (Claude only)";
+		default:
+			return "on";
+	}
+}
+
 /** Scheme-less display form of a browser deep link: accent + underline, OSC-8 linked to the full URL. */
 function collabWebLinkClickable(webLink: string): string {
 	const display = theme.fg("accent", `\x1b[4m${webLink.replace(/^https?:\/\//, "")}\x1b[24m`);
@@ -271,6 +284,16 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "guided-goal",
+		description: "Interview and refine a goal before enabling goal mode",
+		inlineHint: "[rough objective]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleGuidedGoalCommand(command.args || undefined);
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "loop",
 		description:
@@ -359,7 +382,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return commandConsumed();
 			}
 			if (arg === "status") {
-				await runtime.output(`Fast mode is ${runtime.session.isFastModeEnabled() ? "on" : "off"}.`);
+				await runtime.output(`Fast mode is ${formatFastModeStatus(runtime.session)}.`);
 				return commandConsumed();
 			}
 			return usage("Usage: /fast [on|off|status]", runtime);
@@ -388,8 +411,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return;
 			}
 			if (arg === "status") {
-				const enabled = runtime.ctx.session.isFastModeEnabled();
-				runtime.ctx.showStatus(`Fast mode is ${enabled ? "on" : "off"}.`);
+				runtime.ctx.showStatus(`Fast mode is ${formatFastModeStatus(runtime.ctx.session)}.`);
 				runtime.ctx.editor.setText("");
 				return;
 			}
@@ -1005,7 +1027,21 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "logout",
 		description: "Logout from OAuth provider",
-		handleTui: (_command, runtime) => {
+		inlineHint: "[provider]",
+		allowArgs: true,
+		handleTui: (command, runtime) => {
+			const providerId = command.args.trim();
+			if (providerId) {
+				const matchedProvider = getOAuthProviders().find(provider => provider.id === providerId);
+				if (!matchedProvider) {
+					runtime.ctx.showWarning(`Unknown OAuth provider: ${providerId}`);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				void runtime.ctx.showOAuthSelector("logout", matchedProvider.id);
+				runtime.ctx.editor.setText("");
+				return;
+			}
 			void runtime.ctx.showOAuthSelector("logout");
 			runtime.ctx.editor.setText("");
 		},

package/src/slash-commands/helpers/logout.ts

@@ -0,0 +1,88 @@
+import type { OAuthAccountIdentity, StoredAuthCredential } from "../../session/auth-storage";
+
+export interface LogoutAccount {
+	credentialId: number;
+	provider: string;
+	label: string;
+	detail: string;
+	type: "api_key" | "oauth";
+	active: boolean;
+}
+
+interface LogoutAccountOptions {
+	activeIdentity?: OAuthAccountIdentity;
+	activeApiKey?: boolean;
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function oauthLabel(row: StoredAuthCredential): string {
+	const credential = row.credential;
+	if (credential.type !== "oauth") return `API key #${row.id}`;
+	return (
+		nonEmpty(credential.email) ??
+		nonEmpty(credential.accountId) ??
+		nonEmpty(credential.projectId) ??
+		nonEmpty(credential.enterpriseUrl) ??
+		`OAuth credential #${row.id}`
+	);
+}
+
+function oauthDetail(row: StoredAuthCredential, label: string): string {
+	const credential = row.credential;
+	if (credential.type === "api_key") return `stored API key #${row.id}`;
+	const parts: string[] = [];
+	const email = nonEmpty(credential.email);
+	const accountId = nonEmpty(credential.accountId);
+	const projectId = nonEmpty(credential.projectId);
+	const enterpriseUrl = nonEmpty(credential.enterpriseUrl);
+	if (email && email !== label) parts.push(email);
+	if (accountId && accountId !== label) parts.push(`account ${accountId}`);
+	if (projectId && projectId !== label) parts.push(`project ${projectId}`);
+	if (enterpriseUrl && enterpriseUrl !== label) parts.push(enterpriseUrl);
+	parts.push(`oauth #${row.id}`);
+	return parts.join(" · ");
+}
+
+function oauthMatchesActiveIdentity(
+	row: StoredAuthCredential,
+	activeIdentity: OAuthAccountIdentity | undefined,
+): boolean {
+	if (!activeIdentity || row.credential.type !== "oauth") return false;
+	const credential = row.credential;
+	return (
+		(activeIdentity.accountId !== undefined && credential.accountId === activeIdentity.accountId) ||
+		(activeIdentity.email !== undefined && credential.email === activeIdentity.email) ||
+		(activeIdentity.projectId !== undefined && credential.projectId === activeIdentity.projectId)
+	);
+}
+
+export function toLogoutAccounts(
+	provider: string,
+	credentials: StoredAuthCredential[],
+	options: LogoutAccountOptions = {},
+): LogoutAccount[] {
+	return credentials
+		.map(row => {
+			const label = oauthLabel(row);
+			const active =
+				row.credential.type === "oauth"
+					? oauthMatchesActiveIdentity(row, options.activeIdentity)
+					: options.activeApiKey === true;
+			return {
+				credentialId: row.id,
+				provider,
+				label,
+				detail: oauthDetail(row, label),
+				type: row.credential.type,
+				active,
+			} satisfies LogoutAccount;
+		})
+		.sort((left, right) => {
+			if (left.active !== right.active) return left.active ? -1 : 1;
+			return left.label.localeCompare(right.label) || left.credentialId - right.credentialId;
+		});
+}