muonroi-cli 1.8.5 → 1.9.0

package/dist/packages/agent-harness-core/src/event-filter.js

@@ -28,9 +28,20 @@ export const LIFECYCLE_PRESET = new Set([
     "askcard-cancel",
     "sprint-stage",
     "sprint-halt",
+    // Emitted at product-loop/index.ts on plan commit; a wake-at-milestone monitor
+    // must see it. Was previously dropped by this preset despite being emitted.
+    "sprint-plan-committed",
     "route-decision",
     "steer-inject",
     "usage",
+    // Ephemeral kinds carry a visualText snapshot for wake-at-milestone monitors
+    // (event-tee.ts EPHEMERAL_KINDS). The default preset must not drop them, or a
+    // monitor on MUONROI_HARNESS_EVENT_LOG misses errors/timeouts/disconnects.
+    "ee-timeout",
+    "ee-error",
+    "grounding-flag",
+    "stream-retry",
+    "disconnect",
 ]);
 /**
  * Returns a predicate that returns true when an event kind is allowed to emit.

package/dist/packages/agent-harness-core/src/event-redact.js

@@ -53,6 +53,13 @@ const ALLOWED_FIELDS = {
         status: "pass",
         round: "pass",
         correlationId: "pass",
+        // Liveness counters. Plain magnitudes (like elapsedMs / charCount above) —
+        // no prompt or response content — and without them a harness consumer
+        // cannot tell a slow reasoning call from a hung one, because `elapsedMs`
+        // alone freezes whenever the tick generator stops being pulled.
+        streamedChars: "pass",
+        lastDeltaAgeMs: "pass",
+        elapsedMs: "pass",
     },
     "council-turn-length": {
         role: "pass",

package/dist/packages/agent-harness-core/src/event-tee.d.ts

@@ -19,8 +19,11 @@
  * card) stay put, so the agent renders them fresh on demand; embedding a stale
  * snapshot for those would be worse, not better.
  *
- * Gated entirely behind MUONROI_HARNESS_EVENT_LOG — unset means zero behavior
- * change (clean checkouts are byte-identical to before this file existed).
+ * ON BY DEFAULT (see {@link resolveEventLogPath}): an opt-in sink is one nobody
+ * remembers to opt into, and the cost of the log missing is an agent that
+ * cannot tell "waiting for a human" from "hung" — the exact confusion this file
+ * exists to prevent. Set MUONROI_HARNESS_EVENT_LOG=0 (or "off"/"false") to
+ * disable, or to a path to choose your own.
  */
 import type { LiveEvent } from "./protocol.js";
 /**
@@ -37,8 +40,21 @@ export interface TeedEventLine {
     visualText?: string;
 }
 /**
- * Build an event-tee sink. Returns null when MUONROI_HARNESS_EVENT_LOG is unset
- * or blank (no-op path — caller skips it entirely).
+ * Resolve where events are teed, from the MUONROI_HARNESS_EVENT_LOG value.
+ *
+ * - unset/blank → a per-pid file in the OS temp dir (the default-on path)
+ * - "0" / "off" / "false" / "no" → null, sink disabled
+ * - anything else → that literal path
+ *
+ * Per-pid keeps concurrent harness servers from interleaving into one file, and
+ * puts the log where the OS already reclaims it — no rotation to maintain.
+ *
+ * @param pid - process id (injectable for tests).
+ */
+export declare function resolveEventLogPath(envValue?: string, pid?: number): string | null;
+/**
+ * Build an event-tee sink. Returns null only when the sink is explicitly
+ * disabled — see {@link resolveEventLogPath}.
  *
  * @param getVisualText - lazily renders the current visual frame to plain text
  *   (driver.render_visual). Called ONLY for ephemeral kinds, so persistent

package/dist/packages/agent-harness-core/src/event-tee.js

@@ -19,10 +19,15 @@
  * card) stay put, so the agent renders them fresh on demand; embedding a stale
  * snapshot for those would be worse, not better.
  *
- * Gated entirely behind MUONROI_HARNESS_EVENT_LOG — unset means zero behavior
- * change (clean checkouts are byte-identical to before this file existed).
+ * ON BY DEFAULT (see {@link resolveEventLogPath}): an opt-in sink is one nobody
+ * remembers to opt into, and the cost of the log missing is an agent that
+ * cannot tell "waiting for a human" from "hung" — the exact confusion this file
+ * exists to prevent. Set MUONROI_HARNESS_EVENT_LOG=0 (or "off"/"false") to
+ * disable, or to a path to choose your own.
  */
 import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 /**
  * Event kinds that flash and disappear before an agent can wake + render.
  * Only these carry an at-emit visual snapshot in the teed line.
@@ -35,9 +40,31 @@ export const EPHEMERAL_KINDS = new Set([
     "ee-error",
     "grounding-flag",
 ]);
+/** Values that turn the sink off. Anything else is treated as a path. */
+const DISABLE_VALUES = new Set(["0", "off", "false", "no"]);
 /**
- * Build an event-tee sink. Returns null when MUONROI_HARNESS_EVENT_LOG is unset
- * or blank (no-op path — caller skips it entirely).
+ * Resolve where events are teed, from the MUONROI_HARNESS_EVENT_LOG value.
+ *
+ * - unset/blank → a per-pid file in the OS temp dir (the default-on path)
+ * - "0" / "off" / "false" / "no" → null, sink disabled
+ * - anything else → that literal path
+ *
+ * Per-pid keeps concurrent harness servers from interleaving into one file, and
+ * puts the log where the OS already reclaims it — no rotation to maintain.
+ *
+ * @param pid - process id (injectable for tests).
+ */
+export function resolveEventLogPath(envValue, pid = process.pid) {
+    const raw = (envValue ?? "").trim();
+    if (DISABLE_VALUES.has(raw.toLowerCase()))
+        return null;
+    if (raw)
+        return raw;
+    return join(tmpdir(), `muonroi-harness-events-${pid}.jsonl`);
+}
+/**
+ * Build an event-tee sink. Returns null only when the sink is explicitly
+ * disabled — see {@link resolveEventLogPath}.
  *
  * @param getVisualText - lazily renders the current visual frame to plain text
  *   (driver.render_visual). Called ONLY for ephemeral kinds, so persistent
@@ -45,7 +72,7 @@ export const EPHEMERAL_KINDS = new Set([
  * @param envValue - value of MUONROI_HARNESS_EVENT_LOG (injectable for tests).
  */
 export function createEventTee(getVisualText, envValue) {
-    const path = (envValue ?? "").trim();
+    const path = resolveEventLogPath(envValue);
     if (!path)
         return null;
     return (event) => {

package/dist/packages/agent-harness-core/src/mcp-server.d.ts

@@ -47,6 +47,18 @@ export declare function validateStartArgs(args: string[]): {
     bad: string;
 };
 export declare function sanitizeEnv(env: Record<string, string>): Record<string, string>;
+/**
+ * Build the child TUI's environment for tui.start.
+ *
+ * Starts from the driver's own env so PATH/HOME survive, overlays the
+ * caller-supplied keys, THEN strips the dangerous ones. The merge-before-strip
+ * order keeps the security posture (NODE_OPTIONS/LD_PRELOAD/… still removed)
+ * while guaranteeing PATH is present: bun drops the fd 3/4 stdio channels when a
+ * child is spawned with a partial env that lacks PATH, which yields a null
+ * inWrite and crashes the whole driver on spawn. `base` defaults to process.env
+ * and is injectable for tests.
+ */
+export declare function buildChildEnv(callerEnv?: Record<string, string>, base?: Record<string, string | undefined>): Record<string, string>;
 /**
  * Opt-in extra cwd roots for tui.start, layered ON TOP of the default
  * {home, repo-root} allowlist. The posture stays deny-by-default: only roots an
@@ -73,6 +85,8 @@ export declare function validateMockLlmPath(value: string): boolean;
 export declare function buildCapabilitiesPayload(): {
     protocol: string;
     features: readonly string[];
+    /** Where LiveEvents are teed as JSONL, or null when the sink is disabled. */
+    eventLogPath: string | null;
 };
 export declare function registerReadTools(server: McpServer, getDriver: () => Driver | null): void;
 export declare function registerActionTools(server: McpServer, getDriver: () => Driver | null): void;

package/dist/packages/agent-harness-core/src/mcp-server.js

@@ -18,7 +18,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { createDriver } from "./driver.js";
-import { createEventTee } from "./event-tee.js";
+import { createEventTee, resolveEventLogPath } from "./event-tee.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
 const ARG_ALLOW = /^(--agent-[a-z-]+(=.*)?|--mock-llm(=.+)?|--profile=[a-zA-Z0-9_-]+)$/;
 const ENV_KEY_RE = /^[A-Z_][A-Z0-9_]{0,63}$/;
@@ -50,6 +50,25 @@ export function sanitizeEnv(env) {
     }
     return out;
 }
+/**
+ * Build the child TUI's environment for tui.start.
+ *
+ * Starts from the driver's own env so PATH/HOME survive, overlays the
+ * caller-supplied keys, THEN strips the dangerous ones. The merge-before-strip
+ * order keeps the security posture (NODE_OPTIONS/LD_PRELOAD/… still removed)
+ * while guaranteeing PATH is present: bun drops the fd 3/4 stdio channels when a
+ * child is spawned with a partial env that lacks PATH, which yields a null
+ * inWrite and crashes the whole driver on spawn. `base` defaults to process.env
+ * and is injectable for tests.
+ */
+export function buildChildEnv(callerEnv = {}, base = process.env) {
+    const merged = {};
+    for (const [k, v] of Object.entries(base)) {
+        if (v !== undefined)
+            merged[k] = v;
+    }
+    return sanitizeEnv({ ...merged, ...callerEnv });
+}
 const REPO_ROOT = process.cwd();
 /**
  * Opt-in extra cwd roots for tui.start, layered ON TOP of the default
@@ -147,11 +166,17 @@ const FEATURES = [
     "snapshot_visual",
     "cell",
     "visual_quality",
+    "wait_for_event",
+    "event_log",
 ];
 export function buildCapabilitiesPayload() {
     return {
         protocol: PROTOCOL_VERSION,
         features: FEATURES,
+        // A default-on sink nobody can locate is still opt-in. Reporting the
+        // resolved path here is what makes it discoverable without the caller
+        // reproducing the env/tmpdir/pid rule.
+        eventLogPath: resolveEventLogPath(process.env["MUONROI_HARNESS_EVENT_LOG"]),
     };
 }
 export function registerReadTools(server, getDriver) {
@@ -211,7 +236,13 @@ export function registerReadTools(server, getDriver) {
             return noDriver();
         return { content: [{ type: "text", text: String(d.count(selector)) }] };
     });
-    server.registerTool("tui.render_text", { description: "ASCII debug render of the current frame.", inputSchema: {} }, async () => {
+    server.registerTool("tui.render_text", {
+        // "debug render" undersold it: this is the primary way to see what is on
+        // screen right now — every node, modal and message in the semantic tree.
+        description: "See the current screen as a semantic tree (every node, modal, message, and focus state). " +
+            "Use tui.render_visual instead for the literal characters a human reads.",
+        inputSchema: {},
+    }, async () => {
         const d = getDriver();
         if (!d)
             return noDriver();
@@ -318,21 +349,53 @@ export function registerAsyncTools(server, getDriver, deps) {
     const waitConditionShape = {
         selector: z.string().max(500).optional(),
         idle: z.boolean().optional(),
+        event: z.string().max(64).optional(),
     };
+    /**
+     * Rebuild the driver's WaitArgs from validated MCP input.
+     *
+     * Built key-by-key rather than passed through, because the driver dispatches
+     * on `"selector" in args` BEFORE `"event" in args` — an explicitly-`undefined`
+     * `selector` key would still win that check and silently wait on nothing.
+     */
+    function toWaitArgs(c) {
+        if (typeof c.selector === "string")
+            return { selector: c.selector };
+        if (typeof c.event === "string")
+            return { event: c.event };
+        if (c.idle)
+            return { idle: true };
+        return {};
+    }
     server.registerTool("tui.wait_for", {
-        description: "Wait until a selector matches or the TUI is idle (or both for all=).",
+        description: "Block until a selector matches, a LiveEvent of the given kind arrives, or the TUI is idle " +
+            "(all= requires every condition). Prefer this over polling: the wait resolves on the driver's " +
+            "own event stream, so a modal pause (event='askcard-open') or a sprint halt wakes it immediately.",
         inputSchema: {
             selector: z.string().max(500).optional(),
             idle: z.boolean().optional(),
+            // The driver has always supported an `event` condition (buildCheck in
+            // driver.ts); only this MCP schema withheld it, so external agents fell
+            // back to polling a DB that never records askcard-open at all.
+            event: z.string().max(64).optional(),
             all: z.array(z.object(waitConditionShape)).max(10).optional(),
-            timeoutMs: z.number().int().min(0).max(60_000).optional(),
+            // 10 min, matching the longest legitimate single wait (a council debate
+            // phase measured 119.5s, and an unattended /ideal sprint runs longer).
+            // At 60s a caller had to re-issue the wait repeatedly — polling wearing
+            // a wait_for costume.
+            timeoutMs: z.number().int().min(0).max(600_000).optional(),
         },
     }, async (input) => {
         const d = getDriver();
         if (!d)
             return noDriver();
+        const args = input.all
+            ? { all: input.all.map(toWaitArgs) }
+            : toWaitArgs(input);
+        if (typeof input.timeoutMs === "number")
+            args.timeoutMs = input.timeoutMs;
         try {
-            await d.wait_for(input);
+            await d.wait_for(args);
             return { content: [{ type: "text", text: "ok" }] };
         }
         catch (e) {
@@ -355,7 +418,17 @@ export function registerAsyncTools(server, getDriver, deps) {
         return { content: [{ type: "text", text: String(ok) }] };
     });
     server.registerTool("tui.last_event", {
-        description: "Return the most recent event of the given kind (null if none).",
+        // Keyword-loaded on purpose: deferred-tool search matches this text, and
+        // the terse original ("Return the most recent event of the given kind")
+        // did not rank for "is the TUI waiting for input or hung" — the exact
+        // question it answers. An unfindable tool is an absent one.
+        description: "Check what a live run is doing: is it waiting on a human (kind='askcard-open' — the " +
+            "modal/prompt/approval question), what stage it reached (kind='sprint-stage'), did it " +
+            "fail or hang (kind='sprint-halt' / 'toast'), how the council progressed " +
+            "(kind='council-step'). Returns the most recent event of that kind with its FULL payload " +
+            "(null if none) — including the complete askcard question text, which tui.query truncates. " +
+            "Use this instead of polling a database or log file: modal pauses write no DB row, so a " +
+            "poller cannot tell 'waiting for a human' from 'hung'. Pair with tui.wait_for to block.",
         // Full protocol event set (minus the idle sentinel) so an external agent can
         // observe lifecycle events — council/sprint/route/askcard, not just toasts.
         // The Driver accepts any kind; this enum is the MCP-boundary validation.
@@ -473,7 +546,9 @@ export function createMcpHarnessServer({ spawn }) {
                 isError: true,
             };
         }
-        const sanitizedEnv = sanitizeEnv(input.env ?? {});
+        // See buildChildEnv: merge process.env (keeps PATH so bun allocates the
+        // fd 3/4 transport) with caller keys, then strip dangerous vars.
+        const sanitizedEnv = buildChildEnv(input.env ?? {});
         // Build final arg list.
         const finalArgs = [...input.args];
         if (input.mockLlmDir && !finalArgs.some((a) => a.startsWith("--mock-llm"))) {
@@ -509,9 +584,10 @@ export function createMcpHarnessServer({ spawn }) {
             sendKey: (k) => sendLine(JSON.stringify({ op: "press", key: k })),
             sendType: (t) => sendLine(JSON.stringify({ op: "type", text: t })),
         });
-        // Optional JSONL event sink for external milestone watchers (null unless
-        // MUONROI_HARNESS_EVENT_LOG is set). Ephemeral kinds carry an at-emit
-        // visual snapshot so flash events aren't lost before an agent wakes.
+        // JSONL event sink for external milestone watchers — on by default, null
+        // only when MUONROI_HARNESS_EVENT_LOG explicitly disables it. Ephemeral
+        // kinds carry an at-emit visual snapshot so flash events aren't lost
+        // before an agent wakes. Path is reported by tui.capabilities.
         const eventTee = createEventTee(() => driver.render_visual(), process.env["MUONROI_HARNESS_EVENT_LOG"]);
         // onLine already delivers complete newline-stripped lines — no extra
         // splitting required.

package/dist/packages/agent-harness-core/src/predicate.d.ts

@@ -2,8 +2,8 @@ import { z } from "zod";
 import type { UINode } from "./protocol.js";
 declare const FieldOp: z.ZodObject<{
     field: z.ZodEnum<{
-        name: "name";
         value: "value";
+        name: "name";
         state: "state";
     }>;
     op: z.ZodEnum<{

package/dist/packages/agent-harness-core/src/protocol.d.ts

@@ -131,12 +131,34 @@ export type LiveEvent = {
     kind: "council-speaker";
     /** The council role label (e.g. "architect", "security", "qa"). */
     role: string;
-    /** "start" — speaker began their turn; "done" — speaker finished. */
-    status: "start" | "done";
+    /**
+     * "start" — speaker began; "tick" — 1s progress heartbeat (long phases
+     * like research emit these with an advancing `elapsedMs`); "done" —
+     * speaker finished. A harness poller distinguishes ALIVE (tick with
+     * advancing elapsedMs) from HUNG (elapsedMs frozen) via `tui_last_event`.
+     */
+    status: "start" | "tick" | "done";
     /** Round number if available from the status chunk. */
     round?: number;
     /** Correlation ID linking this speaker event to the enclosing council run. */
     correlationId: string;
+    /** Milliseconds elapsed in this speaker's turn/phase; advances on ticks. */
+    elapsedMs?: number;
+    /**
+     * Chars (text + reasoning deltas) streamed since this phase began.
+     * `elapsedMs` can freeze on a HEALTHY call — its tick generator only
+     * advances when the consumer pulls, and a round awaiting its pairs via
+     * Promise.all does not pull. This counter is pushed from the token stream
+     * itself, so growth here proves liveness regardless of pumping.
+     */
+    streamedChars?: number;
+    /**
+     * Age in ms of the most recent stream delta. Small + growing
+     * `streamedChars` = SLOW BUT ALIVE (e.g. a reasoning model emitting
+     * reasoning tokens for minutes before any text); growing age + static
+     * chars = genuinely STUCK.
+     */
+    lastDeltaAgeMs?: number;
 } | {
     t: "event";
     kind: "council-turn-length";

package/dist/src/agent-harness/mock-model.d.ts

@@ -62,6 +62,16 @@ export interface MockModelFixture {
      *   <taskType>,<style>,<intent>,<deliverable>,<depth>,<scope>,<lang>,<clarity>
      */
     classify?: string;
+    /**
+     * Milliseconds to wait before each streamed chunk. Default 0 (instant).
+     *
+     * A real provider takes seconds; the mock is instant, which makes anything
+     * that only exists WHILE a call is in flight — a progress card, a spinner —
+     * impossible to observe from a spec. Set this to hold the in-flight state open
+     * long enough to assert on it. Keep it small: it is wall-clock in every spec
+     * that sets it.
+     */
+    chunkDelayMs?: number;
     /**
      * Opt in to the PIL-classifier intercept described on `classify`. When true,
      * a `doStream` call carrying the classifier's system prompt is answered with

package/dist/src/agent-harness/mock-model.js

@@ -85,6 +85,7 @@ export function createMockModel(fx) {
     // delivered to the classifier — intercepting would override their reply with
     // DEFAULT_CLASSIFY_LINE and make every classification collapse to "generate".
     const interceptClassify = fx.autoClassify === true || fx.classify !== undefined;
+    const chunkDelayMs = Math.max(0, fx.chunkDelayMs ?? 0);
     const model = new MockLanguageModelV3({
         provider,
         modelId,
@@ -116,8 +117,11 @@ export function createMockModel(fx) {
             return {
                 stream: simulateReadableStream({
                     chunks,
-                    initialDelayInMs: null,
-                    chunkDelayInMs: null,
+                    // Only the turn stream honours the delay — the classify intercept above
+                    // fires on EVERY turn, so pacing it would tax specs that just want a
+                    // slow answer.
+                    initialDelayInMs: chunkDelayMs || null,
+                    chunkDelayInMs: chunkDelayMs || null,
                 }),
             };
         },

package/dist/src/chat/chat-keychain.d.ts

@@ -1,26 +1,21 @@
 /**
  * src/chat/chat-keychain.ts
  *
- * Chat-service keychain loader with env-var fallback.
- * Parallel module to src/mcp/mcp-keychain.ts but keyed by ChatSecretId
- * (chat services like Discord, Slack) instead of MCP servers.
- *
- * Priority: OS keychain (keytar) > environment variable > null.
- * On CLI startup, hydrateChatEnvFromKeychain() populates process.env from
- * keychain for any chat secret not already set in env.
+ * Chat-service secret store, keyed by ChatSecretId (Discord, Slack). Backed by
+ * the env-store (`.env` file + process.env + Windows registry mirror) — the OS
+ * keychain (keytar) has been removed. Reads come straight from process.env.
  */
 export type ChatSecretId = "discord-token" | "discord-guild-id" | "slack-token" | "slack-team-id";
 export declare function setChatSecret(id: ChatSecretId, value: string): Promise<boolean>;
 export declare function getChatSecret(id: ChatSecretId): Promise<string | null>;
 export declare function deleteChatSecret(id: ChatSecretId): Promise<boolean>;
 /**
- * List all stored chat secret IDs.
- * Note: This only returns secrets stored in OS keychain, not those in env.
+ * List all stored chat secret IDs (those present in the environment).
  */
 export declare function listChatSecrets(): Promise<ChatSecretId[]>;
 /**
- * On CLI startup, populate process.env from keychain for any chat secret
- * not already set in env. Allows downstream code (chat/factory.ts) to
- * remain env-based without code changes.
+ * Retained for boot compatibility (index.ts). Chat secrets now live in the
+ * environment (loaded from the env-store at startup), so there is nothing to
+ * hydrate — this is a no-op.
  */
 export declare function hydrateChatEnvFromKeychain(): Promise<void>;

package/dist/src/chat/chat-keychain.js

@@ -1,22 +1,12 @@
 /**
  * src/chat/chat-keychain.ts
  *
- * Chat-service keychain loader with env-var fallback.
- * Parallel module to src/mcp/mcp-keychain.ts but keyed by ChatSecretId
- * (chat services like Discord, Slack) instead of MCP servers.
- *
- * Priority: OS keychain (keytar) > environment variable > null.
- * On CLI startup, hydrateChatEnvFromKeychain() populates process.env from
- * keychain for any chat secret not already set in env.
+ * Chat-service secret store, keyed by ChatSecretId (Discord, Slack). Backed by
+ * the env-store (`.env` file + process.env + Windows registry mirror) — the OS
+ * keychain (keytar) has been removed. Reads come straight from process.env.
  */
+import { clearEnvVar, persistEnvVar } from "../providers/env-store.js";
 import { redactor } from "../utils/redactor.js";
-const KEYCHAIN_SERVICE = "muonroi-cli";
-const ACCOUNT_BY_CHAT = {
-    "discord-token": "chat-discord-token",
-    "discord-guild-id": "chat-discord-guild-id",
-    "slack-token": "chat-slack-token",
-    "slack-team-id": "chat-slack-team-id",
-};
 const ENV_BY_CHAT = {
     "discord-token": "MUONROI_DISCORD_TOKEN",
     "discord-guild-id": "MUONROI_DISCORD_GUILD_ID",
@@ -24,107 +14,50 @@ const ENV_BY_CHAT = {
     "slack-team-id": "MUONROI_SLACK_TEAM_ID",
 };
 const MIN_LEN = 8; // guild IDs are short (18-19 digits); tokens ~70 chars. Use 8 as floor.
-async function loadKeytar() {
-    try {
-        return (await import("keytar"));
-    }
-    catch {
-        return null;
-    }
+function isTokenSecret(id) {
+    return id === "discord-token" || id === "slack-token";
 }
 export async function setChatSecret(id, value) {
     if (!value || value.length < MIN_LEN) {
         throw new Error(`Value for chat secret '${id}' is too short (< ${MIN_LEN} chars).`);
     }
-    const kt = await loadKeytar();
-    if (!kt?.setPassword)
-        return false;
-    // Enroll token values in redactor, but not IDs (they are not secrets)
-    if (id === "discord-token" || id === "slack-token") {
+    if (isTokenSecret(id))
         redactor.enrollSecret(value);
-    }
-    try {
-        await kt.setPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id], value);
-        return true;
-    }
-    catch (err) {
-        // Runtime backend failure (e.g. Linux without libsecret or no active secret service).
-        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
-            console.error(`[chat-keychain] setPassword backend error for ${id}:`, err?.message || err);
-        }
-        return false;
-    }
+    persistEnvVar(ENV_BY_CHAT[id], value);
+    return true;
 }
 export async function getChatSecret(id) {
-    const kt = await loadKeytar();
-    if (kt) {
-        try {
-            const v = await kt.getPassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
-            if (v && v.length >= MIN_LEN) {
-                // Enroll in redactor only for token values
-                if (id === "discord-token" || id === "slack-token") {
-                    redactor.enrollSecret(v);
-                }
-                return v;
-            }
-        }
-        catch {
-            /* keytar backend failure → fall through to env */
-        }
-    }
     const envKey = process.env[ENV_BY_CHAT[id]];
     if (envKey && envKey.length >= MIN_LEN) {
-        // Enroll in redactor only for token values
-        if (id === "discord-token" || id === "slack-token") {
+        if (isTokenSecret(id))
             redactor.enrollSecret(envKey);
-        }
         return envKey;
     }
     return null;
 }
 export async function deleteChatSecret(id) {
-    const kt = await loadKeytar();
-    if (!kt?.deletePassword)
-        return false;
-    try {
-        return await kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
-    }
-    catch (err) {
-        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
-            console.error(`[chat-keychain] deletePassword backend error for ${id}:`, err?.message || err);
-        }
-        return false;
-    }
+    const had = !!process.env[ENV_BY_CHAT[id]];
+    clearEnvVar(ENV_BY_CHAT[id]);
+    return had;
 }
 /**
- * List all stored chat secret IDs.
- * Note: This only returns secrets stored in OS keychain, not those in env.
+ * List all stored chat secret IDs (those present in the environment).
  */
 export async function listChatSecrets() {
     const ids = ["discord-token", "discord-guild-id", "slack-token", "slack-team-id"];
     const stored = [];
     for (const id of ids) {
-        const v = await getChatSecret(id);
-        if (v) {
+        if (await getChatSecret(id))
             stored.push(id);
-        }
     }
     return stored;
 }
 /**
- * On CLI startup, populate process.env from keychain for any chat secret
- * not already set in env. Allows downstream code (chat/factory.ts) to
- * remain env-based without code changes.
+ * Retained for boot compatibility (index.ts). Chat secrets now live in the
+ * environment (loaded from the env-store at startup), so there is nothing to
+ * hydrate — this is a no-op.
  */
 export async function hydrateChatEnvFromKeychain() {
-    const ids = ["discord-token", "discord-guild-id", "slack-token", "slack-team-id"];
-    for (const id of ids) {
-        const envName = ENV_BY_CHAT[id];
-        if (process.env[envName])
-            continue; // env wins
-        const v = await getChatSecret(id);
-        if (v)
-            process.env[envName] = v;
-    }
+    // Intentional no-op: env-store already populated process.env at startup.
 }
 //# sourceMappingURL=chat-keychain.js.map