@sayknow-cli/coding-agent 0.3.5 → 0.3.7

package/src/modes/utils/ui-helpers.ts

@@ -3,6 +3,8 @@ import type { AssistantMessage, ImageContent, Message } from "@sayknow-cli/ai";
 import { type Component, Spacer, Text, TruncatedText } from "@sayknow-cli/tui";
 import { settings } from "../../config/settings";
 import { tMessage } from "../../i18n";
+import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/skc-plugins";
+import { buildSkillPromptMessage, parseSkillInvocations } from "../../extensibility/skills";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
 import { BashExecutionComponent } from "../../modes/components/bash-execution";
 import { BranchSummaryMessageComponent } from "../../modes/components/branch-summary-message";
@@ -616,9 +618,80 @@ export class UiHelpers {
 		this.ctx.updatePendingMessagesDisplay();
 		this.ctx.showStatus("Queued message for after compaction");
 	}
+	#hasSkillInvocations(text: string): boolean {
+		return parseSkillInvocations(text, this.ctx.skillCommands ?? new Map()).length > 0;
+	}
+
+	#isCompactionCommandMessage(text: string): boolean {
+		return this.#hasSkillInvocations(text) || this.isKnownSlashCommand(text);
+	}
+
+	async #deliverQueuedSkillMessage(message: CompactionQueuedMessage): Promise<boolean> {
+		const invocations = parseSkillInvocations(message.text, this.ctx.skillCommands ?? new Map());
+		if (invocations.length === 0) {
+			return false;
+		}
+
+		for (let index = 0; index < invocations.length; index += 1) {
+			const invocation = invocations[index];
+			if (!invocation) continue;
+
+			const activationResult = await resolveSubskillActivationForSkillInvocation({
+				cwd: this.ctx.sessionManager.getCwd(),
+				sessionId: this.ctx.session.sessionId,
+				skillName: invocation.skill.name,
+				args: invocation.args,
+			});
+			const built = await buildSkillPromptMessage(invocation.skill, activationResult.cleanedArgs, {
+				subskillActivation: activationResult.activation,
+				subskillActivationSet: activationResult.activeSubskillsToPersist,
+				cwd: this.ctx.sessionManager.getCwd(),
+				sessionId: this.ctx.session.sessionId,
+			});
+			const details: SkillPromptDetails = built.details;
+			const displayText = `/${invocation.commandName}${activationResult.cleanedArgs ? ` ${activationResult.cleanedArgs}` : ""}`;
+
+			if (this.ctx.session.isStreaming) {
+				const tag = this.ctx.session.enqueueCustomMessageDisplay(displayText, message.mode);
+				details.__pendingDisplayTag = tag;
+			}
+
+			const isLast = index === invocations.length - 1;
+			if (!this.ctx.session.isStreaming && !isLast) {
+				await this.ctx.session.sendCustomMessage({
+					customType: SKILL_PROMPT_MESSAGE_TYPE,
+					content: built.message,
+					display: true,
+					details,
+					attribution: "user",
+				});
+				continue;
+			}
 
+			await this.ctx.session.promptCustomMessage(
+				{
+					customType: SKILL_PROMPT_MESSAGE_TYPE,
+					content: built.message,
+					display: true,
+					details,
+					attribution: "user",
+				},
+				{ streamingBehavior: message.mode },
+			);
+		}
+
+		if (this.ctx.session.isStreaming) {
+			this.ctx.updatePendingMessagesDisplay();
+			this.ctx.ui.requestRender();
+		}
+
+		return true;
+	}
 	async #deliverQueuedMessage(message: CompactionQueuedMessage): Promise<void> {
-		if (this.ctx.isKnownSlashCommand(message.text)) {
+		if (await this.#deliverQueuedSkillMessage(message)) {
+			return;
+		}
+		if (this.isKnownSlashCommand(message.text)) {
 			await this.ctx.session.prompt(message.text);
 			return;
 		}
@@ -677,14 +750,14 @@ export class UiHelpers {
 
 			let firstPromptIndex = -1;
 			for (let i = 0; i < queuedMessages.length; i++) {
-				if (!this.ctx.isKnownSlashCommand(queuedMessages[i].text)) {
+				if (!this.#isCompactionCommandMessage(queuedMessages[i].text)) {
 					firstPromptIndex = i;
 					break;
 				}
 			}
 			if (firstPromptIndex === -1) {
 				for (const message of queuedMessages) {
-					await this.ctx.session.prompt(message.text);
+					await this.#deliverQueuedMessage(message);
 				}
 				return;
 			}

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

@@ -26,7 +26,7 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import type { ImageContent, TextContent } from "@sayknow-cli/ai";
 import { NotificationServer } from "@sayknow-cli/natives";
-import { logger } from "@sayknow-cli/utils";
+import { logger, postmortem } from "@sayknow-cli/utils";
 import { Settings } from "../config/settings";
 import type { ExtensionCommandContext, ExtensionContext, ExtensionFactory } from "../extensibility/extensions";
 import { registerAskAnswerSource } from "../tools/ask-answer-registry";
@@ -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). */
@@ -339,6 +348,8 @@ interface SessionRuntime {
 	/** Assistant text already flushed before an ask this turn (turn-scoped dedupe
 	 * so turn_end does not re-emit the pre-ask lead-in). Reset each turn. */
 	preAskFlushedText?: string;
+	/** Cancels the postmortem cleanup that emits `session_closed` on process teardown. */
+	cancelPostmortemCleanup: () => void;
 }
 
 interface ResolvedSettings {
@@ -491,6 +502,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		if (!rt) return false;
 		runtimes.delete(id);
 		try {
+			rt.cancelPostmortemCleanup();
 			rt.disposeAnswerSource();
 			rt.disposeFileSink();
 		} catch {}
@@ -671,6 +683,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				pendingInteractive,
 				disposeAnswerSource,
 				disposeFileSink,
+				cancelPostmortemCleanup: () => {},
 				redact,
 				verbosity,
 				sessionTag: tag,
@@ -678,6 +691,15 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 				pendingInbound: new Set<number>(),
 			};
 			runtimes.set(id, runtime);
+			// A native terminal close (SIGHUP), SIGTERM, Ctrl+C exit, or fatal error
+			// skips AgentSession.dispose(), so the `session_shutdown` extension event
+			// never fires and the daemon-side topic would be orphaned. postmortem
+			// awaits registered cleanups on those paths, so send the graceful
+			// `session_closed` frame from there too. stopSession() cancels this
+			// registration on every other teardown path, so it never double-fires.
+			runtime.cancelPostmortemCleanup = postmortem.register(`notifications-session-closed:${id}`, async () => {
+				await stopSession(id);
+			});
 			logger.info(`notifications: serving session ${id} at ${endpoint.url} (unattended=${unattended})`);
 
 			if (settingsAvailable && settings && isGloballyConfigured(cfg)) {
@@ -839,9 +861,15 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 		// Re-bind the interactive ask answer source: the ask tool resolves the
 		// source by the current session id, which just changed.
 		try {
+			rt.cancelPostmortemCleanup();
 			rt.disposeAnswerSource();
 			rt.disposeFileSink();
 		} catch {}
+		// Follow the id change so a later process teardown closes the re-keyed
+		// session (the old closure captured the retired id).
+		rt.cancelPostmortemCleanup = postmortem.register(`notifications-session-closed:${newId}`, async () => {
+			await stopSession(newId);
+		});
 		rt.disposeAnswerSource = registerInteractiveAnswerSource(
 			newId,
 			rt.server,
@@ -973,7 +1001,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 +1011,7 @@ export const createNotificationsExtension: ExtensionFactory = api => {
 							tokenUsage,
 							model: modelId,
 							diff,
+							cwd,
 						}),
 					);
 				} catch (e) {

package/src/notifications/lifecycle-control-runtime.ts

@@ -238,6 +238,7 @@ export function daemonResumeSession(env: NodeJS.ProcessEnv = process.env, opts:
 		// restart, so an unknown or ambiguous prefix fails closed instead of
 		// blindly spawning `skc --resume <prefix>` against a non-authoritative id.
 		let resumeId = target.sessionIdOrPrefix;
+		let resumeCwd = target.path;
 		if (opts.sessionsRoot) {
 			const saved = listRecentSessions({ sessionsRoot: opts.sessionsRoot, limit: 1000 });
 			const prefixed = saved.filter(
@@ -249,11 +250,19 @@ export function daemonResumeSession(env: NodeJS.ProcessEnv = process.env, opts:
 			if (resolved.length > 1) {
 				return { ambiguous: resolved.map(s => ({ sessionId: s.sessionId, path: s.path })) };
 			}
-			resumeId = resolved[0]!.sessionId;
+			const selected = resolved[0]!;
+			resumeId = selected.sessionId;
+			resumeCwd = selected.path;
+		}
+		const resolvedResumeCwd = resumeCwd ? path.resolve(resumeCwd) : undefined;
+		const resumeCwdStat = resolvedResumeCwd ? fs.statSync(resolvedResumeCwd, { throwIfNoEntry: false }) : undefined;
+		if (!resumeCwdStat?.isDirectory()) {
+			throw new Error(`skc_lifecycle_resume_cwd_unavailable: ${resolvedResumeCwd ?? "(missing)"}`);
 		}
 		const tmux = resolveSkcTmuxCommand(env);
 		const name = tmuxSessionNameFor(resumeId);
-		const command = `exec env SKC_TMUX_LAUNCHED=1 SKC_NOTIFICATIONS=1 skc --resume ${shellQuote(resumeId)}`;
+		const cwdPrefix = resolvedResumeCwd ? `cd ${shellQuote(resolvedResumeCwd)} && ` : "";
+		const command = `${cwdPrefix}exec env SKC_TMUX_LAUNCHED=1 SKC_NOTIFICATIONS=1 skc --resume ${shellQuote(resumeId)}`;
 		const r = Bun.spawnSync([tmux, "new-session", "-d", "-s", name, "sh", "-c", command], {
 			stdout: "pipe",
 			stderr: "pipe",
@@ -261,7 +270,7 @@ export function daemonResumeSession(env: NodeJS.ProcessEnv = process.env, opts:
 		});
 		if (r.exitCode !== 0) throw new Error(r.stderr.toString().trim() || "skc_lifecycle_resume_failed");
 		const tgt = buildSkcTmuxExactOptionTarget(name);
-		for (const cmd of buildSkcTmuxProfileCommands(tgt, env, { sessionId: resumeId })) {
+		for (const cmd of buildSkcTmuxProfileCommands(tgt, env, { sessionId: resumeId, project: resolvedResumeCwd })) {
 			Bun.spawnSync([tmux, ...cmd.args], { stdout: "pipe", stderr: "pipe", env });
 		}
 		return {

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

@@ -1,14 +1,23 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { Settings } from "../config/settings";
+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?: Pick<typeof Settings, "init">;
-	DaemonImpl?: typeof TelegramNotificationDaemon;
+	SettingsImpl?: { init: (options?: { agentDir?: string }) => Promise<Pick<Settings, "get" | "getAgentDir">> };
+	DaemonImpl?: TelegramDaemonConstructor;
 	processPid?: number;
+	pidAlive?: (pid: number) => boolean;
 }
 
 function argValue(argv: string[], name: string): string | undefined {
@@ -16,9 +25,105 @@ function argValue(argv: string[], name: string): string | undefined {
 	return i >= 0 ? argv[i + 1] : undefined;
 }
 
+function getByPath(obj: unknown, pathSegments: string[]): unknown {
+	let current = obj;
+	for (const segment of pathSegments) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return undefined;
+		current = (current as Record<string, unknown>)[segment];
+	}
+	return current;
+}
+
+function asString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function asBoolean(value: unknown, fallback: boolean): boolean {
+	return typeof value === "boolean" ? value : fallback;
+}
+
+function asIdleTimeoutMs(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 60_000;
+}
+
+export function createLightweightDaemonSettings(input: {
+	agentDir: string;
+	rawConfig?: unknown;
+}): Pick<Settings, "get" | "getAgentDir"> {
+	const rawConfig = input.rawConfig && typeof input.rawConfig === "object" ? input.rawConfig : {};
+	return {
+		get(pathName: string): unknown {
+			const value = getByPath(rawConfig, pathName.split("."));
+			switch (pathName) {
+				case "notifications.enabled":
+					return asBoolean(value, false);
+				case "notifications.telegram.botToken":
+				case "notifications.telegram.chatId":
+				case "notifications.discord.botToken":
+				case "notifications.discord.channelId":
+				case "notifications.slack.botToken":
+				case "notifications.slack.channelId":
+					return asString(value);
+				case "notifications.redact":
+					return asBoolean(value, false);
+				case "notifications.verbosity":
+					return value === "verbose" ? "verbose" : "lean";
+				case "notifications.daemon.idleTimeoutMs":
+					return asIdleTimeoutMs(value);
+				default:
+					return undefined;
+			}
+		},
+		getAgentDir(): string {
+			return input.agentDir;
+		},
+	} as Pick<Settings, "get" | "getAgentDir">;
+}
+
+export async function loadLightweightDaemonSettings(agentDir: string): Promise<Pick<Settings, "get" | "getAgentDir">> {
+	const configPath = path.join(agentDir, "config.yml");
+	let rawConfig: unknown = {};
+	try {
+		rawConfig = YAML.parse(await fs.promises.readFile(configPath, "utf8"));
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	return createLightweightDaemonSettings({ agentDir, rawConfig });
+}
+
+async function resolveDaemonSettings(
+	agentDir: string,
+	deps: RunDaemonInternalDeps,
+): Promise<Pick<Settings, "get" | "getAgentDir">> {
+	if (deps.SettingsImpl) return await deps.SettingsImpl.init({ agentDir });
+	return await loadLightweightDaemonSettings(agentDir);
+}
+
+export function ownerPidFromOwnerId(ownerId: string): number | undefined {
+	const match = /^(\d+)(?:-|$)/.exec(ownerId);
+	if (!match) return undefined;
+	const pid = Number(match[1]);
+	return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
+}
+
+function defaultPidAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function ownerProcessIsAlive(ownerId: string, deps: RunDaemonInternalDeps): boolean {
+	const ownerPid = ownerPidFromOwnerId(ownerId);
+	if (ownerPid === undefined) return true;
+	return (deps.pidAlive ?? defaultPidAlive)(ownerPid);
+}
+
 export async function runDaemonSmoke(opts: { agentDir?: string } = {}): Promise<void> {
 	const agentDir = opts.agentDir ?? fs.mkdtempSync(path.join(process.cwd(), ".telegram-daemon-smoke-"));
-	const settings = Settings.isolated({});
+	const settings = createLightweightDaemonSettings({ agentDir, rawConfig: {} });
 	const paths = daemonPaths(agentDir);
 	await fs.promises.mkdir(paths.dir, { recursive: true, mode: 0o700 });
 	const tempLock = `${paths.lock}.smoke.${process.pid}`;
@@ -34,12 +139,19 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 	if (smoke) return runDaemonSmoke({ agentDir });
 	const ownerId = argValue(argv, "--owner-id");
 	if (!ownerId) throw new Error("missing --owner-id");
-	const settings = await (deps.SettingsImpl ?? Settings).init(agentDir ? { agentDir } : {});
-	const cfg = getNotificationConfig(settings);
+	if (!ownerProcessIsAlive(ownerId, deps)) {
+		process.stderr.write(`SKC notify daemon exiting: owner process from --owner-id ${ownerId} is not alive.\n`);
+		return;
+	}
+	const resolvedAgentDir = agentDir ?? process.env.SKC_CODING_AGENT_DIR ?? path.join(process.cwd(), ".skc", "agent");
+	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: settings as Settings,
 		ownerId,
 		botToken: cfg.botToken,
 		chatId: cfg.chatId,
@@ -47,15 +159,15 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 		pid: deps.processPid ?? process.pid,
 		control: {
 			shouldStop: async owner => {
-				const req = await readTelegramControlRequest(settings);
+				const req = await readTelegramControlRequest(settings as Settings);
 				return Boolean(req && (!req.ownerId || req.ownerId === owner));
 			},
 			clear: async owner => {
-				const req = await readTelegramControlRequest(settings);
+				const req = await readTelegramControlRequest(settings as Settings);
 				// Only clear a request that targets this daemon owner, so an exiting
 				// daemon never erases a newer request meant for a different owner.
 				if (req && (!req.ownerId || req.ownerId === owner)) {
-					await clearTelegramControlRequest(settings, req.requestId);
+					await clearTelegramControlRequest(settings as Settings, req.requestId);
 				}
 			},
 		},

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. `skc 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,