@mnemom/mnemom 0.17.32-next.0 → 0.17.32-next.2

package/dist/commands/agent-share-fixture.d.ts

@@ -0,0 +1,20 @@
+/**
+ * FIXTURE-ONLY statement source and card issuer for `mnemom agent share` (MNE-9037).
+ *
+ * Selected only when MNEMOM_AGENT_SHARE=1 AND MNEMOM_AGENT_SHARE_FIXTURE=1. It holds no key
+ * and signs nothing: the cards below are the two TEST cards committed in mnemom/aip
+ * (packages/verifier/test/fixtures/sharecard/{valid,period-revert}.json, key id
+ * test-sharecard-key-1) that the /share page's fixture verifier (MNE-9031) recognises. The
+ * issuer returns one of them only when the picked lines are exactly that card's lines; any
+ * other pick is an error. Two extra candidates (an estimate and an identifying label) exist so
+ * the refusal path can be shown. This is not a real issuer: a production source and signer
+ * are a separate, human-gated change.
+ */
+import type { AgentShareDeps, CandidateLine, ShareCardLike } from "./agent-share.js";
+export declare const AGENT_SHARE_FIXTURE_ENV = "MNEMOM_AGENT_SHARE_FIXTURE";
+export declare function agentShareFixtureEnabled(env?: Record<string, string | undefined>): boolean;
+export declare const FIXTURE_CARD_VALID: ShareCardLike;
+export declare const FIXTURE_CARD_PERIOD_REVERT: ShareCardLike;
+/** Real candidate lines plus two that must be refused. */
+export declare const FIXTURE_CANDIDATES: CandidateLine[];
+export declare const fixtureAgentShareParts: Pick<AgentShareDeps, "source" | "issuer">;

package/dist/commands/agent-share-fixture.js

@@ -0,0 +1,134 @@
+/**
+ * FIXTURE-ONLY statement source and card issuer for `mnemom agent share` (MNE-9037).
+ *
+ * Selected only when MNEMOM_AGENT_SHARE=1 AND MNEMOM_AGENT_SHARE_FIXTURE=1. It holds no key
+ * and signs nothing: the cards below are the two TEST cards committed in mnemom/aip
+ * (packages/verifier/test/fixtures/sharecard/{valid,period-revert}.json, key id
+ * test-sharecard-key-1) that the /share page's fixture verifier (MNE-9031) recognises. The
+ * issuer returns one of them only when the picked lines are exactly that card's lines; any
+ * other pick is an error. Two extra candidates (an estimate and an identifying label) exist so
+ * the refusal path can be shown. This is not a real issuer: a production source and signer
+ * are a separate, human-gated change.
+ */
+export const AGENT_SHARE_FIXTURE_ENV = "MNEMOM_AGENT_SHARE_FIXTURE";
+export function agentShareFixtureEnabled(env = process.env) {
+    return env.MNEMOM_AGENT_SHARE === "1" && env[AGENT_SHARE_FIXTURE_ENV] === "1";
+}
+export const FIXTURE_CARD_VALID = {
+    typ: "AAP-ShareCard/v1",
+    card_id: "card-valid-0001",
+    period: {
+        start: "2026-10-01",
+        end: "2026-10-07",
+    },
+    issued_at: "2026-10-08T00:00:00.000Z",
+    signing_key_id: "test-sharecard-key-1",
+    statements: [
+        {
+            typ: "AAP-Statement/v1",
+            hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+    ],
+    lines: [
+        {
+            id: "l1",
+            kind: "count",
+            label: "Changes reviewed",
+            value: 42,
+            statement_hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            id: "l2",
+            kind: "count",
+            label: "Checks passed",
+            value: 40,
+            statement_hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+    ],
+    signature: "qsHSChAxBEnEyNoQQLQMFXZ6LKxruMyijxA5s3h9oPKl4OijJqxFm3QC0rteDXJsYwJCMeKyk_0xzGTDc3wDAQ",
+};
+export const FIXTURE_CARD_PERIOD_REVERT = {
+    typ: "AAP-ShareCard/v1",
+    card_id: "card-period-0001",
+    period: {
+        start: "2026-10-01",
+        end: "2026-10-07",
+    },
+    issued_at: "2026-10-08T00:00:00.000Z",
+    signing_key_id: "test-sharecard-key-1",
+    statements: [
+        {
+            typ: "AAP-Statement/v1",
+            hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+        {
+            typ: "AAP-Statement/v1",
+            hash: "3333333333333333333333333333333333333333333333333333333333333333",
+        },
+    ],
+    lines: [
+        {
+            id: "l1",
+            kind: "count",
+            label: "Changes reviewed",
+            value: 42,
+            statement_hash: "1111111111111111111111111111111111111111111111111111111111111111",
+        },
+        {
+            id: "l2",
+            kind: "count",
+            label: "Checks passed",
+            value: 40,
+            statement_hash: "2222222222222222222222222222222222222222222222222222222222222222",
+        },
+        {
+            id: "l3",
+            kind: "revert",
+            label: "Changes reverted",
+            value: 2,
+            statement_hash: "3333333333333333333333333333333333333333333333333333333333333333",
+        },
+    ],
+    signature: "OQf-4xgUQbIxOef_BsJeTehfpqLPPR2GTv8_y6EbxPX9UkFp2PpE2pnETh2VqcwDfV1U_4bSR8Pwrpsch3DwCw",
+};
+const FIXTURE_CARDS = [FIXTURE_CARD_VALID, FIXTURE_CARD_PERIOD_REVERT];
+const HASH_E = "e".repeat(64);
+const HASH_F = "f".repeat(64);
+/** Real candidate lines plus two that must be refused. */
+export const FIXTURE_CANDIDATES = [
+    ...FIXTURE_CARD_PERIOD_REVERT.lines,
+    {
+        id: "e1",
+        kind: "count",
+        label: "Hours saved",
+        value: 12,
+        statement_hash: HASH_E,
+        estimated: true,
+    },
+    { id: "r1", kind: "count", label: "Repo mnemom/aip", value: 3, statement_hash: HASH_F },
+];
+const same = (a, b) => a.length === b.length &&
+    a.every((l) => {
+        const m = b.find((x) => x.id === l.id);
+        return m !== undefined && JSON.stringify(m) === JSON.stringify(l);
+    });
+export const fixtureAgentShareParts = {
+    source: { listLines: async () => FIXTURE_CANDIDATES },
+    issuer: {
+        issue: async (lines) => {
+            const card = FIXTURE_CARDS.find((c) => same(c.lines, lines));
+            if (!card) {
+                throw new Error("fixture issuer only issues the two test cards: pick l1,l2 or l1,l2,l3");
+            }
+            return structuredClone(card);
+        },
+    },
+};

package/dist/commands/agent-share.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `mnemom agent share` (MNE-9037, parent MNE-9014) — build a shareable work card from the
+ * lines of your own signed statements and print a link to the static share page with the
+ * card in the URL fragment (`/share#card=<base64url(JSON)>`). The fragment is never sent to
+ * a server. The command only PRINTS the link: it never posts, uploads or opens it anywhere
+ * (W6.2 — the share offer never auto-posts).
+ *
+ * Gated by MNEMOM_AGENT_SHARE=1 (not experimental-registry; off by default, so default CLI
+ * behaviour is unchanged). Everything outside the process is injected:
+ *   - `source`   lists candidate lines from the user's signed statements,
+ *   - `issuer`   returns the SIGNED AAP-ShareCard/v1 for the chosen lines (the CLI never holds
+ *                a signing key),
+ *   - `renderer` the aip `renderLines` (MNE-9026, unpublished) behind a small interface.
+ * The CLI refuses, before anything is issued, lines that are estimates or that carry
+ * identifying fields, and re-checks the returned card for the same.
+ */
+export declare const AGENT_SHARE_ENV = "MNEMOM_AGENT_SHARE";
+export declare function agentShareEnabled(env?: Record<string, string | undefined>): boolean;
+/** A line as offered by the statement source. Extra keys are kept so they can be refused. */
+export interface CandidateLine {
+    id: string;
+    kind: string;
+    label: string;
+    value: number;
+    statement_hash: string;
+    [extra: string]: unknown;
+}
+export interface SharedCardLine {
+    id: string;
+    kind: "count" | "revert";
+    label: string;
+    value: number;
+    statement_hash: string;
+}
+/** Shape of AAP-ShareCard/v1 as far as the CLI needs it (full verification is the page's job). */
+export interface ShareCardLike {
+    typ: string;
+    lines: SharedCardLine[];
+    [key: string]: unknown;
+}
+export interface RenderedLinePreview {
+    text: string;
+    coverage?: string;
+    kind: string;
+}
+/** The aip `renderLines` contract, injected (not yet published). */
+export interface LineRenderer {
+    renderLines(card: unknown): RenderedLinePreview[];
+}
+export interface StatementSource {
+    listLines(): Promise<CandidateLine[]>;
+}
+export interface CardIssuer {
+    /** Signed card committing to exactly these lines. */
+    issue(lines: SharedCardLine[]): Promise<ShareCardLike>;
+}
+export interface AgentShareDeps {
+    source: StatementSource;
+    issuer: CardIssuer;
+    renderer: LineRenderer;
+    /** Interactive picker: returns the chosen line ids. */
+    pick: (lines: SharedCardLine[]) => Promise<string[]>;
+    isTTY: () => boolean;
+    websiteBase: () => string;
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+export interface AgentShareFlags {
+    lines?: string;
+    list?: boolean;
+    json?: boolean;
+}
+export type RefusalReason = "estimate" | "identifying" | "malformed";
+export interface Refusal {
+    id: string;
+    reason: RefusalReason;
+    detail: string;
+}
+/** Null when the line may be shared; otherwise why it is refused. Fails closed. */
+export declare function refuseReason(line: CandidateLine): Refusal | null;
+export declare function toSharedLine(line: CandidateLine): SharedCardLine;
+/** Card → `<base>/share#card=<base64url(UTF-8 JSON)>` (the format the share page reads). */
+export declare function buildShareLink(card: unknown, websiteBase: string): string;
+/** Inverse of buildShareLink's fragment, for tests and `--json` consumers. */
+export declare function decodeShareFragment(link: string): unknown;
+export declare function agentShareCommand(flags: AgentShareFlags, deps: AgentShareDeps, env?: Record<string, string | undefined>): Promise<number>;
+export declare const liveAgentShareDeps: AgentShareDeps;

package/dist/commands/agent-share.js

@@ -0,0 +1,251 @@
+/**
+ * `mnemom agent share` (MNE-9037, parent MNE-9014) — build a shareable work card from the
+ * lines of your own signed statements and print a link to the static share page with the
+ * card in the URL fragment (`/share#card=<base64url(JSON)>`). The fragment is never sent to
+ * a server. The command only PRINTS the link: it never posts, uploads or opens it anywhere
+ * (W6.2 — the share offer never auto-posts).
+ *
+ * Gated by MNEMOM_AGENT_SHARE=1 (not experimental-registry; off by default, so default CLI
+ * behaviour is unchanged). Everything outside the process is injected:
+ *   - `source`   lists candidate lines from the user's signed statements,
+ *   - `issuer`   returns the SIGNED AAP-ShareCard/v1 for the chosen lines (the CLI never holds
+ *                a signing key),
+ *   - `renderer` the aip `renderLines` (MNE-9026, unpublished) behind a small interface.
+ * The CLI refuses, before anything is issued, lines that are estimates or that carry
+ * identifying fields, and re-checks the returned card for the same.
+ */
+import { createInterface } from "node:readline/promises";
+import { getWebsiteUrl } from "../lib/config.js";
+import { fmt } from "../lib/format.js";
+export const AGENT_SHARE_ENV = "MNEMOM_AGENT_SHARE";
+export function agentShareEnabled(env = process.env) {
+    return env[AGENT_SHARE_ENV] === "1";
+}
+const HEX64 = /^[0-9a-f]{64}$/;
+const OPAQUE_ID = /^[a-z0-9_-]{1,64}$/;
+/** Same charset the verifier enforces on labels. */
+const LABEL = /^[A-Za-z0-9 .,()+-]{1,40}$/;
+/** The only top-level fields an AAP-ShareCard/v1 may carry. */
+const CARD_KEYS = [
+    "typ",
+    "card_id",
+    "period",
+    "issued_at",
+    "signing_key_id",
+    "statements",
+    "lines",
+    "signature",
+];
+const LINE_KEYS = ["id", "kind", "label", "value", "statement_hash"];
+/** Words that mark a label as naming a repo, org, person, tool, code or goal text. */
+const IDENTIFYING_LABEL = /\b(repo|repository|org|organization|organisation|team|person|user|author|tool|goal|code|branch|commit|pr)\b/i;
+/** Null when the line may be shared; otherwise why it is refused. Fails closed. */
+export function refuseReason(line) {
+    const id = typeof line.id === "string" ? line.id : "(unknown)";
+    const no = (reason, detail) => ({ id, reason, detail });
+    if (line.estimated === true || line.estimate === true || line.provenance === "estimate") {
+        return no("estimate", "it is an estimate, not a count from a signed statement");
+    }
+    const extras = Object.keys(line).filter((k) => !LINE_KEYS.includes(k));
+    if (extras.length > 0) {
+        return no("identifying", `it carries extra field(s): ${extras.join(", ")}`);
+    }
+    if (typeof line.id !== "string" || !OPAQUE_ID.test(line.id))
+        return no("malformed", "bad line id");
+    if (line.kind !== "count" && line.kind !== "revert")
+        return no("malformed", "unsupported line kind");
+    if (typeof line.value !== "number" || !Number.isSafeInteger(line.value) || line.value < 0) {
+        return no("estimate", "its value is not an exact non-negative integer");
+    }
+    if (typeof line.statement_hash !== "string" || !HEX64.test(line.statement_hash)) {
+        return no("estimate", "it is not tied to a signed statement");
+    }
+    if (typeof line.label !== "string" ||
+        !LABEL.test(line.label) ||
+        /[/#]|:\/\/|www\./i.test(line.label)) {
+        return no("identifying", "its label is not short plain text");
+    }
+    if (IDENTIFYING_LABEL.test(line.label)) {
+        return no("identifying", "its label names a repo, org, person, tool, code or goal");
+    }
+    return null;
+}
+export function toSharedLine(line) {
+    return {
+        id: line.id,
+        kind: line.kind,
+        label: line.label,
+        value: line.value,
+        statement_hash: line.statement_hash,
+    };
+}
+/** Card → `<base>/share#card=<base64url(UTF-8 JSON)>` (the format the share page reads). */
+export function buildShareLink(card, websiteBase) {
+    const bytes = new TextEncoder().encode(JSON.stringify(card));
+    const b64 = Buffer.from(bytes).toString("base64url");
+    return `${websiteBase.replace(/\/+$/, "")}/share#card=${b64}`;
+}
+/** Inverse of buildShareLink's fragment, for tests and `--json` consumers. */
+export function decodeShareFragment(link) {
+    const hash = link.slice(link.indexOf("#") + 1);
+    const encoded = new URLSearchParams(hash).get("card") ?? "";
+    try {
+        return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** The issued card must contain exactly the chosen lines, unaltered. */
+function checkIssuedCard(card, chosen) {
+    if (!card || typeof card !== "object" || !Array.isArray(card.lines))
+        return "the card has no lines";
+    const extra = Object.keys(card).filter((k) => !CARD_KEYS.includes(k));
+    if (extra.length > 0)
+        return `the card carries unexpected field(s): ${extra.join(", ")}`;
+    if (card.lines.length !== chosen.length)
+        return "the card's lines differ from the ones you picked";
+    for (const want of chosen) {
+        const got = card.lines.find((l) => l.id === want.id);
+        if (!got ||
+            LINE_KEYS.some((k) => got[k] !== want[k]) ||
+            Object.keys(got).length !== LINE_KEYS.length) {
+            return `the card's line "${want.id}" differs from the one you picked`;
+        }
+    }
+    return null;
+}
+export async function agentShareCommand(flags, deps, env = process.env) {
+    if (!agentShareEnabled(env)) {
+        deps.err(fmt.error("unknown command 'share' for 'mnemom agent'"));
+        return 1;
+    }
+    let candidates;
+    try {
+        candidates = await deps.source.listLines();
+    }
+    catch (error) {
+        deps.err(fmt.error(`Could not read your signed statements: ${error.message}`));
+        return 1;
+    }
+    const offered = [];
+    const refused = [];
+    for (const c of candidates) {
+        const r = refuseReason(c);
+        if (r)
+            refused.push(r);
+        else
+            offered.push(toSharedLine(c));
+    }
+    if (flags.list) {
+        if (flags.json) {
+            deps.out(JSON.stringify({ lines: offered, refused }, null, 2));
+        }
+        else {
+            if (offered.length === 0)
+                deps.out("No lines available to share.");
+            for (const l of offered)
+                deps.out(`${l.id}  ${l.label}: ${l.value}`);
+            for (const r of refused)
+                deps.out(`(not shareable) ${r.id}: ${r.detail}`);
+        }
+        return 0;
+    }
+    let ids;
+    if (flags.lines !== undefined) {
+        ids = [
+            ...new Set(flags.lines
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)),
+        ];
+    }
+    else if (deps.isTTY()) {
+        if (offered.length === 0) {
+            deps.err(fmt.error("No lines available to share."));
+            return 1;
+        }
+        ids = await deps.pick(offered);
+    }
+    else {
+        deps.err(fmt.error("No terminal to pick lines in. Pass --lines <id,id> (see --list)."));
+        return 1;
+    }
+    if (ids.length === 0) {
+        deps.err(fmt.error("No lines picked."));
+        return 1;
+    }
+    const chosen = [];
+    for (const id of ids) {
+        const r = refused.find((x) => x.id === id);
+        if (r) {
+            deps.err(fmt.error(`Refusing line "${id}": ${r.detail}.`));
+            return 1;
+        }
+        const line = offered.find((l) => l.id === id);
+        if (!line) {
+            deps.err(fmt.error(`Unknown line "${id}". Run with --list to see what is available.`));
+            return 1;
+        }
+        chosen.push(line);
+    }
+    let card;
+    try {
+        card = await deps.issuer.issue(chosen);
+    }
+    catch (error) {
+        deps.err(fmt.error(`Could not build the card: ${error.message}`));
+        return 1;
+    }
+    const problem = checkIssuedCard(card, chosen);
+    if (problem) {
+        deps.err(fmt.error(`Refusing to share: ${problem}.`));
+        return 1;
+    }
+    const link = buildShareLink(card, deps.websiteBase());
+    if (flags.json) {
+        deps.out(JSON.stringify({ link, lines: chosen }, null, 2));
+        return 0;
+    }
+    deps.out("Your card:");
+    for (const r of deps.renderer.renderLines(card)) {
+        deps.out(`  ${r.text}${r.coverage ? ` (${r.coverage})` : ""}`);
+    }
+    deps.out("");
+    deps.out(link);
+    deps.out("");
+    deps.out("Nothing was posted or sent. The card is in the link's fragment, which a browser never sends to a server; share the link yourself if you want to.");
+    return 0;
+}
+/** Not wired to a backend yet: the signed-statement source and card issuer land with MNE-9026. */
+const notConnected = () => {
+    throw new Error("statement source not connected yet (waiting on the card renderer, MNE-9026)");
+};
+export const liveAgentShareDeps = {
+    source: { listLines: async () => notConnected() },
+    issuer: { issue: async () => notConnected() },
+    renderer: {
+        renderLines: (card) => (card.lines ?? []).map((l) => ({
+            text: `${l.label}: ${l.value}`,
+            kind: l.kind,
+        })),
+    },
+    pick: async (lines) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            lines.forEach((l, i) => process.stderr.write(`${i + 1}. ${l.label}: ${l.value}\n`));
+            const answer = await rl.question("Pick lines (numbers, comma-separated): ");
+            return answer
+                .split(",")
+                .map((s) => lines[Number(s.trim()) - 1]?.id)
+                .filter((x) => typeof x === "string");
+        }
+        finally {
+            rl.close();
+        }
+    },
+    isTTY: () => Boolean(process.stdin.isTTY),
+    websiteBase: getWebsiteUrl,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+};

package/dist/commands/agent.d.ts

@@ -30,7 +30,7 @@ import { type SessionRecord } from "../lib/agent-ledger.js";
 import { type ExperimentalId } from "../lib/experimental.js";
 import { conductReceiptFor, type ReceiptLaunch } from "../lib/conduct-receipt.js";
 import { type GovernanceOptIn } from "./agent-setup.js";
-import { type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
+import { type CcSettingsView, type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
     requirement?: string[];
@@ -311,6 +311,28 @@ export interface RcCapability {
  * and by the auto-default selection (a bare launch prefers RC when capable).
  */
 export declare function checkRcCapability(cli: ResolvedCli): RcCapability;
+/**
+ * The extra `--settings` the launch merges (beside the autocompact guard): the status line's,
+ * and with commit reporting on (W1.8) the `Mnemom-Conversation` commit trailer, which keeps the
+ * user's own commit attribution in front of it. Never when the user passed their own --settings.
+ */
+export declare function launchSettingsExtra(o: {
+    statusline: Record<string, unknown> | null;
+    commitReport: boolean;
+    ownSettings: boolean;
+    conversationId: string;
+    /** Claude Code's settings files, highest precedence first (readCcSettings). */
+    settings: CcSettingsView[];
+}): Record<string, unknown> | null;
+/**
+ * Whether the local base-URL proxy runs: implicit goals (turn header), the conduct receipt and
+ * commit reporting (W1.8) all need it; commit reporting reads the lineage key it records.
+ */
+export declare function proxyWanted(o: {
+    turnHeader: boolean;
+    receipt: boolean;
+    commitReport: boolean;
+}): boolean;
 /**
  * Whether the proxy captures the gateway's record state: the conduct receipt reads it at exit,
  * and the fed status line reads its lineage key while the session runs.
@@ -345,6 +367,15 @@ export declare function prepareStatuslineFeed(o: {
 }): {
     feedFile: string;
 } | null;
+/**
+ * Whether the launch reads or writes Record, and so needs the served agent's org: the conduct
+ * receipt, commit reporting and the fed status line each key on it (lib/record-org).
+ */
+export declare function recordOrgWanted(o: {
+    receipt: boolean;
+    commitReport: boolean;
+    fedStatusline: boolean;
+}): boolean;
 /**
  * Whether this launch feeds the status line measured model cost and μ (W1.4): prerelease
  * builds only (stable stays "mnemom", decision 14), and only when the turn proxy runs, since

package/dist/commands/agent.js

@@ -34,9 +34,11 @@ import { fileURLToPath } from "node:url";
 import { FEED_ENV, statuslineLaunch } from "../lib/statusline.js";
 import { startFeed } from "../lib/statusline-feed.js";
 import { isPrerelease } from "../lib/update/semver.js";
+import { attributionSettings, COMMIT_REPORT_ENV, commitReportEnabled, realGit, startCommitReporter, } from "../lib/commit-report.js";
 import { ALLOW_AUTOCOMPACT_OFF_ENV, dropAutocompactOffEnv, hasOwnSettingsFlag, mergedSettingsArgs, planAutocompactGuard, } from "../lib/autocompact-guard.js";
 import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { createApiKey } from "../lib/api.js";
+import { recordOrgFor } from "../lib/record-org.js";
 import { MNEMOM_KEY_STORE_FIELD, resolveAgentAuth, sayRetiredConsoleNotice, readMnemomKey, resolveSubscriptionMnemomKey, subscriptionChildEnv, subscriptionShape, } from "../lib/subscription-login.js";
 import { LEDGER_FILE, appendSessionRecord, findResumeCandidate, readSessionRecords, resolveRetentionDays, resumedContextProfile, toLedgerContract, } from "../lib/agent-ledger.js";
 import { isLoggedIn } from "../lib/auth.js";
@@ -705,6 +707,16 @@ export async function agentCommand(scenarioArg, options = {}) {
         }
     }
     if (shape === "terminal") {
+        // Record keys the lineage under the served agent's org, not the account org (lib/record-org).
+        const recordOrgId = recordOrgWanted({
+            receipt: experimental.includes("record"),
+            commitReport: cli.name === "claude" && commitReportEnabled(process.env[COMMIT_REPORT_ENV], CLI_VERSION),
+            fedStatusline: cli.name === "claude" && fedStatuslineWanted(CLI_VERSION, Boolean(goalMode), process.env),
+        }) && account.orgId
+            ? await recordOrgFor(servedAgentId, account.orgId, {
+                onFallback: (reason) => say(fmt.warn(`mnemom agent: record: could not read ${servedAgentId}'s org (${reason}); using ${account.orgId}, which may hold none of this session's record.`)),
+            })
+            : account.orgId;
         launchTerminal({
             cli,
             door,
@@ -734,9 +746,12 @@ export async function agentCommand(scenarioArg, options = {}) {
             knownCcSessionId: cc.id ?? continuedCcSessionId,
             plugin,
             receipt: experimental.includes("record")
-                ? { orgId: account.orgId, agentId: servedAgentId }
+                ? { orgId: recordOrgId, agentId: servedAgentId }
                 : undefined,
-            orgId: account.orgId,
+            orgId: recordOrgId,
+            commitReport: cli.name === "claude" &&
+                Boolean(account.orgId) &&
+                commitReportEnabled(process.env[COMMIT_REPORT_ENV], CLI_VERSION),
         });
         return; // launchTerminal exits the process
     }
@@ -1292,9 +1307,18 @@ function launchTerminal(ctx) {
             env: process.env,
             childEnv,
         });
-        // Autocompact guard (lib/autocompact-guard.ts): one --settings carries both layers.
-        const guard = applyAutocompactGuard(childEnv, ctx.options, !hasOwnSettingsFlag(passthrough));
-        args.push(...mergedSettingsArgs(guard, sl?.settings ?? null));
+        // Autocompact guard (lib/autocompact-guard.ts): one --settings carries every layer. The
+        // commit trailer (W1.8) rides in it unless the user passed their own --settings.
+        const ownSettings = hasOwnSettingsFlag(passthrough);
+        const guard = applyAutocompactGuard(childEnv, ctx.options, !ownSettings);
+        const extra = launchSettingsExtra({
+            statusline: sl?.settings ?? null,
+            commitReport: Boolean(ctx.commitReport),
+            ownSettings,
+            conversationId: ctx.conversationId,
+            settings: ctx.commitReport && !ownSettings ? ccSettings() : [],
+        });
+        args.push(...mergedSettingsArgs(guard, extra));
     }
     if (ctx.contextHint) {
         seedContextHintFlag(childEnv);
@@ -1303,7 +1327,17 @@ function launchTerminal(ctx) {
     }
     let recordStatePath;
     const run = () => {
+        const launchedSec = Math.floor(Date.now() / 1000);
         const child = spawn(ctx.cli.bin, args, { stdio: "inherit", env: childEnv });
+        // W1.8: report the session's commits while it runs; no record state (no proxy) → no reports.
+        const commits = ctx.commitReport && ctx.orgId && recordStatePath
+            ? startCommitReporter({
+                orgId: ctx.orgId,
+                recordStateFile: recordStatePath,
+                sinceSec: launchedSec,
+                git: realGit(process.cwd()),
+            })
+            : null;
         child.on("error", (err) => {
             say(`mnemom agent: failed to launch ${ctx.cli.name}: ${err.message}`);
             process.exit(1);
@@ -1313,10 +1347,12 @@ function launchTerminal(ctx) {
                 process.kill(process.pid, signal);
             else
                 void (async () => {
-                    // The conduct receipt never blocks exit (a hard deadline inside) and never changes
-                    // the exit code.
+                    // The conduct receipt and the last commit sweep run side by side, each under its own
+                    // hard deadline inside W1.3's exit budget; neither changes the exit code.
+                    const swept = commits?.finish().catch(() => undefined);
                     if (ctx.receipt)
                         await sayConductReceipt({ ...ctx.receipt, statePath: recordStatePath });
+                    await swept;
                     // Claude Code's own last line is "Resume this session with: claude --resume <id>",
                     // which reopens it OUTSIDE Mnemom (ungoverned, unbilled). Ours goes after it, last.
                     if (code === 0 && ctx.resumeHint && wantsResumeHint(ctx.cli, args)) {
@@ -1334,7 +1370,11 @@ function launchTerminal(ctx) {
     // implicit), to capture the lineage key the conduct receipt reads. Fail-open: no proxy → the
     // door directly, as before, and a receipt that links instead of giving figures.
     const turnHeader = Boolean(ctx.goalMode) && turnProxyWanted(process.env);
-    if (!turnHeader && !ctx.receipt) {
+    if (!proxyWanted({
+        turnHeader,
+        receipt: Boolean(ctx.receipt),
+        commitReport: Boolean(ctx.commitReport),
+    })) {
         run();
         return;
     }
@@ -1343,7 +1383,30 @@ function launchTerminal(ctx) {
             recordStatePath = statePath;
         onBaseUrlProxyReady(baseUrl, statePath, childEnv, feed && ctx.orgId ? { ...feed, orgId: ctx.orgId } : null);
         run();
-    }, { turnHeader, recordState: wantsRecordState(Boolean(ctx.receipt), feed !== null) });
+    }, {
+        turnHeader,
+        recordState: wantsRecordState(Boolean(ctx.receipt || ctx.commitReport), feed !== null),
+    });
+}
+/**
+ * The extra `--settings` the launch merges (beside the autocompact guard): the status line's,
+ * and with commit reporting on (W1.8) the `Mnemom-Conversation` commit trailer, which keeps the
+ * user's own commit attribution in front of it. Never when the user passed their own --settings.
+ */
+export function launchSettingsExtra(o) {
+    const trailer = o.commitReport && !o.ownSettings
+        ? attributionSettings(o.conversationId, o.settings.find((v) => v.commitAttribution !== undefined)?.commitAttribution)
+        : null;
+    if (!o.statusline && !trailer)
+        return null;
+    return { ...(o.statusline ?? {}), ...(trailer ?? {}) };
+}
+/**
+ * Whether the local base-URL proxy runs: implicit goals (turn header), the conduct receipt and
+ * commit reporting (W1.8) all need it; commit reporting reads the lineage key it records.
+ */
+export function proxyWanted(o) {
+    return o.turnHeader || o.receipt || o.commitReport;
 }
 /**
  * Whether the proxy captures the gateway's record state: the conduct receipt reads it at exit,
@@ -1376,6 +1439,13 @@ export function prepareStatuslineFeed(o) {
     o.childEnv[FEED_ENV] = feed.feedFile;
     return feed;
 }
+/**
+ * Whether the launch reads or writes Record, and so needs the served agent's org: the conduct
+ * receipt, commit reporting and the fed status line each key on it (lib/record-org).
+ */
+export function recordOrgWanted(o) {
+    return o.receipt || o.commitReport || o.fedStatusline;
+}
 /**
  * Whether this launch feeds the status line measured model cost and μ (W1.4): prerelease
  * builds only (stable stays "mnemom", decision 14), and only when the turn proxy runs, since

package/dist/index.js

@@ -14,6 +14,8 @@ import { policyInitCommand, policyValidateCommand, policyPublishCommand, policyL
 import { protectionShowCommand, protectionPublishCommand, protectionValidateCommand, protectionEditCommand, protectionDriftCommand, } from "./commands/protection.js";
 import { agentsListCommand, agentsClaimCommand, agentsMoveCommand } from "./commands/agents.js";
 import { agentExportCommand, liveExportDeps } from "./commands/agent-export.js";
+import { agentShareCommand, liveAgentShareDeps } from "./commands/agent-share.js";
+import { agentShareFixtureEnabled, fixtureAgentShareParts, } from "./commands/agent-share-fixture.js";
 import { agentSessionsCommand, agentShowCommand, liveSessionDeps, } from "./commands/agent-sessions.js";
 import { agentGoalPinCommand, agentGoalResetCommand, agentGoalShowCommand, liveGoalDeps, } from "./commands/agent-goal.js";
 import { agentFuelCommand, liveFuelDeps } from "./commands/agent-fuel.js";
@@ -911,6 +913,21 @@ agentCmd
     .action(async (idOrName, opts) => {
     process.exitCode = await agentExportCommand(idOrName, opts, liveExportDeps);
 });
+// Hidden until MNEMOM_AGENT_SHARE=1 (MNE-9037): with the flag off the command behaves as unknown.
+agentCmd
+    .command("share", { hidden: true })
+    .description("Build a shareable card from lines of your signed statements and print the share-page link (card in the URL fragment; nothing is posted). Needs MNEMOM_AGENT_SHARE=1")
+    .option("--lines <ids>", "Comma-separated line ids to include (skips the picker)")
+    .option("--list", "List the lines available to share and exit")
+    .option("--json", "Print JSON instead of text")
+    .action(async (opts) => {
+    // MNEMOM_AGENT_SHARE_FIXTURE=1 (with MNEMOM_AGENT_SHARE=1) swaps in the test-only fixture
+    // source/issuer; otherwise the not-yet-connected live deps are used, unchanged.
+    const deps = agentShareFixtureEnabled()
+        ? { ...liveAgentShareDeps, ...fixtureAgentShareParts }
+        : liveAgentShareDeps;
+    process.exitCode = await agentShareCommand(opts, deps);
+});
 agentCmd
     .command("sessions")
     .description("List your Mnemom Agent sessions from the local ledger (~/.mnemom/sessions.jsonl), newest first — the last 20 unless --all")

package/dist/lib/agent.d.ts

@@ -269,6 +269,8 @@ export declare function supportsOneM(model: string): boolean;
 export interface CcSettingsView {
     model?: string;
     env?: Record<string, string | undefined>;
+    /** `attribution.commit`, or false when `attribution` is false (all attribution hidden). */
+    commitAttribution?: string | false;
 }
 /**
  * Claude Code's settings files, highest precedence first: `<cwd>/.claude/settings.local.json`,

package/dist/lib/agent.js

@@ -314,6 +314,13 @@ export function readCcSettings(opts) {
             const view = {};
             if (typeof o.model === "string")
                 view.model = o.model;
+            if (o.attribution === false)
+                view.commitAttribution = false;
+            else if (o.attribution && typeof o.attribution === "object") {
+                const commit = o.attribution.commit;
+                if (typeof commit === "string")
+                    view.commitAttribution = commit;
+            }
             if (o.env && typeof o.env === "object") {
                 view.env = Object.fromEntries(Object.entries(o.env).filter((e) => typeof e[1] === "string"));
             }

package/dist/lib/api.d.ts

@@ -450,6 +450,19 @@ export interface RecordTotals {
     row_count: number;
 }
 export declare function getRecordTotals(orgId: string, lineageKey: string, signal?: AbortSignal): Promise<RecordTotals>;
+/**
+ * Report one commit to Record's commit index (Doors W1.8, lib/commit-report.ts):
+ * `POST /v1/orgs/{org}/record/commits`, body RecordCommit/v1. Returns the HTTP
+ * status, never throws on a non-2xx: the caller fails open on every outcome.
+ */
+export declare function postRecordCommit(orgId: string, body: {
+    schema: "RecordCommit/v1";
+    lineage_key: string;
+    repo: string;
+    branch: string;
+    sha: string;
+    patch_id: string;
+}, signal?: AbortSignal): Promise<number>;
 export declare function getMuBalance(orgId?: string): Promise<MuBalance>;
 /**
  * Mint the one-time `cards:write:protection` capability for an agent — the

package/dist/lib/api.js

@@ -411,6 +411,25 @@ export async function getMe() {
 export async function getRecordTotals(orgId, lineageKey, signal) {
     return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/record/totals?lineage_key=${encodeURIComponent(lineageKey)}`, signal ? { signal } : {}, { notFoundLabel: "Record totals", fallback: "Could not read record totals" });
 }
+/**
+ * Report one commit to Record's commit index (Doors W1.8, lib/commit-report.ts):
+ * `POST /v1/orgs/{org}/record/commits`, body RecordCommit/v1. Returns the HTTP
+ * status, never throws on a non-2xx: the caller fails open on every outcome.
+ */
+export async function postRecordCommit(orgId, body, signal) {
+    const url = validateUrl(`${API_BASE}/v1/orgs/${encodeURIComponent(orgId)}/record/commits`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        method: "POST",
+        headers: {
+            ...(await authHeaders()),
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        ...(signal ? { signal } : {}),
+    }));
+    return response.status;
+}
 export async function getMuBalance(orgId) {
     const q = orgId ? `?org_id=${encodeURIComponent(orgId)}` : "";
     return gFetch(`/v1/billing/mu${q}`, {}, { fallback: "Could not read MU balance" });

package/dist/lib/commit-report.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Door one's commit reporting (Doors W1.8, OD-3, OD-5): the launcher adds the
+ * `Mnemom-Conversation` trailer and reports every commit the session makes to
+ * Record's commit index, so the PR record reads "N of M commits bound" with N
+ * equal to M.
+ *
+ * TRAILER. Claude Code writes `attribution.commit` into each commit it makes; the
+ * launcher passes it through `--settings` (OD-3). The model writes it, so it is
+ * best-effort; the commit index is the proof. The user's own commit attribution
+ * (or Claude Code's default Co-Authored-By line) is kept in front of ours, because
+ * a `--settings` value replaces theirs.
+ *
+ * INDEX. While Claude Code runs, the launcher looks for commits made in this
+ * repository since the launch, on local branches, by this repository's git user,
+ * and POSTs each one (sha, `git patch-id --stable`, branch, repo) to
+ * `POST /v1/orgs/{org}/record/commits` under the session's lineage key: the
+ * gateway's `x-mnemom-lineage-key`, captured by the local proxy into the
+ * record-state file (the CLI never derives one). Every session commit is
+ * reported, trailer or not: a commit is bound when the index holds its sha or
+ * patch-id, never by its trailer alone.
+ *
+ * PRERELEASE DEFAULT. On for a prerelease build (`next`), off for stable;
+ * MNEMOM_AGENT_COMMIT_REPORT=on|off overrides, and any other value reads off.
+ *
+ * FAIL OPEN. Nothing here throws into the launch or changes its exit code. A
+ * dark route (404) stops reporting for the session; a failed POST is retried on
+ * the next poll; a commit whose fields cannot be read is not sent (it stays
+ * unbound rather than a doomed request). The final sweep at exit races a hard
+ * deadline.
+ */
+export declare const COMMIT_REPORT_ENV = "MNEMOM_AGENT_COMMIT_REPORT";
+export declare const TRAILER_KEY = "Mnemom-Conversation";
+/** Claude Code's own commit attribution when none is configured (settings reference, `attribution`). */
+export declare const CC_DEFAULT_COMMIT_ATTRIBUTION = "Co-Authored-By: Claude <noreply@anthropic.com>";
+/** How often the launcher looks for new commits while the session runs. */
+export declare const COMMIT_POLL_MS = 5000;
+/** The final sweep at exit shares W1.3's 2 s exit budget with the conduct receipt. */
+export declare const COMMIT_FINAL_DEADLINE_MS = 1500;
+/** on | off | unset (prerelease default); any other value reads off. */
+export declare function commitReportEnabled(raw: string | undefined, version: string): boolean;
+/**
+ * The `--settings` fragment carrying the trailer. `user` is the commit attribution
+ * the user's settings files give (highest precedence first; `false` hides all
+ * attribution, an empty string hides the commit line): it is kept in front of ours.
+ */
+export declare function attributionSettings(conversationId: string, user: string | false | undefined): {
+    attribution: {
+        commit: string;
+    };
+};
+/** `owner/name` from a GitHub remote URL (https, ssh or scp form), or null. */
+export declare function parseRepoSlug(url: string): string | null;
+/** The commit index body's schema tag (shared with the fleet worker's reporter). */
+export declare const COMMIT_SCHEMA = "RecordCommit/v1";
+/** RecordCommit/v1: strings only, every field required; the route rejects an unknown field. */
+export interface RecordCommitBody {
+    schema: typeof COMMIT_SCHEMA;
+    lineage_key: string;
+    repo: string;
+    branch: string;
+    sha: string;
+    patch_id: string;
+}
+/** Runs git in the session's repository; null on any failure. */
+export type Git = (args: string[], input?: string) => string | null;
+export declare function realGit(cwd: string): Git;
+/**
+ * Commits made since `sinceSec` (committer time) on local branches by this
+ * repository's git user, oldest first. Remote-tracking refs are left out, so a
+ * teammate's fetched commit is never reported as this session's.
+ */
+export declare function sessionCommits(git: Git, sinceSec: number): string[];
+/** The body for one commit, or the fields that could not be read. */
+export declare function commitBody(git: Git, sha: string, lineageKey: string): {
+    ok: true;
+    body: RecordCommitBody;
+} | {
+    ok: false;
+    missing: string[];
+};
+export type PostResult = "ok" | "dark" | "retry" | "drop";
+export interface ReporterOptions {
+    orgId: string;
+    /** The proxy's record-state file, carrying the gateway's lineage key. */
+    recordStateFile: string;
+    /** Launch time, seconds since the epoch: commits before it are not the session's. */
+    sinceSec: number;
+    git: Git;
+    intervalMs?: number;
+    /** Test seam; the real one is postRecordCommit. */
+    post?: (orgId: string, body: RecordCommitBody, signal: AbortSignal) => Promise<PostResult>;
+    now?: () => number;
+}
+/** postRecordCommit as a PostResult: 404 dark, 429/5xx/network retry, any other 4xx drop. */
+export declare function postCommit(orgId: string, body: RecordCommitBody, signal: AbortSignal): Promise<PostResult>;
+/** The reporter's state across polls (exported for tests). */
+export interface ReporterState {
+    done: Set<string>;
+    dark: boolean;
+}
+/** One sweep: report every session commit not reported yet. Never throws. */
+export declare function reportOnce(o: ReporterOptions, state: ReporterState, signal: AbortSignal): Promise<void>;
+/**
+ * Poll while the session runs; the returned `finish` runs one last sweep under
+ * a hard deadline and stops the timer. The timer is unref'd.
+ */
+export declare function startCommitReporter(o: ReporterOptions): {
+    finish: (deadlineMs?: number) => Promise<void>;
+};

package/dist/lib/commit-report.js

@@ -0,0 +1,205 @@
+/**
+ * Door one's commit reporting (Doors W1.8, OD-3, OD-5): the launcher adds the
+ * `Mnemom-Conversation` trailer and reports every commit the session makes to
+ * Record's commit index, so the PR record reads "N of M commits bound" with N
+ * equal to M.
+ *
+ * TRAILER. Claude Code writes `attribution.commit` into each commit it makes; the
+ * launcher passes it through `--settings` (OD-3). The model writes it, so it is
+ * best-effort; the commit index is the proof. The user's own commit attribution
+ * (or Claude Code's default Co-Authored-By line) is kept in front of ours, because
+ * a `--settings` value replaces theirs.
+ *
+ * INDEX. While Claude Code runs, the launcher looks for commits made in this
+ * repository since the launch, on local branches, by this repository's git user,
+ * and POSTs each one (sha, `git patch-id --stable`, branch, repo) to
+ * `POST /v1/orgs/{org}/record/commits` under the session's lineage key: the
+ * gateway's `x-mnemom-lineage-key`, captured by the local proxy into the
+ * record-state file (the CLI never derives one). Every session commit is
+ * reported, trailer or not: a commit is bound when the index holds its sha or
+ * patch-id, never by its trailer alone.
+ *
+ * PRERELEASE DEFAULT. On for a prerelease build (`next`), off for stable;
+ * MNEMOM_AGENT_COMMIT_REPORT=on|off overrides, and any other value reads off.
+ *
+ * FAIL OPEN. Nothing here throws into the launch or changes its exit code. A
+ * dark route (404) stops reporting for the session; a failed POST is retried on
+ * the next poll; a commit whose fields cannot be read is not sent (it stays
+ * unbound rather than a doomed request). The final sweep at exit races a hard
+ * deadline.
+ */
+import { spawnSync } from "node:child_process";
+import { postRecordCommit } from "./api.js";
+import { readLineage } from "./statusline-feed.js";
+import { isPrerelease } from "./update/semver.js";
+export const COMMIT_REPORT_ENV = "MNEMOM_AGENT_COMMIT_REPORT";
+export const TRAILER_KEY = "Mnemom-Conversation";
+/** Claude Code's own commit attribution when none is configured (settings reference, `attribution`). */
+export const CC_DEFAULT_COMMIT_ATTRIBUTION = "Co-Authored-By: Claude <noreply@anthropic.com>";
+/** How often the launcher looks for new commits while the session runs. */
+export const COMMIT_POLL_MS = 5_000;
+/** The final sweep at exit shares W1.3's 2 s exit budget with the conduct receipt. */
+export const COMMIT_FINAL_DEADLINE_MS = 1_500;
+const HEX40 = /^[0-9a-f]{40}$/;
+const REPO_SLUG = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
+const BRANCH_MAX = 255;
+/** on | off | unset (prerelease default); any other value reads off. */
+export function commitReportEnabled(raw, version) {
+    const v = (raw ?? "").trim().toLowerCase();
+    if (v === "")
+        return isPrerelease(version);
+    return ["on", "1", "true", "yes"].includes(v);
+}
+/**
+ * The `--settings` fragment carrying the trailer. `user` is the commit attribution
+ * the user's settings files give (highest precedence first; `false` hides all
+ * attribution, an empty string hides the commit line): it is kept in front of ours.
+ */
+export function attributionSettings(conversationId, user) {
+    const ours = `${TRAILER_KEY}: ${conversationId}`;
+    const base = user === undefined ? CC_DEFAULT_COMMIT_ATTRIBUTION : user === false ? "" : user;
+    return { attribution: { commit: base.trim() ? `${base.trimEnd()}\n${ours}` : ours } };
+}
+/** `owner/name` from a GitHub remote URL (https, ssh or scp form), or null. */
+export function parseRepoSlug(url) {
+    const m = /github\.com[:/]+([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i.exec(url.trim());
+    if (!m)
+        return null;
+    const slug = `${m[1]}/${m[2]}`;
+    return REPO_SLUG.test(slug) ? slug : null;
+}
+/** The commit index body's schema tag (shared with the fleet worker's reporter). */
+export const COMMIT_SCHEMA = "RecordCommit/v1";
+export function realGit(cwd) {
+    return (args, input) => {
+        const r = spawnSync("git", args, { cwd, encoding: "utf8", input, timeout: 10_000 });
+        return r.status === 0 ? r.stdout : null;
+    };
+}
+/**
+ * Commits made since `sinceSec` (committer time) on local branches by this
+ * repository's git user, oldest first. Remote-tracking refs are left out, so a
+ * teammate's fetched commit is never reported as this session's.
+ */
+export function sessionCommits(git, sinceSec) {
+    const email = (git(["config", "user.email"]) ?? "").trim();
+    if (!email)
+        return [];
+    const out = git(["log", "--branches", "--reverse", `--since=@${sinceSec}`, "--format=%H%x09%ce"]);
+    if (out === null)
+        return [];
+    return out
+        .split("\n")
+        .map((l) => l.split("\t"))
+        .filter(([sha, ce]) => sha !== undefined && HEX40.test(sha) && ce === email)
+        .map(([sha]) => sha);
+}
+/** The body for one commit, or the fields that could not be read. */
+export function commitBody(git, sha, lineageKey) {
+    const diff = git(["diff-tree", "-p", "--root", sha]);
+    const patchId = diff
+        ? (/^\s*([0-9a-f]{40})\b/.exec(git(["patch-id", "--stable"], diff) ?? "")?.[1] ?? "")
+        : "";
+    const current = (git(["symbolic-ref", "--quiet", "--short", "HEAD"]) ?? "").trim();
+    const holders = (git(["for-each-ref", "--contains", sha, "--format=%(refname:short)", "refs/heads"]) ?? "")
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const branch = holders.includes(current) ? current : (holders[0] ?? "");
+    const repo = parseRepoSlug(git(["remote", "get-url", "origin"]) ?? "") ?? "";
+    const missing = [];
+    if (!HEX40.test(sha))
+        missing.push("sha");
+    // A merge commit's or an empty commit's diff has no patch-id.
+    if (!HEX40.test(patchId))
+        missing.push("patch_id");
+    if (!branch || branch.length > BRANCH_MAX)
+        missing.push("branch");
+    if (!repo)
+        missing.push("repo");
+    if (missing.length > 0)
+        return { ok: false, missing };
+    return {
+        ok: true,
+        body: { schema: COMMIT_SCHEMA, lineage_key: lineageKey, repo, branch, sha, patch_id: patchId },
+    };
+}
+/** postRecordCommit as a PostResult: 404 dark, 429/5xx/network retry, any other 4xx drop. */
+export async function postCommit(orgId, body, signal) {
+    try {
+        const status = await postRecordCommit(orgId, body, signal);
+        if (status >= 200 && status < 300)
+            return "ok";
+        if (status === 404)
+            return "dark";
+        if (status === 429 || status >= 500)
+            return "retry";
+        return "drop";
+    }
+    catch {
+        return "retry";
+    }
+}
+/** One sweep: report every session commit not reported yet. Never throws. */
+export async function reportOnce(o, state, signal) {
+    if (state.dark)
+        return;
+    const lineageKey = readLineage(o.recordStateFile);
+    if (!lineageKey)
+        return;
+    for (const sha of sessionCommits(o.git, o.sinceSec)) {
+        if (state.done.has(sha) || signal.aborted)
+            continue;
+        const built = commitBody(o.git, sha, lineageKey);
+        if (!built.ok) {
+            state.done.add(sha);
+            continue;
+        }
+        const r = await (o.post ?? postCommit)(o.orgId, built.body, signal);
+        if (r === "dark") {
+            state.dark = true;
+            return;
+        }
+        if (r !== "retry")
+            state.done.add(sha);
+    }
+}
+/**
+ * Poll while the session runs; the returned `finish` runs one last sweep under
+ * a hard deadline and stops the timer. The timer is unref'd.
+ */
+export function startCommitReporter(o) {
+    const state = { done: new Set(), dark: false };
+    let running = null;
+    const sweep = (signal) => {
+        running ??= reportOnce(o, state, signal)
+            .catch(() => undefined)
+            .finally(() => {
+            running = null;
+        });
+        return running;
+    };
+    const timer = setInterval(() => void sweep(AbortSignal.timeout(o.intervalMs ?? COMMIT_POLL_MS)), o.intervalMs ?? COMMIT_POLL_MS);
+    timer.unref();
+    return {
+        async finish(deadlineMs = COMMIT_FINAL_DEADLINE_MS) {
+            clearInterval(timer);
+            const signal = AbortSignal.timeout(deadlineMs);
+            let timeout;
+            const deadline = new Promise((r) => {
+                timeout = setTimeout(r, deadlineMs);
+                timeout.unref();
+            });
+            // Let an in-flight poll finish first, then sweep once more; both inside the deadline.
+            await Promise.race([
+                (async () => {
+                    if (running)
+                        await running;
+                    await sweep(signal);
+                })(),
+                deadline,
+            ]);
+            clearTimeout(timeout);
+        },
+    };
+}

package/dist/lib/record-org.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The org Record keys a launch's lineage under (Doors W1.2, W1.4, W1.8).
+ *
+ * The gateway writes a request's record deltas under the org it bills, which is the served
+ * agent's org. The launcher's account org can differ: with an org API key, the account
+ * preflight resolves the key owner's personal org (`/v1/auth/me/personal-org`, a `pers-*`
+ * id), so a totals read or commit report keyed on it lands on an org that holds no row for
+ * the lineage, and Record answers 404. Every Record read and write of a launch (conduct
+ * receipt, status-line feed, commit reporting) therefore uses the served agent's org.
+ *
+ * FAIL-OPEN, BOUNDED. One agent read, raced against RECORD_ORG_TIMEOUT_MS; a failed, slow or
+ * off-shape answer falls back to the account org (the behaviour before this read existed), and
+ * `onFallback` says why: Record answers a wrong-org read or commit report with 404, which its
+ * callers treat as "dark", so a silent fallback would look like Record being off. Never throws.
+ */
+/** The most the read adds to launch. */
+export declare const RECORD_ORG_TIMEOUT_MS = 1500;
+export interface RecordOrgDeps {
+    /** The served agent's record; only `org_id` is read. */
+    readAgent?: (agentId: string) => Promise<{
+        org_id?: string | null;
+    }>;
+    timeoutMs?: number;
+    /** Told why the account org was used instead (one line, no secret). */
+    onFallback?: (reason: string) => void;
+}
+export declare function recordOrgFor(agentId: string, accountOrgId: string, deps?: RecordOrgDeps): Promise<string>;

package/dist/lib/record-org.js

@@ -0,0 +1,44 @@
+/**
+ * The org Record keys a launch's lineage under (Doors W1.2, W1.4, W1.8).
+ *
+ * The gateway writes a request's record deltas under the org it bills, which is the served
+ * agent's org. The launcher's account org can differ: with an org API key, the account
+ * preflight resolves the key owner's personal org (`/v1/auth/me/personal-org`, a `pers-*`
+ * id), so a totals read or commit report keyed on it lands on an org that holds no row for
+ * the lineage, and Record answers 404. Every Record read and write of a launch (conduct
+ * receipt, status-line feed, commit reporting) therefore uses the served agent's org.
+ *
+ * FAIL-OPEN, BOUNDED. One agent read, raced against RECORD_ORG_TIMEOUT_MS; a failed, slow or
+ * off-shape answer falls back to the account org (the behaviour before this read existed), and
+ * `onFallback` says why: Record answers a wrong-org read or commit report with 404, which its
+ * callers treat as "dark", so a silent fallback would look like Record being off. Never throws.
+ */
+import { getAgent } from "./api.js";
+/** The most the read adds to launch. */
+export const RECORD_ORG_TIMEOUT_MS = 1500;
+const ORG_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+export async function recordOrgFor(agentId, accountOrgId, deps = {}) {
+    const readAgent = deps.readAgent ?? getAgent;
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), deps.timeoutMs ?? RECORD_ORG_TIMEOUT_MS);
+    });
+    try {
+        let failed = false;
+        const agent = await Promise.race([
+            readAgent(agentId).catch(() => {
+                failed = true;
+                return null;
+            }),
+            timeout,
+        ]);
+        const org = agent?.org_id;
+        if (typeof org === "string" && ORG_ID_RE.test(org))
+            return org;
+        deps.onFallback?.(failed ? "agent read failed" : agent ? "agent has no org" : "agent read timed out");
+        return accountOrgId;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.32-next.0",
+  "version": "0.17.32-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {