@mnemom/mnemom 0.17.34 → 0.17.36

package/dist/index.js

@@ -1147,6 +1147,64 @@ function takeParentOption(cmd, key) {
     gate(agentSessionsCmd.command("unlock <name>", { hidden }))
         .description("EXPERIMENTAL (durable): unlock a locked session back to tracked (device step)")
         .action((name) => exitWith("`mnemom agent sessions unlock`", () => unlockCommand(name, liveVerbDeps())));
+    // S1 amendment 60 (signed off by Wassim 2026-11-02): the inbox door and its sender allowlist.
+    gate(agentSessionsCmd.command("send <name> [text]", { hidden }))
+        .description("EXPERIMENTAL (durable): send a message to a locked session's inbox; the host daemon gives it to the session as its next prompt (text, or - / nothing for stdin)")
+        .option("--idempotency-key <key>", "Retry-safe key (default: a new one per send)")
+        .option("--sender-key-env <VAR>", "Send as an allowlisted agent: the environment variable holding that agent's key")
+        .option("--conversation <cid>", "The session's conversation id (with --sender-key-env)")
+        .option("--agent-id <id>", "The session's agent id (with --sender-key-env)")
+        .option("--json", "Output the answer as JSON")
+        .action(async (name, text, o, cmd) => {
+        const json = cmd.optsWithGlobals().json === true;
+        const { sendCommand } = await import("./commands/durable-inbox.js");
+        const { liveInboxDeps } = await import("./lib/durable/live.js");
+        return exitWith("`mnemom agent sessions send`", () => sendCommand(name, text, { ...o, json }, liveInboxDeps()));
+    });
+    const sendersCmd = gate(agentSessionsCmd.command("senders", { hidden })).description("EXPERIMENTAL (durable): the agents allowed to send to a session's agent's inbox (list | add | remove)");
+    for (const verb of ["list", "add", "remove"]) {
+        const c = sendersCmd
+            .command(verb === "list" ? "list <name>" : `${verb} <name> <agent>`)
+            .description(verb === "list"
+            ? "List the agents that may send to this session's agent"
+            : verb === "add"
+                ? "Allow one of your agents (name or id) to send to this session's agent"
+                : "Stop an agent sending to this session's agent");
+        if (verb === "add")
+            c.option("--label <label>", "A note shown in the list");
+        c.option("--json", "Output the answer as JSON");
+        c.action(async (name, ...rest) => {
+            const agent = verb === "list" ? undefined : rest[0];
+            const cmd = rest[rest.length - 1];
+            const all = cmd.optsWithGlobals();
+            const { sendersCommand } = await import("./commands/durable-inbox.js");
+            const { liveInboxDeps } = await import("./lib/durable/live.js");
+            return exitWith(`\`mnemom agent sessions senders ${verb}\``, () => sendersCommand(verb, name, agent, { label: all.label, json: all.json }, liveInboxDeps()));
+        });
+    }
+    // S1 amendment 61 (signed off by Wassim 2026-11-02): a locked session's questions to its owner.
+    gate(agentSessionsCmd.command("questions <name>", { hidden }))
+        .description("EXPERIMENTAL (durable): a locked session's questions to you (open ones; --all for every one)")
+        .option("--all", "Include answered, dismissed and expired questions")
+        .option("--json", "Output the answer as JSON")
+        .action(async (name, _o, cmd) => {
+        // `agent sessions` takes --all and --json too, so commander may hand either to it.
+        const g = cmd.optsWithGlobals();
+        const json = g.json === true;
+        const { questionsCommand } = await import("./commands/durable-questions.js");
+        const { liveQuestionDeps } = await import("./lib/durable/live.js");
+        return exitWith("`mnemom agent sessions questions`", () => questionsCommand(name, { all: g.all, json }, liveQuestionDeps()));
+    });
+    gate(agentSessionsCmd.command("answer <name> <qid> [choices...]", { hidden }))
+        .description("EXPERIMENTAL (durable): answer a session's question (<qid> or latest); one choice per question: an option number, a label, or free text")
+        .option("--dismiss", "Dismiss the question without answering it")
+        .option("--json", "Output the answer as JSON")
+        .action(async (name, qid, choices, o, cmd) => {
+        const json = cmd.optsWithGlobals().json === true;
+        const { answerCommand } = await import("./commands/durable-questions.js");
+        const { liveQuestionDeps } = await import("./lib/durable/live.js");
+        return exitWith("`mnemom agent sessions answer`", () => answerCommand(name, qid, choices ?? [], { dismiss: o.dismiss, json }, liveQuestionDeps()));
+    });
     if (hidden)
         agentSessionsCmd.usage(sessionsUsage);
 }
@@ -2326,10 +2384,10 @@ program
 program
     .command("scan")
     .description("Read-only local scan of GitHub PR metadata; the report is emailed to you every time (counts only, no repo names) and Mnemom keeps nothing at share level none")
-    .option("--repo <owner/name...>", "Repo to scan (repeatable or comma-separated)")
+    .option("--repo <owner/name...>", "Repo to scan (repeatable or comma-separated; omit on a terminal to pick from your repos)")
     .option("--start <YYYY-MM-DD>", "Period start (default: today)")
     .option("--end <YYYY-MM-DD>", "Period end (default: today)")
-    .option("--share <level>", "summary | full | none (default: ask)")
+    .option("--share <level>", "summary | full | none (default: full when asked; none when not interactive)")
     .option("--cto-email <email>", "CTO who receives the report (required unless you are the CTO; asked when omitted)")
     .option("--monthly-spend <usd>", "Your own approximate monthly AI spend (self-reported; never sent or saved; needs MNEMOM_ORG_SCAN_MODE=true)")
     .option("--anthropic-admin-key", "Ask (masked) for your Anthropic admin key and read measured usage with it, locally; or set ANTHROPIC_ADMIN_KEY. Never stored, logged or sent anywhere but api.anthropic.com (needs MNEMOM_ORG_SCAN_MODE=true)")
@@ -2337,7 +2395,8 @@ program
     .option("--org <org_id>", "Your org id; the report is emailed to you for this org (default: your only organization, else the scan stops and asks). Also selects the Record totals preview (needs MNEMOM_ORG_SCAN_MODE=true)")
     .action(async (options) => {
     try {
-        const repos = parseRepoFlags(options.repo);
+        // Omitted --repo is allowed here: scanCommand picks from your repos on a terminal, else stops with a hint.
+        const repos = options.repo === undefined ? [] : parseRepoFlags(options.repo);
         if (!repos)
             throw new Error("--repo owner/name is required (repeatable)");
         const today = new Date().toISOString().slice(0, 10);

package/dist/lib/api.d.ts

@@ -215,11 +215,14 @@ export declare class MnemomApiError extends Error {
     readonly conflictAgentId?: string;
     /** Top-level enforce-hook sibling (present only on a spec-rewritten body). */
     readonly specDeviation?: SpecDeviation;
+    /** The server's `Retry-After` in ms (delta-seconds or HTTP-date form), when it sent a valid one. */
+    readonly retryAfterMs?: number;
     constructor(status: number, message: string, opts?: {
         code?: string;
         details?: unknown;
         conflictAgentId?: string;
         specDeviation?: SpecDeviation;
+        retryAfterMs?: number;
     });
 }
 /**
@@ -229,6 +232,8 @@ export declare class MnemomApiError extends Error {
  * reflects the true intended status behind any synthetic-500 rewrite.
  */
 export declare function readApiError(response: Response, fallback: string): Promise<MnemomApiError>;
+/** `Retry-After` header to ms: delta-seconds or an HTTP-date. Anything else is undefined. */
+export declare function parseRetryAfterMs(value: string | null | undefined, nowMs: number): number | undefined;
 export declare function postApi<T>(endpoint: string, body: unknown, opts?: {
     idempotencyKey?: string;
 }): Promise<T>;

package/dist/lib/api.js

@@ -85,9 +85,12 @@ export class MnemomApiError extends Error {
     conflictAgentId;
     /** Top-level enforce-hook sibling (present only on a spec-rewritten body). */
     specDeviation;
+    /** The server's `Retry-After` in ms (delta-seconds or HTTP-date form), when it sent a valid one. */
+    retryAfterMs;
     constructor(status, message, opts = {}) {
         super(message);
         this.name = "MnemomApiError";
+        this.retryAfterMs = opts.retryAfterMs;
         this.status = status;
         this.code = opts.code;
         this.details = opts.details;
@@ -110,8 +113,21 @@ export async function readApiError(response, fallback) {
         details: parsed.details,
         conflictAgentId: parsed.conflict_agent_id,
         specDeviation: parsed.spec_deviation,
+        retryAfterMs: parseRetryAfterMs(response.headers?.get("retry-after"), Date.now()),
     });
 }
+/** `Retry-After` header to ms: delta-seconds or an HTTP-date. Anything else is undefined. */
+export function parseRetryAfterMs(value, nowMs) {
+    if (!value)
+        return undefined;
+    const v = value.trim();
+    if (/^\d{1,9}$/.test(v))
+        return Number(v) * 1000;
+    if (!/[A-Za-z]/.test(v))
+        return undefined; // an HTTP-date names its day and month
+    const at = Date.parse(v);
+    return Number.isNaN(at) ? undefined : Math.max(0, at - nowMs);
+}
 export async function postApi(endpoint, body, opts = {}) {
     const url = validateUrl(`${API_BASE}${endpoint}`);
     const headers = {

package/dist/lib/config.d.ts

@@ -42,6 +42,13 @@ export declare function setRing(ring: CellRing | undefined): void;
 export declare function getRing(): CellRing | undefined;
 /** Override the active API base for this process (clears on undefined/empty). */
 export declare function setApiUrlOverride(url: string | undefined): void;
+/**
+ * True when the API is not production but the gateway is the production one. A lease key minted
+ * by a non-production cell's API means nothing to the production gateway, which answers every
+ * model call 401 and still receives the key (door2-path run 41783208169), so `agent run` refuses
+ * this pairing. A base that does not parse decides nothing. Pure.
+ */
+export declare function gatewayRingMismatch(apiUrl: string, gatewayUrl: string): boolean;
 export declare function getApiUrl(): string;
 export declare function getGatewayUrl(): string;
 export declare function getWebsiteUrl(): string;

package/dist/lib/config.js

@@ -113,6 +113,27 @@ function ringUrls() {
     const ring = getRing();
     return ring ? RING_URLS[ring] : undefined;
 }
+function originOf(url) {
+    try {
+        return new URL(url).origin.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * True when the API is not production but the gateway is the production one. A lease key minted
+ * by a non-production cell's API means nothing to the production gateway, which answers every
+ * model call 401 and still receives the key (door2-path run 41783208169), so `agent run` refuses
+ * this pairing. A base that does not parse decides nothing. Pure.
+ */
+export function gatewayRingMismatch(apiUrl, gatewayUrl) {
+    const api = originOf(apiUrl);
+    const gateway = originOf(gatewayUrl);
+    if (api === null || gateway === null)
+        return false;
+    return api !== originOf(API_URLS.production) && gateway === originOf(GATEWAY_URLS.production);
+}
 export function getApiUrl() {
     return (apiUrlOverride ?? envBase("MNEMOM_API_URL") ?? ringUrls()?.api ?? API_URLS[getEnvironment()]);
 }

package/dist/lib/durable/api.d.ts

@@ -108,6 +108,17 @@ export declare class DurableApi {
     createSession(cid: string, agentId: string, body: Record<string, unknown>): Promise<ApiAnswer>;
     /** An owner session verb (S1 ROUTES.own_*). */
     ownerVerb(route: RouteName, cid: string, agentId: string, body?: unknown): Promise<ApiAnswer>;
+    /**
+     * An S1 amendment 60 inbox route on a session (own_inbox_send, own_inbox_list, own_inbox_senders,
+     * own_inbox_sender_add, own_inbox_sender_remove), with the route's own method. `credential`
+     * sends an allowlisted sender agent's key instead of the caller's (own_inbox_send only).
+     */
+    inbox(route: "own_inbox_send" | "own_inbox_list" | "own_inbox_senders" | "own_inbox_sender_add" | "own_inbox_sender_remove", cid: string, agentId: string, body?: unknown, credential?: DurableCredential): Promise<ApiAnswer>;
+    /**
+     * S1 amendment 61: GET ROUTES.own_questions / POST ROUTES.own_answer for one session (owner
+     * credential only; an allowlisted sender may not answer).
+     */
+    questions(route: "own_questions" | "own_answer", cid: string, agentId: string, body?: unknown): Promise<ApiAnswer>;
     /** POST ROUTES.own_lock with the closed S1 lock body (spec, executor_id, own_agent). */
     lock(cid: string, agentId: string, body: unknown): Promise<ApiAnswer>;
     /**

package/dist/lib/durable/api.js

@@ -17,7 +17,7 @@
  *   GET  /v1/agent/sessions/{cid}/lock?agent_id=&dry_run=true -> the doctor's lock preflight
  */
 import { randomUUID } from "node:crypto";
-import { routePath } from "../../vendor/shared/durable-contract/routes.js";
+import { ROUTES, routePath } from "../../vendor/shared/durable-contract/routes.js";
 /** CLI registry timeout, connect plus total (C01-R18: at most 10 s). */
 export const REGISTRY_TIMEOUT_MS = 10_000;
 /** The registry could not be read: transport error, timeout or a non-durable 5xx. */
@@ -75,7 +75,7 @@ export class DurableApi {
         this.deps = deps;
     }
     async request(method, path, opts = {}) {
-        const cred = await this.deps.credential();
+        const cred = opts.credential ?? (await this.deps.credential());
         const headers = { Accept: "application/json" };
         if (cred.type === "jwt")
             headers.Authorization = `Bearer ${cred.token.trim()}`;
@@ -90,7 +90,8 @@ export class DurableApi {
             headers["Content-Type"] = "application/json";
             body = JSON.stringify(opts.body);
         }
-        if (method === "POST")
+        // Every write carries one: POST, and DELETE (own_inbox_sender_remove) since amendment 60.
+        if (method !== "GET")
             headers["Idempotency-Key"] = randomUUID();
         const url = new URL(path, this.deps.apiBase().replace(/\/+$/, "") + "/").href;
         const ctrl = new AbortController();
@@ -159,6 +160,30 @@ export class DurableApi {
             body,
         });
     }
+    /**
+     * An S1 amendment 60 inbox route on a session (own_inbox_send, own_inbox_list, own_inbox_senders,
+     * own_inbox_sender_add, own_inbox_sender_remove), with the route's own method. `credential`
+     * sends an allowlisted sender agent's key instead of the caller's (own_inbox_send only).
+     */
+    async inbox(route, cid, agentId, body, credential) {
+        if (credential !== undefined && route !== "own_inbox_send")
+            throw new Error(`a sender credential goes only with own_inbox_send (got ${route})`);
+        const method = ROUTES[route].method;
+        return this.request(method, `${routePath(route, cid)}${this.q({ agent_id: agentId })}`, {
+            ...(body === undefined ? {} : { body }),
+            ...(credential ? { credential } : {}),
+        });
+    }
+    /**
+     * S1 amendment 61: GET ROUTES.own_questions / POST ROUTES.own_answer for one session (owner
+     * credential only; an allowlisted sender may not answer).
+     */
+    async questions(route, cid, agentId, body) {
+        const method = ROUTES[route].method;
+        return this.request(method, `${routePath(route, cid)}${this.q({ agent_id: agentId })}`, {
+            ...(body === undefined ? {} : { body }),
+        });
+    }
     /** POST ROUTES.own_lock with the closed S1 lock body (spec, executor_id, own_agent). */
     async lock(cid, agentId, body) {
         return this.ownerVerb("own_lock", cid, agentId, body);

package/dist/lib/durable/gate.d.ts

@@ -16,7 +16,7 @@ export declare const DURABLE_ID: "durable";
 /** `mnemom agent <word>` words that exist only with durable on. */
 export declare const DURABLE_VERB_WORDS: readonly ["lock", "pause", "resume", "done", "kill", "amend", "host", "containment"];
 /** `mnemom agent sessions <sub>` sub-verbs that exist only with durable on. */
-export declare const DURABLE_SESSIONS_SUBVERBS: readonly ["unlock", "adopt"];
+export declare const DURABLE_SESSIONS_SUBVERBS: readonly ["unlock", "adopt", "send", "senders", "questions", "answer"];
 export declare function durableOn(enabled: readonly ExperimentalId[]): boolean;
 /**
  * The options that take a value, by flag spelling, as commander parses them: a `required` one always

package/dist/lib/durable/gate.js

@@ -25,7 +25,14 @@ export const DURABLE_VERB_WORDS = [
     "containment",
 ];
 /** `mnemom agent sessions <sub>` sub-verbs that exist only with durable on. */
-export const DURABLE_SESSIONS_SUBVERBS = ["unlock", "adopt"];
+export const DURABLE_SESSIONS_SUBVERBS = [
+    "unlock",
+    "adopt",
+    "send",
+    "senders",
+    "questions",
+    "answer",
+];
 export function durableOn(enabled) {
     return enabled.includes(DURABLE_ID);
 }

package/dist/lib/durable/live.d.ts

@@ -7,6 +7,8 @@ import { type LauncherConfig } from "../launcher-config.js";
 import { type ProcDeps } from "../../durable/proc.js";
 import type { LauncherKey } from "../../vendor/shared/durable-contract/fixlines.js";
 import type { DurableVerbDeps } from "../../commands/durable-verbs.js";
+import type { InboxVerbDeps } from "../../commands/durable-inbox.js";
+import type { QuestionVerbDeps } from "../../commands/durable-questions.js";
 import type { SessionsReadDeps } from "../../commands/durable-sessions.js";
 import { type DoctorLine } from "../../commands/durable-doctor.js";
 import { type OriginalLaunch, type LockDeps, type LockOutcome } from "../../commands/durable-lock.js";
@@ -24,6 +26,9 @@ export declare function liveLauncherKey(load?: () => {
 /** PIDs of local claude processes whose argv names `ccSessionId` (pure over a `ps` listing). */
 export declare function claudePidsFor(psOutput: string, ccSessionId: string, selfPid: number): number[];
 export declare function liveVerbDeps(): DurableVerbDeps;
+/** The inbox verbs' deps: the verb deps, the environment (sender key) and stdin. */
+export declare function liveInboxDeps(): InboxVerbDeps;
+export declare function liveQuestionDeps(): QuestionVerbDeps;
 export declare function liveSessionsReadDeps(): SessionsReadDeps;
 export declare function liveLockDeps(): LockDeps;
 /** The live original's exact argv, its parent launcher's passthrough and its shape (C14-R13). */

package/dist/lib/durable/live.js

@@ -120,6 +120,25 @@ export function liveVerbDeps() {
         stopTrackedClaude,
     };
 }
+/** The inbox verbs' deps: the verb deps, the environment (sender key) and stdin. */
+export function liveInboxDeps() {
+    const base = liveVerbDeps();
+    return {
+        ...base,
+        api: base.api,
+        env: process.env,
+        readStdin: async () => {
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            return Buffer.concat(chunks).toString("utf8");
+        },
+    };
+}
+export function liveQuestionDeps() {
+    const base = liveVerbDeps();
+    return { ...base, api: base.api };
+}
 export function liveSessionsReadDeps() {
     return {
         api: liveDurableApi(),

package/dist/lib/experimental.js

@@ -54,6 +54,7 @@ export const EXPERIMENTAL_FEATURES = [
                 "slack_channel",
                 "slack_listen",
                 "slack_allow",
+                "slack_owner",
                 "slack_aliases",
                 "slack_sticky_threads",
             ],
@@ -217,6 +218,7 @@ export function experimentalIdForConfigKey(key, value) {
     switch (key) {
         case "slack_channel":
         case "slack_allow":
+        case "slack_owner":
             return "slack";
         case "slack_listen":
         case "slack_aliases":
@@ -299,6 +301,7 @@ export function configKeyFeature(key) {
     if (key === "slack_channel" ||
         key === "slack_listen" ||
         key === "slack_allow" ||
+        key === "slack_owner" ||
         key === "slack_aliases" ||
         key === "slack_sticky_threads")
         return "slack";

package/dist/lib/goal-api.d.ts

@@ -7,8 +7,8 @@
  *   POST https://<gateway_host>/mnemom/goal/intent/reset  {conversation_id, thread, statement?, requirements?}
  *
  * Auth is the SAME credential the launch used: `x-api-key` (the Anthropic key from
- * `resolveAnthropicKey`), `x-mnemom-agent: <record.agent_slug>`, `x-mnemom-api-key` when the
- * launch had a Mnemom key, and `x-mnemom-agent-id: <record.agent_id>` when the launch pinned it. The gateway hashes them exactly as a proxied request and only LOOKS
+ * `resolveAnthropicKey`, or a subscription launch's Mnemom key), `x-mnemom-agent: <record.agent_slug>`,
+ * `x-mnemom-api-key` when the launch had a Mnemom key, and `x-mnemom-agent-id: <record.agent_id>` when the launch pinned it. The gateway hashes them exactly as a proxied request and only LOOKS
  * UP the agent. Key material is never printed: errors carry the status, the gateway's error code
  * and its message, nothing else.
  *
@@ -25,12 +25,19 @@ export declare const GOAL_THREAD_RE: RegExp;
 export declare function isValidGoalThread(thread: string): boolean;
 /** The ledger fields the control call needs. */
 export type GoalControlRecord = Pick<SessionRecord, "gateway_host" | "agent_slug" | "conversation_id"> & Partial<Pick<SessionRecord, "agent_id" | "agent_pinned">>;
-export interface GoalControlCreds {
+/**
+ * An api-key launch: its Anthropic key (sent as `x-api-key`) and the Mnemom key it sent beside it,
+ * if any. A subscription launch had no Anthropic key: its Mnemom key is the credential.
+ */
+export type GoalControlCreds = {
     /** The Anthropic key the launch sent as `x-api-key`. */
     anthropicKey: string;
     /** The Mnemom key, only when the launch sent `x-mnemom-api-key`. */
     mnemomKey?: string | null;
-}
+} | {
+    anthropicKey?: undefined;
+    mnemomKey: string;
+};
 export type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
 export interface GoalControlDeps {
     fetch: FetchLike;

package/dist/lib/goal-api.js

@@ -7,8 +7,8 @@
  *   POST https://<gateway_host>/mnemom/goal/intent/reset  {conversation_id, thread, statement?, requirements?}
  *
  * Auth is the SAME credential the launch used: `x-api-key` (the Anthropic key from
- * `resolveAnthropicKey`), `x-mnemom-agent: <record.agent_slug>`, `x-mnemom-api-key` when the
- * launch had a Mnemom key, and `x-mnemom-agent-id: <record.agent_id>` when the launch pinned it. The gateway hashes them exactly as a proxied request and only LOOKS
+ * `resolveAnthropicKey`, or a subscription launch's Mnemom key), `x-mnemom-agent: <record.agent_slug>`,
+ * `x-mnemom-api-key` when the launch had a Mnemom key, and `x-mnemom-agent-id: <record.agent_id>` when the launch pinned it. The gateway hashes them exactly as a proxied request and only LOOKS
  * UP the agent. Key material is never printed: errors carry the status, the gateway's error code
  * and its message, nothing else.
  *
@@ -52,7 +52,8 @@ export function goalControlUrl(record, op, thread = "main") {
 /** The launch's identity headers (never logged). */
 export function goalControlHeaders(record, creds) {
     const headers = {
-        "x-api-key": creds.anthropicKey,
+        // A subscription session's Mnemom key: the gateway resolves the claimed agent from it.
+        "x-api-key": creds.anthropicKey !== undefined ? creds.anthropicKey : creds.mnemomKey,
         "x-mnemom-agent": record.agent_slug,
         accept: "application/json",
     };

package/dist/lib/launcher-config.d.ts

@@ -49,6 +49,11 @@ export interface LauncherConfig {
     slackListen?: boolean;
     /** Slack member ids whose messages the router may deliver into a session. */
     slackAllow?: string[];
+    /**
+     * The owner's own Slack member ids. With durable on, a message from one of them to a locked
+     * durable session goes to its durable inbox as from the owner (S1 amendment 60).
+     */
+    slackOwner?: string[];
     /**
      * Router: honour `mnemom agent slack alias` handles (off when unset). Off means the
      * router routes exactly as it did before aliases existed; registered aliases are kept

package/dist/lib/launcher-config.js

@@ -100,14 +100,14 @@ function coerceCompactAt(raw) {
     parseCompactAt(v, "compact_at");
     return v;
 }
-function coerceMemberIds(raw) {
+function coerceMemberIds(raw, key = "slack_allow") {
     const ids = raw
         .split(/[\s,]+/)
         .map((x) => x.trim())
         .filter(Boolean);
     const bad = ids.filter((x) => !/^[UW][A-Z0-9]{6,}$/.test(x));
     if (!ids.length || bad.length) {
-        throw new Error(`slack_allow must be Slack member ids like U012ABCDEF (Profile → ⋯ → Copy member ID); got '${raw}'.`);
+        throw new Error(`${key} must be Slack member ids like U012ABCDEF (Profile → ⋯ → Copy member ID); got '${raw}'.`);
     }
     return ids;
 }
@@ -238,6 +238,14 @@ export const CONFIG_KEYS = [
             c.slackAllow = coerceMemberIds(v);
         },
     },
+    {
+        key: "slack_owner",
+        describe: "Your own Slack member ids (comma-separated): with durable on, your messages reach a locked durable session's inbox as from you",
+        get: (c) => c.slackOwner?.join(","),
+        set: (c, v) => {
+            c.slackOwner = coerceMemberIds(v, "slack_owner");
+        },
+    },
     {
         key: "slack_aliases",
         describe: "Slack router: route `mnemom agent slack alias` handles, queueing for a stopped session (off by default)",
@@ -366,6 +374,10 @@ export function parseLauncherConfig(text) {
         const v = raw.slack_allow;
         cfg.slackAllow = coerceMemberIds(Array.isArray(v) ? v.map(String).join(",") : String(v));
     }
+    if (raw.slack_owner !== undefined) {
+        const v = raw.slack_owner;
+        cfg.slackOwner = coerceMemberIds(Array.isArray(v) ? v.map(String).join(",") : String(v), "slack_owner");
+    }
     if (raw.slack_channel !== undefined)
         cfg.slackChannel = coerceNonEmpty("slack_channel", str(raw.slack_channel) ?? "");
     if (raw.slack_aliases !== undefined)
@@ -452,6 +464,8 @@ export function serializeLauncherConfig(cfg) {
         doc.slack_listen = cfg.slackListen;
     if (cfg.slackAllow !== undefined)
         doc.slack_allow = cfg.slackAllow;
+    if (cfg.slackOwner !== undefined)
+        doc.slack_owner = cfg.slackOwner;
     if (cfg.slackAliases !== undefined)
         doc.slack_aliases = cfg.slackAliases;
     if (cfg.slackStickyThreads !== undefined)
@@ -550,6 +564,7 @@ export function withoutDisabledExperimental(cfg, enabled) {
         delete out.slackChannel;
         delete out.slackListen;
         delete out.slackAllow;
+        delete out.slackOwner;
         delete out.slackAliases;
         delete out.slackStickyThreads;
     }

package/dist/lib/prompt.d.ts

@@ -19,9 +19,11 @@ export declare function askInput(question: string, mask?: boolean): Promise<stri
 export declare function askMultiSelect(question: string, options: string[]): Promise<string[]>;
 /**
  * Single-select prompt. Displays numbered options, user enters a number.
- * Returns selected label or null if invalid.
+ * Returns selected label or null if invalid. With `defaultIndex` (0-based), pressing Enter on an
+ * interactive terminal picks that option; piped (non-TTY) input never uses it, so an empty or missing
+ * line still returns null and the caller keeps its fail-closed fallback.
  */
-export declare function askSelect(question: string, options: string[]): Promise<string | null>;
+export declare function askSelect(question: string, options: string[], defaultIndex?: number): Promise<string | null>;
 /**
  * Check if running in non-interactive mode (no TTY)
  */

package/dist/lib/prompt.js

@@ -80,8 +80,12 @@ export async function askInput(question, mask = false) {
         process.stdout.write(`${question} `);
         const lines = await readPipedStdinLines();
         const next = lines.shift();
-        process.stdout.write("\n");
-        return (next ?? "").trim();
+        const answer = (next ?? "").trim();
+        // A terminal shows what the user typed; a pipe does not, which left a bare "Question: " line in
+        // logs and scan output. Echo an unmasked answer so the line reads "Question: value". A masked
+        // answer (API key / password) is never echoed.
+        process.stdout.write(mask ? "\n" : `${answer}\n`);
+        return answer;
     }
     const rl = readline.createInterface({
         input: process.stdin,
@@ -169,9 +173,11 @@ function resolveSelection(answer, options) {
 }
 /**
  * Single-select prompt. Displays numbered options, user enters a number.
- * Returns selected label or null if invalid.
+ * Returns selected label or null if invalid. With `defaultIndex` (0-based), pressing Enter on an
+ * interactive terminal picks that option; piped (non-TTY) input never uses it, so an empty or missing
+ * line still returns null and the caller keeps its fail-closed fallback.
  */
-export async function askSelect(question, options) {
+export async function askSelect(question, options, defaultIndex) {
     console.log(`\n${question}`);
     for (let i = 0; i < options.length; i++) {
         console.log(`  ${i + 1}) ${options[i]}`);
@@ -194,8 +200,12 @@ export async function askSelect(question, options) {
         output: process.stdout,
     });
     return new Promise((resolve) => {
-        rl.question("Select: ", (answer) => {
+        const hasDefault = defaultIndex !== undefined && defaultIndex >= 0 && defaultIndex < options.length;
+        const prompt = hasDefault ? `Select [${defaultIndex + 1}]: ` : "Select: ";
+        rl.question(prompt, (answer) => {
             rl.close();
+            if (hasDefault && answer.trim() === "")
+                return resolve(options[defaultIndex]);
             resolve(resolveSelection(answer, options));
         });
     });

package/dist/lib/runner/job.d.ts

@@ -14,7 +14,7 @@
 import { type HttpResult, type RunnerApi } from "./executor-client.js";
 import { type OutcomeFields, type RefusedReason } from "./outcome.js";
 import { type PhaseInvocation } from "./phases.js";
-import type { ModelProxy, ProxyState } from "./proxy.js";
+import { type ModelProxy, type ProxyState } from "./proxy.js";
 import { type RunnerFailMode } from "./settings.js";
 /** A claimed job's working copy. */
 export interface Workspace {
@@ -42,7 +42,7 @@ export interface JobDeps {
     /** Run one phase's process; resolves its exit code. Rejects only when it could not start. */
     runPhase(inv: PhaseInvocation, ws: Workspace, modelUrl: string, signal: AbortSignal): Promise<number>;
     /** Push the job branch and open its PR; resolves the PR URL. */
-    openPr(repo: string, ws: Workspace, title: string): Promise<string>;
+    openPr(repo: string, ws: Workspace, title: string, body: string): Promise<string>;
     /** Commits on the job branch that the base does not have; 0 means there is nothing to open. */
     commitsAhead(ws: Workspace): Promise<number>;
     enableAutoMerge(prUrl: string): Promise<void>;

package/dist/lib/runner/job.js

@@ -19,6 +19,8 @@ import { sealedContractHeader } from "./contract-header.js";
 import { errorCode, errorDetails } from "./executor-client.js";
 import { doneOutcome, failedOutcome, phaseReason, refusedOutcome, } from "./outcome.js";
 import { planPhase } from "./phases.js";
+import { canonNodeKey, prBody } from "./pr-body.js";
+import { requestSummary } from "./proxy.js";
 import { resolveMergeStrategy } from "./settings.js";
 const TOLERATED = RUNNER_OPEN_MODE_TOLERATED;
 const OPEN_MODE_RETRIES = 3;
@@ -154,7 +156,14 @@ function parseJob(body) {
     const agentId = str(b.agent_id);
     if (agentId === null || !AGENT_ID_RE.test(agentId))
         return null;
-    return { repo, agent_id: agentId, contract_sha256: sha, version, contract: b.contract };
+    return {
+        repo,
+        agent_id: agentId,
+        contract_sha256: sha,
+        version,
+        contract: b.contract,
+        canon_node_key: canonNodeKey(b.canon_node_key),
+    };
 }
 /**
  * Run one candidate session to an outcome. Never throws for a Mnemom error: every one is an
@@ -354,7 +363,7 @@ export async function runJob(sessionId, opts, deps) {
                     await reportFail(deps, sessionId, claim.epoch, "runner_failed", "pr_no_changes");
                     return { kind: "outcome", outcome: failedOutcome(facts, "pr_no_changes") };
                 }
-                facts.pr_url = await deps.openPr(job.repo, ws, `mnemom: ${bundle.workflow.id} job ${sessionId.slice(0, 8)}`);
+                facts.pr_url = await deps.openPr(job.repo, ws, `mnemom: ${bundle.workflow.id} job ${sessionId.slice(0, 8)}`, prBody(job));
             }
             catch (e) {
                 deps.log(`opening the PR failed: ${e.message}`);
@@ -377,7 +386,11 @@ export async function runJob(sessionId, opts, deps) {
         if (heartbeat)
             clearInterval(heartbeat);
         opts.stop.removeEventListener("abort", onStop);
-        await proxy?.close();
+        if (proxy) {
+            await proxy.close();
+            // One line per job that reached its phases: what every model request carried (W3.11).
+            deps.log(`model requests: ${JSON.stringify(requestSummary(proxy.forwarded))}`);
+        }
         // A workspace left behind never changes the outcome; it is logged for the operator.
         if (ws)
             await deps.cleanup(ws).catch((e) => deps.log(`cleanup failed: ${e.message}`));

package/dist/lib/runner/pr-body.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The body of the PR `mnemom agent run` opens: the job's goal line from the sealed contract and the
+ * Canon node its seal points to, both from the job read the runner already holds (no extra call).
+ * Never the contract body or any key: the goal is the contract's `statement`, on one line and
+ * capped; the node is cited only when the job read names a well-formed one, and a job without one
+ * still opens its PR, with no citation.
+ */
+/** The goal line's cap, in characters: a PR body line, not the contract. */
+export declare const PR_GOAL_MAX = 280;
+/** The node key when well formed, else null. */
+export declare function canonNodeKey(v: unknown): string | null;
+/** The sealed contract's statement on one line, capped; null when the bytes carry none. */
+export declare function goalLine(contract: string): string | null;
+export declare function prBody(job: {
+    contract: string;
+    canon_node_key: string | null;
+}): string;