@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/sdk/broker/process-incarnation.ts

@@ -1,6 +1,6 @@
 import { dlopen, ptr } from "bun:ffi";
-import * as fs from "node:fs";
 import { Process } from "@gajae-code/natives";
+import { readLinuxProcStartTimeSync } from "../../gjc-runtime/linux-proc";
 
 const DARWIN_PROC_PIDTBSDINFO = 3;
 const DARWIN_PROC_BSDINFO_SIZE = 136;
@@ -95,7 +95,8 @@ export function parseDarwinProcessIncarnation(info: Uint8Array): string | undefi
 	}
 }
 
-function isProcessIncarnation(value: unknown): value is string {
+/** Whether `value` is a canonical process-incarnation string (`linux:`/`darwin:`/`windows:`). */
+export function isProcessIncarnation(value: unknown): value is string {
 	return (
 		typeof value === "string" &&
 		(/^(?:linux:\d+|darwin:[1-9]\d*:\d+)$/.test(value) ||
@@ -116,17 +117,8 @@ export function processIncarnation(pid: number, options: ProcessIncarnationOptio
 		}
 	}
 	if (platform === "linux") {
-		try {
-			const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
-			const close = stat.lastIndexOf(")");
-			const startTicks = stat
-				.slice(close + 2)
-				.trim()
-				.split(/\s+/)[19];
-			return startTicks ? `linux:${startTicks}` : undefined;
-		} catch {
-			return undefined;
-		}
+		const startTicks = readLinuxProcStartTimeSync(pid);
+		return startTicks ? `linux:${startTicks}` : undefined;
 	}
 	if (platform === "darwin") {
 		const info = new Uint8Array(DARWIN_PROC_BSDINFO_SIZE);

package/src/sdk/broker/session-index.ts

@@ -2,7 +2,13 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { withFileLock } from "../../config/file-lock";
-import { assertSupportedStateVersion, SDK_STATE_VERSION, UnsupportedStateVersionError } from "./state-version";
+import {
+	assertSupportedSnapshotVersion,
+	assertSupportedStateVersion,
+	SDK_STATE_VERSION,
+	SESSION_INDEX_SNAPSHOT_VERSION,
+	UnsupportedStateVersionError,
+} from "./state-version";
 
 export type SessionIndexEventType =
 	| "host_registered"
@@ -48,15 +54,94 @@ export const sessionIndexChecksum = (event: Omit<SessionIndexEvent, "checksum">)
 const dirFor = (agentDir: string) => path.join(agentDir, "sdk", "sessions");
 const logFor = (agentDir: string) => path.join(dirFor(agentDir), "index.jsonl");
 const snapshotFor = (agentDir: string) => path.join(dirFor(agentDir), "index.snapshot.json");
+const ROTATE_BYTES = 4 * 1024 * 1024;
+function isValidSnapshot(snapshot: unknown): snapshot is { indexSeq: number; events: SessionIndexEvent[] } {
+	if (!snapshot || typeof snapshot !== "object") return false;
+	const { indexSeq, events } = snapshot as { indexSeq?: unknown; events?: unknown };
+	if (typeof indexSeq !== "number" || !Number.isSafeInteger(indexSeq) || indexSeq < 0) return false;
+	if (!Array.isArray(events)) return false;
+	if (events.length === 0) return indexSeq === 0;
+	// Accept strictly-increasing indexSeq (gaps allowed after compaction), preserving
+	// each event's original checksum. The old contiguous 1..N format is a special case.
+	let previous = 0;
+	for (const event of events) {
+		if (!event || typeof event !== "object") return false;
+		const { checksum, ...unsigned } = event as SessionIndexEvent;
+		if (typeof event.indexSeq !== "number" || !Number.isSafeInteger(event.indexSeq)) return false;
+		if (event.indexSeq <= previous) return false;
+		if (checksum !== sessionIndexChecksum(unsigned)) return false;
+		previous = event.indexSeq;
+	}
+	return previous === indexSeq;
+}
+
+// Compact the event history for a snapshot without renumbering: clients hold indexSeq
+// across calls, so retained events keep their original indexSeq and checksum. Drops
+// terminal+dead sessions entirely, collapses superseded heartbeats to the latest per
+// surviving session, and always retains the global-max indexSeq as the chain anchor.
+function compactEvents(events: SessionIndexEvent[]): SessionIndexEvent[] {
+	if (events.length === 0) return events;
+	const maxIndexSeq = events[events.length - 1]!.indexSeq;
+	const latestBySession = new Map<string, SessionIndexEvent>();
+	for (const event of events) latestBySession.set(event.sessionId, event);
+	const deadTerminal = new Set<string>();
+	for (const [sessionId, latest] of latestBySession) {
+		const terminal = latest.type === "host_unregistered" || latest.type === "session_closed";
+		if (terminal && !alive(latest.pid)) deadTerminal.add(sessionId);
+	}
+	const latestHeartbeatSeq = new Map<string, number>();
+	for (const event of events) {
+		if (event.type === "host_heartbeat" && !deadTerminal.has(event.sessionId)) {
+			latestHeartbeatSeq.set(event.sessionId, event.indexSeq);
+		}
+	}
+	const kept: SessionIndexEvent[] = [];
+	for (const event of events) {
+		if (event.indexSeq === maxIndexSeq) {
+			kept.push(event);
+			continue;
+		}
+		if (deadTerminal.has(event.sessionId)) continue;
+		if (event.type === "host_heartbeat" && latestHeartbeatSeq.get(event.sessionId) !== event.indexSeq) continue;
+		kept.push(event);
+	}
+	return kept;
+}
+
 async function appendSync(file: string, value: string): Promise<void> {
 	const h = await fs.open(file, "a", 0o600);
 	try {
-		await h.write(`${value}\n`);
+		const data = Buffer.from(`${value}\n`);
+		for (let offset = 0; offset < data.length; ) {
+			const { bytesWritten } = await h.write(data, offset, data.length - offset);
+			if (bytesWritten <= 0) throw new Error("Unable to append session index entry");
+			offset += bytesWritten;
+		}
 		await h.sync();
 	} finally {
 		await h.close();
 	}
 }
+
+async function syncDirectory(file: string): Promise<void> {
+	let handle: fs.FileHandle;
+	try {
+		handle = await fs.open(path.dirname(file), "r");
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (process.platform === "win32" && (code === "EPERM" || code === "EACCES")) return;
+		throw error;
+	}
+	try {
+		await handle.sync();
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (process.platform !== "win32" || (code !== "EPERM" && code !== "EACCES")) throw error;
+	} finally {
+		await handle.close();
+	}
+}
+
 function alive(pid: number): boolean {
 	try {
 		process.kill(pid, 0);
@@ -70,20 +155,21 @@ export class SessionIndex {
 	#events: SessionIndexEvent[] = [];
 	#warnings: string[] = [];
 	#logOffset = 0;
+	#corruptSuffix = false;
 	constructor(agentDir: string) {
 		this.#agentDir = agentDir;
 	}
 	async open(): Promise<this> {
-		await this.assertSupportedStateVersions();
 		await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
 		await fs.chmod(dirFor(this.#agentDir), 0o700);
-		await this.replay();
+		await withFileLock(logFor(this.#agentDir), () => this.replay());
 		return this;
 	}
 	async replay(): Promise<void> {
 		this.#events = [];
 		this.#warnings = [];
 		this.#logOffset = 0;
+		this.#corruptSuffix = false;
 		let snapshotSeq = 0;
 		try {
 			const snapshot = JSON.parse(await fs.readFile(snapshotFor(this.#agentDir), "utf8")) as {
@@ -91,35 +177,25 @@ export class SessionIndex {
 				events?: SessionIndexEvent[];
 				indexSeq?: number;
 			};
-			assertSupportedStateVersion(snapshotFor(this.#agentDir), snapshot);
-			const snapshotIndexSeq = snapshot.indexSeq;
-			if (
-				typeof snapshotIndexSeq !== "number" ||
-				!Number.isSafeInteger(snapshotIndexSeq) ||
-				snapshotIndexSeq < 0 ||
-				!Array.isArray(snapshot.events) ||
-				snapshot.events.some(event => {
-					const { checksum, ...unsigned } = event;
-					return event.indexSeq > snapshotIndexSeq || checksum !== sessionIndexChecksum(unsigned);
-				})
-			)
-				throw new Error("invalid snapshot");
+			assertSupportedSnapshotVersion(snapshotFor(this.#agentDir), snapshot);
+			if (!isValidSnapshot(snapshot)) throw new Error("invalid snapshot");
 			this.#events = snapshot.events;
-			snapshotSeq = snapshotIndexSeq;
+			snapshotSeq = snapshot.indexSeq;
 		} catch (e) {
 			if (e instanceof UnsupportedStateVersionError) throw e;
 			if ((e as NodeJS.ErrnoException).code !== "ENOENT") this.#warnings.push("Invalid session index snapshot");
 		}
-		await this.#tail(snapshotSeq);
+		await this.#tail(snapshotSeq, false);
 	}
-	async #tail(snapshotSeq = this.indexSeq): Promise<void> {
+	async #tail(snapshotSeq = this.indexSeq, allowResync = true): Promise<void> {
 		let data: Buffer;
 		try {
 			const handle = await fs.open(logFor(this.#agentDir), "r");
 			try {
 				const stat = await handle.stat();
 				if (stat.size < this.#logOffset) {
-					this.#warnings.push("Session index log was truncated");
+					if (allowResync) await this.replay();
+					else this.#warn("Session index log was truncated");
 					return;
 				}
 				data = Buffer.alloc(stat.size - this.#logOffset);
@@ -132,9 +208,10 @@ export class SessionIndex {
 			throw e;
 		}
 		const lastNewline = data.lastIndexOf(0x0a);
-		if (lastNewline < 0) return;
 		const consumed = data.subarray(0, lastNewline + 1);
 		this.#logOffset += consumed.length;
+		const hasUnterminatedSuffix = data.length > consumed.length;
+		let corrupt = false;
 		for (const line of consumed.toString("utf8").split("\n")) {
 			if (!line) continue;
 			let event: SessionIndexEvent;
@@ -143,18 +220,25 @@ export class SessionIndex {
 				assertSupportedStateVersion(logFor(this.#agentDir), event);
 			} catch (error) {
 				if (error instanceof UnsupportedStateVersionError) throw error;
-				this.#warnings.push("Corrupt session index entry; replay truncated");
-				return;
+				corrupt = true;
+				continue;
 			}
-			if (event.indexSeq <= snapshotSeq) continue;
+			if (corrupt || event.indexSeq <= snapshotSeq) continue;
 			const { checksum, ...unsigned } = event;
-			if (checksum !== sessionIndexChecksum(unsigned) || event.indexSeq !== this.indexSeq + 1) {
-				this.#warnings.push("Corrupt session index entry; replay truncated");
-				return;
-			}
-			this.#events.push(event);
+			if (checksum !== sessionIndexChecksum(unsigned) || event.indexSeq !== this.indexSeq + 1) corrupt = true;
+			else this.#events.push(event);
+		}
+		if (hasUnterminatedSuffix) corrupt = true;
+		if (corrupt) {
+			this.#corruptSuffix = true;
+			this.#warn("Corrupt session index entry; replay truncated");
+			if (allowResync) await this.replay();
 		}
 	}
+	#warn(message: string): void {
+		if (!this.#warnings.includes(message)) this.#warnings.push(message);
+	}
+
 	async refresh(): Promise<void> {
 		await this.#tail();
 	}
@@ -167,7 +251,8 @@ export class SessionIndex {
 	): Promise<SessionIndexEvent> {
 		await fs.mkdir(dirFor(this.#agentDir), { recursive: true, mode: 0o700 });
 		return withFileLock(logFor(this.#agentDir), async () => {
-			await this.refresh();
+			await this.replay();
+			if (this.#corruptSuffix) throw new Error("Cannot append to corrupt session index log");
 			const unsigned: Omit<SessionIndexEvent, "checksum"> = {
 				...input,
 				version: SDK_STATE_VERSION,
@@ -177,16 +262,34 @@ export class SessionIndex {
 			const event: SessionIndexEvent = { ...unsigned, checksum: sessionIndexChecksum(unsigned) };
 			await appendSync(logFor(this.#agentDir), JSON.stringify(event));
 			await this.refresh();
+			if ((await fs.stat(logFor(this.#agentDir))).size >= ROTATE_BYTES) await this.#rotate();
 			return event;
 		});
 	}
 	async snapshot(): Promise<void> {
+		await withFileLock(logFor(this.#agentDir), () => this.#snapshotUnderLock());
+	}
+	async #snapshotUnderLock(): Promise<void> {
+		await this.replay();
 		const file = snapshotFor(this.#agentDir);
+		let current: unknown;
+		try {
+			current = JSON.parse(await fs.readFile(file, "utf8"));
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !(error instanceof SyntaxError)) throw error;
+		}
+		if (isValidSnapshot(current) && current.indexSeq > this.indexSeq) return;
 		const tmp = `${file}.${process.pid}.tmp`;
 		await fs.writeFile(
 			tmp,
-			JSON.stringify({ version: SDK_STATE_VERSION, indexSeq: this.indexSeq, events: this.#events }),
-			{ mode: 0o600 },
+			JSON.stringify({
+				version: SESSION_INDEX_SNAPSHOT_VERSION,
+				indexSeq: this.indexSeq,
+				events: compactEvents(this.#events),
+			}),
+			{
+				mode: 0o600,
+			},
 		);
 		const h = await fs.open(tmp, "r");
 		try {
@@ -195,30 +298,16 @@ export class SessionIndex {
 			await h.close();
 		}
 		await fs.rename(tmp, file);
+		await syncDirectory(file);
 	}
-	async assertSupportedStateVersions(): Promise<void> {
-		const files = [snapshotFor(this.#agentDir), logFor(this.#agentDir)];
-		for (const file of files) {
-			let source: string;
-			try {
-				source = await fs.readFile(file, "utf8");
-			} catch (error) {
-				if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
-				throw error;
-			}
-			if (file.endsWith(".json")) {
-				assertSupportedStateVersion(file, JSON.parse(source));
-				continue;
-			}
-			for (const line of source.split("\n")) {
-				if (!line) continue;
-				try {
-					assertSupportedStateVersion(file, JSON.parse(line));
-				} catch (error) {
-					if (error instanceof UnsupportedStateVersionError) throw error;
-				}
-			}
-		}
+	async #rotate(): Promise<void> {
+		await this.#snapshotUnderLock();
+		const file = logFor(this.#agentDir);
+		const temporary = `${file}.${process.pid}.tmp`;
+		await fs.writeFile(temporary, "", { mode: 0o600 });
+		await fs.rename(temporary, file);
+		await syncDirectory(file);
+		this.#logOffset = 0;
 	}
 
 	listSessions(): SessionList {

package/src/sdk/broker/state-version.ts

@@ -1,5 +1,12 @@
 export const SDK_STATE_VERSION = 1;
 
+// The session-index snapshot carries its own format version, independent of the shared
+// SDK_STATE_VERSION used by discovery, the lifecycle ledger, and per-event records. Version 2
+// snapshots relax the on-disk schema to allow gaps in indexSeq (compaction drops terminal+dead
+// sessions and superseded heartbeats), so an older broker must hard-fail rather than silently
+// fall back to a truncated log. Bumping only this constant keeps the broker protocol untouched.
+export const SESSION_INDEX_SNAPSHOT_VERSION = 2;
+
 export class UnsupportedStateVersionError extends Error {
 	readonly code = "unsupported_state_version";
 
@@ -21,3 +28,17 @@ export function assertSupportedStateVersion(file: string, value: unknown): void
 		}
 	}
 }
+
+// Fences the session-index snapshot format independently of SDK_STATE_VERSION. An older broker
+// (whose SESSION_INDEX_SNAPSHOT_VERSION is 1) trips assertSupportedStateVersion on a version-2
+// snapshot and refuses to start; a current broker accepts both the legacy contiguous format
+// (version 1 or absent) and the gapped version-2 format.
+export function assertSupportedSnapshotVersion(file: string, value: unknown): void {
+	if (!value || typeof value !== "object") return;
+	const record = value as { version?: unknown; stateVersion?: unknown };
+	for (const version of [record.version, record.stateVersion]) {
+		if (typeof version === "number" && Number.isFinite(version) && version > SESSION_INDEX_SNAPSHOT_VERSION) {
+			throw new UnsupportedStateVersionError(file, version);
+		}
+	}
+}

package/src/sdk/broker/transport.ts

@@ -43,7 +43,7 @@ export class BrokerTransport {
 	readonly #broker: Broker;
 	readonly #token: string;
 	readonly #requestedPort: number;
-	#server: ReturnType<typeof Bun.serve> | null = null;
+	#server: Bun.Server<undefined> | null = null;
 	#port = 0;
 	constructor(broker: Broker, token: string, port = 0) {
 		this.#broker = broker;

package/src/sdk/bus/chat-daemon-cli.ts

@@ -66,6 +66,7 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 				rich: { enabled: true },
 				richDraft: { enabled: false },
 				topics: { nameTemplate: undefined },
+				btw: { enabled: true },
 			})
 		) {
 			throw new Error("Discord notifications are enabled but configuration is incomplete");
@@ -98,6 +99,7 @@ async function loadConfig(agentDir: string, kind: ChatDaemonKind): Promise<ChatD
 			rich: { enabled: true },
 			richDraft: { enabled: false },
 			topics: { nameTemplate: undefined },
+			btw: { enabled: true },
 		})
 	) {
 		throw new Error("Slack notifications are enabled but configuration is incomplete");

package/src/sdk/bus/chat-daemon-control.ts

@@ -1,4 +1,4 @@
-import { spawn as childProcessSpawn, spawnSync } from "node:child_process";
+import { spawn as childProcessSpawn } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -12,6 +12,7 @@ import type {
 	DaemonStatus,
 } from "../../daemon/control-types";
 import { resolveGjcRuntimeSpawnInfo } from "../../daemon/runtime";
+import { isProcessIncarnation, processIncarnation } from "../broker/process-incarnation";
 import { getNotificationConfig, isDiscordConfigured, isSlackConfigured } from "./config";
 
 export type ChatDaemonKind = "discord" | "slack";
@@ -121,28 +122,7 @@ function defaultSignal(pid: number, signal: NodeJS.Signals): void {
 		process.kill(pid, signal);
 	} catch {}
 }
-function defaultPidIncarnation(pid: number): string | undefined {
-	if (!Number.isSafeInteger(pid) || pid <= 0) return undefined;
-	if (process.platform === "linux") {
-		try {
-			const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
-			return `linux:${
-				stat
-					.slice(stat.lastIndexOf(")") + 2)
-					.trim()
-					.split(/\s+/)[19]
-			}`;
-		} catch {
-			return undefined;
-		}
-	}
-	if (process.platform === "darwin") {
-		const result = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
-		const startedAt = result.status === 0 ? result.stdout.trim() : "";
-		return startedAt ? `darwin:${startedAt}` : undefined;
-	}
-	return undefined;
-}
+
 function runtimeInfo(execPath?: string): DaemonRuntimeInfo {
 	const rt = resolveGjcRuntimeSpawnInfo(execPath ?? process.execPath);
 	return {
@@ -377,7 +357,7 @@ export class ChatDaemonController implements BuiltInDaemonController {
 		);
 	}
 	private incarnation(pid: number): string | undefined {
-		return (this.deps.pidIncarnation ?? defaultPidIncarnation)(pid);
+		return (this.deps.pidIncarnation ?? processIncarnation)(pid);
 	}
 	private isLiveState(state: ChatDaemonState): boolean {
 		return (
@@ -541,7 +521,7 @@ export async function acquireChatDaemonOwnership(input: {
 	const pid = input.pid ?? process.pid;
 	const probe: ChatDaemonOwnershipProbe = {
 		pidAlive: input.pidAlive ?? defaultPidAlive,
-		pidIncarnation: input.pidIncarnation ?? defaultPidIncarnation,
+		pidIncarnation: input.pidIncarnation ?? processIncarnation,
 	};
 	const incarnation = input.incarnation ?? probe.pidIncarnation(pid) ?? "unavailable";
 	await fs.promises.mkdir(paths.dir, { recursive: true, mode: 0o700 });
@@ -631,9 +611,9 @@ async function isStaleChatDaemonLock(lock: string, probe: ChatDaemonOwnershipPro
 		const currentIncarnation = probe.pidIncarnation(owner.pid);
 		return (
 			!probe.pidAlive(owner.pid) ||
-			(currentIncarnation !== undefined &&
-				owner.incarnation !== "unavailable" &&
-				currentIncarnation !== owner.incarnation)
+			(owner.incarnation !== "unavailable" &&
+				(!isProcessIncarnation(owner.incarnation) ||
+					(currentIncarnation !== undefined && currentIncarnation !== owner.incarnation)))
 		);
 	}
 	const stat = await fs.promises.stat(lock).catch(() => undefined);

package/src/sdk/bus/chat-effect-journal.ts

@@ -118,6 +118,7 @@ function canClaim(effect: ChatEffect, now: number): boolean {
 export class ChatEffectJournal {
 	readonly #store: ConversationStore<ChatEffect>;
 	readonly #mappings: ConversationStore<EffectReferenceMapping>;
+	readonly #maxTerminalEffects: number;
 
 	readonly #now: () => number;
 
@@ -131,10 +132,17 @@ export class ChatEffectJournal {
 		pidIncarnation?: (pid: number) => string | undefined;
 		sleep?: (ms: number) => Promise<void>;
 		lockTimeoutMs?: number;
+		maxTerminalEffects?: number;
 	}) {
 		this.#store = new ConversationStore<ChatEffect>({ ...input, kind: input.transport, fileName: "effects.json" });
 		this.#mappings = new ConversationStore<EffectReferenceMapping>({ ...input, kind: input.transport });
 
+		if (
+			input.maxTerminalEffects !== undefined &&
+			(!Number.isSafeInteger(input.maxTerminalEffects) || input.maxTerminalEffects < 1)
+		)
+			throw new Error("Chat effect terminal retention must be a positive safe integer");
+		this.#maxTerminalEffects = input.maxTerminalEffects ?? MAX_TERMINAL_CHAT_EFFECTS;
 		this.#now = input.now ?? Date.now;
 	}
 
@@ -343,12 +351,12 @@ export class ChatEffectJournal {
 		const terminal = (await this.list())
 			.filter(effect => effect.state === "terminal")
 			.sort((left, right) => left.updatedAt - right.updatedAt);
-		if (terminal.length <= MAX_TERMINAL_CHAT_EFFECTS) return;
+		if (terminal.length <= this.#maxTerminalEffects) return;
 
 		const referenced = new Set<string>();
 		for (const mapping of Object.values((await this.#mappings.load()).conversations))
 			collectEffectReferences(mapping, referenced);
-		for (const effect of terminal.slice(0, terminal.length - MAX_TERMINAL_CHAT_EFFECTS)) {
+		for (const effect of terminal.slice(0, terminal.length - this.#maxTerminalEffects)) {
 			if (!referenced.has(effect.id)) await this.#store.delete(effect.id, effect.generation);
 		}
 	}

package/src/sdk/bus/config-commands.ts

@@ -5,7 +5,7 @@
  * removed), but the user can still adjust per-surface behaviour from inside a
  * session thread with small slash commands:
  *
- * - `/verbose`            switch the mirror to verbose (full tool output + reasoning)
+ * - `/verbose`            switch the mirror to bounded tool-owned summaries + provider-displayable reasoning summaries
  * - `/lean`               switch back to lean (assistant text + tool names)
  * - `/verbosity lean|verbose`
  * - `/redact on|off`      toggle redaction of streamed content
@@ -133,13 +133,14 @@ export function parseInThreadConfigCommand(text: string): ConfigCommandChange |
 
 	switch (command) {
 		case "verbose":
-			return { verbosity: "verbose" };
+			return rest.length === 0 ? { verbosity: "verbose" } : undefined;
 		case "lean":
-			return { verbosity: "lean" };
+			return rest.length === 0 ? { verbosity: "lean" } : undefined;
 		case "verbosity":
-			if (arg === "lean" || arg === "verbose") return { verbosity: arg };
+			if (rest.length === 1 && (arg === "lean" || arg === "verbose")) return { verbosity: arg };
 			return undefined;
 		case "redact":
+			if (rest.length !== 1) return undefined;
 			if (arg === "on" || arg === "true" || arg === "1") return { redact: true };
 			if (arg === "off" || arg === "false" || arg === "0") return { redact: false };
 			return undefined;

package/src/sdk/bus/config.ts

@@ -55,6 +55,9 @@ export interface NotificationSettingsSnapshot {
 		botToken?: string;
 		chatId?: string;
 		activation?: Record<string, unknown>;
+		btw: {
+			enabled: boolean;
+		};
 		rich: {
 			enabled: boolean;
 		};
@@ -93,6 +96,97 @@ export interface NotificationSettingsReader {
 	getNotificationSettingsSnapshot(): NotificationSettingsSnapshot;
 	getAgentDir(): string;
 }
+function notificationConfigurationError(): Error {
+	return new Error("gjc_notify_daemon_invalid_configuration");
+}
+
+function notificationSettingsObject(value: unknown): Record<string, unknown> {
+	if (value === undefined) return {};
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw notificationConfigurationError();
+	return value as Record<string, unknown>;
+}
+
+function notificationSettingsString(value: unknown): string | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "string") return value;
+	throw notificationConfigurationError();
+}
+
+function notificationSettingsBoolean(value: unknown, fallback: boolean): boolean {
+	if (value === undefined) return fallback;
+	if (typeof value === "boolean") return value;
+	throw notificationConfigurationError();
+}
+
+function notificationSettingsChoice<T extends string>(value: unknown, fallback: T, choices: readonly T[]): T {
+	if (value === undefined) return fallback;
+	if (typeof value === "string" && choices.includes(value as T)) return value as T;
+	throw notificationConfigurationError();
+}
+
+function notificationIdleTimeoutMs(value: unknown): number {
+	if (value === undefined) return 60_000;
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
+	throw notificationConfigurationError();
+}
+
+/**
+ * Validate and snapshot the raw global notification configuration used by both
+ * the interactive host and the lightweight daemon process.
+ */
+export function parseNotificationSettingsSnapshot(rawConfig?: unknown): NotificationSettingsSnapshot {
+	const root = notificationSettingsObject(rawConfig);
+	const notifications = notificationSettingsObject(root.notifications);
+	const telegram = notificationSettingsObject(notifications.telegram);
+	const btw = notificationSettingsObject(telegram.btw);
+	const rich = notificationSettingsObject(telegram.rich);
+	const richDraft = notificationSettingsObject(telegram.richDraft);
+	const topics = notificationSettingsObject(telegram.topics);
+	const activation = readTelegramActivationMarkers(notificationSettingsObject(telegram.activation));
+	const discord = notificationSettingsObject(notifications.discord);
+	const slack = notificationSettingsObject(notifications.slack);
+	const daemon = notificationSettingsObject(notifications.daemon);
+	return {
+		enabled: notificationSettingsBoolean(notifications.enabled, false),
+		telegram: {
+			botToken: notificationSettingsString(telegram.botToken),
+			chatId: notificationSettingsString(telegram.chatId),
+			...(Object.keys(activation).length === 0 ? {} : { activation }),
+			btw: {
+				enabled: notificationSettingsBoolean(btw.enabled, true),
+			},
+			rich: {
+				enabled: notificationSettingsBoolean(rich.enabled, true),
+			},
+			richDraft: {
+				enabled: notificationSettingsBoolean(richDraft.enabled, false),
+			},
+			topics: {
+				nameTemplate: notificationSettingsString(topics.nameTemplate),
+			},
+		},
+		discord: {
+			botToken: notificationSettingsString(discord.botToken),
+			applicationId: notificationSettingsString(discord.applicationId),
+			guildId: notificationSettingsString(discord.guildId),
+			parentChannelId: notificationSettingsString(discord.parentChannelId),
+		},
+		slack: {
+			botToken: notificationSettingsString(slack.botToken),
+			appToken: notificationSettingsString(slack.appToken),
+			workspaceId: notificationSettingsString(slack.workspaceId),
+			channelId: notificationSettingsString(slack.channelId),
+			authorizedUserId: notificationSettingsString(slack.authorizedUserId),
+		},
+		redact: notificationSettingsBoolean(notifications.redact, false),
+		verbosity: notificationSettingsChoice<"lean" | "verbose">(notifications.verbosity, "lean", ["lean", "verbose"]),
+		sessionScope: notificationSettingsChoice<"all" | "primary">(notifications.sessionScope, "all", [
+			"all",
+			"primary",
+		]),
+		idleTimeoutMs: notificationIdleTimeoutMs(daemon.idleTimeoutMs),
+	};
+}
 
 export interface NotificationConfig {
 	enabled: boolean;
@@ -121,6 +215,9 @@ export interface NotificationConfig {
 	 */
 	sessionScope: "all" | "primary";
 	idleTimeoutMs: number;
+	btw: {
+		enabled: boolean;
+	};
 	rich: {
 		enabled: boolean;
 	};
@@ -154,6 +251,7 @@ export function getNotificationConfig(settings: NotificationSettingsReader): Not
 		sessionScope: snapshot.sessionScope,
 		idleTimeoutMs: snapshot.idleTimeoutMs,
 		rich: snapshot.telegram.rich,
+		btw: snapshot.telegram.btw,
 		richDraft: snapshot.telegram.richDraft,
 		topics: snapshot.telegram.topics,
 	};