@mnemom/mnemom 0.17.31 → 0.17.32-next.0

package/dist/base-url-proxy.mjs

@@ -21,6 +21,8 @@
 //   MNEMOM_AGENT_BU_PARENT_PID   exit when this pid is gone
 //   MNEMOM_AGENT_BU_PORT         listen port (default 0 = ephemeral)
 //   MNEMOM_AGENT_TURN_HEADER     0/off disables the turn header (the proxy still forwards)
+//   MNEMOM_AGENT_BU_RECORD_STATE write the gateway's x-mnemom-lineage-key and x-mnemom-record-url
+//                                (both non-secret) here as JSON, for the conduct receipt (optional)
 //   CLAUDE_CONFIG_DIR            Claude Code's home (default ~/.claude)
 //
 // stdout: exactly one line, `READY <port>`, once listening. Node >= 18, no deps.
@@ -45,6 +47,7 @@ if (DOOR.protocol !== "https:") die("MNEMOM_AGENT_BU_DOOR must be https");
 const LOGFILE = env.MNEMOM_AGENT_BU_LOG || "";
 const PARENT = Number(env.MNEMOM_AGENT_BU_PARENT_PID || 0);
 const PORT = Number(env.MNEMOM_AGENT_BU_PORT || 0);
+const RECORD_STATE = env.MNEMOM_AGENT_BU_RECORD_STATE || "";
 const TURNS = turnHeaderEnabled(env)
   ? new TurnOrigins({ cwd: env.MNEMOM_AGENT_BU_CWD || process.cwd() })
   : null;
@@ -72,6 +75,32 @@ const HOP = new Set([
   "trailer",
   "transfer-encoding",
 ]);
+const LINEAGE_KEY_RE = /^[A-Za-z0-9:._-]{1,256}$/;
+let recorded = "";
+// The conduct receipt's inputs, from the gateway's own response headers: the newest well-formed
+// lineage key and https record URL. Written whole (tmp + rename), only when they change. Never a
+// request header, never a body. A write failure only means no receipt figures.
+function recordState(h) {
+  if (!RECORD_STATE) return;
+  const key = typeof h["x-mnemom-lineage-key"] === "string" ? h["x-mnemom-lineage-key"] : "";
+  const url = typeof h["x-mnemom-record-url"] === "string" ? h["x-mnemom-record-url"] : "";
+  // A response carrying one header keeps the other one an earlier response gave.
+  const state = recorded ? JSON.parse(recorded) : {};
+  if (LINEAGE_KEY_RE.test(key)) state.lineage_key = key;
+  // Printable ASCII only: the URL is printed to the user's terminal, so no escape bytes.
+  if (url.length <= 2048 && /^https:\/\/[\x21-\x7e]+$/.test(url)) state.record_url = url;
+  if (!state.lineage_key && !state.record_url) return;
+  const next = JSON.stringify(state);
+  if (next === recorded) return;
+  try {
+    fs.writeFileSync(`${RECORD_STATE}.tmp`, next, { mode: 0o600 });
+    fs.renameSync(`${RECORD_STATE}.tmp`, RECORD_STATE);
+    recorded = next;
+  } catch (e) {
+    log(`record state not written: ${e.message}`);
+  }
+}
+
 const agent = new https.Agent({ keepAlive: true, maxSockets: 32 });
 const doorPath = DOOR.pathname.replace(/\/$/, "");
 const isMessages = (u) => u === "/v1/messages" || u.startsWith("/v1/messages?");
@@ -95,6 +124,7 @@ function handle(req, res) {
   const forward = (note) => {
     const target = new URL(DOOR.origin + doorPath + req.url);
     const up = https.request(target, { method: req.method, headers, agent }, (ur) => {
+      recordState(ur.headers);
       res.writeHead(ur.statusCode, ur.headers);
       ur.pipe(res);
       ur.on("end", () => log(`${tag} -> ${ur.statusCode} ${Date.now() - started}ms${note}`));

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

@@ -0,0 +1,75 @@
+/**
+ * `mnemom agent fuel <file>` — the fuel step's CLI verb (Doors W3.2, decision 17).
+ *
+ * One confirmation seals N job contracts: the verb reads the contracts the lead drafted, checks and
+ * hashes each one exactly as the gateway would (`lib/contract-hash.ts`), shows them, asks once, and
+ * sends the whole batch to the batch-seal endpoint, which writes N seals in one api transaction.
+ * It then writes each sealed contract to `.mnemom/contracts/<sha256>.json` in the repo and commits
+ * only those files, so the contract text is in the repo the jobs run against.
+ *
+ * Every arm is unit-tested through `FuelDeps`; `liveFuelDeps` is the thin driver.
+ */
+import { type BatchSealRequest, type BatchSealResponse, type OrgListItem } from "../lib/api.js";
+import { type Contract } from "../lib/contract-hash.js";
+export interface FuelOptions {
+    repo?: string;
+    org?: string;
+    yes?: boolean;
+    commit?: boolean;
+    json?: boolean;
+    /** Replay a batch already sealed with this Idempotency-Key (printed when a seal's local step fails). */
+    key?: string;
+}
+export interface FuelDeps {
+    readInput(path: string): string;
+    listOrgs(): Promise<OrgListItem[]>;
+    seal(orgId: string, body: BatchSealRequest, idempotencyKey: string, githubToken: string): Promise<BatchSealResponse>;
+    /** The caller's own GitHub token (GH_TOKEN, GITHUB_TOKEN, else `gh auth token`), or null. */
+    githubToken(): string | null;
+    newKey(): string;
+    /** Ask one yes/no question; resolves false when there is no terminal to ask on. */
+    confirm(question: string): Promise<boolean>;
+    isInteractive(): boolean;
+    /** The repo's top-level directory, or null outside a git work tree. */
+    gitRoot(): string | null;
+    /** `owner/name` of the `origin` remote, or null. */
+    originRepo(): string | null;
+    writeFile(path: string, text: string): void;
+    /**
+     * Stage and commit exactly `paths` (pathspec-limited); returns the new commit sha, or null when
+     * the files were already committed unchanged (a replayed batch).
+     */
+    commit(root: string, paths: string[], message: string): string | null;
+    /** The bytes of `path` as committed at HEAD. */
+    readCommitted(root: string, path: string): string;
+    out(line: string): void;
+    err(line: string): void;
+}
+/** A contract the lead drafted, checked and hashed locally before anything is sent. */
+interface DraftedContract {
+    contract: Contract;
+    jobKey?: string;
+    sha256: string;
+    text: string;
+}
+/** The batch size the api enforces. */
+export declare const MAX_CONTRACTS = 50;
+/** `owner/name` from a GitHub remote URL (https or ssh), or null. */
+export declare function repoFromRemote(url: string): string | null;
+/**
+ * Parse the input: a JSON array, or `{ "contracts": [...] }`. Each item is a contract object, or
+ * `{ "contract": {...}, "job_key": "..." }`. Every contract must pass the gateway's seal-time
+ * check; the first failure is reported with its index and nothing is sent.
+ */
+export declare function parseFuelInput(raw: string): DraftedContract[];
+export declare function agentFuelCommand(file: string, opts: FuelOptions, deps: FuelDeps): Promise<void>;
+/** Runs a command and returns its trimmed stdout; throws when it cannot run or exits non-zero. */
+export type RunCommand = (cmd: string, args: string[]) => string;
+/** `gh auth token`, or null when gh is missing or logged out. */
+export declare function ghAuthToken(run?: RunCommand): string | null;
+/** The caller's GitHub token: GH_TOKEN, then GITHUB_TOKEN, then `gh auth token`; null when none. */
+export declare function resolveGithubToken(env?: NodeJS.ProcessEnv, gh?: () => string | null): string | null;
+/** The contracts file; `-` reads stdin (fd 0). */
+export declare function readFuelInput(path: string, read?: (file: string | number, enc: "utf8") => string): string;
+export declare const liveFuelDeps: FuelDeps;
+export {};

package/dist/commands/agent-fuel.js

@@ -0,0 +1,298 @@
+/**
+ * `mnemom agent fuel <file>` — the fuel step's CLI verb (Doors W3.2, decision 17).
+ *
+ * One confirmation seals N job contracts: the verb reads the contracts the lead drafted, checks and
+ * hashes each one exactly as the gateway would (`lib/contract-hash.ts`), shows them, asks once, and
+ * sends the whole batch to the batch-seal endpoint, which writes N seals in one api transaction.
+ * It then writes each sealed contract to `.mnemom/contracts/<sha256>.json` in the repo and commits
+ * only those files, so the contract text is in the repo the jobs run against.
+ *
+ * Every arm is unit-tested through `FuelDeps`; `liveFuelDeps` is the thin driver.
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { listMyOrgs, MnemomApiError, newIdempotencyKey, sealContractBatch, } from "../lib/api.js";
+import { checkContract, contractFileText, contractRepoPath, contractSha256, } from "../lib/contract-hash.js";
+/** `owner/name` as GitHub issues it, the same rule the api applies: never `.` or `..` as a name. */
+const REPO_RE = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/(?!\.\.?$)[A-Za-z0-9_.-]{1,100}$/;
+/** The batch size the api enforces. */
+export const MAX_CONTRACTS = 50;
+/** `owner/name` from a GitHub remote URL (https or ssh), or null. */
+export function repoFromRemote(url) {
+    const m = /github\.com[:/]+([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(url.trim());
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+/**
+ * Parse the input: a JSON array, or `{ "contracts": [...] }`. Each item is a contract object, or
+ * `{ "contract": {...}, "job_key": "..." }`. Every contract must pass the gateway's seal-time
+ * check; the first failure is reported with its index and nothing is sent.
+ */
+export function parseFuelInput(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("The contracts file is not valid JSON.");
+    }
+    const items = Array.isArray(parsed)
+        ? parsed
+        : parsed &&
+            typeof parsed === "object" &&
+            Array.isArray(parsed.contracts)
+            ? parsed.contracts
+            : null;
+    if (!items)
+        throw new Error('Expected a JSON array of contracts, or { "contracts": [...] }.');
+    if (items.length === 0)
+        throw new Error("The contracts file holds no contracts.");
+    if (items.length > MAX_CONTRACTS) {
+        throw new Error(`A batch holds at most ${MAX_CONTRACTS} contracts (got ${items.length}).`);
+    }
+    const drafted = [];
+    const seen = new Map();
+    items.forEach((item, i) => {
+        const wrapped = item !== null &&
+            typeof item === "object" &&
+            !Array.isArray(item) &&
+            "contract" in item &&
+            typeof item.contract === "object";
+        const value = wrapped ? item.contract : item;
+        const rawKey = wrapped ? item.job_key : undefined;
+        const check = checkContract(value, `contracts[${i}]`);
+        if (!check.ok)
+            throw new Error(`contracts[${i}]: ${check.message} (${check.reason}).`);
+        const sha256 = contractSha256(check.contract);
+        const dup = seen.get(sha256);
+        if (dup !== undefined)
+            throw new Error(`contracts[${i}] is the same contract as contracts[${dup}].`);
+        seen.set(sha256, i);
+        drafted.push({
+            contract: check.contract,
+            jobKey: typeof rawKey === "string" && rawKey.trim() ? rawKey.trim() : undefined,
+            sha256,
+            text: contractFileText(check.contract),
+        });
+    });
+    return drafted;
+}
+async function resolveOrg(opts, deps) {
+    if (opts.org)
+        return opts.org;
+    const orgs = (await deps.listOrgs()).filter((o) => !o.is_personal);
+    if (orgs.length === 1)
+        return orgs[0].org_id;
+    if (orgs.length === 0)
+        throw new Error("You belong to no organization; pass --org <org_id>.");
+    throw new Error(`You belong to ${orgs.length} organizations; pass --org <org_id> (${orgs.map((o) => o.org_id).join(", ")}).`);
+}
+/**
+ * The statement's first line for the confirmation list. Control characters (ANSI escapes, carriage
+ * returns) are shown as `?`, so a statement cannot redraw the prompt it is confirmed from.
+ */
+// eslint-disable-next-line no-control-regex
+const CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/g;
+function firstLine(text, max = 72) {
+    const line = text.split("\n")[0].trim().replace(CONTROL_RE, "?");
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+}
+export async function agentFuelCommand(file, opts, deps) {
+    const drafted = parseFuelInput(deps.readInput(file));
+    const root = deps.gitRoot();
+    const repo = opts.repo ?? deps.originRepo();
+    if (!repo || !REPO_RE.test(repo)) {
+        throw new Error("Pass --repo <owner/name> (no GitHub origin remote to read it from).");
+    }
+    const commit = opts.commit !== false;
+    if (commit && !root) {
+        throw new Error("Run inside the repo's git work tree to commit the contracts, or pass --no-commit.");
+    }
+    const orgId = await resolveOrg(opts, deps);
+    // The api checks with this token that you can write to the repo (OD-10); ask for it before
+    // the confirmation, so a missing token never costs one.
+    const githubToken = deps.githubToken();
+    if (!githubToken) {
+        throw new Error("Sealing checks you can write to the repo with your GitHub token: set GH_TOKEN, or run `gh auth login`.");
+    }
+    if (!opts.json) {
+        deps.out(`Seal ${drafted.length} contract${drafted.length === 1 ? "" : "s"} for ${repo} (org ${orgId}):`);
+        drafted.forEach((d, i) => {
+            const key = d.jobKey ? ` [${d.jobKey}]` : "";
+            deps.out(`  ${i + 1}. ${d.sha256.slice(0, 16)}${key}  ${firstLine(d.contract.statement)}`);
+        });
+    }
+    if (!opts.yes) {
+        if (!deps.isInteractive()) {
+            throw new Error("Sealing needs one confirmation: run in a terminal, or pass --yes.");
+        }
+        if (!(await deps.confirm(`Seal all ${drafted.length}?`))) {
+            deps.err("Nothing sealed.");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // One key for this confirmation, held across the retry, so a retried send replays the batch.
+    // --key replays a batch whose local write or commit failed, instead of sealing it twice.
+    const key = opts.key?.trim() || deps.newKey();
+    const body = {
+        repo,
+        source: "cli",
+        contracts: drafted.map((d) => d.jobKey ? { contract: d.contract, job_key: d.jobKey } : { contract: d.contract }),
+    };
+    let result;
+    try {
+        result = await deps.seal(orgId, body, key, githubToken);
+    }
+    catch (error) {
+        // A 5xx or a network fault may have reached the api, so retry once with the same key. A 4xx
+        // is the api's answer and is not retried.
+        if (!(error instanceof MnemomApiError) || error.effectiveStatus >= 500) {
+            try {
+                result = await deps.seal(orgId, body, key, githubToken);
+            }
+            catch (retryError) {
+                // The api may have sealed before failing; the same key replays that batch, never a second one.
+                const why = retryError instanceof Error ? retryError.message : String(retryError);
+                throw new Error(`Could not seal the contracts: ${why} Rerun with --key ${key} so a batch the api did seal is replayed, not sealed twice.`, { cause: retryError });
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+    // The server must have sealed exactly what was confirmed, in order.
+    if (result.seals.length !== drafted.length) {
+        throw new Error(`The api sealed ${result.seals.length} contracts, not ${drafted.length}; batch ${result.batch_id}.`);
+    }
+    result.seals.forEach((s, i) => {
+        if (s.contract_sha256 !== drafted[i].sha256) {
+            throw new Error(`contracts[${i}] was sealed as ${s.contract_sha256}, not ${drafted[i].sha256}; batch ${result.batch_id}.`);
+        }
+    });
+    let commitSha = null;
+    const paths = drafted.map((d) => contractRepoPath(d.sha256));
+    if (commit && root) {
+        try {
+            commitSha = writeAndCommit(deps, root, drafted, paths, result.batch_id);
+        }
+        catch (error) {
+            const why = error instanceof Error ? error.message : String(error);
+            throw new Error(`Sealed as batch ${result.batch_id}, but committing the contract files failed: ${why} ` +
+                `Fix that, then rerun with --key ${key} to replay this batch without sealing it twice.`, { cause: error });
+        }
+    }
+    if (opts.json) {
+        deps.out(JSON.stringify({ ...result, files: paths, commit: commitSha }, null, 2));
+        return;
+    }
+    deps.out(`${result.replayed ? "Already sealed" : "Sealed"} ${result.seals.length} as batch ${result.batch_id}. Dispatch: ${result.dispatch}.`);
+    for (const s of result.seals)
+        deps.out(`  ${s.node_id}  canon ${s.canon_status}`);
+    if (commit && !commitSha)
+        deps.out("The contract files were already committed.");
+    if (commitSha)
+        deps.out(`Committed ${paths.length} contract file${paths.length === 1 ? "" : "s"} in ${commitSha.slice(0, 12)}.`);
+}
+/** Write each sealed contract's exact bytes and commit only those paths; returns the commit sha. */
+function writeAndCommit(deps, root, drafted, paths, batchId) {
+    drafted.forEach((d, i) => deps.writeFile(join(root, paths[i]), d.text));
+    const sha = deps.commit(root, paths, `chore(mnemom): seal ${drafted.length} contract${drafted.length === 1 ? "" : "s"}\n\nMnemom-Seal-Batch: ${batchId}`);
+    // A repo hook (a formatter, an end-of-file fixer) may rewrite a staged file. The committed
+    // bytes must still hash to the sealed sha256, or the runner would refuse the job.
+    paths.forEach((p, i) => {
+        const committed = createHash("sha256")
+            .update(deps.readCommitted(root, p), "utf8")
+            .digest("hex");
+        if (committed !== drafted[i].sha256) {
+            throw new Error(`${p} was changed on commit (a repo hook?) and no longer hashes to its sealed sha256; restore its exact bytes and commit with the hook skipped.`);
+        }
+    });
+    return sha;
+}
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+const runQuiet = (cmd, args) => execFileSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+/** `gh auth token`, or null when gh is missing or logged out. */
+export function ghAuthToken(run = runQuiet) {
+    try {
+        return run("gh", ["auth", "token"]) || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The caller's GitHub token: GH_TOKEN, then GITHUB_TOKEN, then `gh auth token`; null when none. */
+export function resolveGithubToken(env = process.env, gh = ghAuthToken) {
+    const fromEnv = (env.GH_TOKEN ?? env.GITHUB_TOKEN ?? "").trim();
+    return fromEnv || gh();
+}
+/** The contracts file; `-` reads stdin (fd 0). */
+export function readFuelInput(path, read = readFileSync) {
+    return read(path === "-" ? 0 : path, "utf8");
+}
+export const liveFuelDeps = {
+    readInput: (path) => readFuelInput(path),
+    listOrgs: () => listMyOrgs(),
+    seal: (orgId, body, key, token) => sealContractBatch(orgId, body, key, token),
+    githubToken: () => resolveGithubToken(),
+    newKey: () => newIdempotencyKey(),
+    async confirm(question) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            return /^y(es)?$/i.test((await rl.question(`${question} [y/N] `)).trim());
+        }
+        finally {
+            rl.close();
+        }
+    },
+    isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    gitRoot() {
+        try {
+            return git(undefined, ["rev-parse", "--show-toplevel"]) || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    originRepo() {
+        try {
+            return repoFromRemote(git(undefined, ["remote", "get-url", "origin"]));
+        }
+        catch {
+            return null;
+        }
+    },
+    writeFile(path, text) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, text, "utf8");
+    },
+    commit(root, paths, message) {
+        git(root, ["add", "--", ...paths]);
+        try {
+            git(root, ["diff", "--cached", "--quiet", "--", ...paths]);
+            return null;
+        }
+        catch {
+            // Exit 1: there are staged changes to commit.
+        }
+        git(root, ["commit", "-m", message, "--only", "--", ...paths]);
+        return git(root, ["rev-parse", "HEAD"]);
+    },
+    readCommitted(root, path) {
+        return execFileSync("git", ["cat-file", "blob", `HEAD:${path}`], {
+            cwd: root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    },
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+};

package/dist/commands/agent-implicit-notice.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The one-time notice for door one's T16 default (decisions 12 and 22, OD-13): on a
+ * prerelease (`next`) build an interactive or Remote Control launch with nothing
+ * configured runs with an implicit goal. The first launch that gets that default says
+ * so once, with both opt-outs; every later launch is silent.
+ *
+ * State file (~/.mnemom/implicit-notice.json): { shown_at }. A launch with an explicit
+ * mode (a flag, `--goal`, `goal_mode`, the experimental feature) never reaches this, and
+ * --dry-run neither prints nor records it. A state file that cannot be read counts as
+ * not shown; one that cannot be written never fails the launch.
+ */
+export declare const IMPLICIT_NOTICE_FILE = "implicit-notice.json";
+export declare const IMPLICIT_DEFAULT_NOTICE: string;
+export interface ImplicitNoticeDeps {
+    /** The state file's text, or null when it is missing or unreadable. */
+    read(): string | null;
+    write(text: string): void;
+    note(line: string): void;
+    now(): Date;
+}
+/** Has the notice been shown on this machine? Any parseable `shown_at` string counts. */
+export declare function noticeShown(text: string | null): boolean;
+/** Print the notice unless it was shown before, then record it. Returns whether it printed. */
+export declare function maybeShowImplicitNotice(opts: {
+    dryRun?: boolean;
+}, deps: ImplicitNoticeDeps): boolean;
+export declare function defaultImplicitNoticeDeps(mnemomDir?: string): ImplicitNoticeDeps;
+/** Called by the launch when its implicit goal came from the prerelease default. */
+export declare function showImplicitDefaultNoticeOnce(opts: {
+    dryRun?: boolean;
+}, deps?: ImplicitNoticeDeps): boolean;

package/dist/commands/agent-implicit-notice.js

@@ -0,0 +1,73 @@
+/**
+ * The one-time notice for door one's T16 default (decisions 12 and 22, OD-13): on a
+ * prerelease (`next`) build an interactive or Remote Control launch with nothing
+ * configured runs with an implicit goal. The first launch that gets that default says
+ * so once, with both opt-outs; every later launch is silent.
+ *
+ * State file (~/.mnemom/implicit-notice.json): { shown_at }. A launch with an explicit
+ * mode (a flag, `--goal`, `goal_mode`, the experimental feature) never reaches this, and
+ * --dry-run neither prints nor records it. A state file that cannot be read counts as
+ * not shown; one that cannot be written never fails the launch.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { MNEMOM_DIR } from "../lib/config.js";
+export const IMPLICIT_NOTICE_FILE = "implicit-notice.json";
+export const IMPLICIT_DEFAULT_NOTICE = "mnemom: implicit goals are on by default in this prerelease. The gateway infers the " +
+    "session's goal from your messages, and the record says the goal was implicit, never sealed. " +
+    "Turn it off for one launch with --no-implicit, or for every launch with " +
+    "`mnemom agent config set goal_mode off`.";
+/** Has the notice been shown on this machine? Any parseable `shown_at` string counts. */
+export function noticeShown(text) {
+    if (text === null)
+        return false;
+    try {
+        const v = JSON.parse(text);
+        return (typeof v === "object" &&
+            v !== null &&
+            typeof v.shown_at === "string");
+    }
+    catch {
+        return false;
+    }
+}
+/** Print the notice unless it was shown before, then record it. Returns whether it printed. */
+export function maybeShowImplicitNotice(opts, deps) {
+    if (opts.dryRun)
+        return false;
+    if (noticeShown(deps.read()))
+        return false;
+    deps.note(IMPLICIT_DEFAULT_NOTICE);
+    try {
+        deps.write(`${JSON.stringify({ shown_at: deps.now().toISOString() })}\n`);
+    }
+    catch {
+        // Never fail a launch over a notice.
+    }
+    return true;
+}
+export function defaultImplicitNoticeDeps(mnemomDir = MNEMOM_DIR) {
+    const path = join(mnemomDir, IMPLICIT_NOTICE_FILE);
+    return {
+        read: () => {
+            try {
+                return readFileSync(path, "utf8");
+            }
+            catch {
+                return null;
+            }
+        },
+        write: (text) => {
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+            const tmp = `${path}.${process.pid}.tmp`;
+            writeFileSync(tmp, text, { mode: 0o600 });
+            renameSync(tmp, path);
+        },
+        note: (line) => console.error(line),
+        now: () => new Date(),
+    };
+}
+/** Called by the launch when its implicit goal came from the prerelease default. */
+export function showImplicitDefaultNoticeOnce(opts, deps = defaultImplicitNoticeDeps()) {
+    return maybeShowImplicitNotice(opts, deps);
+}

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

@@ -12,7 +12,8 @@
  * (`x-mnemom-contract`). Implicit alignment — the goal inferred from your own
  * messages (`x-mnemom-goal-mode: implicit`, no contract) — is the experimental
  * `implicit` feature: while it is on a bare launch runs implicit, while it is off
- * (the default) a bare launch runs with alignment off. `--no-implicit` (or
+ * (the default) a bare launch runs with alignment off. On a prerelease (`next`)
+ * build a bare launch runs implicit unless it is headless `-p` (T16). `--no-implicit` (or
  * launcher.toml `goal_mode = "off"`) turns it off. The mode is resolved upstream
  * (`resolveImplicit`) and announced on the launch line.
  *

package/dist/commands/agent-session.js

@@ -12,7 +12,8 @@
  * (`x-mnemom-contract`). Implicit alignment — the goal inferred from your own
  * messages (`x-mnemom-goal-mode: implicit`, no contract) — is the experimental
  * `implicit` feature: while it is on a bare launch runs implicit, while it is off
- * (the default) a bare launch runs with alignment off. `--no-implicit` (or
+ * (the default) a bare launch runs with alignment off. On a prerelease (`next`)
+ * build a bare launch runs implicit unless it is headless `-p` (T16). `--no-implicit` (or
  * launcher.toml `goal_mode = "off"`) turns it off. The mode is resolved upstream
  * (`resolveImplicit`) and announced on the launch line.
  *

package/dist/commands/agent.d.ts

@@ -28,6 +28,7 @@
 import { type MnemomKeyDeps } from "../lib/subscription-login.js";
 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";
 export interface AgentOptions {
@@ -310,11 +311,57 @@ export interface RcCapability {
  * and by the auto-default selection (a bare launch prefers RC when capable).
  */
 export declare function checkRcCapability(cli: ResolvedCli): RcCapability;
+/**
+ * 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.
+ */
+export declare function wantsRecordState(receipt: boolean, fed: boolean): boolean;
+/**
+ * Point Claude Code at a ready proxy and, on a fed launch, start the status-line feed on the
+ * proxy's record state (no state file, no feed: the line stays "mnemom").
+ */
+export declare function onBaseUrlProxyReady(baseUrl: string | null, recordStateFile: string | undefined, childEnv: NodeJS.ProcessEnv, feed: {
+    feedFile: string;
+    orgId: string;
+} | null, start?: (o: {
+    recordStateFile: string;
+    feedFile: string;
+    orgId: string;
+}) => unknown): void;
+/**
+ * The status-line feed file for a fed launch (and FEED_ENV set on the child), or null: the
+ * segment off, no billing org, or {@link fedStatuslineWanted} false.
+ */
+export declare function prepareStatuslineFeed(o: {
+    statusline: boolean;
+    orgId?: string;
+    version: string;
+    goalMode: boolean;
+    env: NodeJS.ProcessEnv;
+    childEnv: NodeJS.ProcessEnv;
+    files?: () => {
+        feedFile: string;
+    };
+}): {
+    feedFile: string;
+} | null;
+/**
+ * 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
+ * the proxy is what learns the gateway's lineage key for the session.
+ */
+export declare function fedStatuslineWanted(version: string, goalMode: boolean, env: NodeJS.ProcessEnv): boolean;
 /**
  * Add 127.0.0.1 and localhost to BOTH NO_PROXY and no_proxy (proxy clients disagree on which one
  * wins, and some read only the lowercase one), keeping whatever each already listed.
  */
 export declare function exemptLoopbackFromProxy(env: NodeJS.ProcessEnv): void;
+/**
+ * Print the conduct receipt (experimental `record`) — the exit call site here, and the one a
+ * durable park calls. Never throws: a failure is one warning line, and the caller's exit code
+ * is untouched.
+ */
+export declare function sayConductReceipt(launch: ReceiptLaunch, trigger?: "exit" | "park", receipt?: typeof conductReceiptFor): Promise<void>;
 /** Whether a terminal implicit launch runs the turn-origin proxy (MNEMOM_AGENT_TURN_HEADER=0 opts out). */
 export declare function turnProxyWanted(env: NodeJS.ProcessEnv): boolean;
 /** Test seams for startBaseUrlProxy (every real caller omits them). */
@@ -325,6 +372,10 @@ export interface BaseUrlProxyOptions {
     node?: string;
     /** How long to wait for READY before launching straight to the door (default 5 s). */
     readyTimeoutMs?: number;
+    /** Send x-mnemom-turn (default true); false sets MNEMOM_AGENT_TURN_HEADER=0 for the proxy. */
+    turnHeader?: boolean;
+    /** Capture the conduct receipt's record state; its path is `done`'s second argument. */
+    recordState?: boolean;
 }
 /**
  * Start base-url-proxy.mjs in front of `door`; calls `done` exactly once with its
@@ -333,7 +384,7 @@ export interface BaseUrlProxyOptions {
  * script is the same case (node exits 1 before READY). The proxy holds no secret (auth headers
  * pass through it), exits with this process, and is killed on exit.
  */
-export declare function startBaseUrlProxy(door: string, done: (baseUrl: string | null) => void, opts?: BaseUrlProxyOptions): void;
+export declare function startBaseUrlProxy(door: string, done: (baseUrl: string | null, recordStatePath?: string) => void, opts?: BaseUrlProxyOptions): void;
 /**
  * The three secret lines the Remote Control proxy reads on stdin (anthropic, mnemom, openai). The
  * Mnemom key rides line 2 on BOTH auth modes when the launch has one — the proxy forwards it as