@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/scripts/build-sdk-package-smoke.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const packageDir = path.resolve(import.meta.dir, "..");
+const packageName = "@sayknow-cli/coding-agent";
+const aiPackageDir = path.resolve(packageDir, "../ai");
+const bridgeClientPackageDir = path.resolve(packageDir, "../bridge-client");
+const tuiPackageDir = path.resolve(packageDir, "../tui");
+const nativesPackageDir = path.resolve(packageDir, "../natives");
+const linuxX64PackageDir = path.resolve(packageDir, "../natives-linux-x64");
+const manifestsDir = path.join(packageDir, "test/manifests");
+const baselinePath = path.join(manifestsDir, "sdk-public-surface-v1.json");
+const generatedPath = path.join(manifestsDir, "sdk-public-surface.generated.json");
+
+type Surface = { root: string[]; sdk: string[] };
+
+function run(command: string[], cwd: string): string {
+	const result = Bun.spawnSync(command, { cwd, stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) {
+		throw new Error(`${command.join(" ")} failed:\n${new TextDecoder().decode(result.stderr)}`);
+	}
+	return new TextDecoder().decode(result.stdout).trim();
+}
+
+function assertExport(module: Record<string, unknown>, name: string, subpath: string): void {
+	if (!(name in module)) throw new Error(`${subpath} does not export ${name}`);
+}
+
+async function runSmoke(): Promise<Surface> {
+	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "skc-sdk-package-smoke-"));
+	try {
+		const stagedLinuxX64Dir = path.join(tempDir, "natives-linux-x64");
+		await fs.cp(linuxX64PackageDir, stagedLinuxX64Dir, { recursive: true });
+		const stagedNativeDir = path.join(stagedLinuxX64Dir, "native");
+		await fs.mkdir(stagedNativeDir, { recursive: true });
+		for (const entry of await fs.readdir(path.join(nativesPackageDir, "native"))) {
+			if (entry.startsWith("pi_natives.linux-x64") && entry.endsWith(".node")) {
+				await fs.copyFile(path.join(nativesPackageDir, "native", entry), path.join(stagedNativeDir, entry));
+			}
+		}
+		const aiTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], aiPackageDir);
+		const bridgeClientTarball = run(
+			["bun", "pm", "pack", "--destination", tempDir, "--quiet"],
+			bridgeClientPackageDir,
+		);
+		const tuiTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], tuiPackageDir);
+		const nativesTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], nativesPackageDir);
+		const linuxX64Tarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], stagedLinuxX64Dir);
+		const codingAgentTarball = run(["bun", "pm", "pack", "--destination", tempDir, "--quiet"], packageDir);
+		const aiTarballPath = path.isAbsolute(aiTarball) ? aiTarball : path.join(aiPackageDir, aiTarball);
+		const bridgeClientTarballPath = path.isAbsolute(bridgeClientTarball)
+			? bridgeClientTarball
+			: path.join(bridgeClientPackageDir, bridgeClientTarball);
+		const tuiTarballPath = path.isAbsolute(tuiTarball) ? tuiTarball : path.join(tuiPackageDir, tuiTarball);
+		const nativesTarballPath = path.isAbsolute(nativesTarball)
+			? nativesTarball
+			: path.join(nativesPackageDir, nativesTarball);
+		const linuxX64TarballPath = path.isAbsolute(linuxX64Tarball)
+			? linuxX64Tarball
+			: path.join(stagedLinuxX64Dir, linuxX64Tarball);
+		const codingAgentTarballPath = path.isAbsolute(codingAgentTarball)
+			? codingAgentTarball
+			: path.join(packageDir, codingAgentTarball);
+		await fs.writeFile(
+			path.join(tempDir, "package.json"),
+			JSON.stringify(
+				{
+					name: "sdk-smoke",
+					private: true,
+					dependencies: {
+						"@sayknow-cli/ai": `file:${aiTarballPath}`,
+						"@sayknow-cli/bridge-client": `file:${bridgeClientTarballPath}`,
+						[packageName]: `file:${codingAgentTarballPath}`,
+						"@sayknow-cli/tui": `file:${tuiTarballPath}`,
+						"@sayknow-cli/natives": `file:${nativesTarballPath}`,
+						"@sayknow-cli/natives-linux-x64": `file:${linuxX64TarballPath}`,
+					},
+					overrides: {
+						"@sayknow-cli/ai": `file:${aiTarballPath}`,
+						"@sayknow-cli/bridge-client": `file:${bridgeClientTarballPath}`,
+						"@sayknow-cli/tui": `file:${tuiTarballPath}`,
+						"@sayknow-cli/natives": `file:${nativesTarballPath}`,
+						"@sayknow-cli/natives-linux-x64": `file:${linuxX64TarballPath}`,
+					},
+				},
+				null,
+				2,
+			),
+		);
+		// Install the matching packed workspace artifacts so the smoke test exercises the
+		// release dependency boundary without falling back to an older registry package.
+		run(["bun", "install", "--ignore-scripts"], tempDir);
+		const installedPackage = JSON.parse(
+			await fs.readFile(path.join(tempDir, "node_modules", packageName, "package.json"), "utf8"),
+		) as { exports?: Record<string, unknown> };
+		if (installedPackage.exports?.["./session/internal/*"] !== null) {
+			throw new Error("packed package must explicitly block ./session/internal/*");
+		}
+		const probePath = path.join(tempDir, "probe.ts");
+		await fs.writeFile(
+			probePath,
+			`import * as fs from "node:fs/promises";\nimport * as path from "node:path";\nimport * as root from ${JSON.stringify(packageName)};\nimport * as sdk from ${JSON.stringify(`${packageName}/sdk`)};\nimport * as bus from ${JSON.stringify(`${packageName}/sdk/bus`)};\nconst required = [[root, "createAgentSession", "root"], [root, "SESSION_DIRECTORY_API_VERSION", "root"], [root, "resolveManagedSessionScope", "root"], [root, "listManagedSessionCandidates", "root"], [sdk, "createAgentSession", "sdk"], [bus, "createNotificationsExtension", "sdk/bus"], [sdk, "SdkClient", "sdk"], [sdk, "SESSION_DIRECTORY_API_VERSION", "sdk"], [sdk, "resolveManagedSessionScope", "sdk"], [sdk, "listManagedSessionCandidates", "sdk"]] as const;\nfor (const [module, name, subpath] of required) if (!(name in module)) throw new Error(subpath + " missing " + name);\nconst sandbox = path.join(process.cwd(), "managed-listing-smoke");\nconst cwd = path.join(sandbox, "workspace", "a-b", "c");\nconst agentDir = path.join(sandbox, "agent");\nconst sessionsRoot = path.join(agentDir, "sessions");\nawait fs.mkdir(cwd, { recursive: true });\nconst resolved = await sdk.resolveManagedSessionScope({ cwd, agentDir, sessionsRoot });\nif (resolved.kind !== "resolved") throw new Error("packed resolver failed: " + resolved.message);\nawait fs.mkdir(resolved.scope.directoryPath, { recursive: true, mode: 0o700 });\nawait fs.chmod(sessionsRoot, 0o700);\nawait fs.chmod(resolved.scope.directoryPath, 0o700);\nawait fs.writeFile(path.join(resolved.scope.directoryPath, ".skc-managed-session-scope.v2.json"), JSON.stringify({ schemaVersion: 1, layoutVersion: 2, identityVersion: 1, platform: process.platform === "win32" ? "win32" : "posix", canonicalPath: resolved.scope.canonicalCwd, identityDigest: resolved.scope.directoryName.slice(3) }) + "\\n", { mode: 0o600 });\nconst transcriptPath = path.join(resolved.scope.directoryPath, "packed-session.jsonl");\nawait fs.writeFile(transcriptPath, JSON.stringify({ type: "session", id: "packed-session", cwd }) + "\\n", { mode: 0o600 });\nconst snapshot = async () => Promise.all((await fs.readdir(sandbox, { recursive: true })).sort().map(async name => { const pathname = path.join(sandbox, name); const stat = await fs.lstat(pathname); return [name, stat.mode, stat.size, stat.mtimeMs, stat.isFile() ? await fs.readFile(pathname, "utf8") : null]; }));\nconst before = JSON.stringify(await snapshot());\nconst listing = await sdk.listManagedSessionCandidates({ scope: resolved.scope });\nif (listing.kind !== "complete" || listing.owned.length !== 1 || listing.owned[0]?.sessionId !== "packed-session") throw new Error("packed readonly listing failed: " + JSON.stringify(listing));\nconst after = JSON.stringify(await snapshot());\nif (after !== before) throw new Error("packed readonly listing mutated the filesystem");\nconst privateSubpath = ${JSON.stringify(`${packageName}/session/internal/managed-session-scope`)};\ntry { await import(privateSubpath); throw new Error("private managed-session scope subpath resolved"); } catch (error) {\n\tif (error instanceof Error && error.message === "private managed-session scope subpath resolved") throw error;\n\tconst message = String(error);\n\tconst exportsRejected = /Package subpath .* is not defined by "exports"/.test(message);\n\tconst bunRejected = message.startsWith("ResolveMessage: Cannot find module '" + privateSubpath + "' from '") && message.endsWith("/probe.ts'");\n\tif (!exportsRejected && !bunRejected) throw new Error("private managed-session scope failed for an unexpected reason: " + message);\n}\nprocess.stdout.write(JSON.stringify({ root: Object.keys(root).sort(), sdk: Object.keys(sdk).sort() }));\n`,
+		);
+		await fs.appendFile(
+			probePath,
+			`\nconst rootBefore = JSON.stringify(await snapshot());\nconst rootListing = await root.listManagedSessionCandidates({ scope: resolved.scope });\nif (rootListing.kind !== "complete" || rootListing.owned.length !== listing.owned.length || rootListing.owned[0]?.sessionId !== listing.owned[0]?.sessionId || rootListing.owned[0]?.path !== listing.owned[0]?.path) throw new Error("packed root readonly listing diverged from SDK listing");\nconst rootAfter = JSON.stringify(await snapshot());\nif (rootAfter !== rootBefore) throw new Error("packed root readonly listing mutated the filesystem");\nconst bridgeClient = await import("@sayknow-cli/bridge-client");\nif (sdk.SdkClient !== bridgeClient.SdkClient) throw new Error("SdkClient class identity differs between sdk and bridge-client");\n`,
+		);
+		const surface = JSON.parse(run(["bun", "run", probePath], tempDir)) as Surface;
+		assertExport(Object.fromEntries(surface.root.map(name => [name, true])), "createAgentSession", "root");
+		assertExport(Object.fromEntries(surface.sdk.map(name => [name, true])), "SdkClient", "sdk");
+		return { root: [...surface.root].sort(), sdk: [...surface.sdk].sort() };
+	} finally {
+		await fs.rm(tempDir, { recursive: true, force: true });
+	}
+}
+
+async function main(): Promise<void> {
+	const surface = await runSmoke();
+	await fs.mkdir(manifestsDir, { recursive: true });
+	await fs.writeFile(generatedPath, `${JSON.stringify(surface, null, 2)}\n`);
+	const baseline = JSON.parse(await Bun.file(baselinePath).text()) as Surface;
+	const removals = (Object.keys(baseline) as Array<keyof Surface>).flatMap(area =>
+		baseline[area].filter(name => !surface[area].includes(name)).map(name => `${area}.${name}`),
+	);
+	if (removals.length > 0) throw new Error(`SDK public surface removals are not allowed:\n${removals.join("\n")}`);
+	process.stdout.write(`SDK package smoke passed (root: ${surface.root.length}, sdk: ${surface.sdk.length}).\n`);
+}
+
+await main();

package/scripts/capture-notifications-settings-showcase.ts

@@ -0,0 +1,435 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+	NOTIFICATIONS_SETTINGS_SHOWCASE_ENTRIES,
+	NOTIFICATIONS_SETTINGS_SHOWCASE_EXPECTED_ENTRY_COUNT,
+	NOTIFICATIONS_SETTINGS_SHOWCASE_STATE_IDS,
+	NOTIFICATIONS_SETTINGS_SHOWCASE_TARGETED_UNICODE_VARIANTS,
+	NOTIFICATIONS_SETTINGS_SHOWCASE_VIEWPORTS,
+	type NotificationsSettingsShowcaseEntry,
+	renderNotificationsSettingsShowcase,
+} from "../test/fixtures/tui/notifications-settings-showcase";
+
+const CANONICAL_COMMAND =
+	"bun packages/coding-agent/scripts/capture-notifications-settings-showcase.ts --output .skc/qa/issue-2050-notifications";
+const DETERMINISTIC_CAPTURE_TIMESTAMP = "1970-01-01T00:00:00.000Z";
+const CAPTURE_TOOL_VERSION = "notifications-settings-showcase-live-settings-selector-v3";
+
+interface ArtifactFile {
+	path: string;
+	sha256: string;
+	byte_length: number;
+}
+
+interface ManifestEntry {
+	key: string;
+	state_id: string;
+	viewport: {
+		id: string;
+		columns: number;
+		rows: number;
+	};
+	render_mode: string;
+	capture_mode: "live-settings-selector";
+	files: ArtifactFile[];
+}
+
+interface VisualReviewInput {
+	schema_version: 1;
+	manifest_sha256: string;
+	expected_manifest_entries: number;
+	evidence_scope: {
+		component_surface: string;
+		operations_boundary: string;
+		external_effects: string;
+	};
+	reviewer_output_file: "independent-review.json";
+	review_requirements: string[];
+	required_feature_cases: Array<{
+		id: string;
+		entry_key: string;
+		focus: string;
+	}>;
+}
+
+function usage(): never {
+	throw new Error(`Usage: ${CANONICAL_COMMAND}`);
+}
+
+function parseOutputPath(args: string[]): string {
+	if (args.length !== 2 || args[0] !== "--output" || !args[1]) usage();
+	return args[1];
+}
+
+function json(value: unknown): string {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function sha256(text: string): string {
+	return new Bun.CryptoHasher("sha256").update(text).digest("hex");
+}
+
+function escapeHtml(text: string): string {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+type AnsiStyle = {
+	foreground?: string;
+	background?: string;
+	bold?: boolean;
+	dim?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	inverse?: boolean;
+};
+
+const ANSI_COLORS: Record<number, string> = {
+	30: "#000000",
+	31: "#cc0000",
+	32: "#4e9a06",
+	33: "#c4a000",
+	34: "#3465a4",
+	35: "#75507b",
+	36: "#06989a",
+	37: "#d3d7cf",
+	90: "#555753",
+	91: "#ef2929",
+	92: "#8ae234",
+	93: "#fce94f",
+	94: "#729fcf",
+	95: "#ad7fa8",
+	96: "#34e2e2",
+	97: "#eeeeec",
+};
+
+function ansi256Color(index: number): string {
+	if (index < 16) return ANSI_COLORS[index < 8 ? index + 30 : index + 82] ?? "#ffffff";
+	if (index >= 232) {
+		const value = (index - 232) * 10 + 8;
+		return `rgb(${value},${value},${value})`;
+	}
+	const value = index - 16;
+	const red = Math.floor(value / 36);
+	const green = Math.floor((value % 36) / 6);
+	const blue = value % 6;
+	const channel = (component: number) => (component === 0 ? 0 : component * 40 + 55);
+	return `rgb(${channel(red)},${channel(green)},${channel(blue)})`;
+}
+
+function styleAttribute(style: AnsiStyle): string {
+	const declarations: string[] = [];
+	if (style.foreground) declarations.push(`color:${style.foreground}`);
+	if (style.background) declarations.push(`background-color:${style.background}`);
+	if (style.bold) declarations.push("font-weight:700");
+	if (style.dim) declarations.push("opacity:.65");
+	if (style.italic) declarations.push("font-style:italic");
+	if (style.underline) declarations.push("text-decoration:underline");
+	if (style.inverse) declarations.push("filter:invert(1)");
+	return declarations.join(";");
+}
+
+const NON_VISUAL_TERMINAL_CONTROL = /\x1b_[^\x1b\x07]*(?:\x07|\x1b\\)/g;
+
+/** Render the SGR styles emitted by the live editor without retaining raw control codes in HTML. */
+function ansiToHtml(text: string): string {
+	const visibleText = text.replace(NON_VISUAL_TERMINAL_CONTROL, "");
+	const sgr = /\x1b\[([0-9;]*)m/g;
+	let html = "";
+	let offset = 0;
+	let spanOpen = false;
+	let style: AnsiStyle = {};
+	const close = () => {
+		if (!spanOpen) return;
+		html += "</span>";
+		spanOpen = false;
+	};
+	const open = () => {
+		const attribute = styleAttribute(style);
+		if (!attribute) return;
+		html += `<span style="${attribute}">`;
+		spanOpen = true;
+	};
+
+	for (const match of visibleText.matchAll(sgr)) {
+		html += escapeHtml(visibleText.slice(offset, match.index));
+		offset = (match.index ?? 0) + match[0].length;
+		close();
+		const codes = (match[1] || "0").split(";").map(Number);
+		for (let index = 0; index < codes.length; index += 1) {
+			const code = codes[index];
+			if (code === 0) style = {};
+			else if (code === 1) style.bold = true;
+			else if (code === 2) style.dim = true;
+			else if (code === 3) style.italic = true;
+			else if (code === 4) style.underline = true;
+			else if (code === 7) style.inverse = true;
+			else if (code === 22) {
+				style.bold = false;
+				style.dim = false;
+			} else if (code === 23) style.italic = false;
+			else if (code === 24) style.underline = false;
+			else if (code === 27) style.inverse = false;
+			else if (code === 39) style.foreground = undefined;
+			else if (code === 49) style.background = undefined;
+			else if (code in ANSI_COLORS) style.foreground = ANSI_COLORS[code];
+			else if (code >= 40 && code <= 47) style.background = ANSI_COLORS[code - 10];
+			else if (code >= 100 && code <= 107) style.background = ANSI_COLORS[code - 10];
+			else if (code === 38 || code === 48) {
+				const colorMode = codes[index + 1];
+				if (colorMode === 2) {
+					const red = codes[index + 2];
+					const green = codes[index + 3];
+					const blue = codes[index + 4];
+					if ([red, green, blue].every(Number.isInteger)) {
+						if (code === 38) style.foreground = `rgb(${red},${green},${blue})`;
+						else style.background = `rgb(${red},${green},${blue})`;
+					}
+					index += 4;
+				} else if (colorMode === 5 && Number.isInteger(codes[index + 2])) {
+					if (code === 38) style.foreground = ansi256Color(codes[index + 2]!);
+					else style.background = ansi256Color(codes[index + 2]!);
+					index += 2;
+				}
+			}
+		}
+		open();
+	}
+	close();
+	html += escapeHtml(visibleText.slice(offset));
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="color-scheme" content="dark">
+<title>Notifications settings showcase</title>
+<style>body{margin:0;background:#110b0b;color:#ffe7dc}pre{margin:0;padding:1em;white-space:pre-wrap;font-family:ui-monospace,monospace;line-height:1.2}</style>
+</head>
+<body><pre>${html}</pre></body>
+</html>
+`;
+}
+
+const TELEGRAM_TOKEN_CANARY = /\d{6,}:[A-Za-z0-9_-]{20,}/;
+
+function assertNoSecretCanary(artifacts: Readonly<Record<string, string>>): void {
+	for (const [name, content] of Object.entries(artifacts)) {
+		if (TELEGRAM_TOKEN_CANARY.test(content)) throw new Error(`Secret-shaped Telegram token found in ${name}`);
+	}
+}
+
+function validateShowcaseMatrix(entries: readonly NotificationsSettingsShowcaseEntry[]): void {
+	const expectedBaselineCount =
+		NOTIFICATIONS_SETTINGS_SHOWCASE_STATE_IDS.length * NOTIFICATIONS_SETTINGS_SHOWCASE_VIEWPORTS.length;
+	if (expectedBaselineCount !== 102) {
+		throw new Error(`Baseline matrix changed: expected 102 entries, received ${expectedBaselineCount}`);
+	}
+	if (entries.length !== NOTIFICATIONS_SETTINGS_SHOWCASE_EXPECTED_ENTRY_COUNT) {
+		throw new Error(
+			`Showcase matrix changed: expected ${NOTIFICATIONS_SETTINGS_SHOWCASE_EXPECTED_ENTRY_COUNT} entries, received ${entries.length}`,
+		);
+	}
+	const keys = new Set(entries.map(entry => entry.key));
+	if (keys.size !== entries.length) throw new Error("Showcase matrix contains duplicate entry keys");
+
+	for (const stateId of NOTIFICATIONS_SETTINGS_SHOWCASE_STATE_IDS) {
+		for (const viewport of NOTIFICATIONS_SETTINGS_SHOWCASE_VIEWPORTS) {
+			const key = `${stateId}/${viewport.id}/unicode-color`;
+			if (!keys.has(key)) throw new Error(`Showcase matrix is missing ${key}`);
+		}
+	}
+
+	const expectedAsciiKeys = new Set([
+		"home-configured-inactive/80x24/ascii-no-color",
+		"health-warning/80x24/ascii-no-color",
+		"foreign-blocked/120x36/ascii-no-color",
+		"confirmation-remove/80x24/ascii-no-color",
+	]);
+	const actualAsciiKeys = entries.filter(entry => entry.renderMode === "ascii-no-color").map(entry => entry.key);
+	if (actualAsciiKeys.length !== expectedAsciiKeys.size || actualAsciiKeys.some(key => !expectedAsciiKeys.has(key))) {
+		throw new Error("Showcase matrix does not contain the required ASCII/no-color variants");
+	}
+
+	const expectedNarrowKeys = new Set(
+		NOTIFICATIONS_SETTINGS_SHOWCASE_TARGETED_UNICODE_VARIANTS.map(
+			variant => `${variant.stateId}/${variant.viewport.id}/unicode-color`,
+		),
+	);
+	const actualNarrowKeys = entries
+		.filter(entry => entry.viewport.id === "48x36" && entry.renderMode === "unicode-color")
+		.map(entry => entry.key);
+	if (
+		actualNarrowKeys.length !== expectedNarrowKeys.size ||
+		actualNarrowKeys.some(key => !expectedNarrowKeys.has(key))
+	) {
+		throw new Error("Showcase matrix does not contain the required narrow CJK and scroll variants");
+	}
+}
+
+async function writeArtifact(filePath: string, content: string, outputRoot: string): Promise<ArtifactFile> {
+	await Bun.write(filePath, content);
+	return {
+		path: path.relative(outputRoot, filePath).split(path.sep).join("/"),
+		sha256: sha256(content),
+		byte_length: Buffer.byteLength(content, "utf8"),
+	};
+}
+
+async function captureEntry(entry: NotificationsSettingsShowcaseEntry, outputRoot: string): Promise<ManifestEntry> {
+	const rendered = await renderNotificationsSettingsShowcase(entry);
+	const entryDirectory = path.join(outputRoot, entry.stateId, entry.viewport.id, entry.renderMode);
+	await fs.mkdir(entryDirectory, { recursive: true });
+
+	const terminalHtml = ansiToHtml(rendered.terminalAnsiText);
+	const metadata = json({
+		schema_version: 1,
+		entry_key: entry.key,
+		state_id: entry.stateId,
+		viewport: entry.viewport,
+		render_mode: entry.renderMode,
+		capture_mode: rendered.captureMode,
+		capture_timestamp: DETERMINISTIC_CAPTURE_TIMESTAMP,
+		command_or_replay_source: CANONICAL_COMMAND,
+		fixture_source: "packages/coding-agent/test/fixtures/tui/notifications-settings-showcase.ts",
+		tool_version: CAPTURE_TOOL_VERSION,
+		terminal: {
+			columns: entry.viewport.columns,
+			rows: entry.viewport.rows,
+			font_rendering_assumptions:
+				"Embedded red-octopus theme at deterministic truecolor; HTML uses a monospace terminal fallback stack.",
+			wrapping_policy:
+				"SettingsSelectorComponent renders the Notifications tab; status labels remain on one line and status guidance wraps with ANSI-aware terminal-cell width handling.",
+			ansi_control_semantics:
+				"terminal-ansi.txt preserves emitted SGR sequences; terminal.txt and ascii-no-color captures strip them.",
+		},
+		selector_render: {
+			component: "SettingsSelectorComponent",
+			active_tab: rendered.selectorTab,
+			notifications_editor: "NotificationsSettingsEditorComponent",
+			operations: "deterministic in-memory NotificationsEditorOperations adapter; live components only",
+			fixed_clock_timestamp: rendered.fixedClockTimestamp,
+			navigation: rendered.navigation,
+			state: rendered.state,
+		},
+	});
+	assertNoSecretCanary({
+		"terminal.txt": rendered.terminalText,
+		"terminal-ansi.txt": rendered.terminalAnsiText,
+		"terminal.html": terminalHtml,
+		"metadata.json": metadata,
+	});
+
+	const files = await Promise.all([
+		writeArtifact(path.join(entryDirectory, "terminal.txt"), rendered.terminalText, outputRoot),
+		writeArtifact(path.join(entryDirectory, "terminal-ansi.txt"), rendered.terminalAnsiText, outputRoot),
+		writeArtifact(path.join(entryDirectory, "terminal.html"), terminalHtml, outputRoot),
+		writeArtifact(path.join(entryDirectory, "metadata.json"), metadata, outputRoot),
+	]);
+
+	return {
+		key: entry.key,
+		state_id: entry.stateId,
+		viewport: entry.viewport,
+		render_mode: entry.renderMode,
+		capture_mode: rendered.captureMode,
+		files,
+	};
+}
+
+function visualReviewInput(manifestSha256: string): VisualReviewInput {
+	return {
+		schema_version: 1,
+		manifest_sha256: manifestSha256,
+		expected_manifest_entries: NOTIFICATIONS_SETTINGS_SHOWCASE_EXPECTED_ENTRY_COUNT,
+		evidence_scope: {
+			component_surface:
+				"Live SettingsSelectorComponent and NotificationsSettingsEditorComponent rendering and input routing.",
+			operations_boundary:
+				"Deterministic in-memory NotificationsEditorOperations adapter with fixed clock and no fixture filesystem I/O.",
+			external_effects: "No network, daemon, settings-file, or provider operation is invoked by this capture.",
+		},
+		reviewer_output_file: "independent-review.json",
+		review_requirements: [
+			"Inspect every manifest entry at its recorded viewport and render mode.",
+			"Confirm CJK wrapping, action-list position, and selected-row visibility in both 48x36 entries.",
+			"Confirm blocked restore/retain remains visible without resolving it in the rendered evidence.",
+			"Confirm no terminal, HTML, or metadata artifact contains a secret-shaped Telegram token.",
+		],
+		required_feature_cases: [
+			{
+				id: "chat-entry",
+				entry_key: "setup-chat-entry/80x24/unicode-color",
+				focus: "Optional private-chat entry is focused before masked token entry.",
+			},
+			{
+				id: "preferences",
+				entry_key: "preferences/80x24/unicode-color",
+				focus: "Safe scalar preferences remain an unsaved draft until explicit save.",
+			},
+			{
+				id: "blocked-restore-retain",
+				entry_key: "blocked-restore-retain/120x36/unicode-color",
+				focus: "Both explicit CAS restore and retain-inactive choices remain visible.",
+			},
+			{
+				id: "no-health-load",
+				entry_key: "no-health-load/80x24/unicode-color",
+				focus: "Initial status/health failure is rendered with recovery controls still available.",
+			},
+			{
+				id: "narrow-cjk",
+				entry_key: "narrow-cjk/48x36/unicode-color",
+				focus: "Korean, Japanese, and Chinese guidance wraps without clipping wide characters.",
+			},
+			{
+				id: "narrow-scroll",
+				entry_key: "narrow-scroll/48x36/unicode-color",
+				focus: "The final home action and 11/11 list position remain visible in a narrow viewport.",
+			},
+		],
+	};
+}
+
+async function main(): Promise<void> {
+	const outputRoot = path.resolve(parseOutputPath(process.argv.slice(2)));
+	validateShowcaseMatrix(NOTIFICATIONS_SETTINGS_SHOWCASE_ENTRIES);
+	await fs.mkdir(outputRoot, { recursive: true });
+
+	const entries: ManifestEntry[] = [];
+	for (const entry of NOTIFICATIONS_SETTINGS_SHOWCASE_ENTRIES) {
+		entries.push(await captureEntry(entry, outputRoot));
+	}
+
+	const manifest = json({
+		schema_version: 1,
+		capture_tool: CAPTURE_TOOL_VERSION,
+		capture_mode: "live-settings-selector",
+		command: CANONICAL_COMMAND,
+		expected_entry_count: NOTIFICATIONS_SETTINGS_SHOWCASE_EXPECTED_ENTRY_COUNT,
+		entry_count: entries.length,
+		matrix: {
+			canonical_state_ids: NOTIFICATIONS_SETTINGS_SHOWCASE_STATE_IDS,
+			viewports: NOTIFICATIONS_SETTINGS_SHOWCASE_VIEWPORTS,
+			baseline_render_mode: "unicode-color",
+			ascii_no_color_variant_count: 4,
+			targeted_unicode_variants: NOTIFICATIONS_SETTINGS_SHOWCASE_TARGETED_UNICODE_VARIANTS,
+		},
+		evidence_scope: {
+			component_surface:
+				"Live SettingsSelectorComponent and NotificationsSettingsEditorComponent rendering and input routing.",
+			operations_boundary:
+				"Deterministic in-memory NotificationsEditorOperations adapter with fixed clock and no fixture filesystem I/O.",
+			external_effects: "No network, daemon, settings-file, or provider operation is invoked by this capture.",
+		},
+		review_input_file: "visual-review-input.json",
+		entries,
+	});
+	const manifestSha256 = sha256(manifest);
+	await Bun.write(path.join(outputRoot, "manifest.json"), manifest);
+	await Bun.write(path.join(outputRoot, "visual-review-input.json"), json(visualReviewInput(manifestSha256)));
+
+	process.stdout.write(
+		`Captured ${entries.length} deterministic Notifications settings-selector showcase entries to ${outputRoot}\nmanifest.json sha256: ${manifestSha256}\nreview input: visual-review-input.json\n`,
+	);
+}
+
+await main();

package/scripts/compile-args.ts

@@ -7,6 +7,7 @@ export interface CompileArgOptions {
 	externals?: string[];
 }
 
+
 export const compileAutoloadDisableFlags = [
 	"--no-compile-autoload-bunfig",
 	"--no-compile-autoload-dotenv",
@@ -26,7 +27,8 @@ export const releaseEntrypoints = [
 	"./packages/coding-agent/src/tools/browser/tab-worker-entry.ts",
 	"./packages/coding-agent/src/eval/js/worker-entry.ts",
 	"./packages/natives/native/index.js",
-	"./packages/coding-agent/src/notifications/telegram-daemon-cli.ts",
+	"./packages/coding-agent/src/sdk/bus/telegram-daemon-cli.ts",
+	"./packages/coding-agent/src/sdk/bus/chat-daemon-cli.ts",
 	// Hidden Telegram Remote gateway entrypoint. `skc telegram start` self-spawns
 	// `skc telegram __gateway`, which dynamic-imports this bundled entry.
 	"./packages/telegram-remote/src/index.ts",
@@ -44,7 +46,8 @@ export const devEntrypoints = [
 	"../stats/src/sync-worker.ts",
 	"./src/tools/browser/tab-worker-entry.ts",
 	"./src/eval/js/worker-entry.ts",
-	"./src/notifications/telegram-daemon-cli.ts",
+	"./src/sdk/bus/telegram-daemon-cli.ts",
+	"./src/sdk/bus/chat-daemon-cli.ts",
 	"../telegram-remote/src/index.ts",
 ];
 

package/scripts/g005-daemon-smoke.ts

@@ -7,18 +7,17 @@
 // SKC-tagged tmux session and a `session_close` frame into a real hard-close,
 // with idempotent re-ack. Not part of the unit suite.
 import assert from "node:assert";
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { SessionCloseFrame, SessionCreateFrame } from "../src/notifications/index";
+import type { SessionCloseFrame, SessionCreateFrame } from "../src/sdk/bus/index";
 import {
 	type AuditEvent,
 	handleLifecycleRequest,
 	type LedgerDoc,
 	type LedgerStore,
 	type OrchestratorDeps,
-} from "../src/notifications/lifecycle-orchestrator";
+} from "../src/sdk/bus/lifecycle-orchestrator";
 import {
 	buildSkcTmuxExactOptionTarget,
 	buildSkcTmuxProfileCommands,
@@ -61,6 +60,8 @@ const store: LedgerStore = {
 const auditLines: AuditEvent[] = [];
 const deps: OrchestratorDeps = {
 	pairedChatId: "42",
+	auditRedactionKey: new Uint8Array(32).fill(5),
+	isPsmuxProvider: () => false,
 	now: () => Date.now(),
 	store,
 	audit: e => {
@@ -103,8 +104,6 @@ const deps: OrchestratorDeps = {
 		return { processGone: !exists(target.tmuxSession ?? "") };
 	},
 	resumeSession: async () => ({ ambiguous: [] }),
-	newLifecycleRequestId: () => `lc-${crypto.randomUUID()}`,
-	newSessionId: () => `s${crypto.randomUUID().slice(0, 8)}`,
 };
 
 const createFrame: SessionCreateFrame = {

package/scripts/g011-daemon-path-smoke.ts

@@ -18,9 +18,9 @@ import WebSocket from "ws";
 // Import the WORKTREE native build directly (not @sayknow-cli/natives, which can
 // resolve to a different checkout in this dev environment).
 import { NotificationControlServer } from "../../natives/native/index.js";
-import { parseLifecycleCommand } from "../src/notifications/lifecycle-commands";
-import { attachLifecycleControl, fileAudit, fileLedgerStore } from "../src/notifications/lifecycle-control-runtime";
-import type { OrchestratorDeps } from "../src/notifications/lifecycle-orchestrator";
+import { parseLifecycleCommand } from "../src/sdk/bus/lifecycle-commands";
+import { attachLifecycleControl, fileAudit, fileLedgerStore } from "../src/sdk/bus/lifecycle-control-runtime";
+import type { OrchestratorDeps } from "../src/sdk/bus/lifecycle-orchestrator";
 
 const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skc-g011-"));
 const token = crypto.randomBytes(32).toString("base64url");
@@ -30,6 +30,8 @@ const closed: string[] = [];
 function deps(): OrchestratorDeps {
 	return {
 		pairedChatId: "42",
+		auditRedactionKey: new Uint8Array(32).fill(11),
+		isPsmuxProvider: () => false,
 		now: () => Date.now(),
 		store: fileLedgerStore(path.join(tmp, "idempotency.json")),
 		audit: fileAudit(path.join(tmp, "audit.jsonl")),
@@ -47,8 +49,6 @@ function deps(): OrchestratorDeps {
 			return { processGone: true };
 		},
 		resumeSession: async () => ({ ambiguous: [] }),
-		newLifecycleRequestId: () => `lc-${crypto.randomUUID()}`,
-		newSessionId: () => `s${crypto.randomUUID().slice(0, 8)}`,
 	};
 }