surshar / claude-code

Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows - all through natural language commands.

		@@ -6,8 +6,16 @@
6	6	<author><name>Anthropic</name></author>
7	7	<link rel="alternate" type="text/html" href="https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md"/>
8	8	<link rel="self" type="application/atom+xml" href="https://raw.githubusercontent.com/anthropics/claude-code/main/feed.xml"/>
9		- <updated>2026-09-18T18:06:17Z</updated>
	9	+ <updated>2026-09-19T03:10:24Z</updated>
10	10	<entry>
	11	+ <id>https://github.com/anthropics/claude-code/releases/tag/v2.1.278</id>
	12	+ <title>Claude Code v2.1.278</title>
	13	+ <link rel="alternate" type="text/html" href="https://github.com/anthropics/claude-code/releases/tag/v2.1.278"/>
	14	+ <updated>2026-09-19T03:10:24Z</updated>
	15	+ <content type="html"><p>• Changed auto mode for Claude API and Enterprise users, and on Bedrock, Vertex, Foundry and gateways, to default to the server-side classifier, which does not charge for classifier overhead (CLAUDE_CODE_AUTO_MODE_SERVER=0 opts out on Bedrock, Vertex, Foundry and gateways); warns on billed fallback. See https://code.claude.com/docs/en/auto-mode-classifier-billing</p>
	16	+<p>• Added an Auto mode server row to /status showing whether this session's auto mode classifier runs on the server</p></content>
	17	+ </entry>
	18	+ <entry>
11	19	<id>https://github.com/anthropics/claude-code/releases/tag/v2.1.277</id>
12	20	<title>Claude Code v2.1.277</title>
13	21	<link rel="alternate" type="text/html" href="https://github.com/anthropics/claude-code/releases/tag/v2.1.277"/>
		@@ -1150,14 +1158,4 @@
1150	1158	<p>• [VSCode] Changed the action menu to list slash commands in a filterable "Slash commands" dialog instead of inline; picking one runs it; the MCP servers dialog gained the same filter box</p>
1151	1159	<p>• [VSCode] Changed "Delete session" to "Archive session": archived sessions move to a collapsible "Archived sessions" group at the bottom of the list with an Unarchive action</p></content>
1152	1160	</entry>
1153		- <entry>
1154		- <id>https://github.com/anthropics/claude-code/releases/tag/v2.1.252</id>
1155		- <title>Claude Code v2.1.252</title>
1156		- <link rel="alternate" type="text/html" href="https://github.com/anthropics/claude-code/releases/tag/v2.1.252"/>
1157		- <updated>2026-08-31T19:46:48Z</updated>
1158		- <content type="html"><p>• Fixed Bash commands failing with "task output swap refused (tasks dir moved or linked)" on some Macs</p>
1159		-<p>• Fixed "always allow" not saving in a project that has no .claude/settings.local.json yet</p>
1160		-<p>• Fixed Remote Control sessions hosted by Claude Desktop or VS Code stalling for minutes after a tool finished when the connection to claude.ai was degraded</p>
1161		-<p>• Fixed background task notifications with very large failure output (for example git errors on a full disk) making the conversation exceed the API request size limit</p></content>
1162		- </entry>
1163	1161	</feed>

		@@ -9,7 +9,7 @@
9	9	\| --- \| --- \| --- \|
10	10	\| [`sec-default`](sec-default) \| Keeps an organization's classic hooks, prompt content, managed settings and tool policy out of reach of the plugins a person installs; adds no policy of its own. \| Outermost, on a machine with managed settings or for a Team or Enterprise organization, unless managed `prependPlugins` says otherwise \|
11	11	\| [`diff`](diff) \| `/diff`: the session's uncommitted changes in a pane beside the transcript, file by file with their hunks, refreshed as Claude edits files and runs commands. \| Built in \|
12		-\| [`telemetry`](telemetry) \| Adds `$.telemetry` (`log`, `mark`) in the `engine.create` fold so a plugin can record an event as a first-party analytics row; sends nothing wherever Claude Code's analytics are off. \| Built in \|
	12	+\| [`telemetry`](telemetry) \| Adds `$.telemetry` (`log`, `mark`) in the `engine.create` fold so a built-in plugin can record an event as a first-party analytics row, sent in batches; refuses installed plugins; sends nothing wherever Claude Code's analytics are off. \| Built in \|
13	13	\| [`agents-md`](agents-md) \| `AGENTS.md` as project instructions, by one option: loaded where the project has no `CLAUDE.md` of its own (`claude-md-or-agents-md`, the default) or beside it (`claude-md-and-agents-md`), placed and framed exactly as the engine places `CLAUDE.md`, nested ones on a `Read`; or the project's and the person's instruction files dropped and the organization's kept (`managed-only`); or `CLAUDE.md` alone, as the engine reads it (`claude-md`). \| Built in \|
14	14
15	15	Each folder is a complete plugin: `.claude-plugin/plugin.json`, a

		@@ -13,12 +13,19 @@
13	13	through Buttons that declare the engine's own actions. The pane refreshes
14	14	as Claude edits and runs shell commands, and while it is open it polls
15	15	the repository's HEAD so a commit or checkout made elsewhere shows too.
16		-The first successful edit of a session opens the pane by itself where the
	16	+The main loop's first successful edit of a session opens the pane by
	17	+itself, as the built-in panel opens on its first checkpoint: where the
17	18	layout docks it beside the transcript (the fullscreen layout, which each
18		-drawing's `viewport` says) and the terminal is wide enough (144 columns
19		-when the person never chose, 110 when they kept it open before; a person
20		-who closed it is left alone); where the surface does not say, nothing
21		-opens by itself.
	19	+drawing's `viewport` says), the terminal is wide enough (144 columns when
	20	+the person never chose, 110 when they kept it open before; a person who
	21	+closed it is left alone) and file checkpointing is on; a subagent's edit
	22	+opens nothing, and where the surface does not say, nothing opens by
	23	+itself. A docked pane fetches before it opens, as the built-in panel
	24	+primes its data, so it never lands on `Loading diff…`; an open the engine
	25	+leaves waiting undrawn is withdrawn, so no later resize seats it, and the
	26	+next edit asks again. A session resumed or continued whose transcript
	27	+already holds such an edit opens the pane on the same terms as soon as the
	28	+width is known, as the built-in opens on the history it restores.
22	29
23	30	Under the fullscreen layout a terminal under 110 columns gets the
24	31	built-in's line asking for a wider one and nothing opens. Without that
		@@ -34,7 +41,9 @@
34	41	file: its hunks ride the next prompt as context, once.
35	42
36	43	The pane compares the working tree against HEAD, split at the session's
37		-start (the default), against HEAD plainly, or against the merge-base with
	44	+start (the default; the start the engine gives in `$.session.usage()`, so a
	45	+resumed session keeps its first and `/clear` begins anew), against HEAD
	46	+plainly, or against the merge-base with
38	47	the default branch; the base line under the header names a base other than
39	48	the session's, and the choice is kept per repository in the plugin's store.
40	49	A picker shows one earlier turn's edits instead of the working tree, read
		@@ -60,7 +69,7 @@
60	69
61	70	\| event \| what the hook does \|
62	71	\| --- \| --- \|
63		-\| `session.start` \| Binds the engine once and registers `/diff` (a session where another `/diff` is listed leaves the plugin idle); asks nothing of the repository, which `/diff` or the first edit pins when it comes. \|
	72	+\| `session.start` \| Binds the engine once and registers `/diff` (a session where another `/diff` is listed leaves the plugin idle); asks nothing of the repository, which `/diff` or the first edit pins when it comes; off its dispatch, reads the transcript, and for a resumed session whose turns edited opens the pane as the first edit would. \|
64	73	\| `ui.render` of `PromptHint` \| Reads the terminal's width and whether its layout docks a pane, which decide whether the first edit opens the pane. \|
65	74	\| `ui.render` of `Pane` \| Draws the pane: docked, the header, base line, source picker, file list and toggles over the window of hunks; inline, the dialog. \|
66	75	\| `command.run` of `diff` \| Pins the repository when none is, opens or closes the pane (focused and closing on Escape without the fullscreen layout), says which, and remembers the choice. \|
		@@ -68,16 +77,17 @@
68	77	\| `ui.scroll` of the pane \| Docked, moves the hunks under the pinned header and list (three rows a wheel tick, a page a page key), or the list when the wheel is over it, and keeps the engine's window still. \|
69	78	\| `ui.focus` in the pane \| In the dialog's list, selects the file the ring lands on, re-centres the five rows on it, and lands the ring where that row now sits. \|
70	79	\| `command.run` of `clear`, `resume` \| Closes the pane and forgets the session's state, the pinned repository with it. \|
71		-\| `tool.call` of `Edit`, `Write`, `NotebookEdit` \| After an edit that landed (not refused, not failed), refreshes an open pane; the session's first such edit opens it, pinning the repository then if the terminal has the room. \|
	80	+\| `tool.call` of `Edit`, `Write`, `NotebookEdit` \| After an edit that landed (not refused, not failed), refreshes an open pane; the main loop's first such edit opens it, pinning the repository then if the terminal has the room and checkpointing is on. \|
72	81	\| `tool.call` of `Bash`, `PowerShell` \| After a command that was not refused, failed and interrupted ones too, refreshes an open pane. \|
73	82	\| `prompt.submit` \| Adds the armed file's hunks to the prompt's context and disarms. \|
74	83
75	84	## What it calls on `$`
76	85
77		-`clock.after`, `clock.every`, `clock.now`, `command.register`, `fs.list`,
78		-`fs.read`, `fs.stat`, `process.run` (git, read-only), `session.messages`,
79		-`store.get`, `store.set`, `telemetry.log`, `telemetry.mark`, `ui.close`,
80		-`ui.invalidate`, `ui.log`, `ui.open`, `ui.resolve`, `ui.status`.
	86	+`clock.after`, `clock.every`, `clock.now`, `command.register`, `env.get`
	87	+(`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`), `fs.list`, `fs.read`, `fs.stat`,
	88	+`process.run` (git, read-only), `session.id`, `session.messages`,
	89	+`settings.read`, `store.get`, `store.set`, `telemetry.log`, `telemetry.mark`,
	90	+`ui.close`, `ui.invalidate`, `ui.log`, `ui.open`, `ui.resolve`, `ui.status`.
81	91
82	92	`$.telemetry` is the telemetry plugin's noun; where it is absent the rows
83	93	are dropped and nothing else changes.

		@@ -65,6 +65,12 @@
65	65	storeSet: (key: string, value: unknown) => Promise<void>
66	66
67	67	/**
	68	+ * Whether the session checkpoints edits (`$.settings.read`, `$.env.get`):
	69	+ * the built-in panel opens on an edit only while it does.
	70	+ */
	71	+ isCheckpointing: () => Promise<boolean>
	72	+
	73	+ /**
68	74	* `$.session.messages`.
69	75	*/
70	76	messages: () => Promise<SessionMessage[]>
		@@ -105,6 +111,14 @@
105	111	sessionId: () => Promise<string>
106	112
107	113	/**
	114	+ * When the session began, `$.session.usage`'s `startedAt`: where the line
	115	+ * between this session's edits and earlier ones falls, a resumed session's
	116	+ * first start, moved by `/clear`. Not a number under an engine that
	117	+ * predates it, where the plugin's own start stands in.
	118	+ */
	119	+ startedAt: () => Promise<unknown>
	120	+
	121	+ /**
108	122	* `$.telemetry.mark`; rejects where the telemetry built-in is absent.
109	123	*/
110	124	mark: EngineInterface['telemetry']['mark']

		@@ -8,6 +8,7 @@
8	8	export * from './entry-kinds-of'
9	9	export * from './git'
10	10	export * from './host'
	11	+export * from './is-checkpointing'
11	12	export * from './is-on-pane-surface'
12	13	export * from './is-record'
13	14	export * from './kept-of'

		@@ -1,0 +1,3 @@
	1	+export * from './is-checkpointing.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,20 @@
	1	+import type { Settings } from 'claude-code'
	2	+
	3	+/**
	4	+ * Whether the session checkpoints Claude's edits, read as the built-in
	5	+ * reads it: the setting on unless set false, the variable unset or falsy.
	6	+ *
	7	+ * The built-in panel opens on an edit only through a checkpoint, so with
	8	+ * checkpointing off its first-edit open never happens; `/diff` still opens.
	9	+ *
	10	+ * @param settings the merged settings (`$.settings.read()`)
	11	+ * @param disabling `CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING` as `$.env.get`
	12	+ * answers it
	13	+ * @returns false when either turns checkpointing off
	14	+ */
	15	+export const isCheckpointing = (
	16	+ settings: Settings,
	17	+ disabling: string \| undefined,
	18	+): boolean =>
	19	+ settings.fileCheckpointingEnabled !== false &&
	20	+ !['1', 'true', 'yes', 'on'].includes((disabling ?? '').trim().toLowerCase())

		@@ -1,4 +1,5 @@
1	1	import type {
	2	+ Args,
2	3	On,
3	4	PaneOpenArgs,
4	5	ResultOf,
		@@ -13,7 +14,9 @@
13	14	import { entryKindsOf } from './entry-kinds-of'
14	15	import type Git from './git'
15	16	import type { Host } from './host'
	17	+import { isCheckpointing } from './is-checkpointing'
16	18	import { isOnPaneSurface } from './is-on-pane-surface'
	19	+import { isRecord } from './is-record'
17	20	import Limits from './limits'
18	21	import { mapLimited } from './map-limited'
19	22	import { messageOf } from './message-of'
		@@ -23,6 +26,7 @@
23	26	import PaneToggle from './pane-toggle'
24	27	import Record from './record'
25	28	import Tools from './tools'
	29	+import Turns from './turns'
26	30	import Views from './views'
27	31
28	32	/**
		@@ -30,8 +34,11 @@
30	34	* pane's drawing and refresh, its opening on Claude's first edit, the ask.
31	35	*
32	36	* Git runs when the built-in's would: `session.start` binds the host and
33		- * registers `/diff`; `/diff` or the first edit with room pins the backend
34		- * where the session started, until `/clear`; an open pane alone fetches.
	37	+ * registers `/diff`, and off its dispatch reads the transcript, so a resumed
	38	+ * session whose turns already edited opens as its first edit would; `/diff`
	39	+ * or the main loop's first checkpointed edit with room pins the backend,
	40	+ * until `/clear`, which reads afresh under a pane it leaves open; a docked
	41	+ * pane fetches, then opens.
35	42	*
36	43	* @param on the engine's registrar
37	44	*/
		@@ -43,6 +50,7 @@
43	50	let isPaneOpen = false
44	51	let dialogRows: number \| null = null
45	52	let hasAutoOpened = false
	53	+ let hasRestoredEdits = false
46	54	let columns: number \| null = null
47	55	let shownSessionId: string \| null = null
48	56	let armed: Ask.ArmedAsk \| null = null
		@@ -50,6 +58,7 @@
50	58	let isRefreshing = false
51	59	let isRefreshQueued = false
52	60	let generation = 0
	61	+ let landed = 0
53	62	let bodyStamp: string \| null = null
54	63	let bodyBase: string \| null = null
55	64
		@@ -394,7 +403,7 @@
394	403	async function openPane(
395	404	engine: Host,
396	405	trigger: (typeof Record.SHOWN_TRIGGERS)[number],
397		- ): Promise<void> {
	406	+ ): Promise<boolean> {
398	407	const isDialog = model.isFullscreen === false
399	408
400	409	model = {
		@@ -406,12 +415,26 @@
406	415
407	416	dialogRows = isDialog ? Views.dialogRowsOf(model) : null
408	417
409		- await engine.openPane(
	418	+ const landedBefore = landed
	419	+
	420	+ if (!isDialog) {
	421	+ await refresh(engine).catch(() => undefined)
	422	+ }
	423	+
	424	+ const opened = await engine.openPane(
410	425	isDialog
411	426	? { ...dialogPane(), focus: true }
412	427	: { id: Names.PANE_ID, title: Names.PANE_TITLE, holdToasts: true },
413	428	)
414	429
	430	+ const isWaiting = isRecord(opened) && opened.isPlaced === false
	431	+
	432	+ if (isWaiting) {
	433	+ await engine.closePane({ id: Names.PANE_ID }).catch(() => undefined)
	434	+
	435	+ return false
	436	+ }
	437	+
415	438	isPaneOpen = true
416	439
417	440	const sessionId = await engine.sessionId().catch(() => null)
		@@ -421,7 +444,13 @@
421	444	Record.recorderOf(engine).shown(trigger, Record.widthBucketOf(columns))
422	445	}
423	446
424		- void refresh(engine)
	447	+ const isStale = isDialog \|\| landed !== landedBefore
	448	+
	449	+ if (isStale) {
	450	+ void refresh(engine)
	451	+ }
	452	+
	453	+ return true
425	454	}
426	455
427	456	async function closePane(engine: Host): Promise<void> {
		@@ -460,6 +489,12 @@
460	489	return
461	490	}
462	491
	492	+ const isCheckpointed = await engine.isCheckpointing().catch(() => true)
	493	+
	494	+ if (!isCheckpointed \|\| isTaken()) {
	495	+ return
	496	+ }
	497	+
463	498	await pinBackend(engine)
464	499
465	500	if (!backend \|\| isTaken()) {
		@@ -467,9 +502,19 @@
467	502	}
468	503
469	504	hasAutoOpened = true
470		- await openPane(engine, 'auto_open')
	505	+ hasAutoOpened = await openPane(engine, 'auto_open')
471	506	}
472	507
	508	+ async function openOnRestore(engine: Host): Promise<void> {
	509	+ const messages = await engine.messages().catch((): SessionMessage[] => [])
	510	+
	511	+ hasRestoredEdits = Turns.turnDiffsOf(messages).length > 0
	512	+
	513	+ if (hasRestoredEdits) {
	514	+ await openOnFirstEdit(engine)
	515	+ }
	516	+ }
	517	+
473	518	function disarm(engine: Host) {
474	519	armed = null
475	520	model = { ...model, armedPath: null }
		@@ -574,8 +619,14 @@
574	619	redraw(engine)
575	620	}
576	621
	622	+ async function startedAtOf(engine: Host): Promise<number \| null> {
	623	+ const startedAt: unknown = await engine.startedAt().catch(() => undefined)
	624	+
	625	+ return typeof startedAt === 'number' ? startedAt : null
	626	+ }
	627	+
577	628	async function bind(engine: Host, cwd: string): Promise<void> {
578		- sessionStartMs = await engine.now()
	629	+ sessionStartMs = (await startedAtOf(engine)) ?? (await engine.now())
579	630	pin.cwd = cwd
580	631
581	632	try {
		@@ -602,6 +653,11 @@
602	653	readFile: path => $.fs.read(path),
603	654	storeGet: key => $.store.get(key),
604	655	storeSet: (key, value) => $.store.set(key, value),
	656	+ isCheckpointing: async () =>
	657	+ isCheckpointing(
	658	+ await $.settings.read(),
	659	+ await $.env.get('CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING'),
	660	+ ),
605	661	messages: () => $.session.messages(),
606	662	invalidate: () => $.ui.invalidate('ui.render'),
607	663	status: text => $.ui.status(text),
		@@ -610,12 +666,22 @@
610	666	closePane: pane => $.ui.close(pane),
611	667	registerCommand: spec => $.command.register(spec),
612	668	sessionId: () => $.session.id(),
	669	+ startedAt: () =>
	670	+ $.session
	671	+ .usage()
	672	+ .then((usage: unknown) =>
	673	+ isRecord(usage) ? usage.startedAt : undefined,
	674	+ ),
613	675	mark: entry => $.telemetry.mark(entry),
614	676	log: entry => $.telemetry.log(entry),
615	677	},
616	678	e.cwd,
617	679	)
618	680
	681	+ if (host) {
	682	+ void openOnRestore(host).catch(() => undefined)
	683	+ }
	684	+
619	685	return next(e)
620	686	})
621	687
		@@ -624,12 +690,18 @@
624	690	const viewport: { columns?: number; isFullscreen?: boolean } \| undefined =
625	691	e.viewport
626	692
	693	+ const isFirstMeasure = columns === null && viewport?.columns !== undefined
	694	+
627	695	columns = viewport?.columns ?? columns
628	696
629	697	model = {
630	698	...model,
631	699	isFullscreen: viewport?.isFullscreen ?? model.isFullscreen,
632	700	}
	701	+
	702	+ if (isFirstMeasure && hasRestoredEdits && host) {
	703	+ void openOnFirstEdit(host).catch(() => undefined)
	704	+ }
633	705	}
634	706
635	707	return next(e)
		@@ -699,8 +771,15 @@
699	771	}
700	772
701	773	const isOpening = toggle === 'open'
702		- await (isOpening ? openPane(host, 'manual') : closePane(host))
703	774
	775	+ const isDone = isOpening
	776	+ ? await openPane(host, 'manual')
	777	+ : await closePane(host).then(() => true)
	778	+
	779	+ if (!isDone) {
	780	+ return { text: Names.RESIZE_TERMINAL_TEXT }
	781	+ }
	782	+
704	783	if (!isFullscreen) {
705	784	return isOpening ? {} : { text: Names.DIALOG_DISMISSED_TEXT }
706	785	}
		@@ -799,29 +878,48 @@
799	878	on('command.run', { command: ['clear', 'resume'] }, async ($, e, next) => {
800	879	const result = await next(e)
801	880
802		- if (host) {
803		- if (isPaneOpen) {
804		- await closePane(host).catch(() => undefined)
805		- }
	881	+ if (!host) {
	882	+ return result
	883	+ }
806	884
807		- unpin()
808		- hasAutoOpened = false
809		- bodyStamp = null
810		- bodyBase = null
811		- bodyLoads.clear()
812		- disarm(host)
813		- model = PaneState.afterNewSession(model)
	885	+ const isResume = e.command === 'resume'
	886	+ const isKeptOpen = isPaneOpen && !isResume
	887	+
	888	+ if (isPaneOpen && isResume) {
	889	+ await closePane(host).catch(() => undefined)
814	890	}
815	891
	892	+ unpin()
	893	+ hasAutoOpened = false
	894	+ hasRestoredEdits = false
	895	+ bodyStamp = null
	896	+ bodyBase = null
	897	+ bodyLoads.clear()
	898	+ disarm(host)
	899	+ model = PaneState.afterNewSession(model)
	900	+
	901	+ sessionStartMs =
	902	+ (await startedAtOf(host)) ??
	903	+ (isResume ? sessionStartMs : await host.now())
	904	+
	905	+ if (isKeptOpen) {
	906	+ await pinBackend(host)
	907	+ void refresh(host)
	908	+ }
	909	+
	910	+ if (isResume) {
	911	+ void openOnRestore(host).catch(() => undefined)
	912	+ }
	913	+
816	914	return result
817	915	})
818	916
819	917	function afterTool(
820	918	engine: Host,
821		- tool: string,
	919	+ e: Args<'tool.call'>,
822	920	result: ResultOf['tool.call'] \| undefined,
823	921	) {
824		- const isEdit = Tools.EDITING_TOOLS.some(name => name === tool)
	922	+ const isEdit = Tools.EDITING_TOOLS.some(name => name === e.tool)
825	923
826	924	const hasEdited =
827	925	isEdit &&
		@@ -829,14 +927,19 @@
829	927	result.deny === undefined &&
830	928	result.isError !== true
831	929
832		- const isStale =
833		- isPaneOpen && (isEdit ? hasEdited : Tools.mayHaveWritten(result))
	930	+ const hasLanded = isEdit ? hasEdited : Tools.mayHaveWritten(result)
834	931
835		- if (isStale) {
	932	+ if (hasLanded) {
	933	+ landed += 1
	934	+ }
	935	+
	936	+ if (hasLanded && isPaneOpen) {
836	937	scheduleRefresh(engine)
837	938	}
838	939
839		- if (hasEdited) {
	940	+ const isMainLoopEdit = hasEdited && e.agentId === undefined
	941	+
	942	+ if (isMainLoopEdit) {
840	943	void openOnFirstEdit(engine).catch(() => undefined)
841	944	}
842	945	}
		@@ -853,7 +956,7 @@
853	956	return result
854	957	} finally {
855	958	if (host) {
856		- afterTool(host, e.tool, result)
	959	+ afterTool(host, e, result)
857	960	}
858	961	}
859	962	},

		@@ -1,0 +1,35 @@
	1	+import type { SessionMessage, Settings } from 'claude-code'
	2	+
	3	+/**
	4	+ * What the world beneath a repository session holds and answers besides
	5	+ * git: the store, the settings, the environment, the transcript, whether a
	6	+ * pane is seated.
	7	+ */
	8	+export type Beneath = {
	9	+ /**
	10	+ * What the plugin's store holds at the start; nothing when not given.
	11	+ */
	12	+ stored?: Readonly<Record<string, unknown>>
	13	+
	14	+ /**
	15	+ * What `$.settings.read` answers; empty when not given.
	16	+ */
	17	+ settings?: Settings
	18	+
	19	+ /**
	20	+ * The variables `$.env.get` answers from; none set when not given.
	21	+ */
	22	+ env?: Readonly<Record<string, string>>
	23	+
	24	+ /**
	25	+ * What `$.session.messages` answers each time it is read, as a resumed
	26	+ * session's transcript already holds turns; empty when not given.
	27	+ */
	28	+ messages?: () => readonly SessionMessage[]
	29	+
	30	+ /**
	31	+ * Whether an open made now is left waiting undrawn (LEFT_WAITING), as an
	32	+ * engine leaves an unasked open on a narrow terminal; placed when not given.
	33	+ */
	34	+ isLeftWaiting?: () => boolean
	35	+}

		@@ -1,0 +1,5 @@
	1	+export type * from './beneath.js'
	2	+export * from './left-waiting.js'
	3	+export * from './slow-diff-ms.js'
	4	+
	5	+export * as default from '.'

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * How long a slow repository takes to answer `git diff` in the tests that
	3	+ * time the pane's opening against its first fetch: well inside git's timeout.
	4	+ */
	5	+export const SLOW_DIFF_MS = 3000

		@@ -1,6 +1,7 @@
1	1	import type { Args, On } from 'claude-code'
2	2	import { mock } from 'claude-code/testing'
3	3
	4	+import Beneath from './beneath'
4	5	import { gitIn } from './git-in.js'
5	6	import { HINT_DRAWN } from './hint-drawn.js'
6	7	import { keeping } from './keeping.js'
		@@ -11,24 +12,26 @@
11	12	* A session in a repository git answers for from a script (REPOSITORY, in
12	13	* /work, when none is given), keeping what the plugin does there.
13	14	*
14		- * Kept: each git run, ring move, pane opened or closed, status line. The clock
15		- * starts at 0 and the engine draws the hint. A test that rewrites the
16		- * script between calls changes what git answers next.
	15	+ * Kept: each git run, ring move, pane opened, left waiting or closed, status
	16	+ * line. The clock starts at 0 and the engine draws the hint; the rest of the
	17	+ * world is the test's (Beneath). Rewriting the script changes git's answers.
17	18	*
18	19	* @param on the test's `on`
19	20	* @param script git's output for each invocation whose line holds the key
20		- * @param stored what the plugin's store holds at the start
21		- * @returns the runs, the ring's moves, the panes opened and closed, the
22		- * statuses, the clock
	21	+ * @param beneath the store, settings, environment, transcript, whether an
	22	+ * open is seated
	23	+ * @returns the runs, the ring's moves, the panes opened, left waiting and
	24	+ * closed, the statuses, the clock
23	25	*/
24	26	export function inRepository(
25	27	on: On,
26	28	script: Readonly<Record<string, string>> = REPOSITORY,
27		- stored: Readonly<Record<string, unknown>> = {},
	29	+ beneath: Beneath.Beneath = {},
28	30	) {
29	31	const runs: Args<'process.run'>[] = []
30	32	const focused: Args<'ui.focus'>[] = []
31	33	const statuses: (string \| undefined)[] = []
	34	+ const waiting: Args<'ui.open'>[] = []
32	35	const opened = keeping<Args<'ui.open'>>()

		@@ -1,0 +1,14 @@
	1	+/**
	2	+ * What `$.session.usage()` answers for a session that began at the given
	3	+ * moment: an empty window, no rate limits, nothing spent.
	4	+ *
	5	+ * Left untyped, so it compiles against declarations that predate `startedAt`.
	6	+ *
	7	+ * @param startedAt when the session began, by the test's clock
	8	+ * @returns the usage
	9	+ */
	10	+export const usageAt = (startedAt: number) => ({
	11	+ startedAt,
	12	+ context: { window: 200_000 },
	13	+ rateLimits: [],
	14	+})

		@@ -94,4 +94,42 @@
94	94	expect(drawn).toContain('moved.ts')
95	95	expect(drawn).toContain('+1 file edited before this session (show)')
96	96	})
	97	+
	98	+ test("the session began when the engine says: a resumed one's first start, again at /clear", async ($, on) => {
	99	+ let startedAt = 0
	100	+
	101	+ const clock = Fixtures.startsSession(on, Fixtures.SETTLE_MS)
	102	+
	103	+ on('process.run', ($, e) => ({
	104	+ value: Fixtures.gitIn(e.argv, Fixtures.MOVED_IN),
	105	+ }))
	106	+
	107	+ on('ui.open', () => ({ value: undefined }))
	108	+ on('ui.invalidate', () => ({ value: undefined }))
	109	+ on('session.messages', () => ({ value: [] }))
	110	+ on('session.usage', () => ({ value: Fixtures.usageAt(startedAt) }))
	111	+ on('command.run', { command: 'clear' }, () => ({}))
	112	+ Fixtures.oldFiles(on)
	113	+ mock.store(on)
	114	+
	115	+ await $.session.start(Fixtures.SESSION)
	116	+ await $.command.run(Fixtures.DIFF)
	117	+ await clock.advance(Fixtures.SETTLE_MS)
	118	+
	119	+ expect(
	120	+ Fixtures.textOf(await $.ui.render(Fixtures.PANE)),
	121	+ 'resumed from before the old files were written: both are the ' +
	122	+ "session's, as the built-in restores its start",
	123	+ ).toContain('2 files changed +2 -2')
	124	+
	125	+ startedAt = clock.now()
	126	+
	127	+ await $.command.run(Fixtures.CLEAR)
	128	+ await clock.advance(Fixtures.SETTLE_MS)
	129	+
	130	+ expect(
	131	+ Fixtures.textOf(await $.ui.render(Fixtures.PANE)),
	132	+ '/clear started the session over, past the dirty file',

		@@ -1,0 +1,17 @@
	1	+import type { ResultOf } from 'claude-code'
	2	+
	3	+/**
	4	+ * What an engine answers an open it leaves waiting undrawn: the plugin
	5	+ * opened unasked on a terminal narrower than an unrequested pane is given.
	6	+ *
	7	+ * Typed through `never` so it compiles against declarations that predate the
	8	+ * answer, where `ui.open` resolves nothing.
	9	+ */
	10	+export const LEFT_WAITING: ResultOf['ui.open'] = {
	11	+ value: {
	12	+ isPlaced: false,
	13	+ reason:
	14	+ 'unasked below 144 columns (120 now): placed when the person opens ' +
	15	+ 'it, or when the terminal is widened to 144 columns',
	16	+ } as never,
	17	+}

		@@ -1,0 +1,14 @@
	1	+import type { SessionMessage } from 'claude-code'
	2	+
	3	+import { editPatchOf } from './edit-patch-of.js'
	4	+import TurnDiffsOf from './turn-diffs-of'
	5	+
	6	+/**
	7	+ * A transcript a resumed session brings back whose one turn edited a file:
	8	+ * the prompt, the Edit that landed, its result.
	9	+ */
	10	+export const EDITED_TRANSCRIPT: readonly SessionMessage[] = [
	11	+ TurnDiffsOf.promptOf('change a to b'),
	12	+ TurnDiffsOf.editsOf(editPatchOf(['-a', '+b'])),
	13	+ TurnDiffsOf.toolResults(),
	14	+]

		@@ -1,6 +1,7 @@
1	1	export * from './answers-of.js'
2	2	export * from './ask'
3	3	export * from './backend-of'
	4	+export * from './beneath'
4	5	export * from './big-lines.js'
5	6	export * from './branch-base-of'
6	7	export * from './builtin-holds.js'
		@@ -12,6 +13,7 @@
12	13	export * from './diff.js'
13	14	export * from './diff-at.js'
14	15	export * from './edit-patch-of.js'
	16	+export * from './edited-transcript.js'
15	17	export * from './fetch-diff'
16	18	export * from './git-hung.js'
17	19	export * from './git-in.js'
		@@ -42,6 +44,7 @@
42	44	export * from './renamed.js'
43	45	export * from './repository.js'
44	46	export * from './repository-of'
	47	+export * from './resume.js'
45	48	export * from './ring-onto.js'
46	49	export * from './scripted'
47	50	export * from './session.js'
		@@ -54,6 +57,7 @@
54	57	export * from './two-files.js'
55	58	export * from './typed-prompt-of.js'
56	59	export * from './unsaid-hint.js'
	60	+export * from './usage-at.js'
57	61	export * from './vs-main.js'
58	62	export * from './wheel-over-list.js'
59	63	export * from './wheel-tick.js'

		@@ -1,0 +1,12 @@
	1	+import type { CommandRunInput } from 'claude-code'
	2	+
	3	+/**
	4	+ * The command that brings an earlier conversation back, as the person types
	5	+ * it under the fullscreen layout on a 160-column terminal.
	6	+ */
	7	+export const RESUME: CommandRunInput = {
	8	+ command: 'resume',
	9	+ args: '',
	10	+ origin: { kind: 'composer' },
	11	+ presentation: { isFullscreen: true, columns: 160 },
	12	+}

		@@ -1,4 +1,4 @@
1		-import type { Args, ResultOf } from 'claude-code'
	1	+import type { Args, ResultOf, SessionMessage } from 'claude-code'
2	2	import { describe, expect, mock, test, tier } from 'claude-code/testing'
3	3
4	4	import Limits from '../hooks/limits'
		@@ -483,18 +483,372 @@
483	483	).toEqual(['diff'])
484	484	})
485	485
486		- test('/clear closes the pane it finds open', async ($, on) => {
	486	+ test("only the main loop's edit opens the pane", async ($, on) => {
487	487	const world = Fixtures.inRepository(on)
488	488
	489	+ const edit = (agentId?: string) =>
	490	+ $.tool.call({
	491	+ tool: 'Write',
	492	+ file_path: '/work/app.ts',
	493	+ content: '2',
	494	+ ...(agentId !== undefined && { agentId }),
	495	+ })
	496	+
	497	+ on('tool.call', () => ({ result: 'written' }))
	498	+
	499	+ await $.session.start(Fixtures.SESSION)
	500	+ await $.ui.render(Fixtures.HINT)
	501	+ await edit('a-explorer')
	502	+ await world.clock.advance(Fixtures.SETTLE_MS)
	503	+
	504	+ expect(world.opened, 'the built-in checkpoints no subagent edit').toEqual(
	505	+ [],
	506	+ )
	507	+
	508	+ expect(world.runs, 'so nothing was asked of the repository').toEqual([])
	509	+
	510	+ await edit()
	511	+ await world.clock.advance(Fixtures.SETTLE_MS)
	512	+
	513	+ expect(
	514	+ world.opened.map(pane => pane.id),
	515	+ "the main loop's",
	516	+ ).toEqual(['diff'])
	517	+ })
	518	+
	519	+ test('checkpointing off in settings: edits open nothing', async ($, on) => {
	520	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	521	+ settings: { fileCheckpointingEnabled: false },
	522	+ })
	523	+
	524	+ on('tool.call', () => ({ result: 'edited' }))
	525	+
	526	+ await $.session.start(Fixtures.SESSION)
	527	+ await $.ui.render(Fixtures.HINT)
	528	+
	529	+ await $.tool.call({
	530	+ tool: 'Edit',
	531	+ file_path: '/work/app.ts',
	532	+ old_string: '1',
	533	+ new_string: '2',
	534	+ })
	535	+
	536	+ await world.clock.advance(Fixtures.SETTLE_MS)
	537	+
	538	+ expect(world.opened, 'the built-in opens on a checkpoint alone').toEqual([])
	539	+
	540	+ expect(world.runs, 'so nothing was asked of the repository').toEqual([])
	541	+
	542	+ expect(await $.command.run(Fixtures.DIFF)).toEqual({
	543	+ text: 'Diff panel shown',
	544	+ })
	545	+ })
	546	+
	547	+ test('checkpointing off by variable: edits open nothing', async ($, on) => {
	548	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	549	+ env: { CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING: 'true' },
	550	+ })
	551	+
	552	+ on('tool.call', () => ({ result: 'edited' }))
	553	+
	554	+ await $.session.start(Fixtures.SESSION)
	555	+ await $.ui.render(Fixtures.HINT)
	556	+
	557	+ await $.tool.call({
	558	+ tool: 'Edit',
	559	+ file_path: '/work/app.ts',
	560	+ old_string: '1',
	561	+ new_string: '2',
	562	+ })
	563	+
	564	+ await world.clock.advance(Fixtures.SETTLE_MS)
	565	+
	566	+ expect(world.opened).toEqual([])
	567	+ })
	568	+
	569	+ test('an open left waiting is withdrawn; /diff opens it', async ($, on) => {
	570	+ let isNarrow = true
	571	+
	572	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	573	+ stored: { [Names.STORE_OPEN_KEY]: true },
	574	+ isLeftWaiting: () => isNarrow,
	575	+ })
	576	+
	577	+ const edit = () =>
	578	+ $.tool.call({
	579	+ tool: 'Edit',
	580	+ file_path: '/work/app.ts',
	581	+ old_string: '1',
	582	+ new_string: '2',
	583	+ })
	584	+
	585	+ on('tool.call', () => ({ result: 'edited' }))
	586	+
	587	+ await $.session.start(Fixtures.SESSION)
	588	+ await $.ui.render(Fixtures.hintAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1))
	589	+ await edit()
	590	+ await world.clock.advance(Fixtures.SETTLE_MS)
	591	+
	592	+ expect(
	593	+ world.waiting.map(pane => pane.id),
	594	+ 'the edit opened',
	595	+ ).toEqual(['diff'])
	596	+
	597	+ expect(
	598	+ world.closed.map(pane => pane.id),
	599	+ 'and withdrew the pane the engine left waiting, so no resize seats it',
	600	+ ).toEqual(['diff'])
	601	+
	602	+ expect(
	603	+ world.runs.map(run => Fixtures.gitWordOf(run.argv)).slice(0, 2),
	604	+ 'the repository was found and read once before the open, as the ' +
	605	+ 'built-in primes; nothing polls for a pane no one sees',
	606	+ ).toEqual(['rev-parse --show-toplevel', 'status'])
	607	+
	608	+ expect(
	609	+ world.runs.map(run => Fixtures.gitWordOf(run.argv)),
	610	+ 'no HEAD poll for a withdrawn pane',
	611	+ ).not.toContain(Fixtures.POLL_WORD)
	612	+
	613	+ isNarrow = false
	614	+
	615	+ expect(
	616	+ await $.command.run(Fixtures.diffAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1)),
	617	+ '/diff opens it, where a pane believed open would have been hidden',
	618	+ ).toEqual({ text: 'Diff panel shown' })
	619	+
	620	+ await $.command.run(Fixtures.diffAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1))
	621	+ await edit()
	622	+ await world.clock.advance(Fixtures.SETTLE_MS)
	623	+
	624	+ expect(
	625	+ world.opened.map(pane => pane.id),
	626	+ 'closed by hand, no edit opens it again',
	627	+ ).toEqual(['diff'])
	628	+ })
	629	+
	630	+ test('an unplaced open is tried again at the next edit', async ($, on) => {
	631	+ let isNarrow = true
	632	+
	633	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	634	+ stored: { [Names.STORE_OPEN_KEY]: true },
	635	+ isLeftWaiting: () => isNarrow,
	636	+ })
	637	+
	638	+ const edit = () =>
	639	+ $.tool.call({
	640	+ tool: 'Edit',
	641	+ file_path: '/work/app.ts',
	642	+ old_string: '1',
	643	+ new_string: '2',
	644	+ })
	645	+
	646	+ on('tool.call', () => ({ result: 'edited' }))
	647	+
	648	+ await $.session.start(Fixtures.SESSION)
	649	+ await $.ui.render(Fixtures.hintAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1))
	650	+ await edit()
	651	+ await world.clock.advance(Fixtures.SETTLE_MS)
	652	+
	653	+ expect(world.opened, 'the first try waited and was withdrawn').toEqual([])
	654	+
	655	+ isNarrow = false
	656	+
	657	+ await edit()
	658	+ await world.clock.advance(Fixtures.SETTLE_MS)
	659	+
	660	+ expect(
	661	+ world.opened.map(pane => pane.id),
	662	+ 'the next edit opened it, as the built-in reads the width again then',
	663	+ ).toEqual(['diff'])
	664	+ })
	665	+
	666	+ test('a docked pane opens once its first fetch settled', async ($, on) => {
	667	+ const opened: string[] = []
	668	+ const clock = Fixtures.startsSession(on)
	669	+
	670	+ on('process.run', async ($, e) => {
	671	+ if (e.argv.includes('--shortstat')) {
	672	+ await clock.sleep(Fixtures.SLOW_DIFF_MS)
	673	+ }
	674	+
	675	+ return { value: Fixtures.gitIn(e.argv) }
	676	+ })
	677	+
	678	+ on('ui.open', ($, e) => {
	679	+ opened.push(e.id)
	680	+
	681	+ return { value: undefined }
	682	+ })
	683	+
	684	+ on('ui.close', () => ({ value: undefined }))
	685	+ on('ui.invalidate', () => ({ value: undefined }))
	686	+ on('ui.render', { component: 'PromptHint' }, () => Fixtures.HINT_DRAWN)
	687	+ on('session.messages', () => ({ value: [] }))
	688	+ on('settings.read', () => ({ value: {} }))
	689	+ on('tool.call', () => ({ result: 'edited' }))
	690	+ mock.store(on)
	691	+ mock.env(on, {})
	692	+
	693	+ await $.session.start(Fixtures.SESSION)
	694	+ await $.ui.render(Fixtures.HINT)
	695	+
	696	+ await $.tool.call({
	697	+ tool: 'Edit',
	698	+ file_path: '/work/app.ts',
	699	+ old_string: '1',
	700	+ new_string: '2',
	701	+ })
	702	+
	703	+ await clock.advance(Fixtures.SLOW_DIFF_MS - 1)
	704	+
	705	+ expect(opened, 'git has not answered: no pane, no Loading frame').toEqual(
	706	+ [],
	707	+ )
	708	+
	709	+ await clock.advance(Fixtures.SETTLE_MS)
	710	+
	711	+ expect(opened, 'the fetch settled: the pane opens filled').toEqual(['diff'])
	712	+
	713	+ const drawn = Fixtures.textOf(await $.ui.render(Fixtures.PANE))
	714	+
	715	+ expect(drawn).toContain('1 file changed')
	716	+ expect(drawn).not.toContain('Loading diff')
	717	+ })
	718	+
	719	+ test('/clear leaves the pane it finds open up and reads the repository afresh', async ($, on) => {
	720	+ const world = Fixtures.inRepository(on)
	721	+
489	722	on('command.run', { command: 'clear' }, () => ({}))
490	723
491	724	await $.session.start(Fixtures.SESSION)
492	725	await $.command.run(Fixtures.DIFF)
	726	+ await world.clock.advance(Fixtures.SETTLE_MS)
	727	+
	728	+ const read = world.runs.length
	729	+
493	730	await $.command.run(Fixtures.CLEAR)
	731	+ await world.clock.advance(Fixtures.SETTLE_MS)
494	732
495		- expect(world.closed.map(pane => pane.id)).toEqual(['diff'])
	733	+ expect(world.closed, 'as the built-in panel stays across /clear').toEqual(
	734	+ [],
	735	+ )
	736	+
	737	+ expect(
	738	+ world.runs.slice(read).map(run => Fixtures.gitWordOf(run.argv))[0],
	739	+ 'the repository found again for the conversation that starts over',
	740	+ ).toBe('rev-parse --show-toplevel')
	741	+
	742	+ expect(
	743	+ Fixtures.textOf(await $.ui.render(Fixtures.PANE)),
	744	+ 'drawn from the fresh read',
	745	+ ).toContain('1 file changed')
496	746	})
497	747
	748	+ test('a resumed session whose turns edited opens the pane before any new edit', async ($, on) => {
	749	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	750	+ messages: () => Fixtures.EDITED_TRANSCRIPT,
	751	+ })
	752	+
	753	+ await $.session.start(Fixtures.SESSION)
	754	+
	755	+ expect(world.runs, 'the start itself still runs no git').toEqual([])
	756	+
	757	+ await $.ui.render(Fixtures.HINT)
	758	+ await world.clock.advance(Fixtures.SETTLE_MS)
	759	+
	760	+ expect(
	761	+ world.opened.map(pane => pane.id),
	762	+ 'open once the width is known, as the built-in opens on the restore',
	763	+ ).toEqual(['diff'])
	764	+ })
	765	+
	766	+ test('a resumed session opens nothing where its first edit would not', async ($, on) => {
	767	+ const narrow = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	768	+ messages: () => Fixtures.EDITED_TRANSCRIPT,
	769	+ })
	770	+
	771	+ await $.session.start(Fixtures.SESSION)
	772	+ await $.ui.render(Fixtures.hintAt(Limits.AUTO_OPEN_MIN_COLUMNS - 1))
	773	+ await narrow.clock.advance(Fixtures.SETTLE_MS)
	774	+
	775	+ expect(narrow.opened, 'under the unasked floor, never kept open').toEqual(
	776	+ [],
	777	+ )
	778	+
	779	+ expect(narrow.runs, 'and no git for it').toEqual([])
	780	+ })
	781	+
	782	+ test('a resumed session the person kept the pane open in opens it from the lower floor', async ($, on) => {
	783	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	784	+ messages: () => Fixtures.EDITED_TRANSCRIPT,
	785	+ stored: { [Names.STORE_OPEN_KEY]: true },
	786	+ })
	787	+
	788	+ await $.session.start(Fixtures.SESSION)
	789	+ await $.ui.render(Fixtures.hintAt(Limits.OPEN_MIN_COLUMNS))
	790	+ await world.clock.advance(Fixtures.SETTLE_MS)
	791	+
	792	+ expect(world.opened.map(pane => pane.id)).toEqual(['diff'])
	793	+ })
	794	+
	795	+ test('a resumed session with no edits opens nothing', async ($, on) => {
	796	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	797	+ messages: () => [Fixtures.promptOf('just talk')],
	798	+ })
	799	+
	800	+ await $.session.start(Fixtures.SESSION)
	801	+ await $.ui.render(Fixtures.HINT)
	802	+ await world.clock.advance(Fixtures.SETTLE_MS)
	803	+
	804	+ expect(world.opened).toEqual([])
	805	+ expect(world.runs).toEqual([])
	806	+ })
	807	+
	808	+ test('a resumed session whose pane the person closed opens nothing', async ($, on) => {
	809	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	810	+ messages: () => Fixtures.EDITED_TRANSCRIPT,
	811	+ stored: { [Names.STORE_OPEN_KEY]: false },
	812	+ })
	813	+
	814	+ await $.session.start(Fixtures.SESSION)
	815	+ await $.ui.render(Fixtures.HINT)
	816	+ await world.clock.advance(Fixtures.SETTLE_MS)
	817	+
	818	+ expect(world.opened).toEqual([])
	819	+ expect(world.runs).toEqual([])
	820	+ })
	821	+
	822	+ test('/resume closes the pane, then opens it for the turns it brought back', async ($, on) => {
	823	+ let transcript: readonly SessionMessage[] = []
	824	+
	825	+ const world = Fixtures.inRepository(on, Fixtures.REPOSITORY, {
	826	+ messages: () => transcript,
	827	+ })
	828	+
	829	+ on('command.run', { command: 'resume' }, () => {
	830	+ transcript = Fixtures.EDITED_TRANSCRIPT
	831	+
	832	+ return {}
	833	+ })
	834	+
	835	+ await $.session.start(Fixtures.SESSION)
	836	+ await $.ui.render(Fixtures.HINT)
	837	+ await $.command.run(Fixtures.DIFF)
	838	+ await world.clock.advance(Fixtures.SETTLE_MS)
	839	+ await $.command.run(Fixtures.RESUME)
	840	+ await world.clock.advance(Fixtures.SETTLE_MS)
	841	+
	842	+ expect(world.closed.map(pane => pane.id), 'closed at /resume').toEqual([
	843	+ 'diff',
	844	+ ])
	845	+
	846	+ expect(
	847	+ world.opened.map(pane => pane.id),
	848	+ '/diff opened it, /resume opened it again for the restored turns',
	849	+ ).toEqual(['diff', 'diff'])
	850	+ })
	851	+
498	852	test('ask attaches the hunks on screen and calls no tool', async ($, on) => {
499	853	const world = Fixtures.inRepository(on, Fixtures.oneSecret())
500	854	const called: Args<'tool.call'>[] = []
		@@ -563,7 +917,7 @@
563	917
564	918	test('a worktree opens on the base it kept', async ($, on) => {
565	919	const world = Fixtures.inRepository(on, Fixtures.oneSecret(), {
566		- 'base:/main/wt': 'uncommitted',
	920	+ stored: { 'base:/main/wt': 'uncommitted' },
567	921	})
568	922
569	923	await $.session.start(Fixtures.WORKTREE_SESSION)

		@@ -1,7 +1,7 @@
1	1	{
2	2	"name": "telemetry",
3	3	"version": "0.1.0",
4		- "description": "Plugin analytics: adds $.telemetry in the engine.create fold, so a plugin logs an event or marks a feature's use as one first-party row per call, sent with the session's own credential.",
	4	+ "description": "Plugin analytics: adds $.telemetry in the engine.create fold, so a plugin logs an event or marks a feature's use as a first-party row, sent in batches with the session's own credential.",
5	5	"author": {
6	6	"name": "Anthropic"
7	7	},

		@@ -1,32 +1,55 @@
1	1	# telemetry
2	2
3	3	Plugin analytics as a plugin: one `engine.create` step adds `$.telemetry` to
4		-the engine interface every plugin above it is handed, built over the
5		-`$.session` and `$.http` nouns beneath. `$.telemetry.log({ event, props })`
6		-sends one event as one first-party row, `tengu_plugin_<event>`;
7		-`$.telemetry.mark({ feature, kind, reason?, props? })` marks one use of a
8		-feature as the CLI's own feature events do, `tengu_feature_<kind>` with a
9		-`feature_name` and the mark's properties beside it. Each call is one POST to
10		-the event-logging ingest with the session's own credential
11		-(`$.session.authorize()`, resolved at each call), one attempt, nothing
12		-batched; a session with no first-party credential, or an ingest that
13		-refuses, rejects the caller's promise.
	4	+the engine interface every plugin above it is handed, built over the nouns
	5	+beneath, and a hook on its own two events serves the plugins built into
	6	+Claude Code alone: a call from a plugin a person installed or an
	7	+administrator listed is refused with a reason (the host stamps every call
	8	+with the plugin that raised it, `next.origin`, and the gate reads its tier).
	9	+`$.telemetry.log({ event, props })` queues one event as one first-party
	10	+row, `tengu_plugin_<event>`; `$.telemetry.mark({ feature, kind, reason?,
	11	+props? })` marks one use of a feature as the CLI's own feature events do,
	12	+`tengu_feature_<kind>` with a `feature_name` and the mark's properties
	13	+beside it. Both resolve once the row is queued. Rows go out in batches: one
	14	+POST to the event-logging ingest with the session's own credential
	15	+(`$.session.authorize()`, resolved for each batch) a few seconds after the
	16	+first row was queued, at once when a hundred wait, and when the session
	17	+ends; a batch the ingest refuses with a server error, a timeout or a rate
	18	+limit is tried once more. A session with no first-party credential, or an
	19	+ingest that still refuses, drops the batch; each outcome is one line in the
	20	+debug log.
14	21
	22	+Each row carries what the CLI's own rows carry, gathered through `$` once
	23	+a session: an event id, the install's device id and the signed-in account's
	24	+ids from the CLI's global config, the session's id, model, client type,
	25	+entrypoint and interactivity, and an `env` block (platform and
	26	+architecture from one `uname` probe, terminal, shell, package managers and
	27	+runtimes, CI and GitHub Actions, the remote container, the deployment, the
	28	+Linux distribution and kernel, WSL, the working directory's version
	29	+control), with the repository's remote hash beside the row's properties.
	30	+What the engine alone knows (its version and build time, its runtime's
	31	+version, the process's memory, the request's betas, the subscription tier,
	32	+the calling agent) is not on `$`, and those columns stay empty.
	33	+
15	34	It sends nothing wherever the CLI's own analytics are off: under
16	35	`DISABLE_TELEMETRY`, `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` or
17		-`DO_NOT_TRACK`, on any third-party provider (Bedrock, Vertex, Foundry and
18		-kin), and on a deployment with its own OAuth URL. Each is read through
19		-`$.env` at every call, rows go one after another, and the credential is
20		-authorized afresh right before each POST, so a session that has since moved
21		-to a third-party provider or a cloud gateway sends nothing more. The row's
22		-`user_type` is `ant` when `USER_TYPE` says so, else `external`.
	36	+`DO_NOT_TRACK`, in a test run, on any third-party provider (Bedrock,
	37	+Vertex, Foundry and kin) the host does not manage, on a cloud gateway
	38	+(the environment's switch or the managed policy's login pins), and on a
	39	+deployment with its own OAuth URL. Each is read through `$.env` and
	40	+`$.settings` before every batch, so a session that has since moved to a
	41	+third-party provider or a gateway sends nothing more; when the switches
	42	+cannot be read, nothing is sent either. The row's `user_type` is `ant`
	43	+when `USER_TYPE` says so, else `external`.
23	44
24	45	Nothing free-form reaches a row. An event name and every property key is a
25	46	snake_case token; a value is a finite number, a boolean, or a Choice (a
26	47	string named together with the list it is chosen from), under `log` and
27	48	`mark` alike; `mark` takes `ok`, `sad` or `bad`, with a `reason` required on
28	49	the last two and refused on the first. An entry that breaks a rule is
29		-refused before anything is sent.
	50	+refused before anything is queued. Of the environment, a variable whose
	51	+value is a secret, or names a person or a host, is read for whether it is
	52	+set and nothing more; a shell is its basename from a closed list.
30	53
31	54	`hooks/register.ts` is the module; `types/index.d.ts` is the noun's contract,
32	55	the one declaration of `$.telemetry` that this mod's hooks, a mod calling the
		@@ -35,20 +58,26 @@
35	58	## What it hooks
36	59
37	60	`engine.create`: `{ ...await next(e), telemetry }`, so the noun is added and
38		-nothing beneath is replaced.
	61	+nothing beneath is replaced. `telemetry.*`, the gate: a caller in the
	62	+built-in tier (or the engine) goes on, any other is refused, and a gate
	63	+that throws refuses too. `session.start`, to learn whether a person is at
	64	+the prompt; `session.end`, to send what still waits.
39	65
40	66	## What it calls on `$`
41	67
42		-`session.authorize`, `session.id`, `session.model`, `http.fetch`, `env.get`
43		-(the switches above and `USER_TYPE`, by literal name), each on the
44		-interface the fold handed it.
	68	+`session.authorize`, `session.id`, `session.model`, `session.surfaces`,
	69	+`session.cwd`, `session.repo`, `settings.read`, `env.get` (the switches and
	70	+the describing variables, by literal name), `fs.read`, `fs.list`,
	71	+`fs.exists`, `process.run` (one `sh -c` of `uname` and `command -v`),
	72	+`clock.after`, `clock.sleep`, `http.fetch` and `ui.log` (to the debug log),
	73	+each on the interface the fold handed it.
45	74
46		-## Where it runs
	75	+## Where it runs, whom it serves
47	76
48		-This plugin is seated by the CLI itself, on internal builds whose own
49		-analytics are on, and nowhere else: `session.authorize` exists only there,
50		-and the rows it writes join tables only the CLI's own events reach. It is
51		-not meant to be installed or loaded with `--plugin-dir`; the folder has a
52		-manifest so it reads like every other plugin, not so it can stand alone. A
53		-plugin that calls `$.telemetry` where this one is absent finds no such noun
54		-and should treat that as "no analytics here".
	77	+This plugin is seated by the CLI itself, on every build whose own analytics
	78	+are on, and nowhere else; it serves the plugins bundled with the CLI and
	79	+refuses every other caller. It is not meant to be installed or loaded with
	80	+`--plugin-dir`; the folder has a manifest so it reads like every other
	81	+plugin, not so it can stand alone. A built-in that calls `$.telemetry`
	82	+where this one is absent finds no such noun and should treat that as "no
	83	+analytics here".

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * The most rows one batch carries: a queue this full goes out at once
	3	+ * rather than on the timer.
	4	+ */
	5	+export const BATCH_ROWS = 100

		@@ -1,0 +1,3 @@
	1	+export * from './batch-rows.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * How long a queued row waits for company before its batch goes out, in
	3	+ * milliseconds; a session that ends sooner sends what waits then.
	4	+ */
	5	+export const BATCH_WINDOW_MS = 5000

		@@ -1,0 +1,3 @@
	1	+export * from './batch-window-ms.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,8 @@
	1	+export * from './batch-rows'
	2	+export * from './batch-window-ms'
	3	+export * from './is-retriable'
	4	+export * from './message-of'
	5	+export * from './pending-row'
	6	+export * from './retry-delay-ms'
	7	+
	8	+export * as default from '.'

		@@ -1,0 +1,6 @@
	1	+export * from './is-retriable.js'
	2	+export * from './status-request-timeout'
	3	+export * from './status-server-error'
	4	+export * from './status-too-many-requests'
	5	+
	6	+export * as default from '.'

		@@ -1,0 +1,15 @@
	1	+import { STATUS_REQUEST_TIMEOUT } from './status-request-timeout'
	2	+import { STATUS_SERVER_ERROR } from './status-server-error'
	3	+import { STATUS_TOO_MANY_REQUESTS } from './status-too-many-requests'
	4	+
	5	+/**
	6	+ * Whether an answer from the ingest is worth the one retry: a server error,
	7	+ * a timeout or a rate limit; anything else it refused stays refused.
	8	+ *
	9	+ * @param status the HTTP status the ingest answered
	10	+ * @returns true for 5xx, 408 and 429
	11	+ */
	12	+export const isRetriable = (status: number) =>
	13	+ status >= STATUS_SERVER_ERROR \|\|
	14	+ status === STATUS_REQUEST_TIMEOUT \|\|
	15	+ status === STATUS_TOO_MANY_REQUESTS

		@@ -1,0 +1,4 @@
	1	+/**
	2	+ * HTTP 408: the ingest gave up waiting for the request; worth the one retry.
	3	+ */
	4	+export const STATUS_REQUEST_TIMEOUT = 408

		@@ -1,0 +1,3 @@
	1	+export * from './status-server-error.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,5 @@
	1	+/**
	2	+ * HTTP 500, the first server-side status: it and everything above is the
	3	+ * ingest's own failure and worth the one retry.
	4	+ */
	5	+export const STATUS_SERVER_ERROR = 500

		@@ -1,0 +1,4 @@
	1	+/**
	2	+ * HTTP 429: the ingest is shedding load; worth the one retry after a pause.
	3	+ */
	4	+export const STATUS_TOO_MANY_REQUESTS = 429

		@@ -1,0 +1,3 @@
	1	+export * from './message-of.js'
	2	+
	3	+export * as default from '.'

		@@ -1,0 +1,9 @@
	1	+/**
	2	+ * What a batch's failure says, for the refusal each of its rows rejects
	3	+ * with: the error's own message, or the value as text.
	4	+ *
	5	+ * @param error what sending the batch threw
	6	+ * @returns the message
	7	+ */
	8	+export const messageOf = (error: unknown) =>
	9	+ error instanceof Error ? error.message : String(error)