@sns-myagent/cli 0.2.0 → 0.3.0

package/src/async/task-runner.ts

@@ -0,0 +1,175 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Runner — background execution engine
+// ═══════════════════════════════════════════════════════════════════════════
+
+import type { AsyncTask, TaskExecutionResult, TaskRunnerOptions, NotifyCallback } from "./types";
+import { TaskStore, getTaskStore } from "./task-store";
+
+export type TaskExecutor = (task: AsyncTask) => Promise<TaskExecutionResult>;
+
+export class TaskRunner {
+  #store: TaskStore;
+  #running: Map<string, AbortController> = new Map();
+  #executors: Map<string, TaskExecutor> = new Map();
+  #notifyCallbacks: NotifyCallback[] = [];
+  #maxConcurrent: number;
+  #defaultTimeoutMs: number;
+  #pollTimer: ReturnType<typeof setInterval> | null = null;
+  #destroyed = false;
+
+  constructor(store: TaskStore, options: TaskRunnerOptions = {}) {
+    this.#store = store;
+    this.#maxConcurrent = options.maxConcurrent ?? 3;
+    this.#defaultTimeoutMs = options.defaultTimeoutMs ?? 5 * 60 * 1000; // 5 min default
+  }
+
+  /** Register an executor for a task type */
+  registerExecutor(taskType: string, executor: TaskExecutor): void {
+    this.#executors.set(taskType, executor);
+  }
+
+  /** Register notification callback */
+  onNotify(callback: NotifyCallback): void {
+    this.#notifyCallbacks.push(callback);
+  }
+
+  /** Start the polling loop */
+  start(pollIntervalMs = 5000): void {
+    if (this.#pollTimer) return;
+    this.#pollTimer = setInterval(() => this.#tick(), pollIntervalMs);
+  }
+
+  /** Stop polling */
+  stop(): void {
+    if (this.#pollTimer) {
+      clearInterval(this.#pollTimer);
+      this.#pollTimer = null;
+    }
+  }
+
+  /** Submit a task for background execution */
+  async submit(task: AsyncTask): Promise<void> {
+    if (this.#running.size >= this.#maxConcurrent) {
+      // Will be picked up by poll when a slot opens
+      return;
+    }
+    this.#executeTask(task);
+  }
+
+  /** Cancel a running task */
+  cancel(taskId: string): boolean {
+    const controller = this.#running.get(taskId);
+    if (controller) {
+      controller.abort();
+      this.#running.delete(taskId);
+      this.#store.updateStatus(taskId, "cancelled");
+      return true;
+    }
+    // Maybe it's still pending
+    const task = this.#store.getById(taskId);
+    if (task && task.status === "pending") {
+      this.#store.updateStatus(taskId, "cancelled");
+      return true;
+    }
+    return false;
+  }
+
+  /** Get running task count */
+  get runningCount(): number {
+    return this.#running.size;
+  }
+
+  /** Check if a task is currently running */
+  isRunning(taskId: string): boolean {
+    return this.#running.has(taskId);
+  }
+
+  /** Destroy the runner — cancel all running tasks */
+  destroy(): void {
+    this.#destroyed = true;
+    this.stop();
+    for (const [id, controller] of this.#running) {
+      controller.abort();
+      this.#store.updateStatus(id, "cancelled");
+    }
+    this.#running.clear();
+  }
+
+  // ─── Internal ──────────────────────────────────────────────────────────
+
+  async #tick(): Promise<void> {
+    if (this.#destroyed) return;
+    if (this.#running.size >= this.#maxConcurrent) return;
+
+    const pending = this.#store.listPending(this.#maxConcurrent - this.#running.size);
+    for (const task of pending) {
+      if (this.#running.size >= this.#maxConcurrent) break;
+      this.#executeTask(task);
+    }
+  }
+
+  async #executeTask(task: AsyncTask): Promise<void> {
+    if (this.#destroyed || this.#running.has(task.id)) return;
+
+    const executor = this.#executors.get(task.taskType);
+    if (!executor) {
+      this.#store.updateStatus(task.id, "failed", {
+        error: `No executor registered for task type: ${task.taskType}`,
+      });
+      this.#notify(task);
+      return;
+    }
+
+    const controller = new AbortController();
+    this.#running.set(task.id, controller);
+    this.#store.updateStatus(task.id, "running");
+
+    // Timeout
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, this.#defaultTimeoutMs);
+
+    try {
+      const result = await executor(task);
+      clearTimeout(timeout);
+
+      if (this.#destroyed) return;
+
+      if (result.success) {
+        this.#store.updateStatus(task.id, "completed", { result: result.result });
+      } else {
+        this.#store.updateStatus(task.id, "failed", { error: result.error ?? "Unknown error" });
+      }
+    } catch (err) {
+      clearTimeout(timeout);
+      if (this.#destroyed) return;
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.#store.updateStatus(task.id, "failed", { error: errorMsg });
+    } finally {
+      this.#running.delete(task.id);
+      // Refresh task from store for notification
+      const updated = this.#store.getById(task.id);
+      if (updated) this.#notify(updated);
+    }
+  }
+
+  async #notify(task: AsyncTask): Promise<void> {
+    for (const cb of this.#notifyCallbacks) {
+      try {
+        await cb(task, "cli");
+      } catch {
+        // Don't let notification errors bubble
+      }
+    }
+  }
+}
+
+/** Singleton accessor */
+let _instance: TaskRunner | null = null;
+
+export function getTaskRunner(store?: TaskStore, options?: TaskRunnerOptions): TaskRunner {
+  if (!_instance) {
+    _instance = new TaskRunner(store ?? getTaskStore(), options);
+  }
+  return _instance;
+}

package/src/async/task-store.ts

@@ -0,0 +1,170 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Store — SQLite persistence
+// Pattern: mirrors src/cron/cron-store.ts
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AsyncTask, AsyncTaskRow, TaskStatus, CreateTaskOptions } from "./types";
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS async_tasks (
+  id TEXT PRIMARY KEY,
+  status TEXT NOT NULL DEFAULT 'pending',
+  task_type TEXT NOT NULL DEFAULT 'prompt',
+  description TEXT NOT NULL,
+  result TEXT,
+  error TEXT,
+  created_at INTEGER NOT NULL,
+  started_at INTEGER,
+  completed_at INTEGER,
+  metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_async_tasks_status ON async_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_async_tasks_created ON async_tasks(created_at);
+`;
+
+function rowToTask(row: AsyncTaskRow): AsyncTask {
+  return {
+    id: row.id,
+    status: row.status as TaskStatus,
+    taskType: row.task_type as AsyncTask["taskType"],
+    description: row.description,
+    result: row.result,
+    error: row.error,
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+  };
+}
+
+export class TaskStore {
+  #db: Database;
+
+  constructor(dbPath: string) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.#db = new Database(dbPath);
+    this.#db.exec("PRAGMA journal_mode = WAL");
+    this.#db.exec("PRAGMA foreign_keys = ON");
+    this.#db.exec(SCHEMA_SQL);
+  }
+
+  create(opts: CreateTaskOptions): AsyncTask {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const taskType = opts.taskType ?? "prompt";
+
+    this.#db.run(
+      `INSERT INTO async_tasks (id, status, task_type, description, created_at, metadata)
+       VALUES (?, 'pending', ?, ?, ?, ?)`,
+      [id, taskType, opts.description, now, opts.metadata ? JSON.stringify(opts.metadata) : null],
+    );
+
+    return this.getById(id)!;
+  }
+
+  getById(id: string): AsyncTask | null {
+    const row = this.#db.query<AsyncTaskRow, [string]>(
+      "SELECT * FROM async_tasks WHERE id = ?",
+    ).get(id);
+    return row ? rowToTask(row) : null;
+  }
+
+  list(status?: TaskStatus, limit = 50): AsyncTask[] {
+    const rows = status
+      ? this.#db.query<AsyncTaskRow, [string, number]>(
+          "SELECT * FROM async_tasks WHERE status = ? ORDER BY created_at DESC LIMIT ?",
+        ).all(status, limit)
+      : this.#db.query<AsyncTaskRow, [number]>(
+          "SELECT * FROM async_tasks ORDER BY created_at DESC LIMIT ?",
+        ).all(limit);
+    return rows.map(rowToTask);
+  }
+
+  listPending(limit = 20): AsyncTask[] {
+    return this.list("pending", limit);
+  }
+
+  listRunning(): AsyncTask[] {
+    return this.list("running");
+  }
+
+  updateStatus(id: string, status: TaskStatus, extra?: { result?: string; error?: string }): boolean {
+    const now = Date.now();
+    let sql: string;
+    let params: (string | number | null)[];
+
+    switch (status) {
+      case "running":
+        sql = "UPDATE async_tasks SET status = ?, started_at = ? WHERE id = ?";
+        params = [status, now, id];
+        break;
+      case "completed":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ?, result = ? WHERE id = ?";
+        params = [status, now, extra?.result ?? null, id];
+        break;
+      case "failed":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ?, error = ? WHERE id = ?";
+        params = [status, now, extra?.error ?? null, id];
+        break;
+      case "cancelled":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ? WHERE id = ?";
+        params = [status, now, id];
+        break;
+      default:
+        sql = "UPDATE async_tasks SET status = ? WHERE id = ?";
+        params = [status, id];
+    }
+
+    const stmt = this.#db.prepare(sql);
+    const result = stmt.run(...params);
+    return result.changes > 0;
+  }
+
+  delete(id: string): boolean {
+    const result = this.#db.run("DELETE FROM async_tasks WHERE id = ?", [id]);
+    return result.changes > 0;
+  }
+
+  /** Clean up completed/failed tasks older than maxAgeMs */
+  cleanup(maxAgeMs: number = 7 * 24 * 60 * 60 * 1000): number {
+    const cutoff = Date.now() - maxAgeMs;
+    const result = this.#db.run(
+      "DELETE FROM async_tasks WHERE status IN ('completed', 'failed', 'cancelled') AND completed_at < ?",
+      [cutoff],
+    );
+    return result.changes;
+  }
+
+  count(): { total: number; pending: number; running: number; completed: number; failed: number } {
+    const row = this.#db
+      .prepare(
+        `SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+          SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running,
+          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+          SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed
+        FROM async_tasks`,
+      )
+      .get() as { total: number; pending: number; running: number; completed: number; failed: number } | null;
+    return row ?? { total: 0, pending: 0, running: 0, completed: 0, failed: 0 };
+  }
+
+  close(): void {
+    this.#db.close();
+  }
+}
+
+/** Singleton accessor */
+let _instance: TaskStore | null = null;
+
+export function getTaskStore(agentDir?: string): TaskStore {
+  if (!_instance) {
+    const dir = agentDir ?? `${process.env.HOME ?? "/tmp"}/.sns-myagent`;
+    _instance = new TaskStore(`${dir}/async/tasks.db`);
+  }
+  return _instance;
+}

package/src/async/types.ts

@@ -0,0 +1,70 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Workflow Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Task execution status */
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+
+/** Task action type */
+export type TaskActionType = "prompt" | "shell" | "skill";
+
+/** Task action — what to execute */
+export type TaskAction =
+  | { type: "prompt"; prompt: string }
+  | { type: "shell"; command: string }
+  | { type: "skill"; skillName: string; args?: string };
+
+/** Stored async task — domain model (camelCase) */
+export interface AsyncTask {
+  id: string;
+  status: TaskStatus;
+  taskType: TaskActionType;
+  description: string;
+  result: string | null;
+  error: string | null;
+  createdAt: number;
+  startedAt: number | null;
+  completedAt: number | null;
+  metadata: Record<string, unknown> | null;
+}
+
+/** Row shape coming out of SQLite (snake_case) */
+export interface AsyncTaskRow {
+  id: string;
+  status: string;
+  task_type: string;
+  description: string;
+  result: string | null;
+  error: string | null;
+  created_at: number;
+  started_at: number | null;
+  completed_at: number | null;
+  metadata: string | null;
+}
+
+/** Options for creating a new task */
+export interface CreateTaskOptions {
+  description: string;
+  taskType?: TaskActionType;
+  metadata?: Record<string, unknown>;
+}
+
+/** Task execution result */
+export interface TaskExecutionResult {
+  success: boolean;
+  result?: string;
+  error?: string;
+}
+
+/** Notification channel */
+export type NotifyChannel = "cli" | "telegram";
+
+/** Notification callback */
+export type NotifyCallback = (task: AsyncTask, channel: NotifyChannel) => void | Promise<void>;
+
+/** Task runner options */
+export interface TaskRunnerOptions {
+  maxConcurrent?: number;
+  defaultTimeoutMs?: number;
+  pollIntervalMs?: number;
+}

package/src/cli/entry.ts

@@ -13,9 +13,11 @@ const head = argv[0];
 
 // Auto-boot the Telegram polling adapter when a token is present and the
 // user is not explicitly running a different subcommand. Disable with
-// SNS_TELEGRAM_AUTOSTART=0.
+// SNS_TELEGRAM_AUTOSTART=0. Skip for "launch" which starts the full agent
+// session and will wire the adapter after the session is ready.
 function maybeAutostartTelegram(): void {
 	if (head === "telegram") return; // explicit start/stop handles its own lifecycle
+	if (head === "launch") return; // defer to runInteractiveMode in main.ts
 	if (process.env.SNS_TELEGRAM_AUTOSTART === "0") return;
 	const token = process.env.SNS_TELEGRAM_BOT_TOKEN;
 	if (!token) return;

package/src/cli/index.ts

@@ -15,6 +15,7 @@ import { loadConfig, saveConfig, configPath, ensureConfig } from "../config/load
 import type { Config } from "../config/schema.js";
 import { defaultConfigFn } from "../config/loader.js";
 import { startTelegramAdapter, stopTelegramAdapter } from "../adapters/telegram/index.js";
+import { createForwardToAgent, resetChatSession, getBridgeStats } from "../adapters/telegram/bridge.js";
 
 // ---------- package version (single source of truth) ----------
 
@@ -74,63 +75,19 @@ function cmdInit(): number {
 	}
 }
 
-function cmdChat(args: string[]): number {
-	const stub = args.includes("--stub");
-	process.stdout.write("snscoder chat — interactive mode\n");
-	if (stub) {
-		process.stdout.write("(stub mode: memory wiring arrives in Phase 2B)\n");
-	}
+async function cmdChat(_args: string[]): Promise<number> {
 	const cfg = loadConfig();
-	if (!cfg) {
-		process.stdout.write("! no config found, run `snscoder init` first\n");
-		process.stdout.write("  starting with in-memory defaults for this session\n");
-	} else {
-		process.stdout.write(`model: ${cfg.model.provider}/${cfg.model.model}\n`);
-		process.stdout.write("type 'exit' to quit\n");
-	}
-	// Readline-style loop using readline from Node built-ins.
-	return runReadlineLoop(cfg);
+	const { runEchoChat } = await import("../tui/chat-ui.js");
+	await runEchoChat({
+		model: cfg?.model.model,
+		provider: cfg?.model.provider,
+		version: PKG_VERSION,
+		agentName: cfg?.agentName ?? "SnsCoder",
+	});
+	return 0;
 }
 
-async function readLine(prompt: string): Promise<string> {
-	const { createInterface } = await import("node:readline/promises");
-	const { stdin, stdout } = await import("node:process");
-	const rl = createInterface({ input: stdin, output: stdout });
-	try {
-		const answer = await rl.question(prompt);
-		return answer;
-	} finally {
-		rl.close();
-	}
-}
 
-function runReadlineLoop(cfg: Config | null): number {
-	// Synchronous-ish loop using readline question/await via deasync-free path.
-	// Keep it simple: each turn re-creates the interface so SIGINT cleanly closes it.
-	const modelLabel = cfg ? `${cfg.model.provider}/${cfg.model.model}` : "defaults";
-	process.stdout.write(`[${modelLabel}] ready.\n`);
-	void (async () => {
-		while (true) {
-			let line: string;
-			try {
-				line = await readLine("you> ");
-			} catch {
-				process.stdout.write("\n");
-				break;
-			}
-			const trimmed = line.trim();
-			if (trimmed === "" || trimmed === "exit" || trimmed === "quit") {
-				process.stdout.write("bye.\n");
-				break;
-			}
-			process.stdout.write(`echo: ${trimmed}\n`);
-		}
-		// Explicit exit so the process actually terminates.
-		process.exit(0);
-	})();
-	// Return a non-zero so Node keeps the event loop alive until readline ends.
-	return 0;
-}
 
 function cmdConfigShow(cfg: Config): number {
 	process.stdout.write(JSON.stringify(cfg, null, 2) + "\n");
@@ -268,7 +225,19 @@ async function cmdTelegram(args: string[]): Promise<number> {
 			process.stderr.write(`✗ telegram start: ${probe.error}\n`);
 			return 1;
 		}
-		const bot = startTelegramAdapter(token, { autostart: true });
+
+		// Wire the agent bridge — per-chat sessions via createAgentSession()
+		const agentForwarder = createForwardToAgent();
+		// Adapt 3-arg bridge to 2-arg handler signature: (text, sessionKey) → string
+		const forwardToAgent = (text: string, sessionKey: string) =>
+			agentForwarder(sessionKey, "telegram", text);
+
+		const bot = startTelegramAdapter(token, {
+			autostart: true,
+			forwardToAgent,
+			resetChatSession,
+			getBridgeStats,
+		});
 		if (!bot) {
 			process.stderr.write("✗ autostart refused by adapter\n");
 			return 1;
@@ -366,10 +335,12 @@ Commands:
   version                     print package version
   init                        create .sns-myagent/config.json (defaults)
   chat [--stub]               start interactive chat (stub for Phase 2B)
+  launch                      start full agent interactive mode
   config show                 print current config
   config get <key>            read a dot-path value (e.g. model.provider)
   config set <key> <value>    update a dot-path value
   telegram start|stop|status  manage the Telegram polling adapter
+  orchestrate <prompt>        multi-agent ensemble run (Phase 5)
   help                        print this help
 `;
 
@@ -394,6 +365,10 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 			return cmdConfig(rest);
 		case "telegram":
 			return cmdTelegram(rest);
+		case "launch":
+			return cmdLaunch(rest);
+		case "orchestrate":
+			return cmdOrchestrate(rest);
 		default:
 			process.stderr.write(`✗ unknown command: ${cmd}\n`);
 			process.stderr.write(HELP);
@@ -401,6 +376,46 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 	}
 }
 
+async function cmdOrchestrate(args: string[]): Promise<number> {
+	if (args.length === 0) {
+		process.stderr.write("✗ orchestrate requires a prompt\n");
+		process.stderr.write("  usage: snscoder orchestrate <prompt>\n");
+		process.stderr.write("  flags:  --strategy consensus|critic|best_of_n\n");
+		process.stderr.write("          --agents role1,role2\n");
+		process.stderr.write("          --ensemble <name>   (from agents.yaml)\n");
+		return 1;
+	}
+	const prompt = args.join(" ");
+	const opts: Record<string, unknown> = {};
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (a === "--strategy") opts.strategy = args[++i];
+		else if (a === "--agents") opts.agents = (args[++i] ?? "").split(",").filter(Boolean);
+		else if (a === "--ensemble") opts.ensemble = args[++i];
+	}
+	void prompt; void opts; // parsed for future executor wiring (Task 5.1d)
+	try {
+		// CLI wrapper: no real LLM executor yet (Phase 5 stub).
+		// Until agent invocation is wired, surface a clear message instead of silently failing.
+		process.stderr.write(
+			"✗ orchestrate: agent executor not wired in CLI yet.\n" +
+				"  Phase 5 ships the orchestrator module; the CLI integration lands once\n" +
+				"  the LLM agent executor (src/agents/executor.ts) is implemented.\n" +
+				"  For now use the ensemble module directly: import { executeEnsemble } from \"../agents/ensemble.js\".\n",
+		);
+		return 2;
+	} catch (err) {
+		process.stderr.write(`✗ orchestrate failed: ${(err as Error).message}\n`);
+		return 1;
+	}
+}
+
+async function cmdLaunch(args: string[]): Promise<number> {
+	const { main } = await import("../main.js");
+	await main(args);
+	return 0;
+}
+
 export function runCli(argv: string[]): Promise<number> {
 	return runCliAsync(argv);
 }

package/src/config/index.ts

@@ -8,7 +8,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import {
 	type SnsConfig,
 	ensureConfigDir,

package/src/debug/index.ts

@@ -435,7 +435,7 @@ export class DebugSelectorComponent extends Container {
 		if (!suppressed) {
 			const sessionName = this.ctx.sessionManager.getSessionName();
 			const notification: TerminalNotification = {
-				title: sessionName || "Oh My Pi",
+				title: sessionName || "SnsCoder",
 				body: "Terminal protocol test",
 				type: "test",
 				actions: "focus",

package/src/modes/components/welcome.ts

@@ -453,15 +453,22 @@ export class WelcomeComponent implements Component {
 	}
 }
 
-export const PI_LOGO = ["▀██████████▀", " ╘██    ██  ", "  ██    ██  ", "  ██    ██  ", " ▄██▄  ▄██▄ "];
+export const PI_LOGO = [
+	"███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗",
+	"████╗  ██║██╔════╝╚██╗██╔╝██║   ██║██╔════╝",
+	"██╔██╗ ██║█████╗   ╚███╔╝ ██║   ██║███████╗",
+	"██║╚██╗██║██╔══╝   ██╔██╗ ██║   ██║╚════██║",
+	"██║ ╚████║███████╗██╔╝ ╚██╗╚██████╔╝███████║",
+	"╚═╝  ╚═══╝╚══════╝╚═╝   ╚═╝ ╚═════╝ ╚══════╝",
+];
 
 /** Multi-stop palette for the diagonal gradient. */
 const GRADIENT_STOPS: ReadonlyArray<readonly [number, number, number]> = [
-	[255, 92, 200], // hot pink
-	[200, 110, 255], // violet
-	[120, 130, 255], // periwinkle
-	[60, 200, 255], // bright cyan
-	[120, 255, 220], // mint
+	[0, 210, 255],    // #00d2ff — SNS cyan
+	[80, 150, 255],   // transitional blue
+	[123, 47, 247],   // #7b2ff7 — SNS purple
+	[200, 70, 180],   // transitional pink-purple
+	[255, 107, 157],  // #ff6b9d — SNS pink
 ];
 
 /** 256-color ramp fallback when truecolor isn't available. */

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

@@ -1182,7 +1182,7 @@ export class EventController {
 
 		const sessionName = this.ctx.sessionManager.getSessionName();
 		TERMINAL.sendNotification({
-			title: sessionName || "Oh My Pi",
+			title: sessionName || "SnsCoder",
 			body: "Complete",
 			type: "completion",
 			actions: "focus",

package/src/modes/setup-wizard/scenes/splash.ts

@@ -189,7 +189,7 @@ export function renderSetupSplash(width: number, height: number, elapsedMs: numb
 /** Centered fallback for windows too small to hold the full scene. */
 function renderCompactSplash(width: number, height: number, phase: number, shine: ShineConfig): string[] {
 	const art = height >= 14 ? LARGE_LOGO : PI_LOGO;
-	const content = [...gradientLogo(art, phase, shine), "", theme.bold("O h   M y   P i")];
+	const content = [...gradientLogo(art, phase, shine), "", theme.bold("S n s C o d e r")];
 	const start = Math.max(0, Math.floor((height - content.length) / 2));
 	const lines: string[] = [];
 	for (let y = 0; y < height; y++) {

package/src/session/agent-session.ts

@@ -1376,7 +1376,7 @@ export class AgentSession {
 		if (mode === "off") return;
 		try {
 			this.#powerAssertion = MacOSPowerAssertion.start({
-				reason: "Oh My Pi agent session",
+				reason: "SnsCoder agent session",
 				idle: true,
 				display: mode === "display" || mode === "system",
 				system: mode === "system",