noah-agent 0.1.0

package/dist/session.js

@@ -0,0 +1,113 @@
+/**
+ * NOAH session — wires the Pi SDK with NOAH's tools, safety, and explain-mode,
+ * and renders the experience through the NOAH UI panels.
+ */
+import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { safetyExtension } from "./safety/extension.js";
+import { packageTool } from "./tools/package.js";
+import { serviceTool } from "./tools/service.js";
+import { networkTool } from "./tools/network.js";
+import { systemTool } from "./tools/system.js";
+import { logsTool } from "./tools/logs.js";
+import { NOAH_SYSTEM_PROMPT } from "./prompt/system.js";
+import { buildRegistry } from "./llm/registry.js";
+import { resolveModel } from "./llm/resolve.js";
+import * as ui from "./ui/render.js";
+const out = (s) => process.stdout.write(s);
+/** Human-readable summary of a tool's arguments for the tool card. */
+function describeArgs(toolName, args) {
+    if (!args || typeof args !== "object")
+        return "";
+    const a = args;
+    if (typeof a.command === "string")
+        return a.command;
+    if (toolName === "package")
+        return `${a.action ?? ""} ${a.pkg ?? ""}`.trim();
+    if (toolName === "service")
+        return `${a.action ?? ""} ${a.name ?? ""}`.trim();
+    if (toolName === "network")
+        return `${a.action ?? ""} ${a.target ?? ""}`.trim();
+    if (typeof a.path === "string")
+        return String(a.path);
+    return JSON.stringify(a);
+}
+export async function runNoah(opts) {
+    if (opts.dryRun)
+        process.env.NOAH_DRY_RUN = "1";
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: process.cwd(),
+        agentDir: getAgentDir(),
+        // Replace Pi's "expert coding assistant" base with NOAH's OS-operator prompt.
+        systemPromptOverride: () => NOAH_SYSTEM_PROMPT,
+        // Don't auto-append the user's APPEND_SYSTEM.md — NOAH owns its prompt.
+        appendSystemPromptOverride: () => [],
+        extensionFactories: [safetyExtension({ dryRun: opts.dryRun, autoYes: opts.autoYes })],
+    });
+    await resourceLoader.reload();
+    // Layer 1 — provider abstraction: assemble the registry (local Ollama + cloud)
+    // and resolve which model this run uses.
+    const { authStorage, modelRegistry } = await buildRegistry();
+    const model = resolveModel(modelRegistry, {
+        flagModel: opts.model,
+        envModel: process.env.NOAH_MODEL,
+    });
+    const { session } = await createAgentSession({
+        resourceLoader,
+        // resolveModel returns a structural view; it is the registry's real Model.
+        model: model,
+        authStorage,
+        modelRegistry,
+        tools: ["read", "bash", "edit", "write", "grep", "find", "ls", "package", "service", "network", "system", "logs"],
+        customTools: [packageTool, serviceTool, networkTool, systemTool, logsTool],
+        sessionManager: SessionManager.create(process.cwd()),
+    });
+    // --- render state ---
+    let streaming = false; // currently streaming assistant text under the bar
+    const commands = new Map(); // toolCallId -> command summary
+    const endStream = () => {
+        if (streaming) {
+            out("\n");
+            streaming = false;
+        }
+    };
+    try {
+        out(ui.brand());
+        out(ui.note(`model: ${model.provider}/${model.id}`, "info") + "\n");
+        out(ui.requestPanel(opts.prompt) + "\n");
+        if (opts.dryRun)
+            out("\n" + ui.note("dry-run: NOAH will preview steps, not execute them.", "info") + "\n");
+        session.subscribe((event) => {
+            switch (event.type) {
+                case "message_update": {
+                    const e = event.assistantMessageEvent;
+                    if (e.type === "text_delta") {
+                        if (!streaming) {
+                            out(ui.responseHeader() + "\n" + ui.barPrefix());
+                            streaming = true;
+                        }
+                        out(e.delta.replace(/\n/g, "\n" + ui.barPrefix()));
+                    }
+                    break;
+                }
+                case "tool_execution_start": {
+                    endStream();
+                    const cmd = describeArgs(event.toolName, event.args);
+                    commands.set(event.toolCallId, cmd);
+                    out(ui.toolCard(event.toolName, cmd, "running") + "\n");
+                    break;
+                }
+                case "tool_execution_end": {
+                    const cmd = commands.get(event.toolCallId) ?? "";
+                    out(ui.auditLine(event.toolName, cmd, !event.isError) + "\n");
+                    break;
+                }
+            }
+        });
+        await session.prompt(opts.prompt);
+        endStream();
+        out(ui.divider() + "\n");
+    }
+    finally {
+        session.dispose();
+    }
+}

package/dist/sys/health.js

@@ -0,0 +1,51 @@
+/**
+ * Health assessment — deterministic severity rules over a telemetry snapshot.
+ * No LLM: fast, predictable, runs on launch for the dashboard and `/doctor`.
+ */
+import { humanBytes } from "./probe.js";
+import { realDisks, procLabel } from "./report.js";
+const RANK = { high: 0, medium: 1, low: 2 };
+export function assessHealth(snap) {
+    const items = [];
+    // Disk — worst real mount
+    const disks = realDisks(snap).length ? realDisks(snap) : snap.disks;
+    const worst = disks.slice().sort((a, b) => b.usedPct - a.usedPct)[0];
+    if (worst) {
+        if (worst.usedPct >= 90)
+            items.push({ severity: "high", title: "Disk nearly full", detail: `${worst.mount} at ${worst.usedPct}% (${humanBytes(worst.available)} free)` });
+        else if (worst.usedPct >= 80)
+            items.push({ severity: "medium", title: "Disk filling up", detail: `${worst.mount} at ${worst.usedPct}% (${humanBytes(worst.available)} free)` });
+    }
+    // Memory
+    if (snap.memory) {
+        const p = snap.memory.usedPct;
+        if (p >= 90)
+            items.push({ severity: "high", title: "Memory pressure", detail: `${p}% used` });
+        else if (p >= 80)
+            items.push({ severity: "medium", title: "Memory high", detail: `${p}% used` });
+    }
+    // Failed services
+    if (snap.failedServices.length) {
+        items.push({
+            severity: "high",
+            title: `${snap.failedServices.length} failed service${snap.failedServices.length > 1 ? "s" : ""}`,
+            detail: snap.failedServices.join(", "),
+        });
+    }
+    // Runaway CPU
+    const top = snap.topProcesses[0];
+    if (top && top.cpu >= 85) {
+        items.push({ severity: "low", title: "High CPU usage", detail: `${procLabel(top.command)} at ${top.cpu}%` });
+    }
+    // Updates
+    if (typeof snap.updates === "number" && snap.updates > 0) {
+        items.push({ severity: "low", title: `${snap.updates} update${snap.updates > 1 ? "s" : ""} available`, detail: "Run a system update to stay current" });
+    }
+    items.sort((a, b) => RANK[a.severity] - RANK[b.severity]);
+    const status = items.some((i) => i.severity === "high")
+        ? "critical"
+        : items.some((i) => i.severity === "medium")
+            ? "warn"
+            : "ok";
+    return { status, items };
+}

package/dist/sys/probe.js

@@ -0,0 +1,128 @@
+/**
+ * System telemetry probe — the machine-awareness foundation.
+ *
+ * Pure parsers (TDD'd against captured command output) + a thin, injectable
+ * collector. Every metric is independent and degrades to "unknown"/empty on
+ * failure, so a missing tool never crashes the snapshot.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+/* ------------------------------------------------------------------ parsers */
+/** Parse `df -k -P` (POSIX). Values are 1024-blocks → bytes. */
+export function parseDf(output) {
+    const out = [];
+    const lines = output.trim().split("\n").slice(1); // drop header
+    for (const line of lines) {
+        const t = line.trim().split(/\s+/);
+        if (t.length < 6)
+            continue;
+        const total = Number(t[1]);
+        const used = Number(t[2]);
+        const avail = Number(t[3]);
+        const pct = parseInt(t[4], 10);
+        if (!Number.isFinite(total) || !Number.isFinite(used))
+            continue;
+        out.push({
+            mount: t.slice(5).join(" "),
+            total: total * 1024,
+            used: used * 1024,
+            available: avail * 1024,
+            usedPct: Number.isFinite(pct) ? pct : 0,
+        });
+    }
+    return out;
+}
+/** Parse `ps -axo pid=,pcpu=,pmem=,comm=` → top N by cpu. */
+export function parseProcesses(output, topN = 5) {
+    const procs = [];
+    for (const line of output.trim().split("\n")) {
+        const m = line.trim().match(/^(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+)$/);
+        if (!m)
+            continue;
+        procs.push({ pid: Number(m[1]), cpu: Number(m[2]), mem: Number(m[3]), command: m[4].trim() });
+    }
+    return procs.sort((a, b) => b.cpu - a.cpu).slice(0, topN);
+}
+/** Parse Linux /proc/meminfo (uses MemAvailable). */
+export function parseMemLinux(meminfo) {
+    const kb = (key) => {
+        const m = meminfo.match(new RegExp(`^${key}:\\s+(\\d+)\\s*kB`, "m"));
+        return m ? Number(m[1]) * 1024 : 0;
+    };
+    const total = kb("MemTotal");
+    const available = kb("MemAvailable");
+    const used = total - available;
+    return { total, used, usedPct: total ? Math.round((used / total) * 100) : 0 };
+}
+/** Parse macOS `vm_stat` page counts → used = (active+wired+compressor)*pageSize. */
+export function parseMemMac(vmStat, pageSize, total) {
+    const pages = (label) => {
+        const m = vmStat.match(new RegExp(`${label}:\\s+(\\d+)`));
+        return m ? Number(m[1]) : 0;
+    };
+    const used = (pages("Pages active") + pages("Pages wired down") + pages("Pages occupied by compressor")) * pageSize;
+    return { total, used, usedPct: total ? Math.round((used / total) * 100) : 0 };
+}
+export function parseOsRelease(content) {
+    const m = content.match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+    return m ? m[1] : "Linux";
+}
+export function parseSwVers(content) {
+    const v = content.match(/ProductVersion:\s*([\d.]+)/);
+    return v ? `macOS ${v[1]}` : "macOS";
+}
+/** Parse `systemctl --failed` → failed unit names. */
+export function parseFailedServices(output) {
+    const out = [];
+    for (const line of output.split("\n")) {
+        const m = line.trim().match(/^([\w@.\\-]+\.service)\s+\S+\s+failed/);
+        if (m)
+            out.push(m[1]);
+    }
+    return out;
+}
+export function humanBytes(n) {
+    if (n <= 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB", "PB"];
+    const i = Math.min(units.length - 1, Math.floor(Math.log(n) / Math.log(1024)));
+    const v = n / 1024 ** i;
+    return `${i === 0 ? v : v.toFixed(1)} ${units[i]}`;
+}
+const realRun = async (cmd, args) => {
+    const { stdout } = await exec(cmd, args, { timeout: 8000 });
+    return stdout;
+};
+/** Best-effort, never-throw system snapshot. Each probe degrades independently. */
+export async function collectSnapshot(opts = {}) {
+    const platform = opts.platform ?? process.platform;
+    const run = opts.run ?? realRun;
+    const topN = opts.topN ?? 5;
+    const isMac = platform === "darwin";
+    const safe = async (fn, fallback) => {
+        try {
+            return await fn();
+        }
+        catch {
+            return fallback;
+        }
+    };
+    const os = await safe(async () => isMac
+        ? parseSwVers(await run("sw_vers", []))
+        : parseOsRelease(await run("cat", ["/etc/os-release"])), isMac ? "macOS" : "Linux");
+    const memory = await safe(async () => {
+        if (isMac) {
+            const total = Number((await run("sysctl", ["-n", "hw.memsize"])).trim());
+            const pageSize = Number((await run("sysctl", ["-n", "hw.pagesize"])).trim()) || 4096;
+            return parseMemMac(await run("vm_stat", []), pageSize, total);
+        }
+        return parseMemLinux(await run("cat", ["/proc/meminfo"]));
+    }, undefined);
+    const disks = await safe(async () => parseDf(await run("df", ["-k", "-P"])), []);
+    const topProcesses = await safe(async () => parseProcesses(await run("ps", ["-axo", "pid=,pcpu=,pmem=,comm="]), topN), []);
+    const failedServices = isMac
+        ? []
+        : await safe(async () => parseFailedServices(await run("systemctl", ["--failed", "--no-legend", "--plain"])), []);
+    return { os, memory, disks, topProcesses, failedServices };
+}

package/dist/sys/report.js

@@ -0,0 +1,55 @@
+/**
+ * Telemetry formatting — pure, plain-text renderers used by the `system` tool
+ * (LLM-facing) and the startup dashboard. No colors here; presentation layers
+ * add their own.
+ */
+import { humanBytes } from "./probe.js";
+/** Clean a process command path into a readable name. */
+export function procLabel(command) {
+    const base = command.trim().split("/").pop() ?? command;
+    return base.trim() || command;
+}
+/** Real (non-virtual) mounts worth reporting. */
+export function realDisks(snap) {
+    return snap.disks.filter((d) => d.mount === "/" || d.mount.startsWith("/Volumes") || d.mount.startsWith("/mnt") || d.mount.startsWith("/home"));
+}
+export function formatDisks(snap) {
+    const disks = realDisks(snap);
+    const list = disks.length ? disks : snap.disks;
+    return list.map((d) => `${d.mount}  ${d.usedPct}% used  (${humanBytes(d.used)} / ${humanBytes(d.total)}, ${humanBytes(d.available)} free)`);
+}
+export function formatProcesses(snap) {
+    return snap.topProcesses.map((p) => `${procLabel(p.command)}  cpu ${p.cpu}%  mem ${p.mem}%  (pid ${p.pid})`);
+}
+/** Full deterministic health report (no LLM) for `/doctor` and `noah doctor`. */
+export function formatDoctor(snap, health) {
+    const out = [`SYSTEM HEALTH — ${health.status.toUpperCase()}`, ""];
+    for (const l of formatSnapshot(snap))
+        out.push(l);
+    out.push("");
+    if (health.items.length) {
+        out.push("Recommendations (by priority):");
+        for (const it of health.items)
+            out.push(`  [${it.severity}] ${it.title} — ${it.detail}`);
+    }
+    else {
+        out.push("All clear — nothing needs attention.");
+    }
+    return out;
+}
+export function formatSnapshot(snap) {
+    const out = [`OS: ${snap.os}`];
+    if (snap.memory)
+        out.push(`Memory: ${snap.memory.usedPct}% used (${humanBytes(snap.memory.used)} / ${humanBytes(snap.memory.total)})`);
+    out.push("Disks:");
+    for (const l of formatDisks(snap))
+        out.push(`  ${l}`);
+    out.push("Top processes (by CPU):");
+    for (const l of formatProcesses(snap))
+        out.push(`  ${l}`);
+    if (snap.failedServices.length)
+        out.push(`Failed services: ${snap.failedServices.join(", ")}`);
+    if (typeof snap.updates === "number")
+        out.push(`Available updates: ${snap.updates}`);
+    return out;
+}

package/dist/tools/logs.js

@@ -0,0 +1,24 @@
+/**
+ * `logs` tool — read recent system logs (journalctl on Linux, `log show` on
+ * macOS) via the platform adapter. Read-only; the key to diagnosing failures.
+ */
+import { Type } from "typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { platform } from "../platform/adapter.js";
+export const logsTool = defineTool({
+    name: "logs",
+    label: "System logs",
+    description: "Read recent system logs (journalctl on Linux, unified log on macOS). " +
+        "Pass an optional unit/process name to filter (e.g. the failing service). " +
+        "Use this to find the root cause when a service or the system misbehaves.",
+    promptSnippet: "Read recent system logs (optionally for one unit/process)",
+    promptGuidelines: ["Use the logs tool to find root causes when a service or the system misbehaves"],
+    parameters: Type.Object({
+        unit: Type.Optional(Type.String({ description: "Service unit (Linux) or process name (macOS) to filter" })),
+    }),
+    execute: async (_id, params) => {
+        const { unit } = params;
+        const out = await platform.logs(unit);
+        return { content: [{ type: "text", text: out || "(no log output)" }], details: {} };
+    },
+});

package/dist/tools/network.js

@@ -0,0 +1,47 @@
+/**
+ * Abstract `network` tool — dispatches through the platform adapter.
+ *
+ * Read-only diagnostics (info/ports/connections/ping) plus a gated `fetch`
+ * (HTTP GET). `fetch` is the only mutating-risk action: the safety policy
+ * requires confirmation for it (data-exfiltration guard), and it is audited.
+ */
+import { Type } from "typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { platform } from "../platform/adapter.js";
+/** Actions that need a target (host or URL). */
+const NEEDS_TARGET = new Set(["ping", "fetch"]);
+export const networkTool = defineTool({
+    name: "network",
+    label: "Network",
+    description: "Inspect networking and make simple requests, cross-platform. Actions: " +
+        "info (interfaces/IPs), ports (listening sockets), connections (active TCP), " +
+        "ping <host> (connectivity), fetch <url> (HTTP GET). Prefer this over raw " +
+        "ifconfig/ip/ss/lsof/curl in bash: it is platform-native, safety-gated, and audited. " +
+        "fetch downloads from the network and always requires user confirmation.",
+    promptSnippet: "Inspect network (info/ports/connections/ping) and fetch URLs",
+    promptGuidelines: [
+        "Use the network tool, not raw ip/ifconfig/ss/lsof/curl in bash, for network tasks",
+    ],
+    parameters: Type.Object({
+        action: Type.Union([
+            Type.Literal("info"),
+            Type.Literal("ports"),
+            Type.Literal("connections"),
+            Type.Literal("ping"),
+            Type.Literal("fetch"),
+        ], { description: "What to do" }),
+        target: Type.Optional(Type.String({ description: "Host (for ping) or URL (for fetch); unused otherwise" })),
+    }),
+    execute: async (_id, params) => {
+        const { action, target } = params;
+        if (NEEDS_TARGET.has(action) && !target) {
+            const kind = action === "fetch" ? "url" : "host";
+            return {
+                content: [{ type: "text", text: `network ${action} needs a target ${kind}.` }],
+                details: {},
+            };
+        }
+        const out = await platform.net(action, target);
+        return { content: [{ type: "text", text: out || `${action} done` }], details: {} };
+    },
+});

package/dist/tools/package.js

@@ -0,0 +1,40 @@
+/**
+ * Abstract `package` tool — dispatches through the platform adapter.
+ * Same tool on macOS (brew) and Linux (apt/...). Cross-platform by design.
+ */
+import { Type } from "typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { platform } from "../platform/adapter.js";
+export const packageTool = defineTool({
+    name: "package",
+    label: "Package manager",
+    description: "Install, remove, or update OS packages via the platform-native package manager " +
+        "(apt/dnf/pacman/zypper on Linux, brew on macOS) \u2014 NOAH detects the right one. " +
+        "Always prefer this over running apt/brew/etc. in bash: it is cross-platform, is gated " +
+        "by the safety layer, and is recorded in the audit trail. `action` is install, remove, " +
+        "or update; `pkg` is the package name (omit pkg with update to upgrade everything). " +
+        "Returns the package manager's combined output.",
+    promptSnippet: "Install/remove/update OS packages (apt/dnf/pacman/zypper/brew)",
+    promptGuidelines: [
+        "Use the package tool, not apt/brew/dnf/pacman/zypper in bash, to manage software",
+    ],
+    parameters: Type.Object({
+        action: Type.Union([Type.Literal("install"), Type.Literal("remove"), Type.Literal("update")], {
+            description: "What to do",
+        }),
+        pkg: Type.Optional(Type.String({ description: "Package name (optional for update-all)" })),
+    }),
+    execute: async (_id, params) => {
+        const { action, pkg } = params;
+        if (process.env.NOAH_DRY_RUN === "1") {
+            return {
+                content: [
+                    { type: "text", text: `[DRY-RUN] would ${action} package "${pkg ?? "(all)"}" via ${platform.os}` },
+                ],
+                details: {},
+            };
+        }
+        const out = await platform.pkg(action, pkg);
+        return { content: [{ type: "text", text: out || `${action} ${pkg ?? ""} done` }], details: {} };
+    },
+});

package/dist/tools/service.js

@@ -0,0 +1,45 @@
+/**
+ * Abstract `service` tool — dispatches through the platform adapter.
+ * systemd (systemctl) on Linux, launchd (launchctl) on macOS.
+ */
+import { Type } from "typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { platform } from "../platform/adapter.js";
+export const serviceTool = defineTool({
+    name: "service",
+    label: "Service manager",
+    description: "Manage a system service via the platform-native init system (systemd `systemctl` on " +
+        "Linux, launchd `launchctl` on macOS) \u2014 NOAH picks the right backend. Prefer this over " +
+        "raw shell: it is cross-platform, safety-gated, and audited. `action` is start, stop, " +
+        "restart, status, enable, or disable; `name` is the systemd unit (Linux) or launchd label " +
+        "(macOS). Note: enable/disable are not supported on macOS launchd. Use status (read-only) " +
+        "to inspect a service before changing it.",
+    promptSnippet: "Start/stop/restart/enable/disable/status a service (systemd/launchd)",
+    promptGuidelines: [
+        "Use the service tool, not systemctl/launchctl in bash, to manage services",
+    ],
+    parameters: Type.Object({
+        action: Type.Union([
+            Type.Literal("start"),
+            Type.Literal("stop"),
+            Type.Literal("restart"),
+            Type.Literal("status"),
+            Type.Literal("enable"),
+            Type.Literal("disable"),
+        ], { description: "What to do with the service" }),
+        name: Type.String({ description: "Service/unit name (Linux) or launchd label (macOS)" }),
+    }),
+    execute: async (_id, params) => {
+        const { action, name } = params;
+        if (process.env.NOAH_DRY_RUN === "1") {
+            return {
+                content: [
+                    { type: "text", text: `[DRY-RUN] would ${action} service "${name}" via ${platform.os}` },
+                ],
+                details: {},
+            };
+        }
+        const out = await platform.service(name, action);
+        return { content: [{ type: "text", text: out || `${action} ${name} done` }], details: {} };
+    },
+});

package/dist/tools/system.js

@@ -0,0 +1,33 @@
+/**
+ * `system` tool — gives the agent eyes. Read-only machine telemetry so analysis
+ * ("why is it slow?", "free up space") is grounded in real data, not guesses.
+ */
+import { Type } from "typebox";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { collectSnapshot } from "../sys/probe.js";
+import { formatSnapshot, formatDisks, formatProcesses } from "../sys/report.js";
+export const systemTool = defineTool({
+    name: "system",
+    label: "System telemetry",
+    description: "Inspect the machine's live state (read-only): action 'info' = full snapshot " +
+        "(OS, memory, disks, top processes, failed services); 'disk' = filesystem usage; " +
+        "'processes' = top CPU consumers; 'health' = same as info. ALWAYS call this to " +
+        "understand the machine before recommending or performing system changes.",
+    promptSnippet: "Read live machine state (memory/disk/processes/services)",
+    promptGuidelines: [
+        "Before installing software or diagnosing problems, call the system tool to ground your analysis in real telemetry",
+    ],
+    parameters: Type.Object({
+        action: Type.Union([Type.Literal("info"), Type.Literal("disk"), Type.Literal("processes"), Type.Literal("health")], { description: "What to inspect" }),
+    }),
+    execute: async (_id, params) => {
+        const { action } = params;
+        const snap = await collectSnapshot();
+        const lines = action === "disk"
+            ? ["Disks:", ...formatDisks(snap).map((l) => `  ${l}`)]
+            : action === "processes"
+                ? ["Top processes (by CPU):", ...formatProcesses(snap).map((l) => `  ${l}`)]
+                : formatSnapshot(snap);
+        return { content: [{ type: "text", text: lines.join("\n") || "(no data)" }], details: {} };
+    },
+});

package/dist/tui/app.js

@@ -0,0 +1,104 @@
+/**
+ * NOAH interactive TUI — reuses Pi's full InteractiveMode for an exact pi.dev UX
+ * (streaming, tool cards, model cycling with Ctrl+P, footer, slash commands),
+ * wired to NOAH's provider registry, OS tools, system prompt, and safety gate.
+ *
+ * We build an AgentSessionRuntime via the services factory so /new, /resume,
+ * /fork all keep NOAH's customizations.
+ */
+import { fileURLToPath } from "node:url";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, InteractiveMode, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { buildRegistry } from "../llm/registry.js";
+import { resolveModel } from "../llm/resolve.js";
+import { safetyExtension } from "../safety/extension.js";
+import { packageTool } from "../tools/package.js";
+import { serviceTool } from "../tools/service.js";
+import { networkTool } from "../tools/network.js";
+import { systemTool } from "../tools/system.js";
+import { logsTool } from "../tools/logs.js";
+import { NOAH_SYSTEM_PROMPT } from "../prompt/system.js";
+import { noahBranding } from "./branding.js";
+/** The OS tool set NOAH exposes (Pi built-ins + NOAH abstract tools). */
+export const NOAH_TOOLS = [
+    "read",
+    "bash",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+    "package",
+    "service",
+    "network",
+    "system",
+    "logs",
+];
+const CUSTOM_TOOLS = [packageTool, serviceTool, networkTool, systemTool, logsTool];
+/** Shipped NOAH dark-blue theme (package-root /themes, resolves for src + dist). */
+const NOAH_THEME_PATH = fileURLToPath(new URL("../../themes/noah-dark-blue.json", import.meta.url));
+const NOAH_THEME_NAME = "noah-dark-blue";
+export async function runNoahInteractive(opts) {
+    if (opts.dryRun)
+        process.env.NOAH_DRY_RUN = "1";
+    // Suppress Pi's startup network checks ("New version 0.79.x / Run pi update"
+    // banner and changelog box) — those are Pi's, not NOAH's. Only disables startup
+    // niceties; LLM provider requests are unaffected.
+    if (!process.env.PI_OFFLINE)
+        process.env.PI_OFFLINE = "1";
+    if (!process.env.PI_SKIP_VERSION_CHECK)
+        process.env.PI_SKIP_VERSION_CHECK = "1";
+    // Build the provider registry ONCE (local Ollama + cloud) and reuse it across
+    // session switches so we don't re-probe Ollama on every /new.
+    const { authStorage, modelRegistry } = await buildRegistry();
+    const model = resolveModel(modelRegistry, {
+        flagModel: opts.model,
+        envModel: process.env.NOAH_MODEL,
+    });
+    // All ready models are cycleable with Ctrl+P.
+    const scopedModels = modelRegistry.getAvailable().map((m) => ({ model: m }));
+    const createRuntime = async ({ cwd, sessionManager, sessionStartEvent, }) => {
+        // Activate the NOAH theme in-memory (does not touch the user's settings.json).
+        const settingsManager = SettingsManager.create(cwd, getAgentDir());
+        await settingsManager.reload();
+        settingsManager.applyOverrides({ theme: NOAH_THEME_NAME });
+        const services = await createAgentSessionServices({
+            cwd,
+            authStorage,
+            modelRegistry,
+            settingsManager,
+            resourceLoaderOptions: {
+                additionalThemePaths: [NOAH_THEME_PATH],
+                // NOAH owns its prompt; replace Pi's coding-assistant base.
+                systemPromptOverride: () => NOAH_SYSTEM_PROMPT,
+                appendSystemPromptOverride: () => [],
+                // Safety gate + audit (unbypassable) and NOAH header/footer branding.
+                extensionFactories: [
+                    safetyExtension({ dryRun: opts.dryRun, autoYes: opts.autoYes }),
+                    noahBranding({ dryRun: opts.dryRun }),
+                ],
+            },
+        });
+        const created = await createAgentSessionFromServices({
+            services,
+            sessionManager,
+            sessionStartEvent,
+            // resolveModel returns a structural view; it is the registry's real Model.
+            model: model,
+            scopedModels,
+            tools: NOAH_TOOLS,
+            customTools: CUSTOM_TOOLS,
+        });
+        return { ...created, services, diagnostics: services.diagnostics };
+    };
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+        cwd: process.cwd(),
+        agentDir: getAgentDir(),
+        sessionManager: SessionManager.create(process.cwd()),
+    });
+    const mode = new InteractiveMode(runtime, {
+        initialMessage: opts.initialMessage,
+        modelFallbackMessage: runtime.modelFallbackMessage,
+    });
+    await mode.init();
+    await mode.run();
+}

package/dist/tui/branding.js

@@ -0,0 +1,14 @@
+import { HeaderComponent } from "./components/header.js";
+import { NoahFooterComponent } from "./components/noah-footer.js";
+export const noahBranding = (opts) => (pi) => {
+    const apply = (ctx) => {
+        if (!ctx.hasUI)
+            return;
+        ctx.ui.setTitle("NOAH");
+        ctx.ui.setHeader(() => new HeaderComponent());
+        ctx.ui.setFooter((tui, _theme, footerData) => new NoahFooterComponent(footerData, () => ctx.model?.id, { dryRun: opts.dryRun }, () => tui.requestRender()));
+    };
+    // session_start fires for the initial session and every /new, /resume, /fork,
+    // so branding survives session replacement.
+    pi.on("session_start", (_event, ctx) => apply(ctx));
+};