@gajae-code/coding-agent 0.9.6 → 0.10.0

package/src/modes/utils/irc-message.ts

@@ -0,0 +1,138 @@
+import * as crypto from "node:crypto";
+import type { AgentMessage } from "@gajae-code/agent-core";
+import { getSegmenter } from "@gajae-code/tui";
+import { sanitizeText } from "@gajae-code/utils";
+import { associateSessionMessageObservationId, getSessionMessageObservationId } from "../../session/session-manager";
+
+const graphemeSegmenter = getSegmenter();
+const IRC_IDENTITY_SOURCE_MAX_UTF8_BYTES = 4 * 1_024;
+const IRC_IDENTITY_DISPLAY_MAX_UTF8_BYTES = 256;
+export type IrcMessageKind = "incoming" | "autoreply" | "relay";
+
+export type ParsedIrcMessage = {
+	observationId: string;
+	from: string;
+	to: string;
+	text: string;
+	timestamp: number;
+	kind: IrcMessageKind;
+};
+
+export interface IrcMessageBlock {
+	readonly sender: string;
+	readonly recipient: string;
+	readonly kind: "incoming" | "autoreply" | "outgoing";
+	readonly time: string;
+	readonly bodyLines: readonly string[];
+}
+
+export function projectIrcText(
+	text: string,
+	maxUtf8Bytes: number,
+): { text: string; truncated: boolean; utf8Bytes: number } {
+	let end = 0;
+	let utf8Bytes = 0;
+	for (const part of graphemeSegmenter.segment(text)) {
+		const segmentBytes = Buffer.byteLength(part.segment, "utf8");
+		if (utf8Bytes + segmentBytes > maxUtf8Bytes) break;
+		utf8Bytes += segmentBytes;
+		end = part.index + part.segment.length;
+	}
+	return { text: text.slice(0, end), truncated: end < text.length, utf8Bytes };
+}
+
+/** Normalizes and bounds untrusted IRC identity fields without splitting visible graphemes. */
+export function normalizeIrcIdentity(identity: string): string {
+	const source = projectIrcText(identity, IRC_IDENTITY_SOURCE_MAX_UTF8_BYTES);
+	const sanitized = sanitizeText(source.text.replace(/[\r\n\t\u2028\u2029]+/g, " ")).replace(
+		/[\u061C\u200E-\u200F\u202A-\u202E\u2066-\u2069]/g,
+		"",
+	);
+	const display = projectIrcText(sanitized, IRC_IDENTITY_DISPLAY_MAX_UTF8_BYTES);
+	return source.truncated || display.truncated ? `${display.text}…` : display.text;
+}
+
+/** Formats IRC observations into display-neutral semantic blocks for both IRC surfaces. */
+export function formatIrcMessageBlock(message: ParsedIrcMessage & { timestamp: number }): IrcMessageBlock {
+	const date = new Date(message.timestamp);
+	// IRC timestamps are human-facing, so use local time rather than UTC serialization.
+	const time = Number.isFinite(date.getTime())
+		? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`
+		: "--:--";
+	const bodyLines = message.text === "" ? [] : message.text.replaceAll("\t", "    ").split("\n");
+	return {
+		sender: normalizeIrcIdentity(message.from),
+		recipient: normalizeIrcIdentity(message.to),
+		kind: message.kind === "relay" ? "outgoing" : message.kind,
+		time,
+		bodyLines,
+	};
+}
+
+type IrcCustomMessage = Extract<AgentMessage, { role: "custom" }>;
+
+export function isIrcCustomType(customType: string | undefined): customType is `irc:${IrcMessageKind}` {
+	return customType === "irc:incoming" || customType === "irc:autoreply" || customType === "irc:relay";
+}
+
+function stringDetail(details: unknown, key: string): string {
+	if (!details || typeof details !== "object") return "";
+	const value = (details as Record<string, unknown>)[key];
+	return typeof value === "string" ? value : "";
+}
+
+function legacyObservationId(fields: readonly string[]): string {
+	const hash = crypto.createHash("sha256");
+	hash.update("gjc:irc:legacy-observation:v1\0");
+	for (const field of fields) {
+		hash.update(String(Buffer.byteLength(field, "utf8")));
+		hash.update(":");
+		hash.update(field);
+	}
+	return `legacy:sha256:${hash.digest("hex")}`;
+}
+
+/**
+ * Normalizes every supported IRC custom message into its UI observation shape.
+ * Legacy records have no UUID, so their immutable payload is used as a stable key.
+ */
+export function parseIrcMessage(message: IrcCustomMessage): ParsedIrcMessage | undefined {
+	if (!isIrcCustomType(message.customType)) return undefined;
+
+	const kind = message.customType.slice(4) as IrcMessageKind;
+	const sourceTimestamp =
+		typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : undefined;
+	const timestamp = sourceTimestamp ?? Date.now();
+	const rawFrom = kind === "autoreply" ? "you" : stringDetail(message.details, "from") || "?";
+	const rawTo = kind === "incoming" ? "you" : stringDetail(message.details, "to") || "?";
+	const rawText =
+		kind === "incoming"
+			? stringDetail(message.details, "message")
+			: kind === "autoreply"
+				? stringDetail(message.details, "reply")
+				: stringDetail(message.details, "body");
+	const from = normalizeIrcIdentity(rawFrom);
+	const to = normalizeIrcIdentity(rawTo);
+	const text = sanitizeText(rawText);
+	const explicitObservationId = stringDetail(message.details, "observationId");
+	const observationId = associateSessionMessageObservationId(
+		message,
+		explicitObservationId ||
+			getSessionMessageObservationId(message) ||
+			legacyObservationId([
+				kind,
+				sourceTimestamp === undefined ? "null" : String(sourceTimestamp),
+				rawFrom,
+				rawTo,
+				rawText,
+			]),
+	);
+	return {
+		observationId,
+		from,
+		to,
+		text,
+		timestamp,
+		kind,
+	};
+}

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

@@ -1,6 +1,6 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { AssistantMessage, ImageContent, Message } from "@gajae-code/ai";
-import { type Component, Spacer, Text, TruncatedText } from "@gajae-code/tui";
+import { type Component, Spacer, Text, TruncatedText, type TUI, truncateToWidth } from "@gajae-code/tui";
 import { settings } from "../../config/settings";
 import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
 import { buildSkillPromptMessage, parseSkillInvocations } from "../../extensibility/skills";
@@ -20,17 +20,69 @@ import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { ToolExecutionComponent } from "../../modes/components/tool-execution";
 import { UserMessageComponent } from "../../modes/components/user-message";
 import { theme } from "../../modes/theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext } from "../../modes/types";
+import type {
+	CompactionQueuedMessage,
+	InteractiveModeContext,
+	IrcArrivalSnapshot,
+	TranscriptRebuildPolicy,
+} from "../../modes/types";
 import {
 	type CustomMessage,
 	isSilentAbort,
 	SKILL_PROMPT_MESSAGE_TYPE,
 	type SkillPromptDetails,
 } from "../../session/messages";
-import type { SessionContext } from "../../session/session-manager";
+import {
+	associateSessionMessageViewportAnchorId,
+	getSessionMessageEntryId,
+	getSessionMessageViewportAnchorId,
+	type SessionContext,
+} from "../../session/session-manager";
 import { formatBytes, formatDuration } from "../../tools/render-utils";
 import { buildAbortDisplayMessage } from "./abort-message";
+import {
+	formatIrcMessageBlock,
+	isIrcCustomType,
+	type ParsedIrcMessage,
+	parseIrcMessage,
+	projectIrcText,
+} from "./irc-message";
+
+export type { TranscriptRebuildPolicy } from "../../modes/types";
+
+const IRC_INLINE_MAX_RENDER_ROWS = 2_048;
+const IRC_INLINE_MAX_SOURCE_UTF8_BYTES = 64 * 1_024;
+const IRC_INLINE_ELISION = "  … message elided …";
+
+class BoundedIrcTextComponent implements Component {
+	#text: Text;
+	#sourceTruncated: boolean;
+
+	constructor(text: string, sourceTruncated: boolean) {
+		this.#text = new Text(text, 0, 0);
+		this.#sourceTruncated = sourceTruncated;
+	}
+
+	render(width: number): string[] {
+		const rendered = this.#text.render(width);
+		if (!this.#sourceTruncated && rendered.length <= IRC_INLINE_MAX_RENDER_ROWS) return rendered;
+		const lines = rendered.slice(0, IRC_INLINE_MAX_RENDER_ROWS);
+		const marker = truncateToWidth(theme.fg("dim", IRC_INLINE_ELISION), width);
+		if (lines.length === 0) return [marker];
+		if (this.#sourceTruncated && rendered.length < IRC_INLINE_MAX_RENDER_ROWS) lines.push(marker);
+		else lines[lines.length - 1] = marker;
+		return lines;
+	}
 
+	invalidate(): void {
+		this.#text.invalidate();
+	}
+}
+
+export function prepareTranscriptRebuild(ui: TUI, policy: TranscriptRebuildPolicy): void {
+	if (policy === "replace-identity") ui.resetViewportAnchorIntent();
+	else ui.prepareViewportAnchorForTranscriptRebuild();
+}
 type TextBlock = { type: "text"; text: string };
 interface RenderInitialMessagesOptions {
 	preserveExistingChat?: boolean;
@@ -118,8 +170,18 @@ function getChatChildTime(component: Component): number {
 	return chatChildAddedAt.get(component) ?? Date.now();
 }
 
+function stableSemanticIdPart(value: string): string {
+	let hash = 0xcbf29ce484222325n;
+	for (const char of value) {
+		hash ^= BigInt(char.codePointAt(0)!);
+		hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+	}
+	return hash.toString(36);
+}
+
 export function addChatChild(ctx: InteractiveModeContext, component: Component): void {
 	ctx.chatContainer.addChild(component);
+
 	chatChildAddedAt.set(component, Date.now());
 	trimChatChildren(ctx);
 }
@@ -186,8 +248,114 @@ export function trimChatChildren(ctx: InteractiveModeContext): void {
 }
 
 export class UiHelpers {
+	#renderedIrcInlineComponents = new Map<string, readonly Component[]>();
+	#viewportAnchorOccurrences = new WeakMap<object, { base: string; epoch: number; id: string }>();
+	#nextViewportAnchorOccurrence = new Map<string, number>();
+	#viewportAnchorOccurrenceEpoch = 0;
+	#ircSidebarHintShown = false;
+
 	constructor(private ctx: InteractiveModeContext) {}
 
+	#resetViewportAnchorOccurrencePass(): void {
+		this.#viewportAnchorOccurrenceEpoch += 1;
+		this.#nextViewportAnchorOccurrence.clear();
+	}
+
+	#viewportAnchorOccurrenceId(message: object, base: string): string {
+		const existing = this.#viewportAnchorOccurrences.get(message);
+		if (existing?.base === base && existing.epoch === this.#viewportAnchorOccurrenceEpoch) return existing.id;
+		const occurrence = this.#nextViewportAnchorOccurrence.get(base) ?? 0;
+		this.#nextViewportAnchorOccurrence.set(base, occurrence + 1);
+		const id = `${base}:occurrence:${occurrence}`;
+		this.#viewportAnchorOccurrences.set(message, {
+			base,
+			epoch: this.#viewportAnchorOccurrenceEpoch,
+			id,
+		});
+		return id;
+	}
+
+	assistantViewportAnchorId(message: AssistantMessage): string {
+		const semanticId = getSessionMessageViewportAnchorId(message);
+		if (semanticId) return semanticId;
+		const entryId = getSessionMessageEntryId(message);
+		if (entryId) return `assistant:entry:${entryId}`;
+		const base = `assistant:${message.api}:${message.provider}:${message.model}:${message.timestamp}`;
+		const id = this.#viewportAnchorOccurrenceId(message, base);
+		associateSessionMessageViewportAnchorId(message, id);
+		return id;
+	}
+
+	#userViewportAnchorId(message: Extract<Message, { role: "user" }>): string {
+		const semanticId = getSessionMessageViewportAnchorId(message);
+		if (semanticId) return semanticId;
+		const entryId = getSessionMessageEntryId(message);
+		if (entryId) return `user:entry:${entryId}`;
+		const base = `user:local:${message.timestamp}:${stableSemanticIdPart(JSON.stringify(message.content))}`;
+		const id = this.#viewportAnchorOccurrenceId(message, base);
+		associateSessionMessageViewportAnchorId(message, id);
+		return id;
+	}
+
+	getRenderedIrcInlineComponents(): Map<string, readonly Component[]> {
+		return this.#renderedIrcInlineComponents;
+	}
+
+	removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined {
+		const components = this.#renderedIrcInlineComponents.get(observationId);
+		this.#renderedIrcInlineComponents.delete(observationId);
+		return components;
+	}
+
+	resetRenderedIrcInlineComponents(): readonly (readonly Component[])[] {
+		const components = [...this.#renderedIrcInlineComponents.values()];
+		this.#renderedIrcInlineComponents.clear();
+		return components;
+	}
+
+	#addIrcObservationToChat(message: ParsedIrcMessage, sidebarHint?: string): Component[] {
+		const bodyProjection = projectIrcText(message.text, IRC_INLINE_MAX_SOURCE_UTF8_BYTES);
+		const block = formatIrcMessageBlock({ ...message, text: bodyProjection.text });
+		const components: Component[] = [];
+		const header = `${theme.fg("accent", `[IRC] ${block.sender} → ${block.recipient} · ${block.time}`)}${sidebarHint ? theme.fg("dim", sidebarHint) : ""}`;
+		const headerComponent = new Text(header, 1, 0);
+		addChatChild(this.ctx, headerComponent);
+		components.push(headerComponent);
+		if (block.bodyLines.length > 0 || bodyProjection.truncated) {
+			const bodyComponent = new BoundedIrcTextComponent(
+				theme.fg("muted", `  ${block.bodyLines.join("\n  ")}`),
+				bodyProjection.truncated,
+			);
+			addChatChild(this.ctx, bodyComponent);
+			components.push(bodyComponent);
+		}
+		return components;
+	}
+
+	addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[] {
+		// Requested-open panels that merely yielded at narrow widths must not
+		// advertise the toggle key: pressing it would close the pending request.
+		const showSidebarHint =
+			!arrival.panelVisible &&
+			!arrival.panelRequestedVisible &&
+			arrival.sidebarAvailable &&
+			Boolean(arrival.resolvedToggleKey) &&
+			!this.#ircSidebarHintShown;
+		if (showSidebarHint) this.#ircSidebarHintShown = true;
+		return this.#addIrcObservationToChat(
+			message,
+			showSidebarHint ? ` · ${arrival.resolvedToggleKey} opens sidebar` : undefined,
+		);
+	}
+
+	addRebuiltIrcObservationToChat(message: ParsedIrcMessage): Component[] {
+		return this.#addIrcObservationToChat(message);
+	}
+
+	resetIrcSidebarHint(): void {
+		this.#ircSidebarHintShown = false;
+	}
+
 	/** Extract text content from a user message */
 	getUserMessageText(message: Message): string {
 		if (message.role !== "user") return "";
@@ -304,50 +472,9 @@ export class UiHelpers {
 						addChatChild(this.ctx, component);
 						break;
 					}
-					if (
-						message.customType === "irc:incoming" ||
-						message.customType === "irc:autoreply" ||
-						message.customType === "irc:relay"
-					) {
-						const details = (
-							message as CustomMessage<{
-								from?: string;
-								to?: string;
-								message?: string;
-								reply?: string;
-								body?: string;
-								kind?: "message" | "reply";
-							}>
-						).details;
-						let arrow: string;
-						let body: string;
-						if (message.customType === "irc:incoming") {
-							const peer = details?.from ?? "?";
-							body = details?.message ?? "";
-							arrow = `⇦ ${peer}`;
-						} else if (message.customType === "irc:autoreply") {
-							const peer = details?.to ?? "?";
-							body = details?.reply ?? "";
-							arrow = `⇨ ${peer}`;
-						} else {
-							const from = details?.from ?? "?";
-							const to = details?.to ?? "?";
-							body = details?.body ?? "";
-							arrow = `${from} ⇨ ${to}`;
-						}
-						const components: Component[] = [];
-						const header = `${theme.fg("accent", `[IRC] ${arrow}`)}`;
-						const headerComponent = new Text(header, 1, 0);
-						addChatChild(this.ctx, headerComponent);
-						components.push(headerComponent);
-						if (body) {
-							for (const line of body.split("\n")) {
-								const lineComponent = new Text(theme.fg("muted", `  ${line}`), 0, 0);
-								addChatChild(this.ctx, lineComponent);
-								components.push(lineComponent);
-							}
-						}
-						return components;
+					if (message.role === "custom" && isIrcCustomType(message.customType)) {
+						const parsed = parseIrcMessage(message);
+						if (parsed) return this.addRebuiltIrcObservationToChat(parsed);
 					}
 					if (message.customType === "subagent:steer" || message.customType === "subagent:steer:relay") {
 						const details = (
@@ -421,7 +548,11 @@ export class UiHelpers {
 				const textContent = this.ctx.getUserMessageText(message);
 				if (textContent) {
 					const isSynthetic = message.role === "developer" ? true : (message.synthetic ?? false);
-					const userComponent = new UserMessageComponent(textContent, isSynthetic);
+					const userComponent = new UserMessageComponent(
+						textContent,
+						isSynthetic,
+						message.role === "user" && !isSynthetic ? this.#userViewportAnchorId(message) : undefined,
+					);
 					addChatChild(this.ctx, userComponent);
 					if (options?.populateHistory && message.role === "user" && !isSynthetic) {
 						this.ctx.editor.addToHistory(textContent);
@@ -430,8 +561,11 @@ export class UiHelpers {
 				break;
 			}
 			case "assistant": {
-				const assistantComponent = new AssistantMessageComponent(message, this.ctx.hideThinkingBlock, () =>
-					this.ctx.ui.requestRender(),
+				const assistantComponent = new AssistantMessageComponent(
+					message,
+					this.ctx.hideThinkingBlock,
+					() => this.ctx.ui.requestRender(),
+					this.assistantViewportAnchorId(message),
 				);
 				addChatChild(this.ctx, assistantComponent);
 				break;
@@ -469,12 +603,35 @@ export class UiHelpers {
 		const readToolCallArgs = new Map<string, Record<string, unknown>>();
 		const readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 		const deferredMessages: AgentMessage[] = [];
+		const persistedIrcObservationIds = new Set<string>();
+		const now = Date.now();
+		this.#resetViewportAnchorOccurrencePass();
+		this.#renderedIrcInlineComponents.clear();
 		for (const message of sessionContext.messages) {
 			// Defer compaction summaries so they render at the bottom (visible after scroll)
 			if (message.role === "compactionSummary") {
 				deferredMessages.push(message);
 				continue;
 			}
+			if (message.role === "custom" && isIrcCustomType(message.customType)) {
+				const parsed = parseIrcMessage(message);
+				if (parsed) {
+					persistedIrcObservationIds.add(parsed.observationId);
+					const record = this.ctx.ircLedger.getRecord(parsed.observationId);
+					if (
+						record &&
+						(record.mode === "persistent" || now < record.expiresAt!) &&
+						!this.#renderedIrcInlineComponents.has(record.observationId)
+					) {
+						this.#renderedIrcInlineComponents.set(
+							record.observationId,
+							this.addRebuiltIrcObservationToChat(record),
+						);
+					}
+				}
+				continue;
+			}
+
 			// Assistant messages need special handling for tool calls
 			if (message.role === "assistant") {
 				this.ctx.addMessageToChat(message);
@@ -625,6 +782,15 @@ export class UiHelpers {
 		for (const message of deferredMessages) {
 			this.ctx.addMessageToChat(message, options);
 		}
+		for (const record of this.ctx.ircLedger.getInlineProjection(now)) {
+			if (
+				persistedIrcObservationIds.has(record.observationId) ||
+				this.#renderedIrcInlineComponents.has(record.observationId)
+			) {
+				continue;
+			}
+			this.#renderedIrcInlineComponents.set(record.observationId, this.addRebuiltIrcObservationToChat(record));
+		}
 
 		this.ctx.pendingTools.clear();
 		this.ctx.ui.requestRender();

package/src/notifications/config.ts

@@ -1,6 +1,17 @@
 import * as crypto from "node:crypto";
 import type { Settings } from "../config/settings";
 
+/**
+ * Env marker set by GJC's own programmatic separate-process child spawn sites
+ * (team workers, harness RPC owners) and carrying the spawning session id.
+ *
+ * Presence — not the value — marks a session as GJC-spawned. It is consumed
+ * (read once, then deleted from the child's own env) at startup so it is
+ * per-spawn rather than dynastic: a grandchild is marked only if its own spawn
+ * site marks it, never by inheriting a marked ancestor's environment.
+ */
+export const SPAWN_PROVENANCE_ENV = "GJC_SPAWNED_BY_SESSION";
+
 export interface NotificationConfig {
 	enabled: boolean;
 	botToken?: string;
@@ -15,6 +26,12 @@ export interface NotificationConfig {
 	};
 	redact: boolean;
 	verbosity: "lean" | "verbose";
+	/**
+	 * Which sessions may register a notification endpoint. `all` (default)
+	 * preserves historical behavior; `primary` suppresses GJC-spawned children
+	 * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
+	 */
+	sessionScope: "all" | "primary";
 	idleTimeoutMs: number;
 	rich: {
 		enabled: boolean;
@@ -22,6 +39,15 @@ export interface NotificationConfig {
 	richDraft: {
 		enabled: boolean;
 	};
+	topics: {
+		/**
+		 * Optional Telegram forum-topic name template with `{repo}`, `{branch}`,
+		 * and `{title}` placeholders. Unset preserves the built-in
+		 * `{repo}/{branch} - {title}` composition (with its title/repo/branch
+		 * fallbacks).
+		 */
+		nameTemplate?: string;
+	};
 }
 
 /** Read typed config from Settings. */
@@ -40,6 +66,7 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 		},
 		redact: settings.get("notifications.redact"),
 		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
+		sessionScope: settings.get("notifications.sessionScope") === "primary" ? "primary" : "all",
 		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
 		rich: {
 			enabled: settings.get("notifications.telegram.rich.enabled"),
@@ -47,6 +74,9 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 		richDraft: {
 			enabled: settings.get("notifications.telegram.richDraft.enabled"),
 		},
+		topics: {
+			nameTemplate: settings.get("notifications.telegram.topics.nameTemplate"),
+		},
 	};
 }
 
@@ -95,11 +125,25 @@ export function shouldRegisterNotificationsExtension(input: {
 	parentTaskPrefix?: string;
 	/** Role-agent type/name; present for task sessions even if depth metadata is lost. */
 	currentAgentType?: string;
+	/**
+	 * True when this session was launched by one of GJC's own programmatic
+	 * separate-process child spawn sites (marked via {@link SPAWN_PROVENANCE_ENV}).
+	 * Under `notifications.sessionScope = "primary"` such children are suppressed
+	 * unless they explicitly opt in, so an interactive parent that fans out work
+	 * does not flood the paired chat with topics for children the user never
+	 * asked for. User-opened sessions (CLI/tmux/headless) never carry the marker.
+	 */
+	spawnedByGjc?: boolean;
 }): boolean {
 	if ((input.taskDepth ?? 0) > 0 || input.parentTaskPrefix || input.currentAgentType) return false;
 	if (completionNotifyDisabledByEnv(input.env)) return false;
 	if (input.env.GJC_NOTIFICATIONS === "0") return false;
 	if (input.env.GJC_NOTIFICATIONS === "1" || input.env.GJC_NOTIFICATIONS_TOKEN) return true;
+	// Spawned-child suppression sits below explicit opt-in (so Telegram
+	// `/session_create` and cold `/session_resume`, which launch with
+	// GJC_NOTIFICATIONS=1, keep their fully bidirectional topic) and above global
+	// auto-on (so their children stay silent under `primary`).
+	if (input.spawnedByGjc && input.cfg?.sessionScope === "primary") return false;
 	return input.cfg ? isGloballyConfigured(input.cfg) : false;
 }
 

package/src/notifications/daemon-paths.ts

@@ -1,5 +1,13 @@
 import * as path from "node:path";
 
+/**
+ * Owner heartbeat freshness window. A daemon ownership record older than this
+ * (without a live pid) is considered stale. Lives here, in the lightweight
+ * paths module, so secret-safe consumers (e.g. the notification service) can
+ * reuse it without importing the heavy daemon runtime.
+ */
+export const HEARTBEAT_TTL_MS = 20_000;
+
 export interface DaemonPaths {
 	dir: string;
 	lock: string;