hob-bot 1.0.4 → 1.2.0

package/vendor/claude-bridge/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eli Dickinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/claude-bridge/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "pi-claude-bridge",
+  "version": "0.9.3",
+  "private": false,
+  "description": "Pi extension that uses Claude Code (via Agent SDK) as a model provider and adds an AskClaude tool.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "extension",
+    "claude-code",
+    "claude-agent-sdk"
+  ],
+  "author": "Eli Dickinson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elidickinson/pi-claude-bridge.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "assets"
+  ],
+  "scripts": {
+    "test:unit": "node --import tsx --import ./tests/lib/setup.mjs --test tests/unit-*.mjs",
+    "test": "set -a && [ -f .env.test ] && . .env.test; set +a; CLAUDE_BRIDGE_TEST_LOG_DIR=$(mktemp -d); export CLAUDE_BRIDGE_TEST_LOG_DIR; npm run test:unit && tests/int-smoke.sh && tests/int-multi-turn.sh && tests/int-cache.sh && node --import tsx --test tests/int-*.mjs && node tests/lib/check-deadlock-logs.mjs \"$CLAUDE_BRIDGE_TEST_LOG_DIR\"",
+    "test:usage": "tests/usage-test.sh",
+    "typecheck": "tsc --noEmit"
+  },
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.293",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cc-session-io": "^0.4.0",
+    "change-case": "^5.4.4"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.86.1",
+    "@earendil-works/pi-coding-agent": ">=0.86.1",
+    "@earendil-works/pi-tui": ">=0.86.1",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.124.0",
+    "@earendil-works/pi-ai": "^1.2.0",
+    "@earendil-works/pi-coding-agent": "^1.2.0",
+    "@earendil-works/pi-tui": "^1.2.0",
+    "@types/node": "^24.13.2",
+    "tsx": "^4.22.4",
+    "typebox": "^1.3.7",
+    "typescript": "^6.0.3"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/vendor/claude-bridge/src/agents-md.ts

@@ -0,0 +1,14 @@
+// Pi owns context-file discovery; the bridge only formats the list Pi loaded so
+// Claude receives the same instructions, in the same order, that Pi applies.
+
+type ContextFile = { path: string; content: string };
+
+export function formatProjectContext(contextFiles: ContextFile[]): string | undefined {
+	if (contextFiles.length === 0) return undefined;
+
+	let prompt = "<project_context>\n\nProject-specific instructions and guidelines:\n\n";
+	for (const { path, content } of contextFiles) {
+		prompt += `<project_instructions path="${path}">\n${content}\n</project_instructions>\n\n`;
+	}
+	return `${prompt}</project_context>`;
+}

package/vendor/claude-bridge/src/askclaude-schema.ts

@@ -0,0 +1,92 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import type { Config } from "./config.js";
+
+export type AskClaudeMode = "full" | "read" | "none";
+
+export interface AskClaudeDefaults {
+	mode: AskClaudeMode;
+	isolated: boolean;
+	allowFull: boolean;
+}
+
+const PACKAGE_DEFAULT_MODE: AskClaudeMode = "read";
+const PACKAGE_DEFAULT_ISOLATED = false;
+
+export function resolveAskClaudeDefaults(conf: Config["askClaude"]): AskClaudeDefaults {
+	const rawAllowFull: unknown = conf?.allowFullMode;
+	const allowFull = rawAllowFull == null ? true : rawAllowFull === true;
+	const configuredMode: unknown = conf?.defaultMode;
+	const mode = configuredMode == null
+		? PACKAGE_DEFAULT_MODE
+		: configuredMode === "full" || configuredMode === "read" || configuredMode === "none"
+			? configuredMode
+			// Unrecognized value: the most restrictive mode, not the package default.
+			: "none";
+	return { mode: !allowFull && mode === "full" ? PACKAGE_DEFAULT_MODE : mode, isolated: conf?.defaultIsolated ?? PACKAGE_DEFAULT_ISOLATED, allowFull };
+}
+
+export function resolveAskClaudeMode(mode: unknown, defaults: AskClaudeDefaults): AskClaudeMode {
+	const resolved = mode === undefined ? defaults.mode : mode;
+	if (resolved !== "full" && resolved !== "read" && resolved !== "none") throw new Error(`Invalid AskClaude mode: ${String(resolved)}`);
+	if (resolved === "full" && !defaults.allowFull) throw new Error("AskClaude full mode is disabled.");
+	return resolved;
+}
+
+function modeDescription(defaults: AskClaudeDefaults): string {
+	const mark = (mode: AskClaudeMode) => (mode === defaults.mode ? " (default)" : "");
+	const parts = [
+		`"read"${mark("read")}: questions about the codebase — review, analysis, explain.`,
+		`"none"${mark("none")}: general knowledge only (no file access).`,
+	];
+	if (defaults.allowFull) {
+		parts.push(`"full"${mark("full")}: allows writing and bash execution (careful: runs without feedback to pi).`);
+	}
+	return parts.join(" ");
+}
+
+export function buildAskClaudeParams(defaults: AskClaudeDefaults) {
+	const visibility = defaults.isolated
+		? "By default Claude sees only this prompt (isolated session)."
+		: "By default Claude sees the full conversation history.";
+	const trueDefault = defaults.isolated ? " (default)" : "";
+	const falseDefault = defaults.isolated ? "" : " (default)";
+	const modeValues: readonly AskClaudeMode[] = defaults.allowFull ? ["read", "full", "none"] : ["read", "none"];
+	return Type.Object({
+		prompt: Type.String({ description: `The question or task for Claude Code. ${visibility} Don't research up front, let Claude explore.` }),
+		mode: Type.Optional(StringEnum(modeValues, { description: modeDescription(defaults) })),
+		model: Type.Optional(Type.String({ description: 'Claude model (e.g. "opus", "sonnet", "haiku", or full ID). Defaults to "opus".' })),
+		thinking: Type.Optional(StringEnum(["off", "minimal", "low", "medium", "high", "xhigh"] as const, { description: "Thinking effort level. Omit to use Claude Code's default." })),
+		isolated: Type.Optional(Type.Boolean({ description: `When true${trueDefault}, Claude sees only this prompt (clean session). When false${falseDefault}, Claude sees the full conversation history.` })),
+	});
+}
+
+export function askClaudeToolDescription(defaults: AskClaudeDefaults, override?: string | null): string {
+	if (override != null) return override;
+	const suffix = " Prefer to handle straightforward tasks yourself.";
+	if (!defaults.allowFull) {
+		const middle = defaults.mode === "none"
+			? 'Defaults to no file access — pass mode "read" to let Claude Code explore the codebase; it can never make changes.'
+			: "Read-only — Claude Code can explore the codebase but not make changes.";
+		return `Delegate to Claude Code for a second opinion or analysis (code review, architecture questions, debugging theories). ${middle}${suffix}`;
+	}
+	const middle = defaults.mode === "full"
+		? 'Defaults to full mode — Claude Code writes files and runs bash without feedback to pi; pass mode "read" to keep it to exploration.'
+		: defaults.mode === "none"
+			? 'Defaults to no file access — pass mode "read" to let Claude Code explore the codebase, or "full" for a task that requires changes.'
+			: "Defaults to read-only mode — use full mode when the user wants to delegate a task that requires changes.";
+	return `Delegate to Claude Code for a second opinion or analysis (code review, architecture questions, debugging theories), or to autonomously handle a task. ${middle}${suffix}`;
+}
+
+export function askClaudeCallTags(
+	args: { mode?: AskClaudeMode; model?: string; thinking?: string; isolated?: boolean },
+	defaults: AskClaudeDefaults,
+): string[] {
+	const tags: string[] = [];
+	const mode = args.mode ?? defaults.mode;
+	if (mode !== PACKAGE_DEFAULT_MODE || (args.mode !== undefined && args.mode !== defaults.mode)) tags.push(`mode=${mode}`);
+	if (args.model) tags.push(`model=${args.model}`);
+	if (args.thinking) tags.push(`thinking=${args.thinking}`);
+	if ((args.isolated ?? defaults.isolated) !== PACKAGE_DEFAULT_ISOLATED) tags.push("isolated");
+	return tags;
+}

package/vendor/claude-bridge/src/askclaude-ui.ts

@@ -0,0 +1,90 @@
+// Status-line rendering helpers for the AskClaude tool.
+//
+// While Claude Code runs inside an AskClaude call, the pi TUI can't surface
+// each tool_use individually — there's only one status row for the whole
+// delegation. These helpers shape a tool_use record into a short, path-aware
+// label (e.g. "Read(src/foo.ts)", "Bash(git log --oneline…)") and collapse
+// runs of the same tool so the line doesn't flicker. Used only by
+// promptAndWait; the provider path exposes tools directly through pi's TUI
+// and doesn't need this.
+
+export interface ToolCallState {
+	name: string;
+	status: string;
+	rawInput?: unknown;
+}
+
+export function extractPath(rawInput: unknown): string | undefined {
+	if (!rawInput || typeof rawInput !== "object") return undefined;
+	const input = rawInput as Record<string, unknown>;
+	if (typeof input.file_path === "string") return input.file_path;
+	if (typeof input.path === "string") return input.path;
+	if (typeof input.command === "string") return input.command.substring(0, 80);
+	return undefined;
+}
+
+export function shortPath(p: string): string {
+	const cwd = process.cwd();
+	if (p.startsWith(cwd + "/")) return p.slice(cwd.length + 1);
+	if (p.startsWith("/")) {
+		const parts = p.split("/");
+		if (parts.length > 3) return parts.slice(-2).join("/");
+	}
+	return p;
+}
+
+export function formatToolAction(tc: ToolCallState): string | undefined {
+	const path = extractPath(tc.rawInput);
+	const verb = tc.name.toLowerCase().split(/\s/)[0];
+	if (verb === "read" || verb === "readfile") {
+		return path ? `Read(${shortPath(path)})` : "Read";
+	} else if (verb === "glob") {
+		const input = tc.rawInput as Record<string, unknown> | undefined;
+		const pat = typeof input?.pattern === "string" ? input.pattern.slice(0, 40) : "";
+		return pat ? `Glob(${pat})` : "Glob";
+	} else if (verb === "edit" || verb === "write" || verb === "writefile" || verb === "multiedit") {
+		return path ? `Edit(${shortPath(path)})` : "Edit";
+	} else if (verb === "bashoutput") {
+		return undefined; // redundant with preceding Bash call
+	} else if (verb === "bash" || verb === "terminal") {
+		return path ? `Bash(${path})` : "Bash";
+	} else if (verb === "agent") {
+		const input = tc.rawInput as Record<string, unknown> | undefined;
+		return `Agent(${String(input?.description ?? "").slice(0, 40)})`;
+	} else if (verb === "grep") {
+		const input = tc.rawInput as Record<string, unknown> | undefined;
+		const pat = typeof input?.pattern === "string" ? input.pattern.slice(0, 40) : "";
+		return pat ? `Grep(${pat})` : "Grep";
+	} else if (verb === "skill") {
+		const input = tc.rawInput as Record<string, unknown> | undefined;
+		const name = typeof input?.skill === "string" ? input.skill.slice(0, 40) : "";
+		return name ? `Skill(${name})` : "Skill";
+	} else if (verb === "todowrite" || verb === "taskcreate" || verb === "taskupdate") {
+		const todos = Array.isArray((tc.rawInput as any)?.todos) ? (tc.rawInput as any).todos : [];
+		const current = todos.find((t: any) => t.status === "in_progress") ?? todos.find((t: any) => t.status === "pending");
+		const label = current ? String(current.content ?? "").slice(0, 40) : "";
+		return label || undefined;
+	} else if (verb === "askclaude") {
+		// Recursive — don't show AskClaude in its own action summary
+		return undefined;
+	}
+	return tc.name;
+}
+
+export function buildActionSummary(calls: Map<string, ToolCallState>): string {
+	const parts: string[] = [];
+	let prevVerb = "";
+	for (const [, tc] of calls) {
+		const action = formatToolAction(tc);
+		if (!action) continue;
+		const verb = tc.name.toLowerCase().split(/\s/)[0];
+		// Collapse consecutive calls to the same tool — keep only the latest
+		if (verb === prevVerb) {
+			parts[parts.length - 1] = action;
+		} else {
+			parts.push(action);
+		}
+		prevVerb = verb;
+	}
+	return parts.join("; ");
+}

package/vendor/claude-bridge/src/attachments.ts

@@ -0,0 +1,135 @@
+// Carrying Claude Code's own attachments across a session rebuild.
+//
+// CC expands an `@file` mention itself — pi passes `@` through untouched — and
+// writes the expansion as a `type: "attachment"` record in its session file. pi
+// never sees it, so rebuilding a session from pi's history drops the file while
+// keeping the prompt text that referred to it: the model silently loses
+// something it was reasoning about, with nothing logged.
+//
+// Extracted from index.ts so tests can import it without activating the extension.
+
+import type { JsonlRecord, ImportAttachment } from "cc-session-io";
+import { messageContentToText } from "./convert.js";
+
+// Only `@file` expansions are carried. They are the one thing pi genuinely never
+// sees, so a rebuild is the only chance to keep them.
+//
+// `edited_text_file` is deliberately excluded even though it also carries file
+// content. CC writes one after editing a file, and the edit itself is already in
+// pi's history as a tool call and its result, so the attachment duplicates context
+// the rebuild reproduces anyway. It also usually hangs off a *tool result* record
+// rather than a prompt, which has no position in the ordinal scheme below — on
+// real sessions that left 81 of them unresolvable (see
+// diag/attachment-coverage.mjs). Half-carrying a kind is worse than not claiming
+// it: the ones that slipped through would be an arbitrary subset.
+//
+// Everything else CC rewrites every turn (`skill_listing`, `task_reminder`,
+// `agent_listing_delta`, `mcp_instructions_delta`, …) and loses nothing.
+const CONTENT_BEARING = new Set(["file"]);
+
+export type CarriedAttachment = {
+	attachment: { type: string; [key: string]: unknown };
+	/** Position of the parent among the session's text-bearing user records. */
+	userOrdinal: number;
+	/** That record's text, to verify the ordinal still points at the same turn. */
+	parentText: string;
+};
+
+type Rec = Record<string, unknown>;
+
+/** A user record holding a prompt, as opposed to one holding tool results. */
+function userPromptText(record: Rec): string | undefined {
+	if (record.type !== "user") return undefined;
+	const content = (record.message as Rec | undefined)?.content;
+	if (Array.isArray(content) && content.some((b) => (b as Rec)?.type === "tool_result")) return undefined;
+	const text = messageContentToText(content as never);
+	return text ? text : undefined;
+}
+
+/**
+ * Content-bearing attachments in a session, each tagged with where its parent
+ * sits among the text-bearing user records.
+ *
+ * The ordinal is the mapping key rather than the record index: a rebuild does not
+ * reproduce the old record list one-for-one — `importMessages` splits a message
+ * carrying tool results into two records, and CC appends records of its own — but
+ * the sequence of user prompts is the same conversation either way.
+ *
+ * Attachments also chain to one another, so an ordinal is resolved transitively up
+ * the parent links until it reaches a prompt. Most real attachments are
+ * `edited_text_file` records CC writes after editing a file, which have nothing to
+ * do with at-mentions; only their position in the conversation matters here.
+ */
+export function collectCarriedAttachments(records: readonly JsonlRecord[]): CarriedAttachment[] {
+	const ordinalOf = new Map<string, number>();
+	const textOf = new Map<string, string>();
+	let ordinal = 0;
+	const carried: CarriedAttachment[] = [];
+
+	for (const raw of records) {
+		const record = raw as Rec;
+		const prompt = userPromptText(record);
+		if (prompt !== undefined) {
+			ordinalOf.set(record.uuid as string, ordinal++);
+			textOf.set(record.uuid as string, prompt);
+			continue;
+		}
+		if (record.type !== "attachment") continue;
+		const parent = record.parentUuid as string | null;
+		// Attachments chain to each other — a run of them hangs off one prompt, and
+		// 63 of 179 in real sessions parent to another attachment rather than to a
+		// message. Inherit the ordinal so the whole run keys to the prompt that
+		// caused it. Recorded for every attachment, not just the ones carried, since
+		// a content-bearing one can chain off a `skill_listing` we ignore.
+		if (parent === null || !ordinalOf.has(parent)) continue;
+		const inherited = ordinalOf.get(parent)!;
+		ordinalOf.set(record.uuid as string, inherited);
+		textOf.set(record.uuid as string, textOf.get(parent)!);
+
+		const attachment = record.attachment as { type: string; [key: string]: unknown } | undefined;
+		if (!attachment || !CONTENT_BEARING.has(attachment.type)) continue;
+		carried.push({ attachment, userOrdinal: inherited, parentText: textOf.get(parent)! });
+	}
+	return carried;
+}
+
+/**
+ * Resolve each carried attachment to a position in the array about to be
+ * imported — the messages *after* conversion and repair, since that is the index
+ * space `importMessages` reads. Repair is idempotent, so an already-repaired array
+ * passes through its second run unchanged and the indices stay valid.
+ *
+ * Deliberately conservative: attaching a file to the wrong turn tells the model it
+ * saw something at a point it did not, which is worse than the loss this exists to
+ * prevent. So the ordinal has to land on a prompt whose text still matches; any
+ * disagreement is reported and dropped rather than approximated.
+ */
+export function placeCarriedAttachments(
+	carried: readonly CarriedAttachment[],
+	messages: readonly { role: string; content: unknown }[],
+): { attachments: ImportAttachment[]; skipped: string[] } {
+	const prompts: { index: number; text: string }[] = [];
+	messages.forEach((msg, index) => {
+		if (msg.role !== "user") return;
+		if (Array.isArray(msg.content) && msg.content.some((b) => (b as Rec)?.type === "tool_result")) return;
+		const text = messageContentToText(msg.content as never);
+		if (text) prompts.push({ index, text });
+	});
+
+	const attachments: ImportAttachment[] = [];
+	const skipped: string[] = [];
+	for (const item of carried) {
+		const name = String(item.attachment.filename ?? item.attachment.type);
+		const candidate = prompts[item.userOrdinal];
+		if (!candidate) {
+			skipped.push(`${name}: prompt #${item.userOrdinal} is no longer in history`);
+			continue;
+		}
+		if (candidate.text !== item.parentText) {
+			skipped.push(`${name}: prompt #${item.userOrdinal} changed`);
+			continue;
+		}
+		attachments.push({ afterIndex: candidate.index, attachment: item.attachment });
+	}
+	return { attachments, skipped };
+}

package/vendor/claude-bridge/src/config.ts

@@ -0,0 +1,105 @@
+// Hob loads only the bridge configuration written in its own engine directory.
+// Missing or unparseable files are reported and treated as an empty object.
+
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+export interface Config {
+	/** Date (YYYY-MM-DD) the one-time startup notice was shown. Written by the extension, not the user. */
+	startupNoticeShown?: string;
+	/** Date (YYYY-MM-DD) the AskClaude deprecation notice was shown. Written by the extension, not the user. */
+	askClaudeDeprecationShown?: string;
+	askClaude?: {
+		enabled?: boolean;
+		name?: string;
+		label?: string;
+		description?: string;
+		defaultMode?: "full" | "read" | "none";
+		defaultIsolated?: boolean;
+		allowFullMode?: boolean;
+		appendSkills?: boolean;
+	};
+	/** Low-level Claude Agent SDK plumbing. Most users won't need these. */
+	provider?: {
+		strictMcpConfig?: boolean;
+		autoMemoryEnabled?: boolean;
+		pathToClaudeCodeExecutable?: string;
+		// Subscription plan tier. Setting to "max" enables Opus 4.6 at 1M context
+		plan?: "pro" | "max";
+		// Set to true to opt into metered 1M context usage ("extra usage" in
+		// Anthropic billing). Enables Sonnet 4.6 [1m] on every plan and Opus 4.6
+		// [1m] on Pro.
+		longContextExtraUsage?: boolean;
+		// Model ids (e.g. "claude-future-9") whose declared 1M context Claude Code
+		// does not actually serve; pins them to the bare id at 200K.
+		forceTwoHundredK?: string[];
+	};
+}
+
+export function tryParseJson(path: string): Partial<Config> {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch (e) {
+		console.error(`claude-bridge: failed to parse ${path}: ${e}`);
+		return {};
+	}
+}
+
+export function claudeCodeSettings(provider: Config["provider"] = {}): { autoMemoryEnabled: boolean } {
+	return { autoMemoryEnabled: provider.autoMemoryEnabled ?? false };
+}
+
+export function globalConfigPath(): string {
+	return join(getAgentDir(), "claude-bridge.json");
+}
+
+/** Record today's date in the global config so the startup notice shows once, preserving every
+ *  other field. Returns the config path for display either way.
+ *
+ *  Parses directly rather than through tryParseJson, which reports an unparseable file as `{}`:
+ *  spreading that would replace a user's whole config with just this marker the first time they
+ *  leave a trailing comma in it. Losing the notice is the cheaper failure, so the write is
+ *  skipped and the notice simply shows again next session. */
+export function markStartupNoticeShown(): string {
+	const path = globalConfigPath();
+	let existing: Partial<Config> = {};
+	if (existsSync(path)) {
+		try {
+			existing = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (e) {
+			console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+			return path;
+		}
+	}
+	// en-CA renders YYYY-MM-DD in local time; toISOString() would report UTC.
+	const next = { ...existing, startupNoticeShown: new Date().toLocaleDateString("en-CA") };
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return path;
+}
+
+/** Record when the AskClaude deprecation notice was shown in the global config, preserving every
+ *  other field. Returns the config path either way. */
+export function markAskClaudeDeprecationNoticeShown(): string {
+	const path = globalConfigPath();
+	let existing: Partial<Config> = {};
+	if (existsSync(path)) {
+		try {
+			existing = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (e) {
+			console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+			return path;
+		}
+	}
+	// Match startupNoticeShown's local YYYY-MM-DD date format.
+	const next = { ...existing, askClaudeDeprecationShown: new Date().toLocaleDateString("en-CA") };
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return path;
+}
+
+export function loadConfig(_cwd: string): Config {
+	return tryParseJson(globalConfigPath());
+}