@mnemom/mnemom 0.17.34-next.4 → 0.17.35

package/dist/vendor/shared/durable-contract/admission.d.ts

@@ -15,7 +15,11 @@
  *   7 fenced (unless nofence)           -> 409 durable_lease_fenced
  *   8 paused or non-admitting suspended -> 423 durable_session_stopped {state, state_reason}
  *   9 posture: attended admits; unattended -> 503 durable_guard_unavailable on a guard fault,
- *     else 503 durable_unattended_unavailable (M1 refuses all unattended work).
+ *     else 503 durable_unattended_unavailable, except (amendment 58) a locked pool session whose
+ *     unfenced key holds its live lease, sealed with a charter, with a valid C08-R13 guard: that
+ *     unattended chain is admitted, and G2's charter ceilings bind it as they bind an attended one;
+ *     and (amendment 60) a locked homed session answering an open inbox message, its org's host
+ *     policy and its owner both allowing unattended work, admitted the same way.
  * The one exception (wave-0 fix ruling 22): a POST /v1/messages/count_tokens with no chain= (header
  * absent, or no chain on the newest entry) runs steps 1-8 and skips step 9: it is admitted as
  * admit_unchained, with no chain row and no posture insert. Every other request is unchanged.
@@ -77,6 +81,18 @@ export interface ResolverDurable {
     charter_hash: string | null;
     guard_state: Record<string, unknown> | null;
     has_pointer: boolean;
+    /**
+     * Amendment 58, optional: the session has a dispatch_jobs row (a pool session). Absent reads as
+     * false, so an api that does not send it decides exactly as before.
+     */
+    pool?: boolean;
+    /** A1's charter field, optional here: the session's current charter version (amendment 58 (d)). */
+    charter_version?: number | null;
+    /**
+     * Amendment 60, optional: the sha256 hex of every inbox message delivered to this session and not
+     * yet acked or dead. Absent reads as none, so an api that does not send it decides as before.
+     */
+    inbox_open?: readonly string[] | null;
 }
 /** One resolver field against its spec (pure; exported for its direct test). */
 export declare function fieldOk(spec: FieldSpec, v: unknown): boolean;
@@ -99,6 +115,17 @@ export declare const GUARD_STATE_OK: Readonly<{
 export declare const GUARD_STATE_FAULT: Readonly<{
     spend_usd: string;
 }>;
+/**
+ * Amendment 58 (e): the unattended pool branch's guard check, the C08-R13 shape the gateway guard
+ * enforces: schema_version 1, finite non-negative `turns` and `spend_usd` (numbers, never strings).
+ * Used for that branch only; guardStateOk and every other verdict are unchanged.
+ */
+export declare function guardStateV1Ok(guard: Record<string, unknown> | null): boolean;
+/**
+ * Amendment 58 (a)-(d): a locked pool session whose unfenced key holds its live lease (whatever
+ * DURABLE_ADMIT says), sealed with a charter of current version >= 1. The guard, (e), is separate.
+ */
+export declare function unattendedPoolEligible(d: ResolverDurable): boolean;
 /** Whether DURABLE_ADMIT is honoured: only the exact bytes "nofence" (NOFENCE_M1, r3 I01). */
 export declare function nofenceHonoured(durableAdmit: string | undefined): boolean;
 export type AdmissionStep = "unknown_key" | "resolver_fault" | "revoked" | "identity" | "tracked" | "terminal" | "fenced" | "stopped" | "posture" | "admit";
@@ -136,6 +163,8 @@ export interface AdmissionInput {
     durableAdmit: string | undefined;
     /** The request (ruling 22). Absent: decided as any request other than an unchained count_tokens. */
     request?: AdmissionRequest;
+    /** Amendment 60: the newest x-mnemom-turn entry's `inbox=<sha>` value, when it carried one. */
+    inboxSha?: string | null;
 }
 export type AdmissionVerdict = {
     kind: "baseline_unknown_key";
@@ -151,7 +180,8 @@ export type AdmissionVerdict = {
 } | {
     kind: "admit";
     step: "admit";
-    posture: "attended";
+    /** "unattended" only for amendment 58's pool branch. */
+    posture: Posture;
     guardFault: boolean;
     fenceSource: FenceSource;
     /** True when the session is effectively resuming: this request moves it to running. */
@@ -171,6 +201,15 @@ export type AdmissionVerdict = {
 };
 export declare const RESOLVER_FAULT: "fault";
 /** The admission function. Total: every input maps to exactly one verdict; it never throws. */
+/** At most this many open inbox messages are read from a resolver answer (amendment 60 (e)). */
+export declare const INBOX_OPEN_MAX = 64;
+/**
+ * Amendment 60 (a)-(e): a locked homed session (no pool row) whose unfenced key holds its live
+ * lease, sealed with a charter of version >= 1, whose org host policy and owner both allow unattended
+ * work, answering an inbox message the api delivered and nobody has acked yet. The guard, (f), is
+ * separate, as in 58.
+ */
+export declare function unattendedHomedInboxEligible(d: ResolverDurable, inboxSha: string | null | undefined): boolean;
 export declare function admit(input: AdmissionInput): AdmissionVerdict;
 export declare const ADMISSION_REQUEST_KINDS: readonly ["standard", "count_tokens_unchained"];
 export type AdmissionRequestKind = (typeof ADMISSION_REQUEST_KINDS)[number];
@@ -205,6 +244,25 @@ export declare function stateRows(): {
 }[];
 /** The full cross product over the admission dimensions, each row decided by `admit`. */
 export declare function admissionTruthTable(): TruthRow[];
+/** The guard_state the amendment 58 vectors call valid (C08-R13 shape). */
+export declare const GUARD_STATE_V1_OK: Readonly<Record<string, number>>;
+export interface UnattendedPoolVector {
+    readonly name: string;
+    /** Overrides on the eligible base (fixtureResolver + pool, unattended, charter v1, a v1 guard). */
+    readonly over: Readonly<Partial<ResolverDurable>> & {
+        readonly pool?: boolean | undefined;
+    };
+    readonly nofence: boolean;
+    /** "admit" (unattended) or the refusal code. */
+    readonly outcome: string;
+}
+/**
+ * The base row admits an unattended chain; each other row flips exactly one condition. Every
+ * missing condition keeps the pre-58 refusal; (e) answers durable_guard_unavailable.
+ */
+export declare const UNATTENDED_POOL_VECTORS: readonly UnattendedPoolVector[];
+/** Decide one amendment 58 vector (the posture is the resolver's, as the gateway passes it). */
+export declare function decideUnattendedPoolVector(v: UnattendedPoolVector): AdmissionVerdict;
 /** Golden vectors: a 3-dim toy sweep (every line) and C06 SWEEP_A (count, first 3 lines, digest). */
 export declare const ADMIT_SWEEP_VECTORS_PATH = "src/vectors/admit-sweep-vectors.json";
 /**
@@ -238,3 +296,24 @@ export declare function admitSweepDigest(sweep: AdmitSweep): Promise<{
     tuples: number;
     verdicts_sha256: string;
 }>;
+/** The inbox message the amendment 60 vectors answer: sha256 hex, open on the base row. */
+export declare const INBOX_SHA_FIXTURE: string;
+export interface HomedInboxVector {
+    readonly name: string;
+    /** Overrides on the eligible base (fixtureResolver + unattended, charter v1, open inbox). */
+    readonly over: Readonly<Partial<ResolverDurable>> & {
+        readonly pool?: boolean | undefined;
+    };
+    /** The newest turn entry's inbox value (base: INBOX_SHA_FIXTURE). */
+    readonly inboxSha?: string | null;
+    readonly nofence: boolean;
+    /** "admit" (unattended) or the refusal code. */
+    readonly outcome: string;
+}
+/**
+ * The base row admits an unattended inbox turn on a homed session; each other row flips exactly one
+ * condition. Every missing condition keeps the pre-60 refusal; (f) answers durable_guard_unavailable.
+ */
+export declare const HOMED_INBOX_VECTORS: readonly HomedInboxVector[];
+/** Decide one amendment 60 vector (the posture is the resolver's, as the gateway passes it). */
+export declare function decideHomedInboxVector(v: HomedInboxVector): AdmissionVerdict;

package/dist/vendor/shared/durable-contract/admission.js

@@ -16,7 +16,11 @@
  *   7 fenced (unless nofence)           -> 409 durable_lease_fenced
  *   8 paused or non-admitting suspended -> 423 durable_session_stopped {state, state_reason}
  *   9 posture: attended admits; unattended -> 503 durable_guard_unavailable on a guard fault,
- *     else 503 durable_unattended_unavailable (M1 refuses all unattended work).
+ *     else 503 durable_unattended_unavailable, except (amendment 58) a locked pool session whose
+ *     unfenced key holds its live lease, sealed with a charter, with a valid C08-R13 guard: that
+ *     unattended chain is admitted, and G2's charter ceilings bind it as they bind an attended one;
+ *     and (amendment 60) a locked homed session answering an open inbox message, its org's host
+ *     policy and its owner both allowing unattended work, admitted the same way.
  * The one exception (wave-0 fix ruling 22): a POST /v1/messages/count_tokens with no chain= (header
  * absent, or no chain on the newest entry) runs steps 1-8 and skips step 9: it is admitted as
  * admit_unchained, with no chain row and no posture insert. Every other request is unchanged.
@@ -52,7 +56,8 @@ export const RESOLVER_SCHEMA = {
     },
     epoch: { type: "integer", nullable: false },
     fenced: { type: "boolean", nullable: false },
-    agent_id: { type: "uuid", nullable: false },
+    // The opaque agents.id text, e.g. "mnm-<hex>" (ruling 33.29), never a uuid.
+    agent_id: { type: "string", nullable: false },
     home_cell: { type: "enum", nullable: false, values: CANONICAL_CELL_IDS },
     posture: {
         type: "enum",
@@ -141,6 +146,30 @@ export const GUARD_STATE_OK = Object.freeze({ spend_usd: 0 });
 export const GUARD_STATE_FAULT = Object.freeze({
     spend_usd: "unparseable",
 });
+/**
+ * Amendment 58 (e): the unattended pool branch's guard check, the C08-R13 shape the gateway guard
+ * enforces: schema_version 1, finite non-negative `turns` and `spend_usd` (numbers, never strings).
+ * Used for that branch only; guardStateOk and every other verdict are unchanged.
+ */
+export function guardStateV1Ok(guard) {
+    if (guard === null || guard.schema_version !== 1)
+        return false;
+    return [guard.turns, guard.spend_usd].every((v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
+}
+/**
+ * Amendment 58 (a)-(d): a locked pool session whose unfenced key holds its live lease (whatever
+ * DURABLE_ADMIT says), sealed with a charter of current version >= 1. The guard, (e), is separate.
+ */
+export function unattendedPoolEligible(d) {
+    return (d.durable_mode === "locked" &&
+        d.pool === true &&
+        !d.fenced &&
+        d.lease_executor_id !== null &&
+        (d.effective_state === "running" || d.effective_state === "resuming") &&
+        d.sealed &&
+        Number.isSafeInteger(d.charter_version) &&
+        d.charter_version >= 1);
+}
 /** Whether DURABLE_ADMIT is honoured: only the exact bytes "nofence" (NOFENCE_M1, r3 I01). */
 export function nofenceHonoured(durableAdmit) {
     return durableAdmit === NOFENCE_ADMIT_VALUE;
@@ -195,6 +224,32 @@ export function isUnchainedCountTokens(r) {
 }
 export const RESOLVER_FAULT = "fault";
 /** The admission function. Total: every input maps to exactly one verdict; it never throws. */
+/** At most this many open inbox messages are read from a resolver answer (amendment 60 (e)). */
+export const INBOX_OPEN_MAX = 64;
+const INBOX_SHA_RE = /^[0-9a-f]{64}$/;
+/**
+ * Amendment 60 (a)-(e): a locked homed session (no pool row) whose unfenced key holds its live
+ * lease, sealed with a charter of version >= 1, whose org host policy and owner both allow unattended
+ * work, answering an inbox message the api delivered and nobody has acked yet. The guard, (f), is
+ * separate, as in 58.
+ */
+export function unattendedHomedInboxEligible(d, inboxSha) {
+    const open = d.inbox_open;
+    return (d.durable_mode === "locked" &&
+        d.pool !== true &&
+        !d.fenced &&
+        d.lease_executor_id !== null &&
+        (d.effective_state === "running" || d.effective_state === "resuming") &&
+        d.sealed &&
+        Number.isSafeInteger(d.charter_version) &&
+        d.charter_version >= 1 &&
+        d.host_unattended === true &&
+        typeof inboxSha === "string" &&
+        INBOX_SHA_RE.test(inboxSha) &&
+        Array.isArray(open) &&
+        open.length <= INBOX_OPEN_MAX &&
+        open.includes(inboxSha));
+}
 export function admit(input) {
     const fenceSource = nofenceHonoured(input.durableAdmit) ? "nofence" : "fresh";
     const posture = input.posture ?? "unattended";
@@ -240,6 +295,24 @@ export function admit(input) {
             writes: false,
         };
     if (posture === "unattended") {
+        if (unattendedPoolEligible(d) || unattendedHomedInboxEligible(d, input.inboxSha)) {
+            if (guardStateV1Ok(d.guard_state))
+                return {
+                    kind: "admit",
+                    step: "admit",
+                    posture: "unattended",
+                    guardFault: false,
+                    fenceSource,
+                    helloTransition: false,
+                };
+            return {
+                kind: "refuse",
+                step: "posture",
+                code: "durable_guard_unavailable",
+                posture,
+                fenceSource,
+            };
+        }
         return {
             kind: "refuse",
             step: "posture",
@@ -396,6 +469,128 @@ export function admissionTruthTable() {
     }
     return out;
 }
+// ---- Amendment 58 vectors: the unattended pool branch, one condition flipped per row -------------
+/** The guard_state the amendment 58 vectors call valid (C08-R13 shape). */
+export const GUARD_STATE_V1_OK = Object.freeze({
+    schema_version: 1,
+    turns: 0,
+    spend_usd: 0,
+});
+/**
+ * The base row admits an unattended chain; each other row flips exactly one condition. Every
+ * missing condition keeps the pre-58 refusal; (e) answers durable_guard_unavailable.
+ */
+export const UNATTENDED_POOL_VECTORS = Object.freeze([
+    { name: "all hold: admitted unattended", over: {}, nofence: false, outcome: "admit" },
+    {
+        name: "all hold, resuming: admitted, no hello",
+        over: { effective_state: "resuming", state: "resuming" },
+        nofence: false,
+        outcome: "admit",
+    },
+    {
+        name: "(b) pool absent",
+        over: { pool: undefined },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(b) pool false",
+        over: { pool: false },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(c) fenced key under nofence",
+        over: { fenced: true },
+        nofence: true,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(c) no lease executor",
+        over: { lease_executor_id: null },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(c) lease lapsed (detached)",
+        over: { effective_state: "detached" },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(d) not sealed",
+        over: { sealed: false },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(d) no charter version",
+        over: { charter_version: null },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(d) charter version 0",
+        over: { charter_version: 0 },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(d) charter version not an integer",
+        over: { charter_version: 1.5 },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(e) guard null",
+        over: { guard_state: null },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "(e) guard without schema_version",
+        over: { guard_state: { turns: 0, spend_usd: 0 } },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "(e) guard without turns",
+        over: { guard_state: { schema_version: 1, spend_usd: 0 } },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "(e) guard turns as a string",
+        over: { guard_state: { schema_version: 1, turns: "0", spend_usd: 0 } },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "attended on a pool session: unchanged",
+        over: { posture: "attended" },
+        nofence: false,
+        outcome: "admit",
+    },
+]);
+/** Decide one amendment 58 vector (the posture is the resolver's, as the gateway passes it). */
+export function decideUnattendedPoolVector(v) {
+    const base = {
+        posture: "unattended",
+        pool: true,
+        charter_version: 1,
+        guard_state: { ...GUARD_STATE_V1_OK },
+    };
+    const resolver = { ...fixtureResolver(base), ...v.over };
+    if (v.over.pool === undefined && "pool" in v.over)
+        delete resolver.pool;
+    return admit({
+        resolver,
+        pinAgentId: FIXTURE_AGENT,
+        posture: resolver.posture,
+        durableAdmit: v.nofence ? NOFENCE_ADMIT_VALUE : undefined,
+    });
+}
 // ---- admit sweep digest (rulings 24.11, 24.11.1; C06-SWEEP-001/002) ----------------------------
 /** Golden vectors: a 3-dim toy sweep (every line) and C06 SWEEP_A (count, first 3 lines, digest). */
 export const ADMIT_SWEEP_VECTORS_PATH = "src/vectors/admit-sweep-vectors.json";
@@ -531,3 +726,125 @@ export async function admitSweepDigest(sweep) {
     const { tuples, text } = admitSweepText(sweep);
     return { tuples, verdicts_sha256: await sha256Hex(text) };
 }
+// ---- Amendment 60 vectors: the homed inbox branch, one condition flipped per row ----------------
+/** The inbox message the amendment 60 vectors answer: sha256 hex, open on the base row. */
+export const INBOX_SHA_FIXTURE = "ab".repeat(32);
+/**
+ * The base row admits an unattended inbox turn on a homed session; each other row flips exactly one
+ * condition. Every missing condition keeps the pre-60 refusal; (f) answers durable_guard_unavailable.
+ */
+export const HOMED_INBOX_VECTORS = Object.freeze([
+    { name: "all hold: admitted unattended", over: {}, nofence: false, outcome: "admit" },
+    {
+        name: "all hold, resuming: admitted, no hello",
+        over: { effective_state: "resuming", state: "resuming" },
+        nofence: false,
+        outcome: "admit",
+    },
+    {
+        name: "(a) a pool session takes 58, not 60: still admitted",
+        over: { pool: true },
+        nofence: false,
+        outcome: "admit",
+    },
+    {
+        name: "(b) fenced key under nofence",
+        over: { fenced: true },
+        nofence: true,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(b) no lease executor",
+        over: { lease_executor_id: null },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(b) lease lapsed (detached)",
+        over: { effective_state: "detached" },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(c) not sealed",
+        over: { sealed: false },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(c) no charter version",
+        over: { charter_version: null },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(d) host policy or the owner's opt-out says no",
+        over: { host_unattended: false },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(e) no inbox key on the newest entry",
+        over: {},
+        inboxSha: null,
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(e) inbox sha not open (acked, dead or never delivered)",
+        over: { inbox_open: ["cd".repeat(32)] },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(e) inbox_open absent",
+        over: { inbox_open: undefined },
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(e) inbox sha malformed",
+        over: { inbox_open: ["AB".repeat(32)] },
+        inboxSha: "AB".repeat(32),
+        nofence: false,
+        outcome: "durable_unattended_unavailable",
+    },
+    {
+        name: "(f) guard null",
+        over: { guard_state: null },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "(f) guard without schema_version",
+        over: { guard_state: { turns: 0, spend_usd: 0 } },
+        nofence: false,
+        outcome: "durable_guard_unavailable",
+    },
+    {
+        name: "attended on a homed session: unchanged",
+        over: { posture: "attended" },
+        inboxSha: null,
+        nofence: false,
+        outcome: "admit",
+    },
+]);
+/** Decide one amendment 60 vector (the posture is the resolver's, as the gateway passes it). */
+export function decideHomedInboxVector(v) {
+    const base = {
+        posture: "unattended",
+        charter_version: 1,
+        inbox_open: [INBOX_SHA_FIXTURE],
+        guard_state: { ...GUARD_STATE_V1_OK },
+    };
+    const resolver = { ...fixtureResolver(base), ...v.over };
+    if ("inbox_open" in v.over && v.over.inbox_open === undefined)
+        delete resolver.inbox_open;
+    return admit({
+        resolver,
+        pinAgentId: FIXTURE_AGENT,
+        posture: resolver.posture,
+        durableAdmit: v.nofence ? NOFENCE_ADMIT_VALUE : undefined,
+        inboxSha: "inboxSha" in v ? v.inboxSha : INBOX_SHA_FIXTURE,
+    });
+}

package/dist/vendor/shared/durable-contract/cli-surface.js

@@ -64,6 +64,20 @@ export const M1_CLI_SURFACE = Object.freeze([
     // BACKBONE C4 (line 147: buildDurableLaunchSpec serves 'sessions adopt'); options: C14 spec
     // (`sessions adopt --dry-run --json`, `sessions adopt --own-agent`); ruling 32.33.
     entry(["agent", "sessions", "adopt"], ["--dry-run", "--json", "--own-agent"]),
+    // S1 amendment 61 (signed off by Wassim 2026-11-02): the owner's answer or dismissal of a locked
+    // session's question (own_answer, via coding_agent).
+    entry(["agent", "sessions", "answer"], ["--dismiss", "--json"]),
+    // S1 amendment 61: the session's questions to its owner (own_questions).
+    entry(["agent", "sessions", "questions"], ["--all", "--json"]),
+    // S1 amendment 60 (signed off by Wassim 2026-11-02): the owner door into a locked session's inbox. `send`
+    // posts own_inbox_send (owner credential, or an allowlisted agent's key named by --sender-key-env);
+    // --agent-id/--conversation address a session the caller cannot list (an allowlisted agent).
+    entry(["agent", "sessions", "send"], ["--agent-id", "--conversation", "--idempotency-key", "--json", "--sender-key-env"]),
+    // S1 amendment 60: the owner-managed inbox sender allowlist (own_inbox_senders, _sender_add, _sender_remove).
+    entry(["agent", "sessions", "senders"]),
+    entry(["agent", "sessions", "senders", "add"], ["--json", "--label"]),
+    entry(["agent", "sessions", "senders", "list"], ["--json"]),
+    entry(["agent", "sessions", "senders", "remove"], ["--json"]),
     // fixlines.ts launch_spec_change_sole_unlock (`mnemom agent sessions unlock <name>`); C11, C16 and
     // C17 specs; no source names an option; ruling 32.33.
     entry(["agent", "sessions", "unlock"]),
@@ -89,6 +103,13 @@ export const M1_CLI_SURFACE_BUILDERS = Object.freeze({
         "agent lock",
         "agent pause",
         "agent resume",
+        "agent sessions answer",
+        "agent sessions questions",
+        "agent sessions send",
+        "agent sessions senders",
+        "agent sessions senders add",
+        "agent sessions senders list",
+        "agent sessions senders remove",
         "agent sessions unlock",
     ]),
     C2: Object.freeze([

package/dist/vendor/shared/durable-contract/codes.d.ts

@@ -366,6 +366,66 @@ export declare const DURABLE_CODES: {
         readonly surfaces: readonly ["api"];
         readonly fields: readonly [];
     };
+    /** An agent sender with no live allowlist row for the recipient agent, set by the session's owner. */
+    readonly durable_inbox_not_allowlisted: {
+        readonly status: 403;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly [];
+    };
+    /** The session cannot take inbox work: reason not_locked, ended, unsealed or unattended_off (host_unattended is not true, so §60 (e) could never admit the turn). */
+    readonly durable_inbox_closed: {
+        readonly status: 409;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["reason"];
+    };
+    /** INBOX_OPEN_CAP messages are already open (admitted or delivered). */
+    readonly durable_inbox_full: {
+        readonly status: 429;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["open", "cap"];
+    };
+    /** A send, allowlist, take or ack body outside its closed shape or limits; field names the first bad key (null: not an object). */
+    readonly durable_inbox_body_invalid: {
+        readonly status: 422;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["field"];
+    };
+    /** An ack of a message not delivered to this session at this epoch with this sha. */
+    readonly durable_inbox_not_open: {
+        readonly status: 409;
+        readonly surfaces: readonly ["api"];
+        readonly fields: readonly [];
+    };
+    /** A sender identity or allowlist change the api refuses; reason is one of inbox.ts INBOX_SENDER_INVALID_REASONS. */
+    readonly durable_inbox_sender_invalid: {
+        readonly status: 422;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["reason"];
+    };
+    /** An ask, poll, release or answer body outside its closed shape or limits; field names the first bad key. */
+    readonly durable_question_body_invalid: {
+        readonly status: 422;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["field"];
+    };
+    /** No question with that approval_id on this session. */
+    readonly durable_question_not_found: {
+        readonly status: 404;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly [];
+    };
+    /** The question is no longer open (answered, dismissed, expired); state names which. */
+    readonly durable_question_closed: {
+        readonly status: 409;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["state"];
+    };
+    /** An ask while the session's open question is a different one (another question_sha); approval_id and state name it. Nothing is stored. */
+    readonly durable_question_busy: {
+        readonly status: 409;
+        readonly surfaces: readonly ["api", "cli"];
+        readonly fields: readonly ["approval_id", "state"];
+    };
 };
 export type DurableCode = keyof typeof DURABLE_CODES;
 export declare function isDurableCode(v: unknown): v is DurableCode;

package/dist/vendor/shared/durable-contract/codes.js

@@ -176,6 +176,28 @@ export const DURABLE_CODES = {
      * versions, or no charter at all (a malformed body). The gateway refuses admission on it.
      */
     durable_charter_not_found: { status: 404, surfaces: ["api"], fields: [] },
+    // ---- api inbox, S1 amendment 60 (signed off by Wassim 2026-11-02; inbox.ts INBOX_REJECT_CODES) ----
+    /** An agent sender with no live allowlist row for the recipient agent, set by the session's owner. */
+    durable_inbox_not_allowlisted: { status: 403, surfaces: ["api", "cli"], fields: [] },
+    /** The session cannot take inbox work: reason not_locked, ended, unsealed or unattended_off (host_unattended is not true, so §60 (e) could never admit the turn). */
+    durable_inbox_closed: { status: 409, surfaces: ["api", "cli"], fields: ["reason"] },
+    /** INBOX_OPEN_CAP messages are already open (admitted or delivered). */
+    durable_inbox_full: { status: 429, surfaces: ["api", "cli"], fields: ["open", "cap"] },
+    /** A send, allowlist, take or ack body outside its closed shape or limits; field names the first bad key (null: not an object). */
+    durable_inbox_body_invalid: { status: 422, surfaces: ["api", "cli"], fields: ["field"] },
+    /** An ack of a message not delivered to this session at this epoch with this sha. */
+    durable_inbox_not_open: { status: 409, surfaces: ["api"], fields: [] },
+    /** A sender identity or allowlist change the api refuses; reason is one of inbox.ts INBOX_SENDER_INVALID_REASONS. */
+    durable_inbox_sender_invalid: { status: 422, surfaces: ["api", "cli"], fields: ["reason"] },
+    // ---- api questions, S1 amendment 61 (signed off by Wassim 2026-11-02; question.ts) ----
+    /** An ask, poll, release or answer body outside its closed shape or limits; field names the first bad key. */
+    durable_question_body_invalid: { status: 422, surfaces: ["api", "cli"], fields: ["field"] },
+    /** No question with that approval_id on this session. */
+    durable_question_not_found: { status: 404, surfaces: ["api", "cli"], fields: [] },
+    /** The question is no longer open (answered, dismissed, expired); state names which. */
+    durable_question_closed: { status: 409, surfaces: ["api", "cli"], fields: ["state"] },
+    /** An ask while the session's open question is a different one (another question_sha); approval_id and state name it. Nothing is stored. */
+    durable_question_busy: { status: 409, surfaces: ["api", "cli"], fields: ["approval_id", "state"] },
 };
 export function isDurableCode(v) {
     return typeof v === "string" && Object.prototype.hasOwnProperty.call(DURABLE_CODES, v);

package/dist/vendor/shared/durable-contract/events.d.ts

@@ -30,9 +30,11 @@ export declare const DESIGN_EVENT_KINDS: {
 export declare const M1_EXCLUDED_KINDS: readonly ["intent.issued", "intent.committed", "intent.unknown", "intent.resolved", "intent.readmission_flagged", "context.note", "context.compacted", "inbox.acked"];
 /**
  * Every M1 kind (80) with its group, in §3.7 order, then the Doors amendment's three (rulings
- * 34.02, 34.06), appended so no existing index moves. Mirrors durable_event_kinds (parity test).
+ * 34.02, 34.06), executor.turn_continued, and inbox.acked (S1 amendment 60: M1 left it out, the
+ * inbox ack writes it; M1_EXCLUDED_KINDS stays the frozen M1 record), appended so no existing index
+ * moves. Mirrors durable_event_kinds (parity test).
  */
-export declare const DURABLE_EVENT_KINDS: readonly ["session.registered", "session.locked", "session.unlocked", "session.resumed", "session.detached", "session.parked", "session.suspended", "session.paused", "session.unpaused", "session.moved", "session.completed", "session.failed", "session.killed", "session.expired", "session.adopted", "seat.hello", "charter.sealed", "charter.amended", "charter.goal_sealed", "charter.card_drift", "profile.amended", "executor.upgraded", "attestation.passed", "attestation.failed", "lease.acquired", "lease.reclaimed", "lease.released", "lease.expired", "lease.fenced", "lease.zombie_call", "lease.stale_admit", "executor.enrolled", "executor.revoked", "executor.spawned", "executor.exited", "executor.contract_violation", "inbox.admitted", "inbox.rejected", "inbox.coalesced", "inbox.held_unsealed", "inbox.queued_for_home", "inbox.reverted", "inbox.delivered", "inbox.unmatched", "inbox.dead", "timer.set", "timer.fired", "timer.cancelled", "trigger.added", "trigger.removed", "trigger.fired", "trigger.suppressed", "trigger.over_cap", "wake.undelivered", "question.asked", "question.answered", "approval.requested", "approval.resolved", "approval.consumed", "approval.expired", "approval.superseded", "approval.single_person_override", "never.held", "chain.posture", "guard.refused", "guard.unavailable", "budget.reached", "grant.renewed", "grant.revoked", "verdict.violation", "identity.mismatch", "containment.pause", "containment.kill", "containment.auto_pause", "governance.degraded_admit", "governance.outage_mode_set", "policy.host_unattended_changed", "workspace.checkpointed", "rearm.recorded", "tip.signed", "session.ready", "session.waiting", "session.wait_cleared", "executor.turn_continued"];
+export declare const DURABLE_EVENT_KINDS: readonly ["session.registered", "session.locked", "session.unlocked", "session.resumed", "session.detached", "session.parked", "session.suspended", "session.paused", "session.unpaused", "session.moved", "session.completed", "session.failed", "session.killed", "session.expired", "session.adopted", "seat.hello", "charter.sealed", "charter.amended", "charter.goal_sealed", "charter.card_drift", "profile.amended", "executor.upgraded", "attestation.passed", "attestation.failed", "lease.acquired", "lease.reclaimed", "lease.released", "lease.expired", "lease.fenced", "lease.zombie_call", "lease.stale_admit", "executor.enrolled", "executor.revoked", "executor.spawned", "executor.exited", "executor.contract_violation", "inbox.admitted", "inbox.rejected", "inbox.coalesced", "inbox.held_unsealed", "inbox.queued_for_home", "inbox.reverted", "inbox.delivered", "inbox.unmatched", "inbox.dead", "timer.set", "timer.fired", "timer.cancelled", "trigger.added", "trigger.removed", "trigger.fired", "trigger.suppressed", "trigger.over_cap", "wake.undelivered", "question.asked", "question.answered", "approval.requested", "approval.resolved", "approval.consumed", "approval.expired", "approval.superseded", "approval.single_person_override", "never.held", "chain.posture", "guard.refused", "guard.unavailable", "budget.reached", "grant.renewed", "grant.revoked", "verdict.violation", "identity.mismatch", "containment.pause", "containment.kill", "containment.auto_pause", "governance.degraded_admit", "governance.outage_mode_set", "policy.host_unattended_changed", "workspace.checkpointed", "rearm.recorded", "tip.signed", "session.ready", "session.waiting", "session.wait_cleared", "executor.turn_continued", "inbox.acked"];
 export type DurableEventKind = (typeof DURABLE_EVENT_KINDS)[number];
 export declare function isDurableEventKind(v: unknown): v is DurableEventKind;
 /**