@gajae-code/coding-agent 0.7.9 → 0.7.10

package/src/modes/components/hook-selector.ts

@@ -58,6 +58,11 @@ export interface HookSelectorOptions {
 		optionLabel: string;
 		onSubmit: (text: string) => void;
 	};
+	clarificationInput?: {
+		optionLabel: string;
+		onSubmit: (text: string) => void;
+		allowEmpty?: boolean;
+	};
 	/**
 	 * Autocomplete provider for the inline custom-input editor. When present,
 	 * the "Other (type your own)" editor gains the same `@` file-link and `/`
@@ -338,6 +343,8 @@ export class HookSelectorComponent extends Container {
 	#outline: boolean;
 	#scrollTitleRows: number | undefined;
 	#customInput: { optionLabel: string; onSubmit: (text: string) => void } | undefined;
+	#clarificationInput: { optionLabel: string; onSubmit: (text: string) => void; allowEmpty?: boolean } | undefined;
+	#activeInput: { onSubmit: (text: string) => void; allowEmpty?: boolean } | undefined;
 	#inputArea: Container;
 	#inlineEditor: Editor | undefined;
 	#helpTextComponent: Text;
@@ -365,6 +372,7 @@ export class HookSelectorComponent extends Container {
 		this.#wrapFocused = opts?.wrapFocused === true;
 		this.#outline = opts?.outline === true;
 		this.#customInput = opts?.customInput;
+		this.#clarificationInput = opts?.clarificationInput;
 		this.#tui = opts?.tui;
 		this.#autocompleteProvider = opts?.autocompleteProvider;
 
@@ -500,7 +508,11 @@ export class HookSelectorComponent extends Container {
 			const selected = this.#options[this.#selectedIndex];
 			if (!selected) return;
 			if (this.#customInput && selected === this.#customInput.optionLabel) {
-				this.#enterInputMode();
+				this.#enterInputMode(this.#customInput);
+				return;
+			}
+			if (this.#clarificationInput && selected === this.#clarificationInput.optionLabel) {
+				this.#enterInputMode(this.#clarificationInput);
 				return;
 			}
 			this.#onSelectCallback(selected);
@@ -535,14 +547,19 @@ export class HookSelectorComponent extends Container {
 			return;
 		}
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return")) {
-			this.#customInput?.onSubmit(editor.getExpandedText());
+			const text = editor.getExpandedText();
+			if (this.#activeInput?.allowEmpty === false && text.trim() === "") {
+				return;
+			}
+			this.#activeInput?.onSubmit(text);
 			return;
 		}
 		editor.handleInput(keyData);
 	}
 
-	#enterInputMode(): void {
+	#enterInputMode(input: { onSubmit: (text: string) => void; allowEmpty?: boolean }): void {
 		if (this.#inlineEditor) return;
+		this.#activeInput = input;
 		// Stop the auto-select countdown for good: the user is actively typing,
 		// matching the old behavior where the separate editor had no timeout.
 		if (this.#countdown) {
@@ -577,6 +594,7 @@ export class HookSelectorComponent extends Container {
 	#exitInputMode(): void {
 		if (!this.#inlineEditor) return;
 		this.#inlineEditor = undefined;
+		this.#activeInput = undefined;
 		this.#inputArea.clear();
 		this.#helpTextComponent.setText(theme.fg("dim", this.#baseHelpText));
 		this.invalidate();

package/src/modes/components/settings-selector.ts

@@ -164,6 +164,7 @@ class SelectSubmenu extends Container {
 	}
 }
 const STATUS_LINE_CUSTOM_EDITOR_ID = "statusLine.customEditor";
+const STATUS_LINE_USAGE_MODE_ID = "statusLine.usageMode";
 const PUBLIC_STATUS_SEGMENTS = ALL_SEGMENT_IDS.filter(id => id !== "pi");
 
 type StatusLineDraft = Required<
@@ -183,6 +184,8 @@ const USAGE_MODE_OPTIONS: SelectItem[] = [
 	{ value: "used", label: "Used" },
 	{ value: "remaining", label: "Remaining" },
 ];
+const USAGE_MODE_VALUES = ["used", "remaining"] as const;
+type UsageMode = (typeof USAGE_MODE_VALUES)[number];
 
 function cloneSegmentOptions(options: StatusLineSegmentOptions | undefined): StatusLineSegmentOptions {
 	return mergeSegmentOptions(undefined, options);
@@ -223,6 +226,25 @@ function effectiveCustomSegments(
 	};
 }
 
+function getSavedUsageMode(): UsageMode {
+	const segmentOptions = settings.get("statusLine.segmentOptions") as StatusLineSegmentOptions;
+	return segmentOptions.usage?.mode === "remaining" ? "remaining" : "used";
+}
+
+function setSavedUsageMode(mode: string): StatusLineSegmentOptions {
+	const normalizedMode: UsageMode = mode === "remaining" ? "remaining" : "used";
+	const segmentOptions = settings.get("statusLine.segmentOptions") as StatusLineSegmentOptions;
+	const nextOptions: StatusLineSegmentOptions = {
+		...segmentOptions,
+		usage: {
+			...(segmentOptions.usage ?? {}),
+			mode: normalizedMode,
+		},
+	};
+	settings.set("statusLine.segmentOptions", nextOptions as Record<string, unknown>);
+	return nextOptions;
+}
+
 function statusSegmentLabel(id: StatusLineSegmentId): string {
 	return id.replace(/_/g, " ");
 }
@@ -844,9 +866,7 @@ export class SettingsSelectorComponent extends Container {
 			};
 		} else if (def.path === "statusLine.preset") {
 			onPreview = value => {
-				const presetDef = getPreset(
-					value as "default" | "minimal" | "compact" | "full" | "nerd" | "ascii" | "custom",
-				);
+				const presetDef = getPreset(value as StatusLinePreset);
 				this.callbacks.onStatusLinePreview?.({
 					preset: value as StatusLinePreset,
 					leftSegments: presetDef.leftSegments,
@@ -984,6 +1004,16 @@ export class SettingsSelectorComponent extends Container {
 			10,
 			getSettingsListTheme(),
 			(id, newValue) => {
+				if (id === STATUS_LINE_USAGE_MODE_ID) {
+					const segmentOptions = setSavedUsageMode(newValue);
+					this.callbacks.onChange("statusLine.segmentOptions", segmentOptions);
+					if (tabId === "appearance") {
+						this.#triggerStatusLinePreview();
+					}
+					this.#refreshCurrentTabItems(defs);
+					return;
+				}
+
 				const def = defs.find(d => d.path === id);
 				if (!def) return;
 
@@ -1048,6 +1078,20 @@ export class SettingsSelectorComponent extends Container {
 			} else {
 				items.push(customEditorItem);
 			}
+			{
+				const usageModeItem: SettingItem = {
+					id: STATUS_LINE_USAGE_MODE_ID,
+					label: "Status Line Usage Mode",
+					description: "Show provider quota in the status line as used or remaining.",
+					currentValue: getSavedUsageMode(),
+					values: [...USAGE_MODE_VALUES],
+				};
+				if (presetIndex >= 0) {
+					items.splice(presetIndex + 2, 0, usageModeItem);
+				} else {
+					items.push(usageModeItem);
+				}
+			}
 		}
 		return items;
 	}

package/src/modes/components/status-line/presets.ts

@@ -12,6 +12,17 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 		},
 	},
 
+	"default-usage": {
+		leftSegments: ["model", "mode", "git", "pr", "path"],
+		rightSegments: ["session_name", "jobs", "token_rate", "usage", "context_pct", "cost"],
+		separator: "slash",
+		segmentOptions: {
+			model: { showThinkingLevel: true },
+			path: { abbreviate: true, maxLength: 32, stripWorkPrefix: true },
+			git: { showBranch: true, showStaged: true, showUnstaged: true, showUntracked: true },
+		},
+	},
+
 	minimal: {
 		leftSegments: ["path", "git"],
 		rightSegments: ["session_name", "jobs", "mode", "context_pct"],

package/src/modes/controllers/extension-ui-controller.ts

@@ -617,7 +617,8 @@ export class ExtensionUiController {
 		const listChromeRows = dialogOptions?.outline === true ? HOOK_SELECTOR_OUTLINE_ROWS : 0;
 		// Reserve rows for the inline custom-input editor so opening it doesn't
 		// push the scrollable title past the viewport into terminal scrollback.
-		const inlineInputRows = dialogOptions?.customInput ? HOOK_SELECTOR_INLINE_INPUT_ROWS : 0;
+		const inlineInputRows =
+			dialogOptions?.customInput || dialogOptions?.clarificationInput ? HOOK_SELECTOR_INLINE_INPUT_ROWS : 0;
 		const availableTitleRows =
 			this.ctx.ui.terminal.rows - scrollOptionRows - listChromeRows - inlineInputRows - HOOK_SELECTOR_CHROME_ROWS;
 		const scrollTitleRows =
@@ -659,7 +660,10 @@ export class ExtensionUiController {
 				tui: this.ctx.ui,
 				// Share the main prompt editor's autocomplete provider so the
 				// inline "Other (type your own)" editor supports `@` file links.
-				autocompleteProvider: dialogOptions?.customInput ? this.ctx.editor.getAutocompleteProvider() : undefined,
+				autocompleteProvider:
+					dialogOptions?.customInput || dialogOptions?.clarificationInput
+						? this.ctx.editor.getAutocompleteProvider()
+						: undefined,
 				outline: dialogOptions?.outline,
 				wrapFocused: dialogOptions?.wrapFocused,
 				scrollTitleRows,
@@ -675,6 +679,18 @@ export class ExtensionUiController {
 							},
 						}
 					: undefined,
+				clarificationInput: dialogOptions?.clarificationInput
+					? {
+							optionLabel: dialogOptions.clarificationInput.optionLabel,
+							allowEmpty: dialogOptions.clarificationInput.allowEmpty,
+							onSubmit: text => {
+								const optionLabel = dialogOptions.clarificationInput?.optionLabel;
+								this.hideHookSelector();
+								dialogOptions.clarificationInput?.onSubmit(text);
+								finish(optionLabel);
+							},
+						}
+					: undefined,
 			},
 		);
 		// Detach (not dispose) the reusable editor before mounting the transient hook UI, so the

package/src/modes/shared/agent-wire/deep-interview-gate.ts

@@ -53,6 +53,7 @@ export interface AskGateResult {
 	multi: boolean;
 	selectedOptions: string[];
 	customInput?: string;
+	clarificationQuestion?: string;
 }
 
 /**
@@ -61,12 +62,15 @@ export interface AskGateResult {
  * `selected` are picked option labels; free text is conveyed by `other: true`
  * plus `custom`, encoded separately from `selected` so a real option whose label
  * happens to equal the display sentinel can never collide with the free-text path.
+ *
+ * `action: "clarify"` is a non-answer. It lets a Deep Interview user ask about
+ * the presented choices without advancing the round, scoring ambiguity, or
+ * recording selection state.
  */
-export interface DeepInterviewGateAnswer {
-	selected: string[];
-	other?: boolean;
-	custom?: string;
-}
+export type DeepInterviewGateAnswer =
+	| { selected: string[]; other?: false; custom?: undefined; action?: "answer" }
+	| { selected: string[]; other: true; custom: string; action?: "answer" }
+	| { action: "clarify"; question: string };
 
 export class DeepInterviewGateError extends Error {
 	constructor(
@@ -75,6 +79,7 @@ export class DeepInterviewGateError extends Error {
 			| "unknown_option"
 			| "multi_not_allowed"
 			| "missing_custom"
+			| "missing_clarification"
 			| "empty_selection"
 			| "duplicate_selection",
 		message: string,
@@ -127,13 +132,22 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 			selected: selectedBase,
 			other: { type: "boolean", description: "set true to provide a free-text answer in `custom`" },
 			custom: { type: "string", minLength: 1, description: "free-text answer; required when `other` is true" },
+			action: {
+				type: "string",
+				enum: ["answer", "clarify"],
+				description: "set to `clarify` to ask about the choices without answering the round",
+			},
+			question: {
+				type: "string",
+				minLength: 1,
+				description: "clarification question; required when action is `clarify`",
+			},
 		},
-		required: ["selected"],
 		additionalProperties: false,
 		anyOf: [
 			{
 				type: "object",
-				properties: { selected: selectedOnly, other: { const: false } },
+				properties: { selected: selectedOnly, other: { const: false }, action: { const: "answer" } },
 				required: ["selected"],
 				additionalProperties: false,
 			},
@@ -143,10 +157,20 @@ function questionAnswerSchema(question: AskGateQuestion, labels: string[]): RpcJ
 					selected: selectedWithOther,
 					other: { const: true },
 					custom: { type: "string", minLength: 1 },
+					action: { const: "answer" },
 				},
 				required: ["selected", "other", "custom"],
 				additionalProperties: false,
 			},
+			{
+				type: "object",
+				properties: {
+					action: { const: "clarify" },
+					question: { type: "string", minLength: 1 },
+				},
+				required: ["action", "question"],
+				additionalProperties: false,
+			},
 		],
 	};
 }
@@ -185,6 +209,7 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 				multi: question.multi ?? false,
 				options: labels,
 				other_option: GATE_OTHER_OPTION,
+				clarification_action: "clarify",
 				...(question.deepInterview
 					? structuredDeepInterviewState(question.deepInterview)
 					: deepInterviewQuestionState(question.question)),
@@ -195,8 +220,14 @@ export function questionToGate(question: AskGateQuestion): OpenGateInput {
 
 function isAnswer(value: unknown): value is DeepInterviewGateAnswer {
 	if (typeof value !== "object" || value === null) return false;
-	const v = value as DeepInterviewGateAnswer;
+	const v = value as Record<string, unknown>;
+	if (v.action === "clarify") {
+		return (
+			typeof v.question === "string" && v.selected === undefined && v.other === undefined && v.custom === undefined
+		);
+	}
 	return (
+		(v.action === undefined || v.action === "answer") &&
 		Array.isArray(v.selected) &&
 		v.selected.every(s => typeof s === "string") &&
 		(v.other === undefined || typeof v.other === "boolean") &&
@@ -214,11 +245,24 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	if (!isAnswer(answer)) {
 		throw new DeepInterviewGateError(
 			"invalid_answer_shape",
-			"answer must be { selected: string[]; other?: boolean; custom?: string }",
+			'answer must be an answer ({ selected: string[]; other?: boolean; custom?: string }) or clarification ({ action: "clarify"; question: string })',
 		);
 	}
 	const labels = question.options.map(o => o.label);
 	const multi = question.multi ?? false;
+	if (answer.action === "clarify") {
+		if (answer.question.trim() === "") {
+			throw new DeepInterviewGateError("missing_clarification", "clarification question is required");
+		}
+		return {
+			id: question.id,
+			question: question.question,
+			options: labels,
+			multi,
+			selectedOptions: [],
+			clarificationQuestion: answer.question,
+		};
+	}
 	const valid = new Set(labels);
 	for (const sel of answer.selected) {
 		if (!valid.has(sel)) throw new DeepInterviewGateError("unknown_option", `unknown option: ${sel}`);

package/src/notifications/html-format.ts

@@ -248,6 +248,8 @@ interface Token {
 	value: string;
 	/** Tag name if this token opens a tag, else undefined. */
 	open?: string;
+	/** Exact opening tag text, including attributes, for safe chunk reopening. */
+	openTag?: string;
 	/** Tag name if this token closes a tag, else undefined. */
 	close?: string;
 }
@@ -266,8 +268,10 @@ function tokenize(html: string): Token[] {
 				const openMatch = /^<([a-z-]+)(?:\s[^>]*)?>$/i.exec(raw);
 				const token: Token = { value: raw };
 				if (close && ALLOWED_TAGS.has(close[1]!.toLowerCase())) token.close = close[1]!.toLowerCase();
-				else if (openMatch && ALLOWED_TAGS.has(openMatch[1]!.toLowerCase()))
+				else if (openMatch && ALLOWED_TAGS.has(openMatch[1]!.toLowerCase())) {
 					token.open = openMatch[1]!.toLowerCase();
+					token.openTag = raw;
+				}
 				tokens.push(token);
 				i = end + 1;
 				continue;
@@ -330,6 +334,76 @@ export function truncateTelegramHtml(message: string, max = TELEGRAM_MESSAGE_LIM
 	return out + closersFor(stack) + effectiveMarker;
 }
 
+interface OpenTag {
+	name: string;
+	tag: string;
+}
+
+/** Split a finished Telegram HTML message into ordered chunks without splitting tags or entities. */
+export function splitTelegramHtml(message: string, max = TELEGRAM_MESSAGE_LIMIT): string[] {
+	if (message.length <= max) return [message];
+	const chunks: string[] = [];
+	const tokens = tokenize(message);
+	const stack: OpenTag[] = [];
+	let out = "";
+	let chunkHasBody = false;
+
+	const closersFor = (s: OpenTag[]): string =>
+		s
+			.map(t => `</${t.name}>`)
+			.reverse()
+			.join("");
+	const openersFor = (s: OpenTag[]): string => s.map(t => t.tag).join("");
+	const minimumChunkLengthFor = (s: OpenTag[]): number => openersFor(s).length + closersFor(s).length + 1;
+	const flush = (): void => {
+		if (!chunkHasBody) return;
+		chunks.push(out + closersFor(stack));
+		out = openersFor(stack);
+		chunkHasBody = false;
+	};
+
+	const updateStackForClose = (name: string): boolean => {
+		const idx = stack.findLastIndex(t => t.name === name);
+		if (idx === -1) return false;
+		stack.splice(idx, 1);
+		return true;
+	};
+
+	for (const token of tokens) {
+		if (token.open) {
+			const nextStack = [...stack, { name: token.open, tag: token.openTag ?? token.value }];
+			if (minimumChunkLengthFor(nextStack) > max) continue;
+			if (chunkHasBody && out.length + token.value.length + closersFor(nextStack).length > max) flush();
+			if (out.length + token.value.length + closersFor(nextStack).length > max) continue;
+			out += token.value;
+			chunkHasBody = true;
+			stack.push({ name: token.open, tag: token.openTag ?? token.value });
+			continue;
+		}
+
+		if (token.close) {
+			const idx = stack.findLastIndex(t => t.name === token.close);
+			if (idx === -1) continue;
+			const nextStack = stack.toSpliced(idx, 1);
+			if (chunkHasBody && out.length + token.value.length + closersFor(nextStack).length > max) flush();
+			if (out.length + token.value.length + closersFor(nextStack).length > max) {
+				updateStackForClose(token.close);
+				continue;
+			}
+			out += token.value;
+			chunkHasBody = true;
+			updateStackForClose(token.close);
+			continue;
+		}
+
+		if (chunkHasBody && out.length + token.value.length + closersFor(stack).length > max) flush();
+		out += token.value;
+		chunkHasBody = true;
+	}
+	if (chunkHasBody) chunks.push(out + closersFor(stack));
+	return chunks;
+}
+
 /** Finalize an optional message: undefined passthrough, else safe-truncate. */
 export function finalizeTelegramHtml(message?: string): string | undefined {
 	if (message === undefined) return undefined;

package/src/notifications/index.ts

@@ -297,6 +297,15 @@ function buildIdentity(
 	return { repo, branch, machine: os.hostname(), title: sessionName };
 }
 
+/** Compact cwd label for remote session identity; never emits the full host path by default. */
+function compactCwd(cwd: string): string | undefined {
+	const home = os.homedir();
+	const resolved = path.resolve(cwd);
+	if (resolved === home) return "~";
+	const base = path.basename(resolved);
+	return base || path.parse(resolved).root || undefined;
+}
+
 const execFileAsync = promisify(execFile);
 
 /** Best-effort working-tree diff stat for the context update (no throw). */
@@ -973,7 +982,8 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 			const tokenUsage = usage && usage.tokens != null ? `${usage.tokens}/${usage.contextWindow}` : undefined;
 			const modelId = model?.id;
 			void readGitDiffStat(ctx.cwd).then(diff => {
-				if (!diff && !tokenUsage && !modelId) return;
+				const cwd = compactCwd(ctx.cwd);
+				if (!diff && !tokenUsage && !modelId && !cwd) return;
 				try {
 					rt.server.pushFrame(
 						JSON.stringify({
@@ -982,6 +992,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 							tokenUsage,
 							model: modelId,
 							diff,
+							cwd,
 						}),
 					);
 				} catch (e) {

package/src/notifications/recent-activity.ts

@@ -25,6 +25,8 @@ export interface RecentSessionEntry {
 	mtimeMs: number;
 	/** True when a terminal breadcrumb points at this session file. */
 	currentTerminal?: boolean;
+	/** True when this history is an internal helper/sub-agent session. */
+	internal?: boolean;
 }
 
 export interface RecentActivityDeps {
@@ -34,17 +36,18 @@ export interface RecentActivityDeps {
 	breadcrumbPaths?: string[];
 	/** Max entries to return (default 20). */
 	limit?: number;
+	/** Include internal helper/sub-agent sessions (default true). */
+	includeInternal?: boolean;
 	/** Injection seam for tests. */
-	readFirstLine?: (file: string) => string | undefined;
+	readInitialLines?: (file: string, maxLines: number) => string[];
 }
 
-function defaultReadFirstLine(file: string): string | undefined {
+function defaultReadInitialLines(file: string, maxLines: number): string[] {
 	try {
-		const buf = fs.readFileSync(file, "utf8");
-		const nl = buf.indexOf("\n");
-		return nl === -1 ? buf : buf.slice(0, nl);
+		const lines = fs.readFileSync(file, "utf8").split("\n");
+		return lines.slice(0, maxLines);
 	} catch {
-		return undefined;
+		return [];
 	}
 }
 
@@ -65,6 +68,22 @@ function headerMeta(line: string | undefined): { id?: string; path?: string; bra
 	}
 }
 
+/** Detect task-tool helper sessions from the durable early session_init metadata entry. */
+function isInternalSession(lines: readonly string[]): boolean {
+	for (const line of lines.slice(1)) {
+		if (!line.trim()) continue;
+		try {
+			const obj = JSON.parse(line) as unknown;
+			if (typeof obj === "object" && obj !== null && (obj as { type?: unknown }).type === "session_init") {
+				return true;
+			}
+		} catch {
+			// Ignore malformed JSONL entries; classification is best-effort.
+		}
+	}
+	return false;
+}
+
 /**
  * The authoritative session id for a history file: the header `id` when present,
  * else the filename stem with a leading `<timestamp>_` prefix stripped (matching
@@ -85,7 +104,8 @@ function sessionIdForFile(stem: string, headerId: string | undefined): string {
  */
 export function listRecentSessions(deps: RecentActivityDeps): RecentSessionEntry[] {
 	const limit = deps.limit ?? 20;
-	const readFirstLine = deps.readFirstLine ?? defaultReadFirstLine;
+	const includeInternal = deps.includeInternal ?? true;
+	const readInitialLines = deps.readInitialLines ?? defaultReadInitialLines;
 	const breadcrumbs = new Set((deps.breadcrumbPaths ?? []).map(p => path.resolve(p)));
 
 	let projectDirs: string[];
@@ -114,7 +134,10 @@ export function listRecentSessions(deps: RecentActivityDeps): RecentSessionEntry
 			} catch {
 				continue;
 			}
-			const meta = headerMeta(readFirstLine(file));
+			const initialLines = readInitialLines(file, 8);
+			const meta = headerMeta(initialLines[0]);
+			const internal = isInternalSession(initialLines);
+			if (internal && !includeInternal) continue;
 			entries.push({
 				sessionId: sessionIdForFile(name.slice(0, -".jsonl".length), meta.id),
 				path: meta.path,
@@ -123,6 +146,7 @@ export function listRecentSessions(deps: RecentActivityDeps): RecentSessionEntry
 				sessionStateFile: file,
 				mtimeMs,
 				currentTerminal: breadcrumbs.has(path.resolve(file)) || undefined,
+				internal: internal || undefined,
 			});
 		}
 	}

package/src/notifications/telegram-daemon-control.ts

@@ -97,6 +97,14 @@ export interface TelegramDaemonControlDeps {
 	sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
 	spawn?: TelegramDaemonDeps["spawn"];
 	execPath?: string;
+	/**
+	 * Stable process id encoded into freshly-spawned daemon owner ids.
+	 *
+	 * The daemon-internal entrypoint rejects numeric owner ids whose process is
+	 * already gone. `gjc daemon reload` is a short-lived CLI process, so using its
+	 * own pid can race the child startup and make the replacement exit immediately.
+	 */
+	ownerPid?: number;
 	randomId?: () => string;
 	sleep?: (ms: number) => Promise<void>;
 	waitStepMs?: number;
@@ -188,6 +196,7 @@ export class TelegramDaemonController implements BuiltInDaemonController {
 			fs: this.deps.fs,
 			now: this.deps.now,
 			pidAlive: this.deps.pidAlive,
+			pid: this.deps.ownerPid ?? process.ppid,
 			spawn: this.deps.spawn,
 			execPath: this.deps.execPath,
 			randomId: this.deps.randomId,