@gajae-code/coding-agent 0.7.8 → 0.7.10

package/src/modes/controllers/selector-controller.ts

@@ -4,8 +4,14 @@ import type { OAuthProvider } from "@gajae-code/ai/utils/oauth/types";
 import type { Component, OverlayHandle } from "@gajae-code/tui";
 import { Input, Loader, Spacer, Text } from "@gajae-code/tui";
 import { getAgentDbPath, getProjectDir } from "@gajae-code/utils";
-import { activateModelProfile, materializeActiveModelProfileAssignment } from "../../config/model-profile-activation";
-import { recommendModelProfileForProvider } from "../../config/model-profiles";
+import {
+	activateModelProfile,
+	type MaterializeModelProfileForDeletionResult,
+	materializeActiveModelProfileAssignment,
+	materializeModelProfileForDeletion,
+	restoreMaterializedModelProfileForDeletion,
+} from "../../config/model-profile-activation";
+import { formatModelProfileDisplayLabel, recommendModelProfileForProvider } from "../../config/model-profiles";
 import { GJC_MODEL_ASSIGNMENT_TARGETS } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
@@ -39,7 +45,11 @@ import {
 	CREDENTIAL_AUTO_IMPORT_ROTATION_WARNING,
 	runExternalCredentialAutoImport,
 } from "../../setup/credential-auto-import";
-import { filterAutoImportOAuthCredentials, formatDiscoverySummary } from "../../setup/credential-import";
+import {
+	filterAutoImportOAuthCredentials,
+	formatDiscoverySummary,
+	type ImportableCredential,
+} from "../../setup/credential-import";
 import {
 	MODEL_ONBOARDING_API_PROVIDER_COMMAND,
 	MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
@@ -248,7 +258,7 @@ export class SelectorController {
 					const profile = await this.ctx.session.modelRegistry.saveCustomModelProfile(input.name, input.profile);
 					await this.ctx.session.modelRegistry.refresh("offline");
 					await this.ctx.notifyConfigChanged?.();
-					this.ctx.showStatus(`Custom model preset created: ${profile.displayName ?? profile.name}`);
+					this.ctx.showStatus(`Custom model preset created: ${formatModelProfileDisplayLabel(profile)}`);
 					done();
 					this.ctx.ui.requestRender();
 				} catch (err) {
@@ -271,6 +281,106 @@ export class SelectorController {
 		});
 	}
 
+	async #renameCustomModelPreset(profileName: string, modelSelector: ModelSelectorComponent): Promise<void> {
+		const profile = this.ctx.session.modelRegistry.getModelProfile(profileName);
+		const currentName = profile ? formatModelProfileDisplayLabel(profile) : profileName;
+		const input = await this.ctx.showHookInput(`Rename custom model preset: ${currentName}`, undefined, undefined, {
+			initialValue: currentName,
+		});
+		if (input === undefined) {
+			this.ctx.showStatus("Preset rename cancelled.");
+			this.ctx.ui.requestRender();
+			return;
+		}
+		try {
+			const renamed = await this.ctx.session.modelRegistry.renameCustomModelProfile(profileName, input);
+			await this.ctx.session.modelRegistry.refresh("offline");
+			await this.ctx.notifyConfigChanged?.();
+			modelSelector.refreshPresetProfiles(renamed.name);
+			this.ctx.showStatus(`Custom model preset renamed: ${formatModelProfileDisplayLabel(renamed)}`);
+			this.ctx.ui.requestRender();
+		} catch (err) {
+			this.ctx.showError(`Preset rename failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+
+	async #deleteCustomModelPreset(profileName: string, modelSelector: ModelSelectorComponent): Promise<void> {
+		const profile = this.ctx.session.modelRegistry.getModelProfile(profileName);
+		const profileLabel = profile ? formatModelProfileDisplayLabel(profile) : profileName;
+		const confirmed = await this.ctx.showHookConfirm(
+			`Delete custom model preset: ${profileLabel}`,
+			"This removes the preset entry after preserving current role model settings when this preset is active/default.",
+		);
+		if (!confirmed) {
+			this.ctx.showStatus("Preset delete cancelled.");
+			this.ctx.ui.requestRender();
+			return;
+		}
+
+		const activeProfile = this.ctx.session.getActiveModelProfile?.();
+		const defaultProfile = this.ctx.settings.get("modelProfile.default");
+		let snapshot: MaterializeModelProfileForDeletionResult | undefined;
+		let deletedProfile: ModelProfileConfig | undefined;
+		const refreshSelectorState = (refreshedProfileName?: string): void => {
+			modelSelector.refreshRoleAssignments({
+				currentModel: this.ctx.session.model,
+				currentThinkingLevel: this.ctx.session.thinkingLevel,
+				activeModelProfile:
+					this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
+			});
+			modelSelector.refreshPresetProfiles(refreshedProfileName);
+		};
+		try {
+			if (activeProfile === profileName || defaultProfile === profileName) {
+				snapshot = await materializeModelProfileForDeletion({
+					session: this.ctx.session,
+					modelRegistry: this.ctx.session.modelRegistry,
+					settings: this.ctx.settings,
+					profileName,
+				});
+			}
+			deletedProfile = await this.ctx.session.modelRegistry.deleteCustomModelProfile(profileName);
+			await this.ctx.session.modelRegistry.refresh("offline");
+			await this.ctx.notifyConfigChanged?.();
+			refreshSelectorState();
+			this.ctx.showStatus(`Custom model preset deleted: ${profileLabel}`);
+			this.ctx.ui.requestRender();
+		} catch (err) {
+			let presetRestoreError: unknown;
+			if (deletedProfile) {
+				try {
+					await this.ctx.session.modelRegistry.saveCustomModelProfile(profileName, deletedProfile);
+					await this.ctx.session.modelRegistry.refresh("offline");
+				} catch (restoreErr) {
+					presetRestoreError = restoreErr;
+				}
+			}
+			if (snapshot) {
+				try {
+					await restoreMaterializedModelProfileForDeletion({
+						settings: this.ctx.settings,
+						session: this.ctx.session,
+						snapshot,
+					});
+				} catch (restoreErr) {
+					refreshSelectorState(deletedProfile ? profileName : undefined);
+					this.ctx.showError(
+						`Preset delete failed and settings rollback failed: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`,
+					);
+					return;
+				}
+			}
+			if (deletedProfile) refreshSelectorState(profileName);
+			if (presetRestoreError) {
+				this.ctx.showError(
+					`Preset delete failed and preset restore failed: ${presetRestoreError instanceof Error ? presetRestoreError.message : String(presetRestoreError)}`,
+				);
+				return;
+			}
+			this.ctx.showError(`Preset delete failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+
 	showCustomProviderWizard(): void {
 		this.showSelector(done => {
 			let wizard: CustomProviderWizardComponent;
@@ -693,7 +803,20 @@ export class SelectorController {
 							this.showCustomModelPresetWizard(selection.profile);
 							return;
 						}
+						if (selection.kind === "renameProfile") {
+							await this.#renameCustomModelPreset(selection.profileName, modelSelector);
+							return;
+						}
+						if (selection.kind === "deleteProfile") {
+							await this.#deleteCustomModelPreset(selection.profileName, modelSelector);
+							return;
+						}
 						if (selection.kind === "profile") {
+							const profileLabel = formatModelProfileDisplayLabel(
+								this.ctx.session.modelRegistry.getModelProfile(selection.profileName) ?? {
+									name: selection.profileName,
+								},
+							);
 							await activateModelProfile(
 								{
 									session: this.ctx.session,
@@ -707,8 +830,8 @@ export class SelectorController {
 							this.ctx.updateEditorBorderColor();
 							this.ctx.showStatus(
 								selection.setDefault
-									? `Default model profile: ${selection.profileName}`
-									: `Model profile: ${selection.profileName}`,
+									? `Default model profile: ${profileLabel}`
+									: `Model profile: ${profileLabel}`,
 							);
 							done();
 							this.ctx.ui.requestRender();
@@ -1338,7 +1461,7 @@ export class SelectorController {
 			}
 		}
 
-		let externalCredentialCandidates: ReturnType<typeof filterAutoImportOAuthCredentials> = [];
+		let externalCredentialCandidates: ImportableCredential[] = [];
 		if (
 			mode === "login" &&
 			providerId === undefined &&

package/src/modes/interactive-mode.ts

@@ -2684,8 +2684,13 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#extensionUiController.hideHookSelector();
 	}
 
-	showHookInput(title: string, placeholder?: string): Promise<string | undefined> {
-		return this.#extensionUiController.showHookInput(title, placeholder);
+	showHookInput(
+		title: string,
+		placeholder?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+		inputOptions?: { readonly initialValue?: string },
+	): Promise<string | undefined> {
+		return this.#extensionUiController.showHookInput(title, placeholder, dialogOptions, inputOptions);
 	}
 
 	hideHookInput(): void {

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

@@ -11,7 +11,7 @@
  * the interactive select/editor UI) when an unattended controller + gate broker
  * are attached is wired with the transport in #321 and exercised by #323.
  */
-import type { RpcJsonSchema } from "../../rpc/rpc-types";
+import type { RpcJsonSchema, RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
 import type { OpenGateInput } from "./workflow-gate-broker";
 
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
@@ -26,6 +26,11 @@ export interface AskGateDeepInterviewState {
 	ambiguity: number;
 }
 
+export interface AskGateWorkflowGateMeta {
+	stage: RpcWorkflowStage;
+	kind: RpcWorkflowGateKind;
+}
+
 export interface AskGateQuestion {
 	id: string;
 	question: string;
@@ -37,6 +42,8 @@ export interface AskGateQuestion {
 	 * `stage_state`; when absent, the question text is regex-parsed as a fallback.
 	 */
 	deepInterview?: AskGateDeepInterviewState;
+	/** Override the emitted workflow gate address for non-deep-interview ask prompts. */
+	workflowGate?: AskGateWorkflowGateMeta;
 }
 
 export interface AskGateResult {
@@ -46,6 +53,7 @@ export interface AskGateResult {
 	multi: boolean;
 	selectedOptions: string[];
 	customInput?: string;
+	clarificationQuestion?: string;
 }
 
 /**
@@ -54,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(
@@ -68,6 +79,7 @@ export class DeepInterviewGateError extends Error {
 			| "unknown_option"
 			| "multi_not_allowed"
 			| "missing_custom"
+			| "missing_clarification"
 			| "empty_selection"
 			| "duplicate_selection",
 		message: string,
@@ -120,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,
 			},
@@ -136,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,
+			},
 		],
 	};
 }
@@ -157,13 +188,13 @@ function structuredDeepInterviewState(meta: AskGateDeepInterviewState): Record<s
 	return state;
 }
 
-/** Build the `workflow_gate` open-input for one deep-interview question. */
+/** Build the `workflow_gate` open-input for one ask question. */
 export function questionToGate(question: AskGateQuestion): OpenGateInput {
 	const labels = question.options.map(o => o.label);
 	const schema = questionAnswerSchema(question, labels);
 	return {
-		stage: "deep-interview",
-		kind: "question",
+		stage: question.workflowGate?.stage ?? "deep-interview",
+		kind: question.workflowGate?.kind ?? "question",
 		schema,
 		options: question.options.map((o, i) => ({
 			value: o.label,
@@ -178,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)),
@@ -188,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") &&
@@ -207,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/modes/types.ts

@@ -290,7 +290,12 @@ export interface InteractiveModeContext {
 		dialogOptions?: ExtensionUIDialogOptions,
 	): Promise<string | undefined>;
 	hideHookSelector(): void;
-	showHookInput(title: string, placeholder?: string): Promise<string | undefined>;
+	showHookInput(
+		title: string,
+		placeholder?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+		inputOptions?: { readonly initialValue?: string },
+	): Promise<string | undefined>;
 	hideHookInput(): void;
 	showHookEditor(
 		title: string,

package/src/notifications/daemon-paths.ts

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+
+export interface DaemonPaths {
+	dir: string;
+	lock: string;
+	state: string;
+	roots: string;
+	steal: string;
+	aliases: string;
+}
+
+export function daemonPaths(agentDir: string): DaemonPaths {
+	const dir = path.join(agentDir, "notifications");
+	return {
+		dir,
+		lock: path.join(dir, "telegram-daemon.lock"),
+		state: path.join(dir, "telegram-daemon.state.json"),
+		roots: path.join(dir, "telegram-daemon.roots.json"),
+		steal: path.join(dir, "telegram-daemon.steal"),
+		aliases: path.join(dir, "telegram-callback-aliases.json"),
+	};
+}

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-cli.ts

@@ -3,12 +3,19 @@ import * as path from "node:path";
 import { YAML } from "bun";
 import type { Settings } from "../config/settings";
 import { getNotificationConfig, isGloballyConfigured } from "./config";
-import { daemonPaths, TelegramNotificationDaemon } from "./telegram-daemon";
-import { clearTelegramControlRequest, readTelegramControlRequest } from "./telegram-daemon-control";
+import { daemonPaths } from "./daemon-paths";
+import type { TelegramDaemonOptions } from "./telegram-daemon";
+
+type TelegramDaemonRunner = {
+	run(): Promise<void>;
+	requestStop(reason?: "reload" | "signal" | "stop"): void;
+};
+
+type TelegramDaemonConstructor = new (opts: TelegramDaemonOptions) => TelegramDaemonRunner;
 
 export interface RunDaemonInternalDeps {
 	SettingsImpl?: { init: (options?: { agentDir?: string }) => Promise<Pick<Settings, "get" | "getAgentDir">> };
-	DaemonImpl?: typeof TelegramNotificationDaemon;
+	DaemonImpl?: TelegramDaemonConstructor;
 	processPid?: number;
 	pidAlive?: (pid: number) => boolean;
 }
@@ -140,7 +147,9 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 	const settings = await resolveDaemonSettings(resolvedAgentDir, deps);
 	const cfg = getNotificationConfig(settings as Settings);
 	if (!isGloballyConfigured(cfg) || !cfg.botToken || !cfg.chatId) return;
-	const Daemon = deps.DaemonImpl ?? TelegramNotificationDaemon;
+	const { clearTelegramControlRequest, readTelegramControlRequest } = await import("./telegram-daemon-control");
+	const Daemon: TelegramDaemonConstructor =
+		deps.DaemonImpl ?? (await import("./telegram-daemon")).TelegramNotificationDaemon;
 	const daemon = new Daemon({
 		settings: settings as Settings,
 		ownerId,