@norman-else/dsh-claude 0.1.42 → 0.1.44

package/lib/index.mjs

@@ -1408,56 +1408,108 @@ function normalizeSdkMessage(message) {
 }
 //#endregion
 //#region src/model-catalog.ts
-/** What the selector shows before any session has initialized in this Host
-*  process -- a fresh app launch lands here. `default` is the only id that is
-*  valid on every release and plan; the aliases after it are the stable
-*  `/model` spellings Claude Code has kept across releases, so the menu is
-*  usable at first paint instead of a single row. The first initialize
-*  response replaces the whole list with the CLI's own lineup. */
+/** The Claude Code model lineup, read from the running CLI instead of pinned
+*  here.
+*
+*  Anthropic ships models between releases of this plugin -- Fable arrived in a
+*  CLI update, not in one of ours -- so a table maintained here is stale the day
+*  it is written, and a model the user can already pick in `/model` is missing
+*  from the DSH selector until someone edits an array. The CLI answers the same
+*  question itself: every session's initialize response carries the lineup it
+*  would show in `/model`, already narrowed to the logged-in account's plan and
+*  to any `availableModels` restriction the settings cascade imposes.
+*
+*  What DSH persists on a session, though, must NOT be a CLI model id. DSH
+*  stores the selector row's id verbatim and matches it back by string
+*  equality, so a concrete id (`claude-fable-5-1[1m]`) turns into a dangling
+*  reference the moment Anthropic bumps the version -- the session keeps
+*  pointing at a row nothing advertises any more, and the composer falls back
+*  to printing the raw id. The selector therefore advertises an alias this
+*  plugin owns (`fable[1m]`), derived from the row rather than tabulated, and
+*  the CLI id it stands for is kept beside it and used only at dispatch.
+*/
+/** A 1M-context route spells it in the id (`opus[1m]`, `claude-fable-5-1[1m]`). */
+const WIDE_ROUTE = /\[1m\]$/u;
+/** What the selector shows before the lineup is known -- the probe below failed
+*  or has not answered yet. `default` is the only id that is valid on every
+*  release and plan; the rest are the stable `/model` spellings Claude Code has
+*  kept across releases, and every one of them is a spelling the CLI accepts,
+*  so a session that persists one still dispatches. */
 const SEED = [
 	{
 		id: "default",
+		value: "default",
 		name: "Default (recommended)",
 		description: ""
 	},
 	{
 		id: "opus[1m]",
+		value: "opus[1m]",
 		name: "Opus (1M context)",
 		description: "",
 		contextWindow: 1e6
 	},
 	{
 		id: "fable",
+		value: "fable",
 		name: "Fable",
 		description: ""
 	},
 	{
 		id: "sonnet",
+		value: "sonnet",
 		name: "Sonnet",
 		description: ""
 	},
 	{
 		id: "haiku",
+		value: "haiku",
 		name: "Haiku",
 		description: ""
 	}
 ];
-/** A 1M-context route spells it in the id (`opus[1m]`, `claude-fable-5[1m]`),
-*  so this needs no capacity table either. It is only a floor: the supervisor
-*  overrides it with the window the CLI reports once a turn has run. */
+/** A 1M-context route spells it in the id, so this needs no capacity table
+*  either. It is only a floor: the supervisor overrides it with the window the
+*  CLI reports once a turn has run. */
 function declaredContextWindow(row) {
-	return /\[1m\]$/u.test(row.resolvedModel ?? row.value) ? 1e6 : void 0;
+	return WIDE_ROUTE.test(row.resolvedModel ?? row.value) ? 1e6 : void 0;
+}
+/**
+* The selector id for one CLI row: the model's family, plus the `[1m]` marker
+* when the route carries one.
+*
+* Derived, never tabulated -- a family this plugin has never heard of gets its
+* id the same way, so a model Anthropic ships tomorrow lands in the selector
+* without an edit here, and a version bump (`claude-fable-5-1` ->
+* `claude-fable-5-2`) leaves an already-persisted selection pointing at the
+* same row. The family is the first non-numeric segment, which covers both
+* spellings Anthropic has used (`claude-fable-5-1`, `claude-3-5-sonnet-…`).
+*
+* Read off `value` alone, never the id it resolves to: `default` names a route
+* whose resolution moves with the account and the release, so folding the
+* resolved `[1m]` in would flip an already-persisted `default` to `default[1m]`
+* the day Anthropic repoints it.
+* @param value - the CLI's own id for the row.
+* @returns the alias to advertise.
+*/
+function claudeModelAlias(value) {
+	const wide = WIDE_ROUTE.test(value);
+	const bare = value.replace(WIDE_ROUTE, "").replace(/^claude-/u, "");
+	const family = bare.split("-").find((segment) => !/^\d+$/u.test(segment)) ?? bare;
+	return wide ? `${family}[1m]` : family;
 }
-function projectModel(row) {
+function projectModel(row, id) {
 	const contextWindow = declaredContextWindow(row);
 	return {
-		id: row.value,
+		id,
+		value: row.value,
 		name: row.displayName,
 		description: row.description,
 		...contextWindow === void 0 ? {} : { contextWindow }
 	};
 }
 let latest$1;
+let inflight;
 /**
 * Learn the lineup from one session's initialize response.
 * @param models - the CLI's own `/model` rows; an empty list is ignored so a
@@ -1465,20 +1517,96 @@ let latest$1;
 */
 function recordClaudeModels(models) {
 	if (models.length === 0) return;
-	latest$1 = models.map(projectModel);
+	const taken = /* @__PURE__ */ new Set();
+	latest$1 = models.map((row) => {
+		const alias = claudeModelAlias(row.value);
+		const id = taken.has(alias) ? row.value : alias;
+		taken.add(id);
+		return projectModel(row, id);
+	});
 }
 /** The lineup to advertise: whatever the CLI last reported, else the seed. */
 function latestClaudeModels() {
 	return latest$1 ?? SEED;
 }
+/** A throwaway probe should not outlive a wedged CLI. */
+const CLAUDE_MODEL_PROBE_TIMEOUT_MS = 2e4;
+/**
+* Read the lineup from a throwaway CLI process.
+*
+* Waiting for a session to start is too late: DSH loads the model catalog once
+* per Host generation, at connect, and does not reload it when this plugin
+* later learns the real lineup. A selector left on the seed until then hands
+* out seed ids, which is exactly how a session ends up persisting an id the
+* next launch cannot resolve. This query carries no tools, no permission
+* bridge and no session binding: it starts, reports what `/model` would show,
+* and is killed -- no prompt is ever sent, so it costs no tokens.
+* @param executablePath - the resolved CLI, or '' to let the SDK find it.
+* @param factory - test seam for the SDK query.
+* @returns the CLI's own `/model` rows.
+*/
+async function probeClaudeModels(executablePath, factory = query) {
+	const lifetime = new AbortController();
+	const timer = setTimeout(() => lifetime.abort(), CLAUDE_MODEL_PROBE_TIMEOUT_MS);
+	timer.unref?.();
+	const query$2 = factory({
+		prompt: (async function* () {
+			await new Promise(() => {});
+		})(),
+		options: {
+			cwd: process.cwd(),
+			abortController: lifetime,
+			...executablePath.length === 0 ? {} : { pathToClaudeCodeExecutable: executablePath }
+		}
+	});
+	try {
+		(async () => {
+			for await (const _ of query$2);
+		})().catch(() => void 0);
+		return (await Promise.race([query$2.initializationResult(), new Promise((_resolve, reject) => {
+			setTimeout(() => reject(/* @__PURE__ */ new Error("dsh-claude: the model lineup probe did not answer in time")), CLAUDE_MODEL_PROBE_TIMEOUT_MS).unref?.();
+		})])).models;
+	} finally {
+		clearTimeout(timer);
+		lifetime.abort();
+	}
+}
+/**
+* The lineup, learning it from the CLI the first time DSH asks for the catalog.
+* @param probe - reads the CLI's rows; a failure leaves the seed in place and
+*   is retried on the next catalog load.
+* @returns the rows to advertise, never rejecting.
+*/
+function ensureClaudeModels(probe) {
+	if (latest$1 !== void 0) return Promise.resolve(latest$1);
+	inflight ??= probe().then((models) => {
+		recordClaudeModels(models);
+	}).catch(() => void 0).then(() => {
+		inflight = void 0;
+		return latestClaudeModels();
+	});
+	return inflight;
+}
 /**
 * Look one id up in the current lineup.
-* @param id - the id DSH persisted on the session, which may name a model the
+* @param id - the id DSH persisted on the session, which may be an alias, a
+*   concrete CLI id persisted before this plugin aliased anything, or a row the
 *   running CLI no longer lists.
 * @returns the row, or undefined when the lineup does not cover the id.
 */
 function claudeModelRow(id) {
-	return latestClaudeModels().find((row) => row.id === id);
+	const rows = latestClaudeModels();
+	return rows.find((row) => row.id === id) ?? rows.find((row) => row.value === id) ?? rows.find((row) => row.id === claudeModelAlias(id));
+}
+/**
+* The spelling to hand the CLI for one selector id.
+* @param id - the id DSH persisted on the session.
+* @returns the CLI's own id, or the selector id itself when the lineup does not
+*   cover it -- the seed vocabulary is made of spellings the CLI accepts, and a
+*   session persisted before this plugin aliased anything already holds one.
+*/
+function claudeModelValue(id) {
+	return claudeModelRow(id)?.value ?? id;
 }
 //#endregion
 //#region src/plan-usage.ts
@@ -2478,7 +2606,7 @@ var ClaudeSupervisor = class {
 				resume: binding.claudeSessionId,
 				...forkAt === void 0 ? {} : { resumeSessionAt: forkAt }
 			},
-			model,
+			model: claudeModelValue(model),
 			...thinkingMode === void 0 ? {} : thinkingMode === "off" ? { thinking: { type: "disabled" } } : thinkingMode === "ultracode" ? { settings: { ultracode: true } } : { effort: thinkingMode }
 		};
 		entry.query = this.#queryFactory({
@@ -2876,20 +3004,7 @@ var ClaudeSupervisor = class {
 			...result.usage.outputTokens === void 0 ? {} : { outputTokens: result.usage.outputTokens }
 		};
 	}
-	async #completeProgressSegment(active, result, recordUsage = true) {
-		if (recordUsage && (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0)) {
-			await this.#appendSafely(active, {
-				kind: "usage",
-				phase: "completed",
-				title: "Claude usage",
-				summary: usageSummary(result.usage),
-				usage: this.#timedUsage(active, result.usage)
-			});
-			active.output.push({
-				type: "usage",
-				usage: this.#reportedUsage(active, result)
-			});
-		}
+	async #completeProgressSegment(active, result) {
 		if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
 			active.text = result.text;
 			active.transcriptText = result.text;
@@ -2909,6 +3024,25 @@ var ClaudeSupervisor = class {
 		this.#closeTranscriptTextSegment(active);
 		active.thinking = "";
 	}
+	/** The turn's accounting, recorded once the turn is actually over.
+	*
+	*  A turn that hands off to background tasks passes through the same result
+	*  handling on its way to `waiting-tasks`, and recording there drew a closing
+	*  total under a turn that was still running. */
+	async #recordTurnUsage(active, result) {
+		if (result.usage.inputTokens === void 0 && result.usage.outputTokens === void 0 && result.usage.cumulativeCostUsd === void 0) return;
+		await this.#appendSafely(active, {
+			kind: "usage",
+			phase: "completed",
+			title: "Claude usage",
+			summary: usageSummary(result.usage),
+			usage: this.#timedUsage(active, result.usage)
+		});
+		active.output.push({
+			type: "usage",
+			usage: this.#reportedUsage(active, result)
+		});
+	}
 	async #completeTurn(entry, active, result) {
 		if (entry.active !== active) return;
 		if (active.aborted) {
@@ -2930,19 +3064,6 @@ var ClaudeSupervisor = class {
 			this.#scheduleLimitReconciliation();
 			return;
 		}
-		if (result.usage.inputTokens !== void 0 || result.usage.outputTokens !== void 0 || result.usage.cumulativeCostUsd !== void 0) {
-			await this.#appendSafely(active, {
-				kind: "usage",
-				phase: "completed",
-				title: "Claude usage",
-				summary: usageSummary(result.usage),
-				usage: this.#timedUsage(active, result.usage)
-			});
-			active.output.push({
-				type: "usage",
-				usage: this.#reportedUsage(active, result)
-			});
-		}
 		const unmatchedDenials = (result.permissionDenials ?? []).filter((denial) => !active.deniedToolUseIds.has(denial.toolUseId));
 		if (unmatchedDenials.length > 0) await this.#appendSafely(active, {
 			kind: "permission",
@@ -2951,6 +3072,7 @@ var ClaudeSupervisor = class {
 			summary: unmatchedDenials.map((denial) => denial.toolName).join(", ")
 		});
 		if (!result.success) {
+			await this.#recordTurnUsage(active, result);
 			if (!active.sawTextDelta && active.text.length === 0 && result.text !== void 0) {
 				active.text = result.text;
 				active.transcriptText = result.text;
@@ -2989,9 +3111,10 @@ var ClaudeSupervisor = class {
 					phase: "updated",
 					title: "Claude Code is waiting for background tasks"
 				});
-				await this.#completeProgressSegment(active, result, false);
+				await this.#completeProgressSegment(active, result);
 				return;
 			}
+			await this.#recordTurnUsage(active, result);
 			await this.#appendSafely(active, {
 				kind: "status",
 				phase: "completed",
@@ -3532,7 +3655,10 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 	*  Settings dialog, and the read is dwarfed by the process the turn spawns. */
 	#renderMode;
 	#summarizeTitle;
-	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
+	/** Reads the CLI's own `/model` rows, so the selector never has to advertise
+	*  the seed vocabulary once the CLI can answer for itself. */
+	#probeModels;
+	constructor(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request), probeModels = async () => []) {
 		super();
 		this.#supervisor = supervisor;
 		this.#agents = agents;
@@ -3541,6 +3667,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		this.#drainReviewComments = drainReviewComments;
 		this.#renderMode = renderMode;
 		this.#summarizeTitle = summarizeTitle;
+		this.#probeModels = probeModels;
 	}
 	providerInfo(provider) {
 		return {
@@ -3552,7 +3679,7 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		return NO_RETRY_POLICY;
 	}
 	async listModels(provider) {
-		return latestClaudeModels().map((model) => ({
+		return (await ensureClaudeModels(this.#probeModels)).map((model) => ({
 			provider,
 			id: model.id,
 			name: model.name,
@@ -3753,8 +3880,8 @@ var ClaudeCodeAdapter = class extends LlmAdapter {
 		if (!completed) throw new Error("dsh-claude: Claude turn stream ended without a result");
 	}
 };
-function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request)) {
-	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode, summarizeTitle);
+function createClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments = () => [], renderMode = async () => DEFAULT_CLAUDE_RENDER_MODE, summarizeTitle = (request) => summarizeSessionTitle("", request), probeModels = async () => []) {
+	return new ClaudeCodeAdapter(supervisor, agents, attachments, presetIdFor, drainReviewComments, renderMode, summarizeTitle, probeModels);
 }
 //#endregion
 //#region src/plugin-budget.ts
@@ -4319,6 +4446,82 @@ function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSes
 	});
 }
 //#endregion
+//#region src/diff-funcname.ts
+/** Extensions mapped onto a funcname driver, so `@@` hunk headers name the
+*  method a change sits in. Without one git falls back to "the last line that
+*  starts in column 0", which in Java or Kotlin is always the class. */
+const DIFF_ATTRIBUTES = [
+	"*.java diff=java",
+	"*.kt diff=kotlin",
+	"*.kts diff=kotlin",
+	"*.py diff=python",
+	"*.pyi diff=python",
+	"*.js diff=dshweb",
+	"*.jsx diff=dshweb",
+	"*.mjs diff=dshweb",
+	"*.cjs diff=dshweb",
+	"*.ts diff=dshweb",
+	"*.tsx diff=dshweb",
+	"*.mts diff=dshweb",
+	"*.cts diff=dshweb",
+	"*.vue diff=dshweb",
+	"*.svelte diff=dshweb",
+	"*.css diff=css",
+	"*.scss diff=css",
+	"*.less diff=css",
+	""
+].join("\n");
+/** git ships no JavaScript driver, so this is the one pattern we write ourselves.
+*
+*  POSIX extended regexes, one per line, matched top-down: a leading `!` marks a
+*  line that can never be a header, and the reported text is capture group 1 --
+*  hence the outer parentheses around everything worth showing.
+*
+*  Line 2 keeps git's own fallback (anything unindented), because a driver
+*  replaces that fallback rather than extending it, and most of a frontend file's
+*  declarations already live in column 0. Lines 3 and 4 add what the fallback
+*  cannot see: nested declarations, and indented class or object methods.
+*
+*  ponytail: a method line must end in `{`. Allowing `)` too would pick up every
+*  bare `foo(bar)` statement, which reads as a header and hides the real one.
+*/
+const DSHWEB_FUNCNAME = [
+	"!^[ 	]*(if|else|for|while|do|switch|case|catch|try|finally|return|await|new|throw|typeof)[^A-Za-z0-9_$]",
+	"^([A-Za-z_$].*)$",
+	"^[ 	]*((export[ 	]+)?(default[ 	]+)?(declare[ 	]+)?(abstract[ 	]+)?(async[ 	]+)?(function|class|interface|enum|namespace|module)[ 	].*)$",
+	"^[ 	]*(((public|private|protected|static|readonly|abstract|async|get|set)[ 	]+)*[A-Za-z_$#][A-Za-z0-9_$]*[ 	]*[:=]?[ 	]*(async[ 	]+)?[(<][^;]*\\{)[ 	]*$"
+].join("\n");
+let attributesFile;
+async function writeAttributes() {
+	const path = dshHomePath("plugins", "dsh-claude", "diff-attributes");
+	try {
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, DIFF_ATTRIBUTES, "utf8");
+		return path;
+	} catch {
+		return;
+	}
+}
+/** `-c` overrides to place in front of a `git diff`, teaching it which funcname
+*  driver each extension uses.
+*
+*  `core.attributesFile` is the lowest-precedence attribute source, so a
+*  repository that already declares its own `.gitattributes` still wins. Better
+*  hunk headers are cosmetic: a failed write drops the overrides and the diff
+*  runs exactly as before.
+*/
+async function diffFuncnameArgs() {
+	attributesFile ??= writeAttributes();
+	const path = await attributesFile;
+	if (path === void 0) return [];
+	return [
+		"-c",
+		`core.attributesFile=${path}`,
+		"-c",
+		`diff.dshweb.xfuncname=${DSHWEB_FUNCNAME}`
+	];
+}
+//#endregion
 //#region src/repository-status.ts
 const MAX_OUTPUT_BYTES$4 = 65536;
 const MAX_DIFF_BYTES = 262144;
@@ -4328,6 +4531,7 @@ const GIT_TIMEOUT_MS$3 = 5e3;
 const GH_TIMEOUT_MS$1 = 8e3;
 const CACHE_TTL_MS = 5e3;
 const MAX_TEXT_CHARS = 1024;
+const MAX_CONFLICT_PATHS = 100;
 function bounded(value) {
 	return value.trim().slice(0, MAX_TEXT_CHARS);
 }
@@ -4365,6 +4569,7 @@ function parseGitStatus(output) {
 	let upstream = false;
 	let ahead;
 	let behind;
+	const conflicts = [];
 	for (const line of output.split(/\r?\n/u)) {
 		if (line.startsWith("# branch.head ")) {
 			const head = bounded(line.slice(14));
@@ -4384,6 +4589,10 @@ function parseGitStatus(output) {
 			}
 			continue;
 		}
+		if (line.startsWith("u ")) {
+			const path = line.split(" ").slice(10).join(" ");
+			if (path.length > 0 && conflicts.length < MAX_CONFLICT_PATHS) conflicts.push(bounded(path));
+		}
 		if (line.length > 0 && !line.startsWith("# ")) dirty = true;
 	}
 	return {
@@ -4392,9 +4601,36 @@ function parseGitStatus(output) {
 		dirty,
 		upstream,
 		...ahead === void 0 ? {} : { ahead },
-		...behind === void 0 ? {} : { behind }
+		...behind === void 0 ? {} : { behind },
+		...conflicts.length === 0 ? {} : { conflicts }
 	};
 }
+/** Ordered so the rebase directories win: a conflicted rebase also writes
+*  MERGE_HEAD-like state, and the two are resumed by different commands. */
+const OPERATION_MARKERS = [
+	["rebase-merge", "rebase"],
+	["rebase-apply", "rebase"],
+	["MERGE_HEAD", "merge"],
+	["CHERRY_PICK_HEAD", "cherry-pick"],
+	["REVERT_HEAD", "revert"]
+];
+/** Reads the in-progress operation out of the worktree's own git dir -- linked
+*  worktrees keep their own, so this must not be handed the common dir. */
+async function detectRepositoryOperation(gitDir) {
+	for (const [marker, operation] of OPERATION_MARKERS) {
+		const path = join(gitDir, marker);
+		try {
+			await stat(path);
+		} catch {
+			continue;
+		}
+		const branch = bounded(operation === "rebase" ? await readFile(join(path, "head-name"), "utf8").catch(() => "") : "").replace(/^refs\/heads\//u, "");
+		return {
+			operation,
+			...branch.length === 0 || branch.includes(" ") ? {} : { branch }
+		};
+	}
+}
 function parseDiffNumstat(value) {
 	let additions = 0;
 	let deletions = 0;
@@ -4601,13 +4837,15 @@ var RepositoryStatusService = class {
 				cwd: safeCwd
 			};
 			const status = parseGitStatus(statusResult.stdout);
+			const operation = await detectRepositoryOperation(gitDir);
+			const branch = operation?.branch ?? status.branch;
 			const remoteResult = await run(this.#runtime, git, [
 				"remote",
 				"get-url",
 				"origin"
 			], cwd, GIT_TIMEOUT_MS$3);
 			const remote = remoteResult.exitCode === 0 ? parseGitHubRemote(remoteResult.stdout) : void 0;
-			const pullRequest = status.branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, status.branch);
+			const pullRequest = branch === void 0 || remote === void 0 ? void 0 : await this.#pullRequest(cwd, remote, branch);
 			const diffBase = pullRequest?.baseBranch === void 0 ? "HEAD" : await this.#mergeBase(cwd, git, pullRequest.baseBranch) ?? "HEAD";
 			const diff = status.dirty || diffBase !== "HEAD" ? await this.#diff(cwd, git, diffBase, signal) : {
 				additions: 0,
@@ -4621,6 +4859,8 @@ var RepositoryStatusService = class {
 				cwd: safeCwd,
 				root,
 				...status,
+				...branch === void 0 ? {} : { branch },
+				...operation === void 0 ? {} : { operation: operation.operation },
 				worktree: normalizedPath(gitDir) !== normalizedPath(commonDir),
 				...remote === void 0 ? {} : { remote },
 				...pullRequest === void 0 ? {} : { pullRequest },
@@ -4675,6 +4915,7 @@ var RepositoryStatusService = class {
 			if (numstat.exitCode !== 0 || numstat.lossy) return void 0;
 			const summary = parseDiffNumstat(numstat.stdout);
 			const patch = await run(this.#runtime, git, [
+				...await diffFuncnameArgs(),
 				"diff",
 				"--no-ext-diff",
 				"--no-color",
@@ -5496,6 +5737,10 @@ function parseRepositoryActionStatus(output) {
 	}
 	return [...files.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
+function conflictPaths(result) {
+	if (result.exitCode !== 0 || result.lossy) return [];
+	return result.stdout.split(/\r?\n/u).filter((line) => line.length > 0).slice(0, 100);
+}
 function fallbackCommitMessage(files) {
 	if (files.length === 1) return `Update ${files[0]?.path ?? "repository files"}`;
 	return `Update ${files.length} repository files`;
@@ -5560,6 +5805,7 @@ var RepositoryActionService = class {
 		return operation;
 	}
 	async #execute(cwd, request) {
+		if (request.action === "resolve-continue" || request.action === "resolve-abort") return this.#resolve(cwd, request.action, request.push === true);
 		const before = await this.#preview(cwd);
 		if (before.fingerprint !== request.fingerprint) throw new RepositoryActionError("repository-changed", "Repository changes have changed. Refresh the commit panel.");
 		if (request.action === "push") {
@@ -5622,13 +5868,12 @@ var RepositoryActionService = class {
 				`origin/${base}`
 			], before.root, REMOTE_TIMEOUT_MS);
 			if (merged.exitCode !== 0 || merged.lossy) {
-				const conflicted = await this.#run(git, [
+				const conflicts = conflictPaths(await this.#run(git, [
 					"diff",
 					"--name-only",
 					"--diff-filter=U",
 					"--"
-				], before.root, GIT_TIMEOUT_MS$1);
-				const conflicts = conflicted.exitCode === 0 && !conflicted.lossy ? conflicted.stdout.split(/\r?\n/u).filter((line) => line.length > 0).slice(0, 100) : [];
+				], before.root, GIT_TIMEOUT_MS$1));
 				if (conflicts.length === 0) {
 					await this.#run(git, [method, "--abort"], before.root, GIT_TIMEOUT_MS$1).catch(() => void 0);
 					throw new RepositoryActionError("merge-failed", `Git could not ${method} the base branch.`);
@@ -5727,6 +5972,87 @@ var RepositoryActionService = class {
 			pullRequestUrl: url
 		};
 	}
+	/** Finishes or discards the merge, rebase, cherry-pick or revert git is
+	*  waiting on. The operation is read from the git dir rather than taken from
+	*  the caller: `--continue` and `--abort` are only safe against the one that
+	*  is actually in progress. */
+	async #resolve(cwd, action, push) {
+		const git = await this.#git();
+		const [rootValue, gitDirValue] = (await this.#mustRun(git, [
+			"rev-parse",
+			"--path-format=absolute",
+			"--show-toplevel",
+			"--absolute-git-dir"
+		], cwd, GIT_TIMEOUT_MS$1, "not-repository", "The session directory is not a Git repository.")).stdout.split(/\r?\n/u);
+		const root = (rootValue ?? "").trim();
+		const gitDir = (gitDirValue ?? "").trim();
+		if (root.length === 0 || gitDir.length === 0) throw new RepositoryActionError("repository-unavailable", "Repository state is unavailable.");
+		const state = await detectRepositoryOperation(gitDir);
+		if (state === void 0) throw new RepositoryActionError("no-operation", "No merge, rebase, cherry-pick or revert is in progress.");
+		const operation = state.operation;
+		if (action === "resolve-abort") {
+			await this.#mustRun(git, [operation, "--abort"], root, GIT_TIMEOUT_MS$1, "abort-failed", `Git could not abort the ${operation}.`);
+			this.#invalidate(root);
+			return {
+				commit: await this.#head(git, root),
+				pushed: false
+			};
+		}
+		if (conflictPaths(await this.#run(git, [
+			"diff",
+			"--name-only",
+			"--diff-filter=U",
+			"--"
+		], root, GIT_TIMEOUT_MS$1)).length > 0) throw new RepositoryActionError("unresolved-conflicts", "Resolve and stage every conflicted file before continuing.");
+		const continued = await this.#run(git, [
+			"-c",
+			"core.editor=true",
+			operation,
+			"--continue"
+		], root, REMOTE_TIMEOUT_MS);
+		this.#invalidate(root);
+		if (continued.exitCode !== 0 || continued.lossy) {
+			const next = conflictPaths(await this.#run(git, [
+				"diff",
+				"--name-only",
+				"--diff-filter=U",
+				"--"
+			], root, GIT_TIMEOUT_MS$1));
+			if (next.length > 0) return {
+				commit: await this.#head(git, root),
+				pushed: false,
+				conflicts: next
+			};
+			const reason = continued.stderr.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
+			throw new RepositoryActionError("continue-failed", reason === void 0 || reason.length === 0 ? `Git could not continue the ${operation}.` : reason);
+		}
+		const head = await this.#head(git, root);
+		if (!push) return {
+			commit: head,
+			pushed: false
+		};
+		const branch = await this.#run(git, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], root, GIT_TIMEOUT_MS$1);
+		if (branch.exitCode !== 0 || branch.lossy) throw new RepositoryActionError("detached-head", "The finished operation left a detached HEAD, so nothing was pushed.", head);
+		try {
+			await this.#push(git, root, branch.stdout.trim(), operation === "rebase");
+		} catch (error) {
+			throw new RepositoryActionError("push-failed", error instanceof Error ? error.message : "Git push failed.", head);
+		}
+		this.#invalidate(root);
+		return {
+			commit: head,
+			pushed: true
+		};
+	}
+	async #head(git, root) {
+		const head = await this.#run(git, ["rev-parse", "HEAD"], root, GIT_TIMEOUT_MS$1);
+		return head.exitCode === 0 && !head.lossy ? head.stdout.trim() : "";
+	}
 	async #preview(cwd) {
 		const git = await this.#git();
 		const root = (await this.#mustRun(git, [
@@ -5734,6 +6060,7 @@ var RepositoryActionService = class {
 			"--path-format=absolute",
 			"--show-toplevel"
 		], cwd, GIT_TIMEOUT_MS$1, "not-repository", "The session directory is not a Git repository.")).stdout.trim();
+		const funcname = await diffFuncnameArgs();
 		const [branchResult, headResult, statusResult, stagedPatch, unstagedPatch] = await Promise.all([
 			this.#run(git, [
 				"symbolic-ref",
@@ -5749,6 +6076,7 @@ var RepositoryActionService = class {
 				"--untracked-files=all"
 			], root, GIT_TIMEOUT_MS$1),
 			this.#run(git, [
+				...funcname,
 				"diff",
 				"--cached",
 				"--no-ext-diff",
@@ -5759,6 +6087,7 @@ var RepositoryActionService = class {
 				":(exclude)**/WARP.md"
 			], root, GIT_TIMEOUT_MS$1, MAX_OUTPUT_BYTES$2),
 			this.#run(git, [
+				...funcname,
 				"diff",
 				"--no-ext-diff",
 				"--no-color",
@@ -6012,7 +6341,17 @@ const ACTIONS = /* @__PURE__ */ new Set([
 	"push",
 	"create-pr",
 	"merge-pr",
-	"update-branch"
+	"update-branch",
+	"resolve-continue",
+	"resolve-abort"
+]);
+/** Actions that commit nothing of their own, so the panel sends no message. */
+const MESSAGELESS = /* @__PURE__ */ new Set([
+	"push",
+	"merge-pr",
+	"update-branch",
+	"resolve-continue",
+	"resolve-abort"
 ]);
 function record$9(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -6051,7 +6390,7 @@ function actionRequest(input) {
 	return {
 		action,
 		fingerprint: string$1(input, "fingerprint"),
-		message: action === "push" || action === "merge-pr" || action === "update-branch" ? optionalString(input, "message") ?? "" : string$1(input, "message"),
+		message: MESSAGELESS.has(action) ? optionalString(input, "message") ?? "" : string$1(input, "message"),
 		includeUnstaged: input.includeUnstaged,
 		...optionalString(input, "prTitle") === void 0 ? {} : { prTitle: optionalString(input, "prTitle") },
 		...optionalString(input, "prBody") === void 0 ? {} : { prBody: optionalString(input, "prBody") },
@@ -6059,6 +6398,9 @@ function actionRequest(input) {
 		...input.draft === void 0 ? {} : typeof input.draft === "boolean" ? { draft: input.draft } : (() => {
 			throw new RepositoryActionError("invalid-request", "The draft field must be a boolean.");
 		})(),
+		...input.push === void 0 ? {} : typeof input.push === "boolean" ? { push: input.push } : (() => {
+			throw new RepositoryActionError("invalid-request", "The push field must be a boolean.");
+		})(),
 		...input.mergeMethod === void 0 ? {} : input.mergeMethod === "merge" || input.mergeMethod === "squash" || input.mergeMethod === "rebase" ? { mergeMethod: input.mergeMethod } : (() => {
 			throw new RepositoryActionError("invalid-request", "The mergeMethod field is invalid.");
 		})()
@@ -9102,7 +9444,7 @@ async function apply(ctx, config) {
 	let resolutionError;
 	try {
 		supervisorConfig.executablePath = (await resolveClaudeExecutable(ctx.subprocess, config.executablePath === void 0 || config.executablePath.length === 0 ? void 0 : config.executablePath)).path;
-		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request)));
+		ctx.llm.registerAdapter([...CLAUDE_CODE_PROVIDER_IDS], createClaudeCodeAdapter(supervisor, ctx.agents, ctx.attachments, (agent) => ctx.agentPresets.composedPreset(agent.ctx), (sessionId) => reviewComments.drain(sessionId), () => readRenderMode(), (request) => summarizeSessionTitle(supervisorConfig.executablePath, request), () => probeClaudeModels(supervisorConfig.executablePath)));
 		ctx.effect(() => {
 			const mounted = /* @__PURE__ */ new Map();
 			const pending = /* @__PURE__ */ new Set();
@@ -9231,7 +9573,7 @@ async function apply(ctx, config) {
 		registerAskRoute(webCtx, new AskService(webCtx.subprocess, supervisorConfig.executablePath), cwdForClaudeSession, (sessionId) => {
 			const snapshot = supervisor.snapshots().find((item) => item.sessionId === sessionId);
 			return snapshot === void 0 ? void 0 : {
-				model: snapshot.model,
+				model: claudeModelValue(snapshot.model),
 				...snapshot.thinkingMode === void 0 ? {} : { thinkingMode: snapshot.thinkingMode }
 			};
 		});