@ouro.bot/cli 0.1.0-alpha.894 → 0.1.0-alpha.897

package/dist/repertoire/tools-cmux.js

@@ -1,396 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cmuxToolDefinitions = exports.cmuxCorrectToolDefinition = exports.cmuxReplyOnceToolDefinition = exports.cmuxSignalToolDefinition = exports.cmuxReadToolDefinition = exports.cmuxOverviewToolDefinition = exports.CMUX_STATUS_KEY = void 0;
-exports.cmuxToolsEnabled = cmuxToolsEnabled;
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const cmux_config_1 = require("../heart/cmux-config");
-const runtime_credentials_1 = require("../heart/runtime-credentials");
-const runtime_1 = require("../nerves/runtime");
-const attention_1 = require("../senses/cmux/attention");
-const answer_1 = require("../senses/cmux/answer");
-const casebook_1 = require("../senses/cmux/casebook");
-const client_1 = require("../senses/cmux/client");
-const principles_1 = require("../senses/cmux/principles");
-const redact_1 = require("../senses/cmux/redact");
-/**
- * The cmux sense's tools: who needs the human (`cmux_overview`), what a terminal shows
- * (`cmux_read`), and a one-line status or desktop notification for the human (`cmux_signal`).
- * They talk to cmux's control socket directly with this machine's cmux credential.
- */
-exports.CMUX_STATUS_KEY = "ouro";
-const STATUS_MAX_CHARS = 120;
-const READ_MAX_CHARS = 16_000;
-const REQUEST_PREVIEW_CHARS = 600;
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function text(value) {
-    return typeof value === "string" ? value : "";
-}
-function list(value) {
-    return Array.isArray(value) ? value.filter(isRecord) : [];
-}
-function cmuxToolsEnabled(agentRoot) {
-    if (!agentRoot)
-        return false;
-    try {
-        const config = JSON.parse(fs.readFileSync(path.join(agentRoot, "agent.json"), "utf-8"));
-        return config.senses?.cmux?.enabled === true;
-    }
-    catch {
-        return false;
-    }
-}
-function clientFor(ctx) {
-    if (!ctx?.agentName || !ctx.agentRoot)
-        return "the cmux tools need an agent runtime";
-    const machine = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(ctx.agentName);
-    const resolved = (0, cmux_config_1.resolveCmuxConnection)(ctx.agentName, machine.ok ? machine.config : {});
-    return resolved.ok ? (0, client_1.createCmuxClient)(resolved.connection, { agentName: ctx.agentName }) : resolved.error;
-}
-function workspacesFrom(tree) {
-    return list(tree.windows).flatMap((window) => list(window.workspaces)).map((workspace) => ({
-        id: text(workspace.id),
-        ref: text(workspace.ref),
-        title: text(workspace.title),
-        selected: workspace.selected === true,
-        surfaces: list(workspace.panes).flatMap((pane) => list(pane.surfaces)).map((surface) => ({
-            id: text(surface.id), ref: text(surface.ref), title: text(surface.title), type: text(surface.type),
-        })),
-    }));
-}
-async function readTree(client) {
-    return workspacesFrom(await client.call("system.tree", { all_windows: true }));
-}
-function failure(tool, error) {
-    const message = error.message;
-    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "repertoire", event: "repertoire.cmux_tool_error", message: "cmux tool call failed", meta: { tool, error: message } });
-    return JSON.stringify({ error: message });
-}
-async function overview(ctx) {
-    const client = clientFor(ctx);
-    if (typeof client === "string")
-        return JSON.stringify({ error: client });
-    const state = (0, attention_1.readCmuxState)(path.join(ctx.agentRoot, "state", "senses", "cmux", "state.json"), new Date().toISOString());
-    try {
-        const workspaces = await readTree(client);
-        const pending = (0, attention_1.pendingFeedItems)(await client.call("feed.list", { pending_only: true }));
-        const refFor = (surfaceId) => {
-            for (const workspace of workspaces) {
-                const surface = workspace.surfaces.find((entry) => entry.id === surfaceId);
-                if (surface)
-                    return { workspace: workspace.ref, surface: surface.ref };
-            }
-            return { workspace: null, surface: null };
-        };
-        (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.cmux_overview", message: "read cmux overview", meta: { workspaces: workspaces.length, waiting: pending.length } });
-        return JSON.stringify({
-            sense: { connected: state.connected, lastError: state.lastError, cmuxVersion: state.cmuxVersion },
-            principles: (0, principles_1.readCmuxPrinciples)(ctx.agentRoot),
-            waitingOnHuman: pending.map((item) => {
-                const where = refFor((0, attention_1.surfaceForSession)(state, item.workstreamId)?.surfaceId);
-                return {
-                    requestId: item.requestId,
-                    kind: item.kind,
-                    agent: item.source,
-                    tool: item.toolName,
-                    cwd: item.cwd,
-                    createdAt: item.createdAt,
-                    workspace: where.workspace,
-                    surface: where.surface,
-                    request: item.toolInput ? (0, redact_1.redactSecrets)(item.toolInput).slice(0, REQUEST_PREVIEW_CHARS) : null,
-                    requestTruncated: item.toolInputTruncated || (item.toolInput?.length ?? 0) > REQUEST_PREVIEW_CHARS,
-                };
-            }),
-            workspaces: workspaces.map((workspace) => ({
-                ref: workspace.ref,
-                title: workspace.title,
-                selected: workspace.selected,
-                surfaces: workspace.surfaces.map((surface) => {
-                    const activity = state.surfaces[surface.id];
-                    return {
-                        ref: surface.ref,
-                        title: surface.title,
-                        type: surface.type,
-                        ...(activity ? { agent: activity.agent, lifecycle: activity.lifecycle, lastHook: activity.lastHook, lastTool: activity.lastTool, lastActivityAt: activity.at, cwd: activity.cwd } : {}),
-                    };
-                }),
-            })),
-        });
-    }
-    catch (error) {
-        return failure("cmux_overview", error);
-    }
-}
-exports.cmuxOverviewToolDefinition = {
-    tool: {
-        type: "function",
-        function: {
-            name: "cmux_overview",
-            description: "Who needs the human, across every coding agent running in cmux on this Mac. Returns the decisions cmux is holding open (permission requests, questions, plan approvals: which agent, tool, folder, terminal, and a redacted preview of the request), and every workspace and terminal with what its agent was last doing (working, idle = finished its turn and waiting for a prompt, waiting = blocked on the human, ended). Read-only.",
-            parameters: { type: "object", properties: {}, additionalProperties: false },
-        },
-    },
-    handler: (_args, ctx) => overview(ctx),
-    summaryKeys: [],
-    riskProfile: { mutates: "none", risk: "low" },
-};
-function boundedLines(value) {
-    const parsed = typeof value === "number" ? value : Number.parseInt(text(value), 10);
-    return Number.isFinite(parsed) ? Math.min(400, Math.max(1, Math.trunc(parsed))) : 60;
-}
-exports.cmuxReadToolDefinition = {
-    tool: {
-        type: "function",
-        function: {
-            name: "cmux_read",
-            description: "Read the text on one cmux terminal (what a coding agent session shows now, or with scrollback what it did recently). Secret-shaped strings are redacted and the text is bounded. Read-only. Take the surface ref (for example surface:12) from cmux_overview.",
-            parameters: {
-                type: "object",
-                properties: {
-                    surface: { type: "string", description: "Surface ref (surface:12) or id from cmux_overview." },
-                    lines: { type: "number", description: "How many lines, 1-400. Default 60." },
-                    scrollback: { type: "boolean", description: "Include scrollback above the visible screen." },
-                },
-                required: ["surface"],
-                additionalProperties: false,
-            },
-        },
-    },
-    handler: async (args, ctx) => {
-        const surface = text(args.surface).trim();
-        if (!surface)
-            return JSON.stringify({ error: "name a surface ref or id from cmux_overview" });
-        const client = clientFor(ctx);
-        if (typeof client === "string")
-            return JSON.stringify({ error: client });
-        try {
-            const scrollback = args.scrollback === true || args.scrollback === "true";
-            const result = await client.call("surface.read_text", { surface_id: surface, lines: boundedLines(args.lines), scrollback });
-            const screen = (0, redact_1.redactSecrets)(text(result.text));
-            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.cmux_read", message: "read cmux terminal text", meta: { chars: screen.length, scrollback } });
-            return JSON.stringify({
-                surface: text(result.surface_ref) || surface,
-                workspace: text(result.workspace_ref) || null,
-                text: screen.length > READ_MAX_CHARS ? screen.slice(-READ_MAX_CHARS) : screen,
-                truncated: screen.length > READ_MAX_CHARS,
-            });
-        }
-        catch (error) {
-            return failure("cmux_read", error);
-        }
-    },
-    summaryKeys: ["surface"],
-    riskProfile: { mutates: "none", risk: "low" },
-};
-/** A v1 socket argument: quoted, with the characters cmux's tokenizer treats as special escaped. */
-function socketQuote(value) {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
-}
-exports.cmuxSignalToolDefinition = {
-    tool: {
-        type: "function",
-        function: {
-            name: "cmux_signal",
-            description: `Tell the human something through cmux on this Mac. status sets this agent's one-line status pill on a workspace's sidebar entry (at most ${STATUS_MAX_CHARS} characters; an empty string clears it). notify_title with notify_body posts a desktop notification tied to that workspace. Give at least one. It changes only what cmux shows; it never types into a terminal or answers an agent.`,
-            parameters: {
-                type: "object",
-                properties: {
-                    workspace: { type: "string", description: "Workspace ref (workspace:3) or id from cmux_overview." },
-                    status: { type: "string", description: "One line for the sidebar status, or an empty string to clear it." },
-                    notify_title: { type: "string", description: "Desktop notification title." },
-                    notify_body: { type: "string", description: "Desktop notification body." },
-                },
-                required: ["workspace"],
-                additionalProperties: false,
-            },
-        },
-    },
-    handler: async (args, ctx) => {
-        const target = text(args.workspace).trim();
-        const status = typeof args.status === "string" ? args.status.trim() : null;
-        const title = text(args.notify_title).trim();
-        if (!target)
-            return JSON.stringify({ error: "name a workspace ref or id from cmux_overview" });
-        if (status === null && !title)
-            return JSON.stringify({ error: "give a status, a notify_title, or both" });
-        if (status !== null && (status.length > STATUS_MAX_CHARS || /[\r\n]/.test(status)))
-            return JSON.stringify({ error: `status must be one line of at most ${STATUS_MAX_CHARS} characters` });
-        const client = clientFor(ctx);
-        if (typeof client === "string")
-            return JSON.stringify({ error: client });
-        try {
-            const workspace = (await readTree(client)).find((entry) => entry.ref === target || entry.id === target);
-            if (!workspace)
-                return JSON.stringify({ error: `no cmux workspace ${target}; see cmux_overview` });
-            const done = [];
-            if (status !== null) {
-                await client.command(status
-                    ? `set_status ${exports.CMUX_STATUS_KEY} ${socketQuote(status)} --tab=${workspace.id}`
-                    : `clear_status ${exports.CMUX_STATUS_KEY} --tab=${workspace.id}`);
-                done.push(status ? "status set" : "status cleared");
-            }
-            if (title) {
-                await client.call("notification.create", { title, subtitle: "", body: text(args.notify_body), workspace_id: workspace.id });
-                done.push("notification sent");
-            }
-            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.cmux_signal", message: "signalled the human through cmux", meta: { done } });
-            return JSON.stringify({ workspace: workspace.ref, done });
-        }
-        catch (error) {
-            return failure("cmux_signal", error);
-        }
-    },
-    summaryKeys: ["workspace", "status", "notify_title"],
-    riskProfile: { mutates: "external_side_effect", risk: "high", reason: "changes what cmux shows the human (sidebar status or a desktop notification)" },
-};
-function answerContext(ctx, client) {
-    const stateDir = (0, answer_1.cmuxStateDir)(ctx.agentRoot);
-    return { agentRoot: ctx.agentRoot, stateDir, client, now: Date.now, cmuxVersion: () => (0, attention_1.readCmuxState)(path.join(stateDir, "state.json"), new Date().toISOString()).cmuxVersion };
-}
-exports.cmuxReplyOnceToolDefinition = {
-    tool: {
-        type: "function",
-        function: {
-            name: "cmux_reply_once",
-            description: "Record your judgment that a coding agent's pending permission request is routine and fine to allow once. Your judgment alone never sends anything: the reply goes out only when the code floor, the human's exact precedent and a standing owner grant all allow it, and then only as 'once'. Otherwise your judgment is logged in shadow for the human to review and the request stays with them. Questions, plan approvals, Codex and Copilot requests always stay with the human.",
-            parameters: {
-                type: "object",
-                properties: {
-                    request_id: { type: "string", description: "The Feed request id from the escalation or cmux_overview." },
-                    reasoning: { type: "string", description: "Why this is routine under the cmux principles, in one or two sentences." },
-                },
-                required: ["request_id", "reasoning"],
-                additionalProperties: false,
-            },
-        },
-    },
-    handler: async (args, ctx) => {
-        const requestId = text(args.request_id).trim();
-        const reasoning = text(args.reasoning).trim();
-        if (!requestId || !reasoning)
-            return JSON.stringify({ error: "give the request_id and your reasoning" });
-        const client = clientFor(ctx);
-        if (typeof client === "string")
-            return JSON.stringify({ error: client });
-        try {
-            const item = (0, attention_1.pendingFeedItems)(await client.call("feed.list", { pending_only: true })).find((entry) => entry.requestId === requestId);
-            if (!item)
-                return JSON.stringify({ error: `request ${requestId} is no longer pending` });
-            const answers = answerContext(ctx, client);
-            const judgment = (0, answer_1.judgeFeedItem)(answers, item);
-            if (judgment.reply) {
-                const outcome = await (0, answer_1.answerOnce)(answers, item, judgment);
-                return JSON.stringify({ sent: outcome === "replied_once", outcome, authority: judgment.authority, ...(outcome === "replied_once" || outcome === "race" ? {} : { next: "The request stays with the human; tell them with cmux_signal if it is urgent." }) });
-            }
-            (0, answer_1.recordDecision)(answers, item, judgment, "shadow", `agent would allow once: ${reasoning}`);
-            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.cmux_shadow_judgment", message: "logged the agent's would-be cmux answer in shadow", meta: { tool: item.toolName } });
-            return JSON.stringify({ sent: false, outcome: "shadow", reason: judgment.reason, next: "The request stays with the human; tell them with cmux_signal if it is urgent." });
-        }
-        catch (error) {
-            return failure("cmux_reply_once", error);
-        }
-    },
-    summaryKeys: ["request_id"],
-    riskProfile: { mutates: "external_side_effect", risk: "high", reason: "may answer a coding agent's permission request once when the floor, a precedent and a standing grant allow it" },
-};
-exports.cmuxCorrectToolDefinition = {
-    tool: {
-        type: "function",
-        function: {
-            name: "cmux_correct",
-            description: "Record the human's answer or correction for a coding-agent request the cmux sense judged, as an exact precedent on this machine. 'once' means the human is fine with exactly this request being allowed once next time, and is accepted only when cmux shows the human allowed that request themselves; 'ask' means always ask them about exactly this request. Use it only for what the human actually said, in conversation with them; it is refused in autonomous turns and while handling an external event. A precedent never overrides the code floor, and live replies still need a standing owner grant.",
-            parameters: {
-                type: "object",
-                properties: {
-                    request_id: { type: "string", description: "The Feed request id the human answered or corrected." },
-                    verdict: { type: "string", enum: ["once", "ask"], description: "once: fine to allow once next time. ask: always ask." },
-                    note: { type: "string", description: "What the human said, briefly." },
-                },
-                required: ["request_id", "verdict", "note"],
-                additionalProperties: false,
-            },
-        },
-    },
-    handler: async (args, ctx) => {
-        const requestId = text(args.request_id).trim();
-        const verdict = args.verdict;
-        if (!requestId || (verdict !== "once" && verdict !== "ask"))
-            return JSON.stringify({ error: "give the request_id and a verdict of once or ask" });
-        if (!ctx?.agentRoot)
-            return JSON.stringify({ error: "the cmux tools need an agent runtime" });
-        if (ctx.currentExternalEvent || ctx.autonomousTurnKind)
-            return JSON.stringify({ error: "cmux_correct records what the human said in conversation; it cannot run in an autonomous turn or while handling an external event" });
-        const stateDir = (0, answer_1.cmuxStateDir)(ctx.agentRoot);
-        const decisions = (0, casebook_1.readDecisions)((0, casebook_1.cmuxDecisionLogPath)(stateDir)).filter((entry) => entry.requestId === requestId);
-        const decision = [...decisions].reverse().find((entry) => entry.shape);
-        if (!decision)
-            return JSON.stringify({ error: `no judged request ${requestId} with a precedent shape; the floor escalates it unconditionally or it was never seen` });
-        const shape = decision.shape;
-        if (!(0, casebook_1.isShape)(shape))
-            return JSON.stringify({ error: `the logged shape for ${requestId} is from an older format and cannot become a precedent; record it again after the sense judges the request anew` });
-        if (verdict === "once") {
-            // A "once" precedent turns into live authority later, so it must rest on the human's own answer in cmux, not on ours.
-            if (decisions.some((entry) => entry.outcome === "reply_sent" || entry.outcome === "replied_once"))
-                return JSON.stringify({ error: `the sense itself replied to ${requestId}; only a request the human answered can become a once precedent` });
-            const client = clientFor(ctx);
-            if (typeof client === "string")
-                return JSON.stringify({ error: client });
-            try {
-                const status = await (0, answer_1.feedItemStatus)(client, requestId);
-                if (status?.status !== "resolved" || status.kind !== "permission" || !status.mode || status.mode === "deny") {
-                    return JSON.stringify({ error: `cmux does not show the human allowing ${requestId} (${status ? `${status.status}${status.mode ? `, ${status.mode}` : ""}` : "not listed"}); record 'ask' instead, or wait until they answer it in cmux` });
-                }
-            }
-            catch (error) {
-                return failure("cmux_correct", error);
-            }
-        }
-        let entry;
-        try {
-            entry = (0, casebook_1.addCase)((0, casebook_1.cmuxCasebookPath)(stateDir), { verdict, shape, requestId, note: text(args.note), at: new Date().toISOString() });
-        }
-        catch (error) {
-            return failure("cmux_correct", error);
-        }
-        (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.cmux_correct", message: "recorded the human's cmux precedent", meta: { verdict } });
-        return JSON.stringify({ case: entry.id, verdict, tool: entry.shape.tool, repoRoot: entry.shape.repoRoot });
-    },
-    summaryKeys: ["request_id", "verdict"],
-    riskProfile: { mutates: "durable_state_write", risk: "high", reason: "records a precedent that later decides whether a coding agent's request is answered" },
-};
-exports.cmuxToolDefinitions = [exports.cmuxOverviewToolDefinition, exports.cmuxReadToolDefinition, exports.cmuxSignalToolDefinition, exports.cmuxReplyOnceToolDefinition, exports.cmuxCorrectToolDefinition];

package/dist/senses/cmux/answer.js

@@ -1,191 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CMUX_MIN_ANSWER_VERSION = exports.CMUX_GRANT_ACTION = exports.CMUX_GRANT_KEY = void 0;
-exports.cmuxStateDir = cmuxStateDir;
-exports.judgeFeedItem = judgeFeedItem;
-exports.recordDecision = recordDecision;
-exports.feedItemStatus = feedItemStatus;
-exports.answerOnce = answerOnce;
-const path = __importStar(require("node:path"));
-const steward_policy_1 = require("../../heart/steward-policy");
-const runtime_1 = require("../../nerves/runtime");
-const attention_1 = require("./attention");
-const casebook_1 = require("./casebook");
-const floor_1 = require("./floor");
-/**
- * Whether the sense may answer a pending Feed permission request itself, and the reply path that
- * sends only `once`. A reply needs all of: the floor (allow, or soft with the human's exact
- * precedent), no "ask me" precedent, cmux 0.65.0 or later, and a standing owner grant for the
- * repository under its count cap. Anything else escalates to the human.
- */
-exports.CMUX_GRANT_KEY = "cmux-feed-once";
-exports.CMUX_GRANT_ACTION = "cmux.feed.once";
-exports.CMUX_MIN_ANSWER_VERSION = "0.65.0";
-/** The only reply mode this code can send. `always`, `all` and `bypass` would widen the coding agent's permissions. */
-const REPLY_MODE = "once";
-function cmuxStateDir(agentRoot) {
-    return path.join(agentRoot, "state", "senses", "cmux");
-}
-function inspectGrant(ctx, repoRoot) {
-    const nowMs = ctx.now();
-    const grant = (0, steward_policy_1.inspectStandingActionGrant)(ctx.agentRoot, {
-        key: exports.CMUX_GRANT_KEY,
-        action: exports.CMUX_GRANT_ACTION,
-        target: repoRoot,
-        now: new Date(nowMs).toISOString(),
-        usesInWindow: (windowMs) => (0, casebook_1.repliesInWindow)((0, casebook_1.readDecisionLog)((0, casebook_1.cmuxDecisionLogPath)(ctx.stateDir)), windowMs, nowMs),
-    });
-    // The decision log keeps reply records for REPLY_HISTORY_MS, so it cannot count a longer window.
-    if (grant.allowed && grant.windowMs > casebook_1.REPLY_HISTORY_MS)
-        return { allowed: false, reason: "the standing grant's window is longer than the 31 days of replies the sense keeps" };
-    return grant;
-}
-function judgeFeedItem(ctx, item) {
-    const floor = (0, floor_1.evaluateFloor)({ kind: item.kind, source: item.source, toolName: item.toolName, toolInput: item.toolInput, toolInputTruncated: item.toolInputTruncated, cwd: item.cwd }, ctx.fsx);
-    if (floor.verdict === "hard")
-        return { reply: false, floor, shape: null, precedent: null, reason: `floor: ${floor.reason}` };
-    const shape = floor.shape;
-    const precedent = (0, casebook_1.findPrecedent)((0, casebook_1.readCasebook)((0, casebook_1.cmuxCasebookPath)(ctx.stateDir)), shape);
-    if (precedent?.verdict === "ask")
-        return { reply: false, floor, shape, precedent, reason: "the human asked to be asked about this exact request" };
-    if (floor.verdict === "soft" && precedent?.verdict !== "once")
-        return { reply: false, floor, shape, precedent, reason: `floor: ${floor.reason}, and the human has not answered this exact request before` };
-    const basis = floor.verdict === "allow" ? `floor: ${floor.reason}` : `precedent ${precedent.id}`;
-    const version = ctx.cmuxVersion();
-    if (!(0, attention_1.cmuxVersionAtLeast)(version, exports.CMUX_MIN_ANSWER_VERSION)) {
-        return { reply: false, floor, shape, precedent, reason: `would answer once (${basis}), but cmux ${version ?? "of unknown version"} is older than ${exports.CMUX_MIN_ANSWER_VERSION}` };
-    }
-    const grant = inspectGrant(ctx, shape.repoRoot);
-    if (!grant.allowed)
-        return { reply: false, floor, shape, precedent, reason: `would answer once (${basis}), but ${grant.reason}` };
-    return { reply: true, floor, shape, precedent, authority: `standing grant v${grant.grantVersion} (${grant.maxCount} per ${Math.round(grant.windowMs / 60_000)} min); ${basis}` };
-}
-function recordDecision(ctx, item, judgment, outcome, detail) {
-    (0, casebook_1.appendDecision)((0, casebook_1.cmuxDecisionLogPath)(ctx.stateDir), {
-        at: new Date(ctx.now()).toISOString(),
-        requestId: item.requestId,
-        source: item.source,
-        tool: item.toolName,
-        cwd: item.cwd,
-        outcome,
-        floor: { verdict: judgment.floor.verdict, reason: judgment.floor.reason },
-        shape: judgment.shape ? (0, casebook_1.storeShape)(judgment.shape) : null,
-        precedent: judgment.precedent ? { id: judgment.precedent.id, verdict: judgment.precedent.verdict } : null,
-        authority: judgment.reply ? judgment.authority : "none",
-        detail,
-    });
-}
-/** A Feed item's current status and decision, from the unfiltered `feed.list`, or null when cmux no longer lists it. */
-async function feedItemStatus(client, requestId) {
-    const result = await client.call("feed.list", {});
-    const items = Array.isArray(result.items) ? result.items : [];
-    const item = items.find((entry) => entry && entry.request_id === requestId);
-    if (!item)
-        return null;
-    const decision = item.decision && typeof item.decision === "object" ? item.decision : {};
-    return {
-        status: typeof item.status === "string" ? item.status : "unknown",
-        mode: typeof decision.mode === "string" ? decision.mode : null,
-        kind: typeof decision.kind === "string" ? decision.kind : null,
-    };
-}
-/**
- * Re-checks that the exact request is still pending, re-checks the grant and records `reply_sent`
- * under the decision log's lock, sends `once`, then reads the item back. cmux reports a reply as
- * delivered even when the waiter is gone, so only a `resolved` item with a `once` permission
- * decision counts as `replied_once`; an item resolved some other way is a race (the human answered).
- * A failed reply call, an item still pending or expired, or one cmux no longer lists is `unconfirmed`,
- * and the caller escalates it.
- */
-async function answerOnce(ctx, item, judgment) {
-    let current;
-    try {
-        current = (0, attention_1.pendingFeedItems)(await ctx.client.call("feed.list", { pending_only: true })).find((entry) => entry.requestId === item.requestId);
-    }
-    catch (error) {
-        recordDecision(ctx, item, judgment, "reply_failed", `could not re-check the request: ${error.message}`);
-        return "not_sent";
-    }
-    if (!current) {
-        recordDecision(ctx, item, judgment, "race", "the request was answered or withdrawn before the reply");
-        return "race";
-    }
-    if (current.toolName !== item.toolName || current.toolInput !== item.toolInput || current.cwd !== item.cwd || current.toolInputTruncated !== item.toolInputTruncated) {
-        recordDecision(ctx, item, judgment, "reply_failed", "the pending request changed after it was judged");
-        return "not_sent";
-    }
-    const reserved = (0, casebook_1.withDecisionLock)(ctx.stateDir, () => {
-        if ((0, casebook_1.readDecisions)((0, casebook_1.cmuxDecisionLogPath)(ctx.stateDir)).some((entry) => entry.requestId === item.requestId && entry.outcome === "reply_sent"))
-            return "the sense already sent a reply for this request";
-        const grant = inspectGrant(ctx, judgment.shape.repoRoot);
-        if (!grant.allowed)
-            return grant.reason;
-        recordDecision(ctx, item, judgment, "reply_sent", judgment.authority);
-        return null;
-    });
-    if (reserved !== null) {
-        recordDecision(ctx, item, judgment, "reply_failed", reserved);
-        return "not_sent";
-    }
-    try {
-        await ctx.client.call("feed.permission.reply", { request_id: item.requestId, mode: REPLY_MODE });
-    }
-    catch (error) {
-        // The call can fail after cmux applied the reply, so its fate is unknown and the human decides.
-        recordDecision(ctx, item, judgment, "reply_failed", `the reply call failed, so the reply may or may not have gone out: ${error.message}`);
-        return "unconfirmed";
-    }
-    let after;
-    try {
-        after = await feedItemStatus(ctx.client, item.requestId);
-    }
-    catch (error) {
-        recordDecision(ctx, item, judgment, "reply_failed", `could not confirm the reply: ${error.message}`);
-        return "unconfirmed";
-    }
-    if (after?.status === "resolved" && after.kind === "permission" && after.mode === REPLY_MODE) {
-        recordDecision(ctx, item, judgment, "replied_once", judgment.authority);
-        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_replied_once", message: "answered a coding agent's permission request once", meta: { requestId: item.requestId, tool: item.toolName } });
-        return "replied_once";
-    }
-    if (after === null || after.status !== "resolved") {
-        recordDecision(ctx, item, judgment, "reply_failed", after ? `the request is ${after.status} after the reply` : "cmux no longer lists the request");
-        return "unconfirmed";
-    }
-    recordDecision(ctx, item, judgment, "race", `after the reply the request was ${after.status}${after.mode ? ` (${after.mode})` : ""}`);
-    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_reply_race", message: "a cmux Feed request was resolved by someone else", meta: { requestId: item.requestId, status: after.status } });
-    return "race";
-}