@sema-agent/server 7.139.0 → 7.140.0

package/dist/lane-home-probe.d.ts

@@ -1,39 +1,53 @@
 /**
- * 执行环境的家目录:**声明 × 实测**的唯一判官与唯一的座(纯叶:零值依赖)。
+ * 执行环境的家目录:**主张 × 实测**的唯一判官与唯一的座(纯叶:零值依赖)。
  *
- * ## 病(一)—— 声明了却对不上
- * `REMOTE_EXEC_HOME_DIR` 是运维对「执行环境以哪个用户的家目录运行」的声明,它是 `~/` 形权限规则的基、引擎家锚拒读行(`~/.ssh` / `~/.npmrc` …)
- * 的落点(`execution-lane-caps.ts` `executionLaneHomeDir` 一只属主,几个消费面同读)。k8s / local-docker / ssh 三条车道的家目录是镜像 / 目标机
- * 登录用户的属性,boot 期不可知 —— 声明了就照单全收。声明 `/home/y` 而车道真实家目录是 `/home/x` 时,`Edit(~/.ssh/**)` 守的是 `/home/y`,
- * `/home/x/.ssh` 照读照写,运维与用户零告警:限制写了不生效且无人知。
+ * ## 病(一)—— 给了家目录却对不上
+ * 部署事先给每只执行环境一个家目录:运维声明 `REMOTE_EXEC_HOME_DIR`,或车道自己的出厂答案(声明缺席时 host = 本进程的家目录、e2b = 平台固定用户的
+ * `/home/user`;`execution-lane-caps.ts` `executionLaneHomeDir` 一只属主)。它是 `~/` 形权限规则的基、引擎家锚拒读行(`~/.ssh` / `~/.npmrc` …)的落点。
+ * 给的是 `/home/y` 而环境里命令真看到的 `$HOME` 是 `/home/x` 时,`Edit(~/.ssh/**)` 守的是 `/home/y`,`/home/x/.ssh` 照读照写,运维与用户零告警:
+ * 限制写了不生效且无人知(镜像换代换了用户、e2b 自定义模板换了用户、host 上会话 `settings.env` 改了 `HOME` —— 都是这一形)。
  *
- * ## 病(二)—— 没声明就恒问人
- * 执行环境不声明家目录时,引擎的家锚拒读行放不下 ⇒ 每一次泄内容的递归读(`grep -r` / `rg` / `git grep` / `tar c`)在全 shell 面恒问人、只读面直接拒。
+ * ## 病(二)—— 没给就恒问人
+ * 执行环境没有家目录时,引擎的家锚拒读行放不下 ⇒ 每一次泄内容的递归读(`grep -r` / `rg` / `git grep` / `tar c`)在全 shell 面恒问人、只读面直接拒。
  * 家目录是执行环境自己的事实,车道开环境那一拍问一次就知道 —— 不必要运维手填。
  *
- * ## 律(一只座、两个来源、一条取值律 —— {@link LaneHomeSeat},四条会问的车道各持一只,不各写一份)
- *  · **声明在场 ⇒ 声明**(座 = 声明原样)。车道对证与否是车道的姿势(`verifiesDeclared`):对证的车道在开环境那一拍问一次(与命令同一条 shell、同一份 env:
- *    `printf %s "$HOME"`),两者不一致 ⇒ 这只执行环境不开(拒句点名两值与两条改法),环境答了的判定记在环境上(同一镜像 / 同一目标机再问也是同一个答案,不重试成风暴);
- *    问不出答案同样不开(证不了声明 = 不拿一个没证过的目录去守),但不记 —— 与任何一次建连失败同,下一次重问;不对证的车道(adb:Android 没有 POSIX 登录家目录,声明是运维的断言)声明照单全收。
- *  · **没声明 ⇒ 实测**:同一拍问同一句;答出绝对路径 ⇒ 座 = 它,之后不再问;
- *  · **实测也缺席**(问不出 / 答的不是绝对路径,含空串)⇒ 座缺席(引擎失败关闭,不猜、不补 `/`),环境照开(没声明就没有声明可拒),一行 warn(点名读到了什么与出路)。
- * 规则基与 422 门在下单那一刻就要家目录,而那一刻执行环境还没开 —— 它们仍只读声明(`executionLaneHomeDir`);实测值只填引擎手里的这一只座。
+ * ## 律(一条:读得出就读,读数是真源 —— {@link LaneHomeSeat},每只读得出家目录的适配器各持一只,不各写一份)
+ *  · **有主张 ⇒ 证**:座 = 主张原样(下单门与引擎 prepare 在环境开起来之前就要基);开环境那一拍读一次(与命令同一条 shell、同一份 env:
+ *    `printf %s "$HOME"`;host 直接读它自己组合给子进程的那份 env),两者不一致 ⇒ 这只执行环境不开(拒句点名两值与改法),环境答了的判定记在环境上
+ *    (同一镜像 / 同一目标机再问也是同一个答案,不重试成风暴);读不出同样不开(证不了主张 = 不拿一个没证过的目录去守),但不记 —— 与任何一次建连失败同,下一次重问。
+ *  · **没主张 ⇒ 实测**:同一拍问同一句;答出绝对路径 ⇒ 座 = 它,之后不再问;
+ *  · **实测也缺席**(问不出 / 答的不是绝对路径,含空串)⇒ 座缺席(引擎失败关闭,不猜、不补 `/`),环境照开(没主张就没有主张可拒),一行 warn(点名读到了什么与出路)。
+ * 读不了家目录的车道(device:设备协议没有读数)不持座 —— 声明就是座,起服披露「来自声明、未实测」(`execution-lane-caps.ts` `buildLaneHomeBootNote`)。
+ * 规则基与 422 门在下单那一刻就要家目录,而那一刻执行环境还没开 —— 它们只读主张(`executionLaneHomeDir`);环境开起来时主张被证,证不了的环境不开。
  */
-/** 探针答案的行首标记:登录脚本 / profile 往 stdout 打的横幅不会被读成家目录 —— 只认带这个标记的那一行(取最后一行)。 */
+/** 探针答案的行首标记:登录脚本 / profile 往 stdout 打的横幅不会被读成家目录 —— 只认带这个标记的那一行(恰一条,见 `markedHome`)。 */
 export declare const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
 /**
  * 执行环境里问家目录的那一句 —— 经车道自己的命令通道跑(同一条 shell、同一份 env),答的就是命令看到的 `$HOME`。
  * 先换一行再打标记行:横幅没以换行收尾时,标记行照样从行首开始。
  */
 export declare const LANE_HOME_PROBE_COMMAND = "printf '\\nsema-lane-home=%s\\n' \"$HOME\"";
-/** 一次问家目录的读数:问到了(stdout 原文)/ 没问到(原因)。 */
+/**
+ * 一次问家目录的读数:探针的 stdout 原文(经车道命令通道跑 {@link LANE_HOME_PROBE_COMMAND})/ 直接读到的值(适配器自己组合子进程 env 的车道 —— host:
+ * 那份 env 里的 `HOME`;缺席时读子进程 shell 对 `~` 的展开,见 `remote-env-host.ts` `childHome`)/ 没问到(原因)。
+ */
 export type LaneHomeProbe = {
     readonly ok: true;
     readonly stdout: string;
+} | {
+    readonly ok: true;
+    readonly value: string;
 } | {
     readonly ok: false;
     readonly reason: string;
 };
+/** 主张的来源 —— 只进拒句(改法随它):运维声明(`REMOTE_EXEC_HOME_DIR`)/ 车道自己的出厂答案(声明缺席时;没有「删声明」这条路)。 */
+export type LaneHomeSource = "declared" | "lane";
+/** 部署交给一只执行环境的家目录主张:值 + 来源。 */
+export interface LaneHomeClaim {
+    readonly home: string;
+    readonly source: LaneHomeSource;
+}
 /**
  * 判定:`undefined` = 一致,照开;否则这只环境不开 —— `refusal` 是拒句,`answered` = 环境**答了**它的家目录(不一致 / 不是绝对路径;同一镜像 / 同一登录用户
  * 再问也是同一个答案 ⇒ 调用方记在环境上),`false` = 没答上(探针失败 / 超时 / 非零退出 / 输出里没有标记行 ⇒ 这一次不开、不记、下一次重问)。
@@ -43,9 +57,17 @@ export type LaneHomeVerdict = {
     readonly answered: boolean;
 } | undefined;
 /**
- * 声明 × 实测的判官。`lane` 只进句子。拒句三形:实测与声明不一致 / 实测不是绝对路径(含空)/ 没问到。每一形都点名声明值与改法,不回显任何别的东西。
+ * 执行环境的路径平台 —— 「绝对」与「同一个目录」两条判据随它:远端车道(k8s / local-docker / ssh / adb / e2b,Linux / Android 的 POSIX shell)= `posix`;
+ * win32 宿主上的 host 车道 = `win32`(子进程的 `HOME` 是盘符形)。车道没得选:是环境自己的平台,由持座的适配器说(缺省 `posix`)。
  */
-export declare function judgeLaneHome(lane: string, declared: string, probe: LaneHomeProbe): LaneHomeVerdict;
+export type LanePathFlavor = "posix" | "win32";
+/**
+ * 主张 × 实测的判官(全仓唯一一只:每只读得出家目录的适配器经 {@link LaneHomeSeat} 用它,自己不比)。`lane` 只进句子。
+ * 拒句闭集 3 形 × 2 来源:实测与主张不一致 / 实测不是绝对路径(含空)/ 没问到;每一句都点名主张(与实测值,有就点名)和改法,不回显任何别的东西。
+ * 改法随来源:声明 ⇒「改成实测值或删掉声明」;出厂答案 ⇒ 只有「设成实测值」(没有声明可删)。另一条路两种来源同:让环境的 `HOME` 读主张那个值。
+ * 次序:读不出 → 不是绝对路径 → 一致 → 不一致(「绝对」先于「一致」:主张自己是相对串时,一个同样相对的读数也不放行)。
+ */
+export declare function judgeLaneHome(lane: string, claim: LaneHomeClaim, probe: LaneHomeProbe, paths?: LanePathFlavor): LaneHomeVerdict;
 /** 起服与每只环境「家目录答不出」那一行 warn 的事件名 —— 一只 code,起服(车道读不了)与环境(实测缺席)共用。 */
 export declare const LANE_HOME_UNDECLARED_EVENT = "execution_lane_home_undeclared";
 /**
@@ -55,52 +77,56 @@ export declare const LANE_HOME_UNDECLARED_EVENT = "execution_lane_home_undeclare
 export declare function buildHomeAbsentNote(lane: string, cause: string, remedy: string): string;
 /** 车道读不了家目录时的出路(起服那一行):声明它。 */
 export declare const DECLARE_HOME_REMEDY = "Declare the home: REMOTE_EXEC_HOME_DIR=<the absolute path the environment's $HOME reads>";
+/** 读不了家目录的车道(今天只有 device)上声明在场时,起服那一行 warn 的事件名:座 = 声明,没有任何读数证过它。 */
+export declare const LANE_HOME_UNMEASURED_EVENT = "execution_lane_home_unmeasured";
+/**
+ * 「这条车道的家目录来自声明、未实测」的一句(纯字符串 ⇒ `build*`)—— 读得出的车道由 {@link judgeLaneHome} 证主张,读不了的车道没有那一步,起服把这件事说出来:
+ * 规则落在哪、对不上时会怎样、运维要守住什么。
+ */
+export declare function buildHomeUnmeasuredNote(lane: string, declared: string): string;
 /** 一行「这只环境没有家目录」的事实:交给运维的那一行 warn 的两个字段。 */
 export interface LaneHomeAbsence {
     readonly provider: string;
     readonly note: string;
 }
-/** 这条车道的座怎么长出来:`declared` = 运维声明(`REMOTE_EXEC_HOME_DIR`,boot 期的唯一属主 `executionLaneHomeDir` 的答案);`verifiesDeclared` = 车道对声明对证。 */
-export interface LaneHomeSeatOptions {
-    readonly lane: string;
-    readonly declared: string | undefined;
-    readonly verifiesDeclared: boolean;
-    /** 实测缺席时交出那一行 warn(缺席 = 不交;生产装配由 boot 递一只带去重的报告座,见 {@link createLaneHomeAbsenceReporter})。 */
-    readonly onAbsent?: ((absence: LaneHomeAbsence) => void) | undefined;
-}
 /**
- * 四条会问家目录的车道(k8s / local-docker / ssh / adb)的适配器配置里与家目录有关的两个键 —— 文字只写这一处,四个配置接口 `extends` 它。
+ * 会读家目录的车道(k8s / local-docker / ssh / adb / e2b / host)的适配器配置里与家目录有关的三个键 —— 文字只写这一处,各配置接口 `extends` 它;
+ * {@link LaneHomeSeat} 直接吃它。
  */
 export interface LaneHomeConfig {
     /**
-     * [ref]④ / core [ref] —— 运维声明的执行环境 **home 目录**(绝对路径,本环境自己的命名空间里;`REMOTE_EXEC_HOME_DIR`)。`~/…` 形权限规则(`Edit(~/.ssh/**)`)对**跑在本 env 里的调用**
-     * 就以它为基。值由 `boot/execution-env.ts` 从**唯一属主** `execution-lane-caps.ts` 的 `executionLaneHomeDir` 递进来;adapter 不自算(两处各算一份 = 422 门与引擎对同一条规则给相反答案)。
-     * 缺席 ⇒ 不声明:车道建环境时自己问执行环境的 `$HOME`({@link LaneHomeSeat});实测也缺席 ⇒ 本 env 的 `homeDir` 座缺席,core 对 `~/` 规则判 `unreadable`
+     * [ref]④ / core [ref] —— 部署给本执行环境的 **home 目录主张**(绝对路径,本环境自己的命名空间里):运维声明 `REMOTE_EXEC_HOME_DIR`,或车道出厂答案。
+     * `~/…` 形权限规则(`Edit(~/.ssh/**)`)对**跑在本 env 里的调用**就以它为基。值由 `boot/execution-env.ts` 从**唯一属主** `execution-lane-caps.ts` 的
+     * `buildLaneHomeClaim` 递进来;adapter 不自算(两处各算一份 = 422 门与引擎对同一条规则给相反答案)。在场 ⇒ 环境开起来时与 `$HOME` 对证,不一致 ⇒ 这只环境不开。
+     * 缺席 ⇒ 车道建环境时自己问执行环境的 `$HOME`({@link LaneHomeSeat});实测也缺席 ⇒ 本 env 的 `homeDir` 座缺席,core 对 `~/` 规则判 `unreadable`
      * (fail-closed 的 ask),绝不回落引擎进程自己的 home(那在远端腿上是另一个用户的另一个目录 —— 静默守错目录正是 [ref] 的病)。
      */
     homeDir?: string;
-    /** 实测缺席(没声明、也没问到绝对路径)时交出那一行 warn;缺席 = 不交。生产装配由 boot 递一只带去重的报告座({@link createLaneHomeAbsenceReporter})。 */
+    /** {@link homeDir} 的来源(只进拒句的改法):`declared` = `REMOTE_EXEC_HOME_DIR`;`lane` = 车道出厂答案。缺席读作 `declared`。 */
+    homeDirSource?: LaneHomeSource;
+    /** 实测缺席(没主张、也没问到绝对路径)时交出那一行 warn;缺席 = 不交。生产装配由 boot 递一只带去重的报告座({@link createLaneHomeAbsenceReporter})。 */
     onHomeAbsent?: (absence: LaneHomeAbsence) => void;
 }
 /**
- * 一只执行环境的家目录座 —— `ExecutionEnv.homeDir` 的**唯一取值律**:声明在场 ⇒ 声明;否则 ⇒ 车道开环境时实测到的绝对路径;实测也缺席 ⇒ `undefined`(引擎失败关闭)。
- * 车道只做两件事:`asks` 为真时经自己的命令通道跑一次 {@link LANE_HOME_PROBE_COMMAND},把读数交给 {@link settle};`homeDir` 读 {@link home}。
+ * 一只执行环境的家目录座 —— `ExecutionEnv.homeDir` 的**唯一取值律**:主张在场 ⇒ 主张(并在开环境时被证);否则 ⇒ 车道开环境时实测到的绝对路径;
+ * 实测也缺席 ⇒ `undefined`(引擎失败关闭)。车道只做两件事:`asks` 为真时读一次(命令通道跑 {@link LANE_HOME_PROBE_COMMAND},或直接读自己组合的 env),
+ * 把读数交给 {@link settle};`homeDir` 读 {@link home}。
  */
 export declare class LaneHomeSeat {
     private measured;
     private readonly lane;
-    private readonly declared;
-    private readonly verifiesDeclared;
+    private readonly claim;
     private readonly onAbsent;
-    constructor(options: LaneHomeSeatOptions);
-    /** 座:声明胜,否则实测,否则缺席。 */
+    private readonly paths;
+    /** `paths` = 执行环境自己的路径平台({@link LanePathFlavor};缺省 POSIX —— 只有 win32 宿主上的 host 适配器说 `win32`)。 */
+    constructor(lane: string, config: LaneHomeConfig, paths?: LanePathFlavor);
+    /** 座:主张胜,否则实测,否则缺席。 */
     get home(): string | undefined;
-    /** 这一拍还要不要问:声明在场 ⇒ 只有对证的车道问(每次连接);没声明 ⇒ 问到量出绝对路径为止。 */
+    /** 这一拍还要不要问:主张在场 ⇒ 每只新环境 / 每条新连接都问(对证);没主张 ⇒ 问到量出绝对路径为止。 */
     get asks(): boolean;
     /**
-     * 收一次读数。声明在场(且车道对证)⇒ {@link judgeLaneHome}:`undefined` = 一致,否则这只环境不开(拒句 + 记不记见 {@link LaneHomeVerdict});
-     * 没声明 ⇒ 读到绝对路径就记下;读不到 / 不是绝对路径 ⇒ 座缺席、交一行 warn、**不拒环境**(`undefined`)—— 没声明就没有声明可拒,引擎对缺席座失败关闭。
-     * 不对证的车道声明在场时不该来问(`asks` 为假),来了照单全收。
+     * 收一次读数。主张在场 ⇒ {@link judgeLaneHome}:`undefined` = 一致,否则这只环境不开(拒句 + 记不记见 {@link LaneHomeVerdict});
+     * 没主张 ⇒ 读到绝对路径就记下;读不到 / 不是绝对路径 ⇒ 座缺席、交一行 warn、**不拒环境**(`undefined`)—— 没主张就没有主张可拒,引擎对缺席座失败关闭。
      */
     settle(probe: LaneHomeProbe): LaneHomeVerdict;
 }

package/dist/lane-home-probe.js

@@ -2,7 +2,13 @@ export const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
 export const LANE_HOME_PROBE_COMMAND = `printf '\\n${LANE_HOME_PROBE_MARKER}%s\\n' "$HOME"`;
 const SHOWN_MAX = 256;
 const shown = (raw) => JSON.stringify(raw.length > SHOWN_MAX ? `${raw.slice(0, SHOWN_MAX)}…` : raw);
-const comparable = (p) => (p.length > 1 ? p.replace(/\/+$/, "") : p);
+const isAbsoluteHome = (p, paths) => (paths === "win32" ? /^[A-Za-z]:[\\/]/.test(p) || /^[\\/]{2}[^\\/]/.test(p) : p.startsWith("/"));
+const comparable = (p, paths) => {
+    if (paths === "posix")
+        return p.length > 1 ? p.replace(/\/+$/, "") : p;
+    const q = p.replace(/\//g, "\\").toLowerCase();
+    return /^[a-z]:\\$/.test(q) ? q : q.replace(/\\+$/, "");
+};
 function markedHome(stdout) {
     const lines = stdout.split("\n").map((l) => l.replace(/\r$/, ""));
     const marked = lines.flatMap((l, i) => (l.startsWith(LANE_HOME_PROBE_MARKER) ? [i] : []));
@@ -13,34 +19,45 @@ function markedHome(stdout) {
         return { why: "the probe output holds more than one home line or text after it, so it cannot be read as one path" };
     return { home: lines[at].slice(LANE_HOME_PROBE_MARKER.length) };
 }
-function readLaneHome(probe) {
+function readLaneHome(probe, paths) {
     if (!probe.ok)
         return { kind: "unread", reason: probe.reason };
-    const marked = markedHome(probe.stdout);
-    if ("why" in marked)
-        return { kind: "unread", reason: marked.why };
-    return marked.home.startsWith("/") ? { kind: "home", home: marked.home } : { kind: "not_absolute", value: marked.home };
+    let home;
+    if ("value" in probe)
+        home = probe.value;
+    else {
+        const marked = markedHome(probe.stdout);
+        if ("why" in marked)
+            return { kind: "unread", reason: marked.why };
+        home = marked.home;
+    }
+    return isAbsoluteHome(home, paths) ? { kind: "home", home } : { kind: "not_absolute", value: home };
 }
-export function judgeLaneHome(lane, declared, probe) {
-    const head = `REMOTE_EXEC_HOME_DIR=${shown(declared)} is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under on the ${lane} execution lane`;
-    const reading = readLaneHome(probe);
+export function judgeLaneHome(lane, claim, probe, paths = "posix") {
+    const declared = claim.source === "declared";
+    const head = declared
+        ? `REMOTE_EXEC_HOME_DIR=${shown(claim.home)} is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under on the ${lane} execution lane`
+        : `${shown(claim.home)} — the ${lane} execution lane's own home, used because REMOTE_EXEC_HOME_DIR is unset — is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under`;
+    const unconfirmed = declared ? "the declaration cannot be confirmed" : "that home cannot be confirmed";
+    const reading = readLaneHome(probe, paths);
     if (reading.kind === "unread") {
         return {
-            refusal: `${head}, but the home of this execution environment could not be read (${reading.reason}) — the declaration cannot be confirmed, so this environment is not started. Fix the lane, or unset REMOTE_EXEC_HOME_DIR (home-relative rules are then refused at submission instead).`,
+            refusal: `${head}, but the home of this execution environment could not be read (${reading.reason}) — ${unconfirmed}, so this environment is not started. ${declared ? "Fix the lane, or unset REMOTE_EXEC_HOME_DIR." : "Fix the lane so the environment answers its $HOME."}`,
             answered: false,
         };
     }
     if (reading.kind === "not_absolute") {
         return {
-            refusal: `${head}, but this execution environment reports HOME=${shown(reading.value)}, not an absolute path — the declaration cannot be confirmed, so this environment is not started. Give the environment's user a home (HOME), or unset REMOTE_EXEC_HOME_DIR.`,
+            refusal: `${head}, but this execution environment reports HOME=${shown(reading.value)}, not an absolute path — ${unconfirmed}, so this environment is not started. ${declared ? "Give the environment's user a home (HOME), or unset REMOTE_EXEC_HOME_DIR." : "Give the environment's user a home (HOME)."}`,
             answered: true,
         };
     }
-    if (comparable(reading.home) === comparable(declared))
+    if (comparable(reading.home, paths) === comparable(claim.home, paths))
         return undefined;
+    const measured = shown(reading.home);
     return {
-        refusal: `${head}, but its commands run with HOME=${shown(reading.home)} — rules would guard ${shown(declared)} while ${shown(reading.home)} stays readable and writable, ` +
-            `so this environment is not started. Set REMOTE_EXEC_HOME_DIR to ${shown(reading.home)}, or run the environment as the user whose home is ${shown(declared)}.`,
+        refusal: `${head}, but its commands run with HOME=${measured} — rules would guard ${shown(claim.home)} while ${measured} stays readable and writable, ` +
+            `so this environment is not started. Set REMOTE_EXEC_HOME_DIR to ${measured}${declared ? " or remove it" : ""}, or make the environment's HOME read ${shown(claim.home)}.`,
         answered: true,
     };
 }
@@ -52,37 +69,43 @@ export function buildHomeAbsentNote(lane, cause, remedy) {
 }
 const DECLARE_ARG = "REMOTE_EXEC_HOME_DIR=<the absolute path the environment's $HOME reads>";
 export const DECLARE_HOME_REMEDY = `Declare the home: ${DECLARE_ARG}`;
+export const LANE_HOME_UNMEASURED_EVENT = "execution_lane_home_unmeasured";
+export function buildHomeUnmeasuredNote(lane, declared) {
+    return (`the ${lane} lane cannot read its execution environment's home, so REMOTE_EXEC_HOME_DIR=${shown(declared)} is taken as declared, not measured: ` +
+        `"~/" permission rules and the engine's home-anchored read-deny rows are placed under it. If the environment's $HOME is another directory, those rules guard ${shown(declared)} ` +
+        `while the real home stays readable and writable — keep REMOTE_EXEC_HOME_DIR equal to the $HOME the environment's commands see.`);
+}
 export class LaneHomeSeat {
     measured;
     lane;
-    declared;
-    verifiesDeclared;
+    claim;
     onAbsent;
-    constructor(options) {
-        this.lane = options.lane;
-        this.declared = options.declared;
-        this.verifiesDeclared = options.verifiesDeclared;
-        this.onAbsent = options.onAbsent;
+    paths;
+    constructor(lane, config, paths = "posix") {
+        this.lane = lane;
+        this.paths = paths;
+        this.claim = config.homeDir === undefined ? undefined : { home: config.homeDir, source: config.homeDirSource ?? "declared" };
+        this.onAbsent = config.onHomeAbsent;
     }
     get home() {
-        return this.declared ?? this.measured;
+        return this.claim?.home ?? this.measured;
     }
     get asks() {
-        return this.declared === undefined ? this.measured === undefined : this.verifiesDeclared;
+        return this.claim !== undefined || this.measured === undefined;
     }
     settle(probe) {
-        if (this.declared !== undefined)
-            return this.verifiesDeclared ? judgeLaneHome(this.lane, this.declared, probe) : undefined;
-        const reading = readLaneHome(probe);
+        if (this.claim !== undefined)
+            return judgeLaneHome(this.lane, this.claim, probe, this.paths);
+        const reading = readLaneHome(probe, this.paths);
         if (reading.kind === "home") {
             this.measured = reading.home;
             return undefined;
         }
         const because = reading.kind === "unread" ? `could not be read (${reading.reason})` : `reads ${shown(reading.value)}, not an absolute path`;
-        const remedy = this.verifiesDeclared
-            ? "Give the environment's user an absolute HOME (a declared REMOTE_EXEC_HOME_DIR is checked against it, so declaring cannot stand in for it)."
-            : `Give the environment's user an absolute HOME, or declare it: ${DECLARE_ARG}.`;
-        this.onAbsent?.({ provider: this.lane, note: buildHomeAbsentNote(this.lane, `REMOTE_EXEC_HOME_DIR is unset and the environment's own $HOME ${because}`, remedy) });
+        this.onAbsent?.({
+            provider: this.lane,
+            note: buildHomeAbsentNote(this.lane, `REMOTE_EXEC_HOME_DIR is unset and the environment's own $HOME ${because}`, "Give the environment's user an absolute HOME (a declared REMOTE_EXEC_HOME_DIR is checked against it, so declaring cannot stand in for it)."),
+        });
         return undefined;
     }
 }

package/dist/leader/wire.js

@@ -9,7 +9,8 @@ import { leaderEntryRefusal, leaderRunEntry } from "./run-entry.js";
 import { buildCheckpointCtx } from "../http/checkpoint-ctx.js";
 import { serviceVersion } from "../service-version.js";
 import { RemoteContainerExecutionEnv } from "../plugins/remote-env-e2b.js";
-import { E2B_SANDBOX_HOME } from "../execution-lane-caps.js";
+import { buildLaneHomeClaim } from "../execution-lane-caps.js";
+const e2bBaseTemplateHomeSeat = buildLaneHomeClaim({ remoteExec: { provider: "e2b" } });
 import { createDurableAskPolicy } from "../approval.js";
 import { gitSubprocessEnv } from "../server-secret-env.js";
 import { presignS3Url } from "../plugins/s3-presign.js";
@@ -366,7 +367,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory+s3 (factory mode) and no e2bApiKey (static mode)");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
             if (!(await env.connect()).ok)
                 throw new Error(`connect failed for ${sub.workerId}`);
             await sh(env)(`${body.seedCmd}; cd ${repo}; git checkout -q -b ${sub.branch}`);
@@ -399,7 +400,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory and no e2bApiKey");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
             if (!(await env.connect()).ok) {
                 await env.destroy().catch(() => { });
                 throw new Error("integ connect failed");
@@ -439,7 +440,7 @@ export function createLeaderRunner(cfg) {
             else {
                 if (!cfg.e2bApiKey)
                     throw new Error("leader wire: repair-loop grader needs an envFactory or e2bApiKey");
-                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
                 if (!(await e2b.connect()).ok) {
                     await e2b.destroy().catch(() => { });
                     throw new Error("repair-loop grader connect failed");

package/dist/memory-bundle-engine.d.ts

@@ -4,11 +4,18 @@
  * ## 为什么需要这个模块(而不是在 main.ts 里直接 new)
  *
  * 本仓**没有**一个长命的 `MemoryEngine` 实例:`boot/stores.ts` 装配出来的 `memoryEngine` 是
- * `{ backend, root }` 二元组,真正的引擎由 **core 的 Runner 每任务现构**
+ * 记忆作用域店(`memory-scope-stores.ts`:部署的店 + 引擎根 + 「一层住哪只店」的唯一读者),真正的引擎由 **core 的 Runner 每任务现构**
  * (`core/runner/prepare-memory.js`),而且构出来的 `memoryDir` 是**按任务的 scope 平面**决定的
  * (personal / project / dual-root 三形,还要看仓根、项目标记、pinned 目录)。
  * 也就是说「这个部署的那一个记忆引擎」这个东西**在本仓不存在** —— HTTP 面若要一个引擎,必须自己构。
  *
+ * ## 引擎建在哪只店上:包点名的层住的那只
+ * 导出按请求的 `scopes` 定店,导入按包自己的 `bundle.scopes` 定店(core 的整包判决保证包里每一条的层都在 `bundle.scopes` 里 —— 自洽是它的校验项);
+ * 几层分住两只店 ⇒ 拒(`request.memory_layer`):一只包是**一只店**单锁复合面里的一个 epoch,两只店封不出一只包。规则唯一属主
+ * `memory-scope-stores.ts` 的 {@link memoryStoreForRequest}。`bundle.scopes` 读不成「非空的非空串数组」的包,本来就过不了 core 的整包判决
+ * (结构项第一条),交部署的店那只引擎去判 —— 拒是包本身的函数,哪只引擎判都一样,什么都不落。
+ * 修前两面都在部署的店上建引擎:目录钉住的部署上,类型化个人层的条目在个人挂载上的另一只店里 —— 导出的包里没有会话写的条目,导入的落在会话不读的店。
+ *
  * ## 为什么自己构是安全的:这两个面是 **backend-scoped**,不碰 `memoryDir`
  *
  * 亲读 core 5.40.0 的 `memory-engine/engine.js`(不信 JSDoc,读实现):
@@ -41,7 +48,9 @@
  * `memory.export_incomplete` —— 那是诚实的运行期拒,附录 A 单列一条。绝不在这里回落到「用通用读面拼
  * 一个包」:core 明写那正是它拒绝生产的形(a governance-less export is the laundering shape)。
  */
-import { type MemoryBackend, type MemoryExportBundle, type MemoryImportReport, type SessionCaptureRecordStore } from "@sema-agent/core";
+import { type MemoryExportBundle, type MemoryImportReport } from "@sema-agent/core";
+import { type MemoryScopeStores } from "./memory-scope-stores.js";
+import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 /** 两口 HTTP 面消费的窄能力面(`ServiceDeps.memoryBundle{Export,Import}` 的实参来源)。 */
 export interface MemoryBundleFaces {
     exportScopes: (scopes: readonly string[]) => Promise<MemoryExportBundle>;
@@ -51,17 +60,15 @@ export interface MemoryBundleFaces {
     }) => Promise<MemoryImportReport>;
 }
 /**
- * 在**已装配的记忆后端**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
+ * 在**记忆作用域店**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点;全仓自构引擎同一条规则,
+ * 店:见文件头「引擎建在哪只店上」;一只店一只引擎。
+ * `memoryDir` = 那只店的**挂载平面**(`memoryMountRootOf(store, root)` 单铸点;全仓自构引擎同一条规则,
  * 由 `test/memory-layout-plane.test.ts` 的归一门咬住)。见文件头:这两条路径**不读它**(机器钉在
  * `test/memory-bundle-engine.test.ts`:给一个不存在的 `memoryDir` 也照样工作),传对的那一只是为了
  * 万一 core 日后真用上时,它拿到的是本部署真正的挂载平面,而不是高一层的配置根。
  */
-export declare function createMemoryBundleFaces(store: {
-    backend: MemoryBackend;
-    root: string;
-}, opts?: {
-    captureRecordStore?: SessionCaptureRecordStore;
+export declare function createMemoryBundleFaces(stores: MemoryScopeStores, opts?: {
+    captureRecords?: SessionCaptureRecordSource;
 }): MemoryBundleFaces | undefined;
 //# sourceMappingURL=memory-bundle-engine.d.ts.map

package/dist/memory-bundle-engine.js

@@ -1,13 +1,36 @@
 import { MemoryEngine } from "@sema-agent/core";
 import { memoryMountRootOf } from "./memory-scope.js";
-export function createMemoryBundleFaces(store, opts) {
-    const b = store.backend;
-    if (typeof b.exportSnapshotOf !== "function" || typeof b.importBundleCommit !== "function")
+import { memoryStoreForRequest } from "./memory-scope-stores.js";
+import { captureRecordStoreOf } from "./memory-operator-faces.js";
+export function createMemoryBundleFaces(stores, opts) {
+    if (!carriesBundleComposite(stores.backend))
         return undefined;
-    const engine = new MemoryEngine({ backend: store.backend, memoryDir: memoryMountRootOf(store.backend, store.root), ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
+    const engines = new Map();
+    const engineOf = (store) => {
+        const known = engines.get(store);
+        if (known !== undefined)
+            return known;
+        if (!carriesBundleComposite(store))
+            throw new Error("the memory store that holds these layers implements no v2-c bundle composite (exportSnapshotOf / importBundleCommit) — a bundle is never assembled outside one");
+        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        const engine = new MemoryEngine({ backend: store, memoryDir: memoryMountRootOf(store, stores.root), ...(records !== undefined ? { captureRecordStore: records } : {}) });
+        engines.set(store, engine);
+        return engine;
+    };
     return {
-        exportScopes: (scopes) => engine.exportMemoryScopes(scopes),
-        importBundle: (bundle, opts) => engine.importMemoryBundle(bundle, opts),
+        exportScopes: async (scopes) => engineOf(memoryStoreForRequest(stores, scopes)).exportMemoryScopes(scopes),
+        importBundle: async (bundle, opts) => {
+            const layers = bundleLayersOf(bundle);
+            return engineOf(layers.length > 0 ? memoryStoreForRequest(stores, layers) : stores.backend).importMemoryBundle(bundle, opts);
+        },
     };
 }
+function carriesBundleComposite(store) {
+    const b = store;
+    return typeof b.exportSnapshotOf === "function" && typeof b.importBundleCommit === "function";
+}
+function bundleLayersOf(bundle) {
+    const scopes = typeof bundle === "object" && bundle !== null ? bundle.scopes : undefined;
+    return Array.isArray(scopes) && scopes.length > 0 && scopes.every((s) => typeof s === "string" && s.length > 0) ? scopes : [];
+}
 //# sourceMappingURL=memory-bundle-engine.js.map