one-code-extension 0.5.0 → 0.6.0

package/extensions/worktree/index.ts

@@ -7,7 +7,9 @@
  * at creation, so the move is enforced on the tool_call hook: bash commands
  * are prefixed with `cd`, relative paths resolve against the worktree (see
  * rewrite.ts), and an every-turn reminder keeps the model oriented. State
- * rides in tool-result details so a resumed or branched session restores it.
+ * rides in tool-result details so a resumed or branched session restores it;
+ * a /clear or /new keeps the worktree, as Claude Code does, by recording it on
+ * the new branch.
  */
 
 import { execFile } from "node:child_process";
@@ -34,6 +36,8 @@ import { rewriteToolInput, validateWorktreeName } from "./rewrite.ts";
 import { ccToolRenderers } from "../lib/tui-render.ts";
 import { findProjectRoot, HARNESS_GIT_CONFIG, HARNESS_GIT_NO_HOOKS, repositoryWorktrees } from "../lib/git.ts";
 import { projectConfigDir, projectConfigDirName } from "../lib/config-mode.ts";
+import { readState, readStringsState, recordState } from "../lib/ledger/state.ts";
+import { processState } from "../lib/process-state.ts";
 
 const run = promisify(execFile);
 const REMINDER_KEY = "cc-worktree-session";
@@ -74,12 +78,24 @@ async function listWorktreePaths(cwd: string): Promise<string[]> {
  */
 const ISOLATION_NOTE = "Git commands aimed at the main checkout or another worktree of this repository are refused until you exit.";
 
+/** The `one-code:state` key of the worktree paths the branch was already told are gone. */
+const MISSING_REPORTED_STATE = "worktree:missing-reported";
+
+/** The `one-code:state` key of the worktree a /clear or /new carried onto its new branch. */
+const CARRIED_STATE = "worktree:carried";
+
 /**
- * Sessions already told their restored worktree is gone, as `<session id>\0<path>`.
- * Module scope on purpose: jiti keeps this module across the factory re-run
- * that `/reload` makes, and a reload restores the same stale state again.
+ * The worktree the session is in, as process state (lib/process-state.ts): a
+ * /clear or /new starts an empty branch, and Claude Code keeps the session in
+ * its worktree across that (decisions/tools.md). Children never load this
+ * extension, so only the main session writes it.
  */
-const reportedMissingWorktrees = new Set<string>();
+const liveWorktree = () => processState<{ state?: WorktreeState }>("worktree:live", () => ({}));
+
+function isWorktreeState(value: unknown): value is WorktreeState {
+	const s = value as Partial<WorktreeState> | null | undefined;
+	return typeof s?.path === "string" && typeof s.originalCwd === "string" && typeof s.sharedRoot === "string" && typeof s.createdByUs === "boolean";
+}
 
 export default function worktreeExtension(pi: ExtensionAPI) {
 	let state: WorktreeState | undefined;
@@ -91,12 +107,12 @@ export default function worktreeExtension(pi: ExtensionAPI) {
 
 	const applyState = (next: WorktreeState | undefined, toolCallId?: string) => {
 		state = next;
+		liveWorktree().state = next;
 		const location: WorktreeLocation | null = next ? { path: next.path, branch: next.branch, sharedRoot: next.sharedRoot } : null;
 		pi.events.emit(WORKTREE_CHANNEL, location);
 		if (next) {
 			pi.events.emit(REMINDER_CHANNEL, {
 				text: reminderFor(next),
-				scope: "every-turn",
 				key: REMINDER_KEY,
 				placement: "sticky-append",
 				toolCallId,
@@ -106,15 +122,35 @@ export default function worktreeExtension(pi: ExtensionAPI) {
 		}
 	};
 
-	const reconstructState = (ctx: ExtensionContext) => {
+	/**
+	 * The worktree a /clear or /new keeps: the one this process was in, when it
+	 * belongs to this directory and still exists, recorded on the new branch so
+	 * a resume of it reads it back. A branch with its own worktree tool results
+	 * follows them instead (they come after the carry).
+	 */
+	const carriedState = (ctx: ExtensionContext, reason: string | undefined): WorktreeState | undefined => {
+		// A recorded carry holds only in the directory it was entered from, as
+		// the live one does: a branch forked into another project, or continued
+		// after its directory went away, starts outside the worktree.
+		const enteredHere = (s: WorktreeState) => comparablePath(tryRealpath(s.originalCwd) ?? s.originalCwd) === comparablePath(tryRealpath(ctx.cwd) ?? ctx.cwd);
+		const recorded = readState(ctx, CARRIED_STATE);
+		if (isWorktreeState(recorded)) return enteredHere(recorded) ? recorded : undefined;
+		const live = liveWorktree().state;
+		if (reason !== "new" || !live || !existsSync(live.path) || !enteredHere(live)) return undefined;
+		recordState(pi, CARRIED_STATE, live);
+		return live;
+	};
+
+	const reconstructState = (ctx: ExtensionContext, reason?: string) => {
 		const details = restoreLatestDetails<WorktreeDetails>(ctx.sessionManager.getBranch(), WORKTREE_TOOLS, (d) => d?.worktreeState !== undefined);
-		let restored = details?.worktreeState ?? undefined;
+		let restored = details ? (details.worktreeState ?? undefined) : carriedState(ctx, reason);
 		if (restored && !existsSync(restored.path)) {
-			// Nothing records that the session left, so every later restore finds
-			// the same stale state; tell the model once per session.
-			const key = `${ctx.sessionManager.getSessionId()}\0${restored.path}`;
-			if (!reportedMissingWorktrees.has(key)) {
-				reportedMissingWorktrees.add(key);
+			// Nothing in the tool details records that the session left, so every
+			// later restore finds the same stale state; tell the branch once, and
+			// record that it was told (a resume, /reload or /tree reads it back).
+			const reported = readStringsState(ctx, MISSING_REPORTED_STATE);
+			if (!reported.includes(restored.path)) {
+				recordState(pi, MISSING_REPORTED_STATE, [...reported, restored.path]);
 				pi.events.emit(REMINDER_CHANNEL, {
 					text: `Left worktree session; back in ${restored.originalCwd}. The worktree at ${restored.path} no longer exists.`,
 				});
@@ -126,7 +162,7 @@ export default function worktreeExtension(pi: ExtensionAPI) {
 		applyState(restored);
 	};
 
-	pi.on("session_start", (_event, ctx) => reconstructState(ctx));
+	pi.on("session_start", (event, ctx) => reconstructState(ctx, event.reason));
 	pi.on("session_tree", (_event, ctx) => reconstructState(ctx));
 
 	/** The repository's worktrees for a git command's target check; undefined when git cannot list them. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "one-code-extension",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "One Code as a pi package — the Claude Code experience on your own pi install: ported system prompt, Claude-Code-format permissions, .claude/ compatibility, ToolSearch-style deferred tools, and system-reminder steering. For the bundled app, install `@one-ai/one-code` instead.",
 	"keywords": [
 		"pi",
@@ -29,6 +29,7 @@
 			"extensions/branding/index.ts",
 			"extensions/claude-compat/index.ts",
 			"extensions/kept-thinking/index.ts",
+			"extensions/ledger/index.ts",
 			"extensions/context-budget/index.ts",
 			"extensions/system-reminder/index.ts",
 			"extensions/claude-context/index.ts",
@@ -75,6 +76,8 @@
 			"extensions/context-management/index.ts",
 			"extensions/compaction/index.ts",
 			"extensions/idle-compact/index.ts",
+			"extensions/ledger/wire.ts",
+			"extensions/cache-marks/index.ts",
 			"extensions/system-prompt/index.ts"
 		],
 		"themes": [
@@ -120,7 +123,7 @@
 		"vitest": "^2.1.0"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.84.3",
+		"@earendil-works/pi-coding-agent": ">=1.0.0",
 		"typebox": "*"
 	}
 }

package/extensions/lib/context-stack.ts

@@ -1,81 +0,0 @@
-/** Session-file context snapshots and the bus contract. No stored value grants permissions. */
-import type { ReminderEntry } from "./reminders.ts";
-
-export const CONTEXT_STACK_ENTRY = "one-code:context-stack";
-export const CONTEXT_STATE_ENTRY = "one-code:context-state";
-export const CONTEXT_RESTORE_CHANNEL = "one-code:context-restore";
-export const CONTEXT_BASELINE_CHANNEL = "one-code:context-baseline";
-/** A completed compaction replaces the Claude context facts, including absent blocks. */
-export const CONTEXT_FACTS_REFRESH_CHANNEL = "one-code:context-facts-refresh";
-
-export interface ContextStackSnapshot {
-	version: 1;
-	stack: ReminderEntry[];
-	sticky: ReminderEntry[];
-	/** Delivered one-shots/breadcrumbs; absent in older snapshots. */
-	pinned?: ReminderEntry[];
-	/** Emitter-owned announcement baselines, not live configuration. */
-	baselines: Record<string, unknown>;
-}
-export interface ContextRestoreRequest { restored?: ContextStackSnapshot }
-export interface ContextBaseline { key: string; value: unknown }
-export interface ContextFactsRefresh { entries: ReminderEntry[]; baseline: unknown }
-interface Bus { emit(channel: string, data: unknown): void }
-
-/** Synchronous request/reply: system-reminder restores before the emitters' session_start hooks. */
-export function restoredContext(events: Bus): ContextStackSnapshot | undefined {
-	const request: ContextRestoreRequest = {};
-	events.emit(CONTEXT_RESTORE_CHANNEL, request);
-	return request.restored;
-}
-
-/** Phase-1 capabilities must be re-emitted by their live owners, including removal. */
-export const LIVE_CONTEXT_KEYS = new Set(["environment", "model-line", "one-shot", "skills"]);
-
-/** Session facts and phase-2 emitters keep even an absent original block absent. */
-export const RESTORED_STACK_KEYS = new Set([
-	"claude-context", "one-code-context", "claude-context-context", "claude-context-date",
-	"total-tokens-first", "auto-mode-note", "deferred-tools", "mcp-instructions", "mcp-failures",
-	"subagent-models", "subagent-agents", "subagent-delegation",
-]);
-
-function record(value: unknown): value is Record<string, unknown> {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function anchor(value: unknown): boolean {
-	return record(value) && ((value.kind === "user" && typeof value.timestamp === "number" && Number.isFinite(value.timestamp)) ||
-		(value.kind === "toolResult" && typeof value.toolCallId === "string"));
-}
-function entries(value: unknown, placement: "first-prepend" | "sticky-append" | "pinned"): value is ReminderEntry[] {
-	return Array.isArray(value) && value.every((e) => record(e) &&
-		(placement === "pinned" ? e.placement === "last-append" || e.placement === "user-prepend" : e.placement === placement) && typeof e.text === "string" &&
-		typeof e.order === "number" && Number.isFinite(e.order) &&
-		(e.key === undefined || typeof e.key === "string") && (e.suffix === undefined || typeof e.suffix === "string") &&
-		(e.toolCallId === undefined || placement === "sticky-append" && typeof e.toolCallId === "string") &&
-		["raw", "systemRoleOnly", "skipStackCarrier"].every((key) => e[key] === undefined || typeof e[key] === "boolean") &&
-		(e.since === undefined || typeof e.since === "number" && Number.isFinite(e.since)) &&
-		(e.until === undefined || placement === "sticky-append" && typeof e.until === "number" && Number.isFinite(e.until)) &&
-		(e.userPins === undefined || placement === "sticky-append" && Array.isArray(e.userPins) && e.userPins.every((stamp) => typeof stamp === "number" && Number.isFinite(stamp))) &&
-		(e.opener === undefined || e.opener === null || typeof e.opener === "number" && Number.isFinite(e.opener)) &&
-		(e.tailPin === undefined || anchor(e.tailPin)) && (placement === "pinned" ? anchor(e.pin) : e.pin === undefined));
-}
-
-/** Read only the selected branch. Malformed/unknown versions are ignored, never partly restored. */
-export function contextStackOnBranch(branch: readonly { type: string; customType?: string; data?: unknown }[]): ContextStackSnapshot | undefined {
-	let snapshot: ContextStackSnapshot | undefined;
-	for (const entry of branch) {
-		if (entry.type !== "custom" || !record(entry.data) || entry.data.version !== 1) continue;
-		const data = entry.data;
-		if (data.pinned !== undefined && !entries(data.pinned, "pinned")) continue;
-		if (entry.customType === CONTEXT_STACK_ENTRY && entries(data.stack, "first-prepend") && entries(data.sticky, "sticky-append") && record(data.baselines)) {
-			snapshot = structuredClone(data) as unknown as ContextStackSnapshot;
-		} else if (snapshot && entry.customType === CONTEXT_STATE_ENTRY && entries(data.sticky, "sticky-append") && record(data.baselines) &&
-			(data.stack === undefined || entries(data.stack, "first-prepend"))) {
-			if (data.stack !== undefined) snapshot.stack = structuredClone(data.stack) as ReminderEntry[];
-			snapshot.sticky = structuredClone(data.sticky);
-			if (data.pinned !== undefined) snapshot.pinned = structuredClone(data.pinned) as ReminderEntry[];
-			snapshot.baselines = structuredClone(data.baselines);
-		}
-	}
-	return snapshot;
-}

package/extensions/subagents/announce.ts

@@ -1,69 +0,0 @@
-/** Pure state for resumed-session subagent capability announcements. */
-
-export type SubagentCapability = "models" | "agents" | "delegation";
-export interface SubagentBaseline {
-	models: string | null;
-	agents: string | null;
-	delegation: string | null;
-	/** Account refusals the narrow tail correction has already communicated. */
-	refusedModels: string[];
-}
-
-export function emptySubagentBaseline(): SubagentBaseline {
-	return { models: null, agents: null, delegation: null, refusedModels: [] };
-}
-
-/** Stored baseline validation deliberately permits arbitrary reminder text. */
-export function subagentBaseline(value: unknown): SubagentBaseline | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const input = value as Record<string, unknown>;
-	const output = emptySubagentBaseline();
-	for (const key of ["models", "agents", "delegation"] as const) {
-		if (input[key] !== null && typeof input[key] !== "string") return undefined;
-		output[key] = (input[key] as string | null | undefined) ?? null;
-	}
-	// v1 phase-2 snapshots did not carry this field; absence means no known
-	// refusal, not malformed state. Keep the list JSON-safe and deterministic.
-	if (input.refusedModels !== undefined && (!Array.isArray(input.refusedModels) || !input.refusedModels.every((model) => typeof model === "string"))) return undefined;
-	output.refusedModels = [...new Set((input.refusedModels as string[] | undefined) ?? [])];
-	return output;
-}
-
-/** A restored first-prepend block is a usable fallback for snapshots predating structured baselines. */
-export function subagentBaselineFromStack(stack: readonly { key?: string; text: string }[]): SubagentBaseline {
-	const baseline = emptySubagentBaseline();
-	const keys: Record<SubagentCapability, string> = {
-		models: "subagent-models", agents: "subagent-agents", delegation: "subagent-delegation",
-	};
-	for (const capability of Object.keys(keys) as SubagentCapability[]) {
-		const entry = stack.find((item) => item.key === keys[capability]);
-		baseline[capability] = entry?.text ?? null;
-	}
-	return baseline;
-}
-
-export type SubagentAnnouncement =
-	| { kind: "none"; baseline: SubagentBaseline }
-	| { kind: "standing"; baseline: SubagentBaseline }
-	| { kind: "addendum"; text: string; baseline: SubagentBaseline };
-
-/**
- * Fresh sessions may rewrite message 1; resumed sessions must leave its locked
- * block alone and describe a real capability change at the tail instead.
- */
-export function planSubagentAnnouncement(input: {
-	restored: boolean;
-	baseline: SubagentBaseline;
-	capability: SubagentCapability;
-	text: string | null;
-}): SubagentAnnouncement {
-	if (input.baseline[input.capability] === input.text) return { kind: "none", baseline: input.baseline };
-	const baseline = { ...input.baseline, [input.capability]: input.text };
-	if (!input.restored) return { kind: "standing", baseline };
-	if (input.text !== null) return { kind: "addendum", text: input.text, baseline };
-	return {
-		kind: "addendum",
-		text: "The subagent delegation guidance previously shown for this conversation is no longer active.",
-		baseline,
-	};
-}

package/extensions/tool-search/announce.ts

@@ -1,58 +0,0 @@
-/**
- * What to tell the model when the deferred-tool set changes (pure).
- *
- * The deferred-tools listing is a `first-prepend` reminder on message 1, so it
- * is part of the cached prefix of every later request. Before the first request
- * nothing is cached and the listing can be rewritten freely; after it, any
- * rewrite re-caches the whole conversation (measured 2026-09-04: 16.7k tokens
- * re-written on request 2 of a run whose MCP tools registered inside the
- * announce debounce). So once a request has gone out the listing is FROZEN and
- * later arrivals ride a one-shot addendum where the model reads next. Names that
- * disappear are not announced: the frozen listing keeps them and `tool_search`
- * reports "not found" if the model asks for one.
- */
-
-export type AnnouncementPlan =
-	| { kind: "none" }
-	/** Nothing is cached yet: (re)write the standing listing with every name. */
-	| { kind: "rewrite"; names: string[] }
-	/** Message 1 is frozen: announce only the new names as a one-shot. */
-	| { kind: "addendum"; added: string[] };
-
-export function planAnnouncement(input: {
-	requestSent: boolean;
-	announced: ReadonlySet<string>;
-	available: readonly string[];
-}): AnnouncementPlan {
-	if (!input.requestSent) {
-		return input.available.length === 0 ? { kind: "none" } : { kind: "rewrite", names: [...input.available] };
-	}
-	const added = input.available.filter((name) => !input.announced.has(name));
-	return added.length === 0 ? { kind: "none" } : { kind: "addendum", added };
-}
-
-/** JSON-safe persisted baseline for the names already described to the model. */
-export function deferredToolsBaseline(value: unknown): string[] | undefined {
-	if (!Array.isArray(value) || !value.every((name) => typeof name === "string")) return undefined;
-	return [...new Set(value)];
-}
-
-/** Compatibility fallback for a v1 stack written before structured baselines. */
-export function deferredToolsFromReminder(text: string | undefined): string[] | undefined {
-	if (!text) return undefined;
-	const marker = "\n";
-	const lines = text.split(marker);
-	return lines.length > 1 && lines[0].startsWith("The following deferred tools are available via tool_search")
-		? lines.slice(1).filter(Boolean)
-		: undefined;
-}
-
-/** Bring the announced set in line with what the plan told the model. */
-export function applyAnnouncement(announced: Set<string>, plan: AnnouncementPlan): void {
-	if (plan.kind === "rewrite") {
-		announced.clear();
-		for (const name of plan.names) announced.add(name);
-	} else if (plan.kind === "addendum") {
-		for (const name of plan.added) announced.add(name);
-	}
-}