@mnemom/mnemom 0.17.34-next.2 → 0.17.34-next.3

package/dist/commands/agent.js

@@ -59,8 +59,8 @@ import { LAUNCHER_STORE_PATH, mergeStore } from "../lib/launcher-store.js";
 import { slackChannelArgs } from "../lib/slack-launch.js";
 import { appendPluginDirsEnv, applyPluginEnv, pluginEnabled, pluginPlanLine, resolvePluginDir, } from "../lib/claude-plugin.js";
 import { CLI_VERSION } from "../version.js";
-import { attachToSeat, firstTurnRow, locksAfterFirstTurn, planDurableLaunch, preReadRegistry, } from "../lib/durable/launch.js";
-import { liveDurableApi, liveHomeFacts, livePlanDeps, liveRegistryReads, liveSeatDeps, liveLockAfterFirstTurn, lockInsteadOfSpawn, createLockedInsteadOfSpawn, liveParentAfterChildEnded, registerDurableSession, saveTtyMode, } from "../lib/durable/live.js";
+import { attachToSeat, launchRow, locksAtCreate, planDurableLaunch, preReadRegistry, trackedNoTtyLine, } from "../lib/durable/launch.js";
+import { liveDurableApi, liveHomeFacts, livePlanDeps, liveRegistryReads, liveSeatDeps, lockInsteadOfSpawn, createLockedInsteadOfSpawn, liveParentAfterChildEnded, registerDurableSession, saveTtyMode, } from "../lib/durable/live.js";
 import { mayBeHandover } from "../lib/durable/handover.js";
 import { fetchTierIndex, profileMayMisfit, profileTierWarning, resolveTier, tierLaunchModel, } from "../lib/model-tier.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
@@ -586,8 +586,6 @@ export async function agentCommand(scenarioArg, options = {}) {
     const conversationId = continuation.conversationId;
     // The registered row of a durable launch: its child's SIGKILL may be a handover (C02-R26 step 7).
     let durableRow = null;
-    // A lock on a new CC session waits for its first turn (dogfood B5): claude spawns attended first.
-    let lockAfterFirstTurn = false;
     if (durablePlan) {
         options = {
             ...options,
@@ -595,25 +593,26 @@ export async function agentCommand(scenarioArg, options = {}) {
                 ? [...durablePlan.passthrough, "--session-id", durablePlan.newCcSessionId]
                 : durablePlan.passthrough,
         };
-        // Register (new) and, under `always` / ask-yes, lock instead of spawning (C02-R23 c, e). A lock
-        // refusal prints the refusal and its fix, then falls through to the tracked spawn below. A new
-        // CC session has no transcript to resume yet: it spawns, and locks after its first turn (B5).
-        // B5a (as amended): a new CC session on a durable-only agent is created locked in one request
-        // and attached; it never registers tracked or runs an attended first turn.
-        if (durablePlan.durableOnly && locksAfterFirstTurn(durablePlan)) {
-            process.exitCode = await createLockedInsteadOfSpawn(durablePlan, scenario, servedAgentId, durableKey, { model: options.model, effort: options.effort, trimMcp: options.trimMcp });
+        // Under `always` / ask-yes the launch locks instead of spawning (C02-R23 c, e). A new CC session
+        // is created locked in one request and attached (ruling A, widening B5a to every agent): no
+        // attended claude runs first. A continued one registers and locks its row. A lock refusal prints
+        // the refusal and its fix and exits 1 for every agent (C02-R24 for a durable-only one): a launch
+        // that locks never falls back to an attended spawn, except on an api without migration 06a
+        // (create-and-lock answers null): it registers tracked and spawns as before ruling A.
+        const atCreate = locksAtCreate(durablePlan);
+        const created = atCreate
+            ? await createLockedInsteadOfSpawn(durablePlan, scenario, servedAgentId, durableKey, { model: options.model, effort: options.effort, trimMcp: options.trimMcp }, durablePlan.durableOnly)
+            : null;
+        if (created !== null) {
+            process.exitCode = created;
             return;
         }
         const row = await registerDurableSession(durablePlan, scenario, servedAgentId);
         clearLaunching(scenario, liveLaunchingDeps(MNEMOM_DIR));
-        durableRow = firstTurnRow(row, durablePlan);
-        lockAfterFirstTurn = locksAfterFirstTurn(durablePlan);
-        if (durablePlan.lock && !lockAfterFirstTurn) {
-            const locked = await lockInsteadOfSpawn(row, scenario, durableKey, durablePlan.durableOnly);
-            if (locked !== null) {
-                process.exitCode = locked;
-                return;
-            }
+        durableRow = launchRow(row, durablePlan);
+        if (durablePlan.lock && !atCreate) {
+            process.exitCode = await lockInsteadOfSpawn(row, scenario, durableKey, durablePlan.durableOnly);
+            return;
         }
     }
     // A relaunch that continues an earlier conversation resumes that Claude Code session, so the
@@ -849,8 +848,8 @@ export async function agentCommand(scenarioArg, options = {}) {
         // 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),
+            commitReport: cli.name === "claude" && commitReportEnabled(process.env[COMMIT_REPORT_ENV]),
+            fedStatusline: cli.name === "claude" && fedStatuslineWanted(CLI_VERSION),
         }) && account.orgId
             ? await readServedOrg(account.orgId).then((o) => {
                 if (o.fallback)
@@ -893,7 +892,6 @@ export async function agentCommand(scenarioArg, options = {}) {
                         row: durableRow,
                         name: scenario,
                         launcherKey: options.durable.launcherKey,
-                        lockAfterFirstTurn,
                     },
                 }
                 : {}),
@@ -903,7 +901,7 @@ export async function agentCommand(scenarioArg, options = {}) {
             orgId: recordOrgId,
             commitReport: cli.name === "claude" &&
                 Boolean(account.orgId) &&
-                commitReportEnabled(process.env[COMMIT_REPORT_ENV], CLI_VERSION),
+                commitReportEnabled(process.env[COMMIT_REPORT_ENV]),
         });
         return; // launchTerminal exits the process
     }
@@ -1012,6 +1010,18 @@ export function resumeHintLine(ctx) {
     return (`Resume with: ${resumeCommand(ctx)}` +
         "  (keeps it governed; `claude --resume` runs outside Mnemom)");
 }
+/** Print trackedNoTtyLine's warning, if any, just before an interactive tracked spawn. */
+function warnNoTty(ctx) {
+    const line = trackedNoTtyLine({
+        name: ctx.scenario,
+        gateOn: ctx.options.durable !== undefined,
+        stdinIsTTY: Boolean(process.stdin.isTTY),
+        cliName: ctx.cli.name,
+        passthrough: ctx.options.passthrough ?? [],
+    });
+    if (line !== null)
+        console.error(line);
+}
 /** An interactive Claude Code session — not `-p` / `--print`, which has nothing to resume into. */
 function wantsResumeHint(cli, args) {
     return cli.name === "claude" && !args.includes("-p") && !args.includes("--print");
@@ -1343,20 +1353,39 @@ function commandExists(cmd) {
     });
     return res.status === 0;
 }
+/** Probe answers per binary, keyed by path, size and mtime: a replaced binary is probed again. */
+const rcProbeMemo = new Map();
 /**
  * Does the resolved coding-agent CLI advertise the `--remote-control` startup
  * flag (Claude Code >= 2.1.269)? Determined by scanning its `--help`. Best-effort:
  * a spawn failure or timeout reads as "no". Only the claude adapter wires RC.
+ * One launch asks this more than once (the shape choice, then the lock's RC naming), so the answer
+ * for an unchanged binary is remembered and `--help` runs once per process (BACKBONE l.150).
  */
 export function cliSupportsRemoteControl(bin) {
+    let key = null;
+    try {
+        const st = statSync(bin);
+        key = `${bin}\0${st.size}\0${st.mtimeMs}`;
+    }
+    catch {
+        // unstatable (e.g. a bare command name): probe every time, as before
+    }
+    const known = key === null ? undefined : rcProbeMemo.get(key);
+    if (known !== undefined)
+        return known;
+    let ok;
     try {
         const res = spawnSync(bin, ["--help"], { encoding: "utf8", timeout: 10_000 });
         const text = `${res.stdout ?? ""}${res.stderr ?? ""}`;
-        return /--remote-control/.test(text);
+        ok = /--remote-control/.test(text);
     }
     catch {
-        return false;
+        ok = false;
     }
+    if (key !== null)
+        rcProbeMemo.set(key, ok);
+    return ok;
 }
 /**
  * Can we launch the DEFAULT Remote-Control-in-terminal shape on this machine?
@@ -1446,8 +1475,6 @@ function launchTerminal(ctx) {
             statusline: sl !== null,
             orgId: ctx.orgId,
             version: CLI_VERSION,
-            goalMode: Boolean(ctx.goalMode),
-            env: process.env,
             childEnv,
         });
         // Autocompact guard (lib/autocompact-guard.ts): one --settings carries every layer. The
@@ -1473,10 +1500,8 @@ function launchTerminal(ctx) {
     const run = () => {
         const savedTty = ctx.durableHandover ? saveTtyMode() : null;
         const launchedSec = Math.floor(Date.now() / 1000);
+        warnNoTty(ctx);
         const child = spawn(ctx.cli.bin, args, { stdio: "inherit", env: childEnv });
-        const firstTurn = ctx.durableHandover?.lockAfterFirstTurn ? ctx.durableHandover : null;
-        if (firstTurn)
-            void liveLockAfterFirstTurn(firstTurn.row, firstTurn.name, firstTurn.launcherKey, () => child.exitCode === null && child.signalCode === null);
         // 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({
@@ -1536,6 +1561,7 @@ function launchTerminal(ctx) {
         turnHeader,
         receipt: Boolean(ctx.receipt),
         commitReport: Boolean(ctx.commitReport),
+        fedStatusline: feed !== null,
     })) {
         run();
         return;
@@ -1568,7 +1594,7 @@ export function launchSettingsExtra(o) {
  * 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;
+    return o.turnHeader || o.receipt || o.commitReport || Boolean(o.fedStatusline);
 }
 /**
  * Whether the proxy captures the gateway's record state: the conduct receipt reads it at exit,
@@ -1595,7 +1621,7 @@ export function onBaseUrlProxyReady(baseUrl, recordStateFile, childEnv, feed, st
  * segment off, no billing org, or {@link fedStatuslineWanted} false.
  */
 export function prepareStatuslineFeed(o) {
-    if (!o.statusline || !o.orgId || !fedStatuslineWanted(o.version, o.goalMode, o.env))
+    if (!o.statusline || !o.orgId || !fedStatuslineWanted(o.version))
         return null;
     const feed = (o.files ?? fedStatuslineFiles)();
     o.childEnv[FEED_ENV] = feed.feedFile;
@@ -1610,11 +1636,12 @@ export function recordOrgWanted(o) {
 }
 /**
  * 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.
+ * builds only (stable stays "mnemom", decision 14). Not tied to goal mode: the base-URL proxy
+ * runs for a fed launch (proxyWanted) and records the lineage key whatever the goal mode, and
+ * since A-W-016 a -next.N launch has no goal by default.
  */
-export function fedStatuslineWanted(version, goalMode, env) {
-    return isPrerelease(version) && goalMode && turnProxyWanted(env);
+export function fedStatuslineWanted(version) {
+    return isPrerelease(version);
 }
 /** A private per-session dir holding the feed (launcher → bin). */
 function fedStatuslineFiles() {
@@ -2077,6 +2104,7 @@ function spawnRcCli(ctx) {
         if (ctx.options.slack)
             args.push(...slackChannelArgs(rcName));
         say(`mnemom agent: remote-control: interactive session in THIS terminal with Remote Control on (session name '${rcName}'); it also appears under Remote Control at claude.ai/code and in the Claude app. Exit the CLI to stop everything.`);
+        warnNoTty(ctx);
     }
     const child = spawn(ctx.cli.bin, args, { stdio: "inherit", env: childEnv });
     child.on("error", (err) => {

package/dist/commands/durable-lock.d.ts

@@ -127,7 +127,8 @@ export interface LockFacts {
     agent: string;
     /** --own-agent: the lock moved the session onto a new agent, named by `agent` (C02-R10). */
     ownAgent: boolean;
-    durableOnly: boolean;
+    /** The locked session's agent id (the new agent's under --own-agent): R17's durable-only fragment. */
+    agentId: string;
     sharedWith: number;
     droppedFlags: readonly string[];
 }
@@ -165,6 +166,12 @@ export interface LockDeps extends DurableVerbDeps {
     handover?: HandoverDeps;
     /** Claude Code's folder trust for the root (cwd_untrusted); absent: not checked. */
     trust?: TrustProbe;
+    /**
+     * Does a live row hold the name (the R27 fix lines' `mnemom agent done <name>` clause)? Absent:
+     * the row being locked is a registered one, so it holds the name unless it has ended. The launch's
+     * create-and-lock passes false: its row is not registered until the create lands.
+     */
+    nameHeld?: boolean;
     /** The live original's exact argv (KERN_PROCARGS2, C14-R13), or null when unreadable. */
     readOriginal?: (pid: number) => OriginalLaunch | null;
     /**

package/dist/commands/durable-lock.js

@@ -223,8 +223,9 @@ export function lockLine(f) {
     ];
     if (f.ownAgent)
         parts.push(`moved to its own agent ${f.agent}`);
-    if (f.durableOnly)
-        parts.push(`agent ${f.agent} durable-only: its plain keys stop`);
+    // R17 lists this fragment unconditionally: a lock that lands leaves its agent with a live locked
+    // session, which is what makes it durable-only (agent_durable_only), so its plain keys stop.
+    parts.push(`agent ${f.agentId} durable-only: its plain keys stop`);
     if (f.sharedWith >= 1)
         parts.push(`shares it with ${f.sharedWith} sessions (pausing pauses all)`);
     parts.push(`mnemom agent show ${f.name}`);
@@ -264,7 +265,11 @@ export function lockFactsOf(body, row, name, built = []) {
             row.agent_name ??
             row.agent_id,
         ownAgent: typeof moved === "string",
-        durableOnly: b.durable_only === true || b.agent_durable_only === true,
+        agentId: (typeof moved === "string" && typeof rec(b.agent).id === "string"
+            ? rec(b.agent).id
+            : null) ??
+            (typeof b.agent_id === "string" ? b.agent_id : null) ??
+            row.agent_id,
         sharedWith: Array.isArray(shared) ? shared.length : (num(shared) ?? 0),
         // The builder's names first (C14-R12), then any the answer adds, each once.
         droppedFlags: [
@@ -407,7 +412,7 @@ export async function lockResolvedRow(row, name, opts, deps) {
         };
     }
     const launcherKey = deps.launcherKey();
-    const held = !isEnded(row);
+    const held = deps.nameHeld ?? !isEnded(row);
     const ruled = cwdRule(row.cwd ?? deps.cwd(), deps.probe);
     const cwd = ruled.ok ? transcriptSlugRule(ruled.root, cc, deps.transcriptDirs) : ruled;
     if (!cwd.ok && cwd.kind === "transcript_unverifiable") {

package/dist/commands/scan.d.ts

@@ -5,9 +5,11 @@
  * arm is unit-testable without Commander (same pattern as commands/usage.ts).
  */
 import { type GitHubCredential } from "../lib/scan/credential.js";
-import { type ScanDeps } from "../lib/scan/scan.js";
+import { type ScanDeps, type ScanResult } from "../lib/scan/scan.js";
+import { selectSpend } from "../lib/scan/spend/spend-tiers.js";
 import { type AnthropicUsageDeps } from "../lib/scan/spend/anthropic-usage.js";
 import { type RecordDeps, type RecordOutcome } from "../lib/scan/record.js";
+import { type CostSpend } from "../lib/scan/cost-per-pr.js";
 import { type ReportEmailDeps } from "../lib/scan/report-email.js";
 import { type ReportRecipients } from "../lib/scan/share.js";
 export interface ScanCommandOptions {
@@ -64,6 +66,15 @@ export declare function resolveRecipients(o: {
 }): Promise<ReportRecipients>;
 /** The CTO's figure in USD, or null for none. Throws fixed text only; the input is never echoed. */
 export declare function resolveSelfReportedSpend(o: ScanCommandOptions): Promise<number | null>;
+/**
+ * The one spend the cost-per-PR figures split, matching the tier the scan chose. Null leaves them out.
+ * Tier 1 sends the measured Anthropic total; tier 2 NEVER does (a figure split from the stated monthly
+ * spend would let that number be recovered, and the tier 2 line promises it is "not sent"); tier 3 (or
+ * tiers off) the modelled range. Sources are never mixed.
+ */
+export declare function resolveCostSpend(o: ScanCommandOptions, result: ScanResult, spend: ReturnType<typeof selectSpend> | null, measured: {
+    usd: number;
+} | null): CostSpend | null;
 export declare const NO_ADMIN_KEY_TERMINAL_MSG = "Set ANTHROPIC_ADMIN_KEY (there is no terminal to ask on).";
 export declare const TIER1_FALLBACK_NOTE = "Tier 1 skipped: falling back to the next tier.";
 /**

package/dist/commands/scan.js

@@ -13,6 +13,7 @@ import { ADMIN_KEY_ENV, AnthropicUsageError, fetchMeasuredUsage, isAdminKeyShape
 import { getAuthInfo } from "../lib/auth.js";
 import { listMyOrgs } from "../lib/api.js";
 import { fetchRecordTotals, isOrgId, } from "../lib/scan/record.js";
+import { modelledSpend } from "../lib/scan/cost-per-pr.js";
 import { RECORD_NO_ORG_NOTE, renderRecordSection } from "../lib/scan/report.js";
 import { buildEmailBody, buildEmailReport, DRY_RUN_MSG, UNAVAILABLE_MSG, failureMessage, ReportEmailError, sendReportEmail, } from "../lib/scan/report-email.js";
 import { buildSharePayload, parseShareLevel, promptShareLevel, } from "../lib/scan/share.js";
@@ -67,6 +68,23 @@ export async function resolveSelfReportedSpend(o) {
         throw new Error(SPEND_INVALID_MSG);
     return n;
 }
+/**
+ * The one spend the cost-per-PR figures split, matching the tier the scan chose. Null leaves them out.
+ * Tier 1 sends the measured Anthropic total; tier 2 NEVER does (a figure split from the stated monthly
+ * spend would let that number be recovered, and the tier 2 line promises it is "not sent"); tier 3 (or
+ * tiers off) the modelled range. Sources are never mixed.
+ */
+export function resolveCostSpend(o, result, spend, measured) {
+    if (spend === null)
+        return modelledSpend(result.spend);
+    if (spend.tier === 1) {
+        const usd = measured?.usd ?? o.anthropicUsageUsd;
+        return typeof usd === "number" ? { source: "anthropic_usage", usd } : null;
+    }
+    if (spend.tier === 2)
+        return null;
+    return spend.tier === 3 ? modelledSpend(result.spend) : null;
+}
 export const NO_ADMIN_KEY_TERMINAL_MSG = "Set ANTHROPIC_ADMIN_KEY (there is no terminal to ask on).";
 export const TIER1_FALLBACK_NOTE = "Tier 1 skipped: falling back to the next tier.";
 /**
@@ -194,7 +212,7 @@ export async function scanCommand(o) {
     const level = parseShareLevel(o.share) ?? (await promptShareLevel());
     // Every successful scan emails the report to the person who ran it, at every share level, no opt-out.
     // Mnemom keeps nothing from a share=none send (the server sends the email and does nothing else).
-    const emailFailure = await emailReport(o, emailOrg, result, level, period, spend);
+    const emailFailure = await emailReport(o, emailOrg, result, level, spend, period, resolveCostSpend(o, result, spend, measured));
     if (level === "none") {
         console.log("Share level: nothing. No share payload is built; Mnemom keeps nothing (the report email is only sent to you).");
         if (emailFailure)
@@ -211,16 +229,17 @@ export async function scanCommand(o) {
  * Emails the report. Loud on every failure: prints the reason name, never the server's words, and
  * returns it so the caller exits non-zero after the local report is shown.
  */
-async function emailReport(o, org, result, level, period, spend) {
+async function emailReport(o, org, result, level, spend, period, costSpend) {
     const fail = (f) => {
         console.log(failureMessage(f));
         return f;
     };
     const report = buildEmailReport(result, {
         orgId: org,
-        period,
         now: o.now ?? Date.now,
         sendSpendRange: spend ? spend.shareable && spend.tier === 3 : true,
+        period,
+        costSpend,
     });
     const body = buildEmailBody(report, level, result.coverage.complete, o.ctoEmail?.trim());
     const outcome = await sendReportEmail(org, body, o.emailDeps);

package/dist/commands/wrap.js

@@ -41,7 +41,7 @@ const PROVIDERS = {
         label: "Google Gemini",
         keyEnv: "GOOGLE_API_KEY",
         keyHeader: "x-goog-api-key",
-        defaultModel: "gemini-2.0-flash",
+        defaultModel: "gemini-2.5-flash",
         basePath: "/gemini",
     },
 };

package/dist/durable/adopt-live.js

@@ -11,7 +11,7 @@ import { executorStateOk, executorStatePath, LAUNCHER_KEYS, } from "../vendor/du
 import { getApiUrl, MNEMOM_DIR } from "../lib/config.js";
 import { resolveAuth } from "../lib/auth.js";
 import { readSessionRecords } from "../lib/agent-ledger.js";
-import { LAUNCHER_CONFIG_PATH } from "../lib/launcher-config.js";
+import { durableLauncherKey, LAUNCHER_CONFIG_PATH } from "../lib/launcher-config.js";
 import { mnemomFetch } from "../lib/version-gate.js";
 import { httpAdoptApi } from "./adopt-api.js";
 import { liveCwdDeps } from "./cwd-rule.js";
@@ -37,21 +37,18 @@ export function ledgerFactsFrom(records, cid) {
 }
 /** The launcher key `durable` (MNEMOM_AGENT_DURABLE, then launcher.toml), default off. */
 export function launcherKeyFrom(env, tomlText) {
-    const ok = (v) => typeof v === "string" && LAUNCHER_KEYS.includes(v);
-    const e = env.MNEMOM_AGENT_DURABLE?.trim().toLowerCase();
-    if (ok(e))
-        return e;
+    let configured;
     if (tomlText !== null) {
         try {
             const v = parseToml(tomlText).durable;
-            if (ok(v))
-                return v;
+            if (typeof v === "string" && LAUNCHER_KEYS.includes(v))
+                configured = v;
         }
         catch {
             // an unparseable launcher.toml is the launcher's error to report, not adopt's
         }
     }
-    return "off";
+    return durableLauncherKey(env, configured);
 }
 /** The executor state file, or null when absent or not the frozen S1 shape. */
 export function executorStateFrom(text) {

package/dist/durable/adopt.d.ts

@@ -172,12 +172,20 @@ export interface AdoptPlan {
 export declare function ruleCwd(live: LiveClaude, realpath: (p: string) => string | null): string | null;
 /** The session row of a GET answer: the body itself, or its `session`; agent_id also from `agent.id`. */
 export declare function rowOf(a: ApiAnswer): SessionRow | null;
+/**
+ * A session's fix lines name it by its registry row's own name (the row discovery matched by
+ * conversation id); only then does the name hold a row, so only then may a line carry the done step.
+ * The environment's name is the launcher's display name (agent-scenario), which no verb resolves.
+ */
+export declare function nameHeldOf(s: Pick<PlannedSession, "name" | "_row">): boolean;
 /** What a refusal's fix line may be filled from. */
 export interface RefusalContext {
     name: string;
     launcherKey: LauncherKey;
     /** The group's agent (for agent_contained when the refusal names none). */
     agent?: string;
+    /** Whether the name holds a registry row (nameHeldOf): only then does the line carry the done step. */
+    nameHeld: boolean;
 }
 /**
  * The S1 fix line for a lock refusal answered by the check or the lock route, or null when the

package/dist/durable/adopt.js

@@ -76,6 +76,14 @@ export function rowOf(a) {
         return { ...inner, agent_id: inner.agent.id };
     return inner;
 }
+/**
+ * A session's fix lines name it by its registry row's own name (the row discovery matched by
+ * conversation id); only then does the name hold a row, so only then may a line carry the done step.
+ * The environment's name is the launcher's display name (agent-scenario), which no verb resolves.
+ */
+export function nameHeldOf(s) {
+    return typeof s._row?.name === "string" && s._row.name !== "" && s._row.name === s.name;
+}
 async function planSession(live, deps, launcherKey) {
     const facts = deps.ledger(live.conversationId);
     const base = {
@@ -117,6 +125,8 @@ async function planSession(live, deps, launcherKey) {
     if (!row)
         return unadoptable("row_unreadable");
     Object.assign(base, { _row: row });
+    if (typeof row.name === "string" && row.name !== "")
+        base.name = row.name;
     const agentId = row.agent_id ?? facts.agentId;
     if (row.durable_mode === "locked") {
         await compareLocked(base, live, row, deps, launcherKey);
@@ -137,7 +147,7 @@ async function planSession(live, deps, launcherKey) {
         base.cwd_kind = verdict.cwd_kind;
         base.reason = `cwd_${verdict.cwd_kind}`;
         // A tracked row holds the name, so the fix carries the done clause (S1 fix-line rule).
-        base.fix = cwdFixLine(verdict, { name: live.sessionName, launcherKey, nameHeld: true });
+        base.fix = cwdFixLine(verdict, { name: base.name, launcherKey, nameHeld: nameHeldOf(base) });
         base.note = cwdNote(verdict.cwd_kind, base.fix);
         return { s: base, agentId, agentLabel: facts.agentLabel };
     }
@@ -199,7 +209,8 @@ async function compareLocked(base, live, row, deps, launcherKey) {
     // read (gaps/c4-relock-sole-unlock.md): it is never offered from here.
     // launchSpecChangeFixLines' tuple type guarantees the launch_spec_change line is first.
     base.fix = launchSpecChangeFixLines({
-        name: live.sessionName,
+        name: base.name,
+        nameHeld: nameHeldOf(base),
         flags: specUserArgv(built.spec).join(" "),
         launcherKey,
         soleLockedSession: false,
@@ -234,7 +245,7 @@ export function refusalFix(code, details, ctx) {
         params.repo = repos.join(", ");
     if (placeholdersOf(key).some((p) => params[p] === undefined))
         return null;
-    return renderFixLine(key, { launcherKey: ctx.launcherKey, nameHeld: true, params });
+    return renderFixLine(key, { launcherKey: ctx.launcherKey, nameHeld: ctx.nameHeld, params });
 }
 const LOCK_REFUSAL_FIX_CODES = Object.freeze({
     durable_lock_not_entitled: true,
@@ -299,7 +310,7 @@ export async function planAdopt(deps, opts = {}) {
             const checkout = root ?? ownCheckout ?? null;
             if (checkout === null)
                 continue;
-            s.fix = cwdFixLine({ ok: false, cwd_kind: "not_git", params: { checkout } }, { name: s.name, launcherKey, nameHeld: true });
+            s.fix = cwdFixLine({ ok: false, cwd_kind: "not_git", params: { checkout } }, { name: s.name, launcherKey, nameHeld: nameHeldOf(s) });
             s.note = cwdNote("not_git", s.fix);
         }
         const adoptable = g.sessions.filter((s) => s.verdict === "adopt");
@@ -343,7 +354,12 @@ export async function planAdopt(deps, opts = {}) {
             else if (a.kind === "error") {
                 g.code = a.code ?? `http_${a.status}`;
                 g.reason = a.message;
-                g.fix = refusalFix(a.code, a.details, { name: s.name, launcherKey, agent: g.agent });
+                g.fix = refusalFix(a.code, a.details, {
+                    name: s.name,
+                    launcherKey,
+                    agent: g.agent,
+                    nameHeld: nameHeldOf(s),
+                });
             }
             else {
                 g.code = "durable_precondition_unavailable";
@@ -513,7 +529,12 @@ export async function handover(s, g, exec, deps, facts, launcherKey) {
             name: s.name,
             committed: false,
             code: a.code ?? `http_${a.status}`,
-            fix: refusalFix(a.code, a.details, { name: s.name, launcherKey, agent: g.agent }),
+            fix: refusalFix(a.code, a.details, {
+                name: s.name,
+                launcherKey,
+                agent: g.agent,
+                nameHeld: nameHeldOf(s),
+            }),
         };
     }
     // No attempt was decisive and a request may still be in flight: only a re-read that shows the

package/dist/durable/cwd-rule.d.ts

@@ -17,7 +17,7 @@
  *
  * The decision is pure over injected facts; liveCwdDeps is the thin driver.
  */
-import { type CwdKind, type LauncherKey } from "../vendor/durable-contract/index.js";
+import { type CwdCheckCause, type CwdKind, type LauncherKey } from "../vendor/durable-contract/index.js";
 export interface CwdDeps {
     /** realpath(p), or null when it does not resolve. */
     realpath(p: string): string | null;
@@ -48,6 +48,14 @@ export declare function projectSlug(path: string): string;
  * not --resume it).
  */
 export declare function classifyCwd(cwd: string, deps: CwdDeps, ccSessionId?: string | null): CwdVerdict;
+/**
+ * The daemon's spawn-time cwd check (attestation check `cwd`, C14-R04; mnemom-test #1002): the
+ * committed cwd's realpath must equal `git rev-parse --show-toplevel` there. Null when it holds;
+ * otherwise the S1 CWD_CHECK_CAUSES value: `missing` when there is no committed cwd or it does not
+ * resolve, `not_toplevel` when it resolves but is not a work tree's top level (a subdirectory, or
+ * not in a git work tree at all).
+ */
+export declare function spawnCwdCause(cwd: string | null, deps: Pick<CwdDeps, "realpath" | "gitToplevel">): CwdCheckCause | null;
 /**
  * The S1 fix line for a cwd refusal (fix-line rule: the done clause when a non-terminal row holds
  * the name, the config suffix when the launcher key is not `always`), or null when a path the

package/dist/durable/cwd-rule.js

@@ -51,6 +51,24 @@ export function classifyCwd(cwd, deps, ccSessionId = null) {
         return { ok: false, cwd_kind: "symlink_transcript", params: { realpath: real } };
     return { ok: false, cwd_kind: null, unadoptable: "no_transcript" };
 }
+/**
+ * The daemon's spawn-time cwd check (attestation check `cwd`, C14-R04; mnemom-test #1002): the
+ * committed cwd's realpath must equal `git rev-parse --show-toplevel` there. Null when it holds;
+ * otherwise the S1 CWD_CHECK_CAUSES value: `missing` when there is no committed cwd or it does not
+ * resolve, `not_toplevel` when it resolves but is not a work tree's top level (a subdirectory, or
+ * not in a git work tree at all).
+ */
+export function spawnCwdCause(cwd, deps) {
+    if (cwd === null)
+        return "missing";
+    const real = deps.realpath(cwd);
+    if (real === null)
+        return "missing";
+    const top = deps.gitToplevel(real);
+    if (top === null)
+        return "not_toplevel";
+    return (deps.realpath(top) ?? top) === real ? null : "not_toplevel";
+}
 const CWD_FIX = {
     subdirectory: "cwd_subdirectory",
     not_git: "cwd_not_git",

package/dist/durable/launch-spec.d.ts

@@ -138,6 +138,8 @@ export declare function launchSpecChangeFixLines(ctx: {
     flags: string;
     launcherKey: LauncherKey;
     soleLockedSession: boolean;
+    /** Whether the name holds a registry row; absent: it does (every launch path). */
+    nameHeld?: boolean;
 }): [string, ...string[]];
 /** The adopt Note for an adopted row (C14-R12, R21): S1 grammar, unchanged builder names. */
 export declare function adoptNote(dropped: readonly string[]): string;

package/dist/durable/launch-spec.js

@@ -270,7 +270,7 @@ export async function compareWithCommitted(built, committed) {
 export function launchSpecChangeFixLines(ctx) {
     const render = {
         launcherKey: ctx.launcherKey,
-        nameHeld: true,
+        nameHeld: ctx.nameHeld ?? true,
         params: { name: ctx.name, flags: ctx.flags },
     };
     const lines = [renderFixLine("launch_spec_change", render)];

package/dist/durable/test-mode.mjs

@@ -6,7 +6,8 @@
 // is a loopback literal; an unset URL counts as non-loopback. Otherwise a seam env is ignored.
 //
 // The CLI seams (closed list): T1 DURABLE_BOOT_ID_FILE, T2 DURABLE_HOST_TEST_PAUSE_AT, T3 the
-// credential proxy's http door on a loopback host.
+// credential proxy's http door on a loopback host, and `agent run`'s GitHub base, read from the
+// api's own T4 variable DURABLE_TEST_GITHUB_API_BASE (Durable lead, Doors W-L13).
 
 const TEST_MODE = "DURABLE_SESSIONS_TEST_MODE";
 /** S1 GUARD_LISTS.cli, in order. */
@@ -40,6 +41,29 @@ export function bootIdFileOverride(env = process.env) {
   return { file, ignored: false };
 }
 
+/**
+ * `agent run`'s GitHub base on a lane: the same fake GitHub the api uses (T4,
+ * DURABLE_TEST_GITHUB_API_BASE), serving git and REST from one origin. Honoured only under the seam
+ * guard and only for an http(s) loopback URL with no credentials, query or fragment; anything else
+ * is null, and `ignored` says a value was set but not used (the caller warns).
+ */
+export function testGithubBase(env = process.env) {
+  const raw = env.DURABLE_TEST_GITHUB_API_BASE;
+  if (typeof raw !== "string" || raw === "") return { base: null, ignored: false };
+  if (!testSeamsHonoured(env) || !isLoopbackUrl(raw)) return { base: null, ignored: true };
+  const u = new URL(raw);
+  if (
+    (u.protocol !== "http:" && u.protocol !== "https:") ||
+    u.username ||
+    u.password ||
+    u.search ||
+    u.hash
+  ) {
+    return { base: null, ignored: true };
+  }
+  return { base: `${u.origin}${u.pathname.replace(/\/+$/, "")}`, ignored: false };
+}
+
 /** S1 T2_PAUSE_POINTS. */
 export const PAUSE_POINTS = Object.freeze([
   "after_claim_before_spawn",