@sema-agent/server 7.127.2 → 7.129.0

package/dist/plugins/session-policy-store-sql.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { assertSessionRuleNamesCurrent, loosenReasons, SessionPolicyError, normalizeRules, stripRev } from "@sema-agent/core";
-import { readSessionPermissionRules, describeSessionPermissionRulesProblem } from "../session-policy-wire.js";
+import { judgeSessionRulesWrite, readSessionRulesShape, SessionPolicyError } from "@sema-agent/core";
+import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
 import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "./sql-json-column.js";
 import { pgHasUnstorable } from "./pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
@@ -8,9 +8,13 @@ import { isDeadlockError, isDupKeyError } from "./sql-errors.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
 const RETRY_LIMIT = 8;
+const RULES = SESSION_RULES_COLUMN.name;
 export function readSessionRulesBody(body) {
-    const read = readSessionPermissionRules(body);
-    return read.problem !== undefined ? { problem: describeSessionPermissionRulesProblem(read.problem) } : { value: read.rules };
+    const read = readSessionRulesShape(body);
+    if ("fault" in read)
+        return { problem: read.sentence };
+    const { grammar, ...buckets } = read.rules;
+    return { value: body.grammar === undefined ? buckets : { ...buckets, grammar } };
 }
 function readRulesBody(text, where) {
     try {
@@ -29,7 +33,7 @@ function rowToStored(r, where) {
     const counters = readRowCounters(r, where);
     if ("problem" in counters)
         throw new SessionPolicyError("corrupt", counters.problem);
-    return { ...readRulesBody(r.rules, `session_policy.rules ${where}`), rev: counters.rev, gen: counters.gen };
+    return { ...readRulesBody(r[RULES], `session_policy.rule_entries ${where}`), rev: counters.rev, gen: counters.gen };
 }
 function readRowCounters(r, where) {
     const rev = Number(r.rev);
@@ -67,8 +71,8 @@ export class SqlSessionPolicyStore {
     }
     async getRules(sessionId, principal) {
         const key = policyKey(sessionId, principal);
-        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, ${jsonColumnText("tidb", "rules")}, rev, gen FROM session_policy WHERE policy_key = ?` +
-            " UNION ALL SELECT 'seal', NULL, rev, gen FROM session_policy_rev_mark WHERE policy_key = ? AND rev = ?", `SELECT 'row' AS src, ${jsonColumnText("pg", "rules")}, rev, gen FROM session_policy WHERE policy_key = $1` +
+        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE policy_key = ?` +
+            " UNION ALL SELECT 'seal', NULL, rev, gen FROM session_policy_rev_mark WHERE policy_key = ? AND rev = ?", `SELECT 'row' AS src, ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1` +
             " UNION ALL SELECT 'seal', NULL, rev, gen FROM session_policy_rev_mark WHERE policy_key = $2 AND rev = $3"), [key, key, SEALED_MARK_REV]);
         if (rows.some((r) => r.src === "seal"))
             throw sealedKeyError(sessionId, `key ${key}`);
@@ -78,8 +82,8 @@ export class SqlSessionPolicyStore {
         return rowToStored(row, `for session ${JSON.stringify(sessionId)}`);
     }
     async listBySession(sessionId) {
-        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, principal, ${jsonColumnText("tidb", "rules")}, rev, gen FROM session_policy WHERE session_id = ?` +
-            " UNION ALL SELECT 'seal', NULL, NULL, rev, gen FROM session_policy_rev_mark WHERE session_id = ? AND rev = ?", `SELECT 'row' AS src, principal, ${jsonColumnText("pg", "rules")}, rev, gen FROM session_policy WHERE session_id = $1` +
+        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, principal, ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE session_id = ?` +
+            " UNION ALL SELECT 'seal', NULL, NULL, rev, gen FROM session_policy_rev_mark WHERE session_id = ? AND rev = ?", `SELECT 'row' AS src, principal, ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE session_id = $1` +
             " UNION ALL SELECT 'seal', NULL, NULL, rev, gen FROM session_policy_rev_mark WHERE session_id = $2 AND rev = $3"), [sessionId, sessionId, SEALED_MARK_REV]);
         if (rows.some((r) => r.src === "seal"))
             throw sealedKeyError(sessionId, "one of its keys");
@@ -91,7 +95,7 @@ export class SqlSessionPolicyStore {
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         return this.retrying(() => this.tx(async (conn) => {
-            const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("tidb", "rules")}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", "rules")}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
+            const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
             const prior = rows[0] ? rowToStored(rows[0], `for session ${JSON.stringify(sessionId)} (pre-write snapshot)`) : undefined;
             const priorRev = prior?.rev ?? 0;
             if (opts?.expectedRev !== undefined && priorRev !== opts.expectedRev) {
@@ -103,14 +107,7 @@ export class SqlSessionPolicyStore {
             if (markRows[0] !== undefined && (!isStoredCounter(markGen, 0) || !isStoredCounter(markRev, 0))) {
                 throw new SessionPolicyError("corrupt", `the session rules rev mark for session ${JSON.stringify(sessionId)} is unreadable (rev ${String(markRows[0].rev)}, gen ${String(markRows[0].gen)}) — refusing rather than stamp a rev/lineage nothing proves`);
             }
-            const clean = normalizeRules(stripRev(rules));
-            assertSessionRuleNamesCurrent(clean);
-            if (prior && opts?.operator !== true) {
-                const loosens = loosenReasons(prior, clean);
-                if (loosens.length > 0) {
-                    throw new SessionPolicyError("loosen_forbidden", `a non-operator session-rule write may only tighten; refused: ${loosens.join("; ")}`);
-                }
-            }
+            const clean = judgeSessionRulesWrite(prior ?? null, rules, opts);
             if (this.db.dialect === "pg" && pgHasUnstorable(clean)) {
                 throw new SessionPolicyError("loosen_forbidden", "rules contain unstorable bytes (NUL / lone surrogate) — refused; strip them at the source (authorization rules are never rewritten by the store)");
             }
@@ -122,12 +119,12 @@ export class SqlSessionPolicyStore {
             const json = JSON.stringify(clean);
             const now = new Date();
             if (prior) {
-                const upd = await conn.query(this.q("UPDATE session_policy SET principal = ?, rules = ?, rev = ?, gen = ?, updated_at = ? WHERE policy_key = ? AND rev = ?", "UPDATE session_policy SET principal = $1, rules = $2::jsonb, rev = $3, gen = $4, updated_at = $5 WHERE policy_key = $6 AND rev = $7"), [principal ?? null, json, nextRev, nextGen, now, key, priorRev]);
+                const upd = await conn.query(this.q(`UPDATE session_policy SET principal = ?, ${RULES} = ?, rev = ?, gen = ?, updated_at = ? WHERE policy_key = ? AND rev = ?`, `UPDATE session_policy SET principal = $1, ${RULES} = $2::jsonb, rev = $3, gen = $4, updated_at = $5 WHERE policy_key = $6 AND rev = $7`), [principal ?? null, json, nextRev, nextGen, now, key, priorRev]);
                 if (upd.affected !== 1)
                     throw new SessionPolicyError("conflict", `session rules rev mismatch (expected ${opts?.expectedRev ?? priorRev}, have ${priorRev})`);
             }
             else {
-                await conn.query(this.q("INSERT INTO session_policy (policy_key, session_id, principal, rules, rev, gen, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?)", "INSERT INTO session_policy (policy_key, session_id, principal, rules, rev, gen, created_at, updated_at) VALUES ($1,$2,$3,$4::jsonb,$5,$6,$7,$8)"), [key, sessionId, principal ?? null, json, nextRev, nextGen, now, now]);
+                await conn.query(this.q(`INSERT INTO session_policy (policy_key, session_id, principal, ${RULES}, rev, gen, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?)`, `INSERT INTO session_policy (policy_key, session_id, principal, ${RULES}, rev, gen, created_at, updated_at) VALUES ($1,$2,$3,$4::jsonb,$5,$6,$7,$8)`), [key, sessionId, principal ?? null, json, nextRev, nextGen, now, now]);
             }
             return structuredClone({ ...clean, rev: nextRev, gen: nextGen });
         }));

package/dist/plugins/session-rules-column.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `session_policy` 装会话规则的那一列 —— 列定义的**唯一属主**:中央 DDL(`tidb-pool.ts` / `pg-pool.ts` 的 `CREATE TABLE session_policy`)、
+ * SQL 会话规则店(`session-policy-store-sql.ts` 的读三处 + 写两处)与一次性迁移 M17(`one-time-migrations.ts`,存量库改列名)都内插这同一份,
+ * 于是新库建出来的列与存量库改出来的列逐字同形(起服列册探针比的是列名,形由这里保证)。
+ *
+ * 规则:**一列一文法**。这一列装的是引擎的规则条目文法(引擎 7.51.0 起 `toolDeny` / `toolAllow` 装规则条目 —— `Bash(rm:*)` 是一条拒 `rm` 的规则;
+ * `allowDirs` 装目录),读它的只有引擎那一只形读者(`readSessionRulesShape`)。按另一种文法读规则的副本(7.128.x 及以前:同名的 `rules` 列,
+ * 条目按整串工具名比,`Bash(rm:*)` 匹配不到任何工具)在这只库上**找不到一列可以读错**:它的每一条规则语句点名的列不存在 ⇒ 响亮失败;
+ * 它的二进制起服时列册探针判出缺列 / 多列 ⇒ 拒启。两样都不是「读成更少的规则」。
+ */
+export declare const SESSION_RULES_COLUMN: {
+    readonly name: "rule_entries";
+    readonly tidb: "rule_entries JSON NOT NULL";
+    readonly pg: "rule_entries JSONB NOT NULL";
+};
+//# sourceMappingURL=session-rules-column.d.ts.map

package/dist/plugins/session-rules-column.js

@@ -0,0 +1,6 @@
+export const SESSION_RULES_COLUMN = {
+    name: "rule_entries",
+    tidb: "rule_entries JSON NOT NULL",
+    pg: "rule_entries JSONB NOT NULL",
+};
+//# sourceMappingURL=session-rules-column.js.map

package/dist/plugins/tidb-pool.js

@@ -7,6 +7,7 @@ import { TIDB_ADOPTION_LOG_STATEMENTS } from "./adoption-log-sql.js";
 import { TIDB_PERMISSION_RULE_STATEMENTS } from "./permission-rule-store-sql.js";
 import { TIDB_RETENTION_STATEMENTS } from "./retention-store-sql.js";
 import { SESSION_META_INCARNATION_COLUMN } from "../session-incarnation.js";
+import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
 import { SESSION_TITLE_MAX_CHARS } from "../session-row.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
@@ -413,7 +414,9 @@ export const SCHEMA_STATEMENTS = [
      -- not part of the CAS/tighten logic — putRules just writes it. NULL = the session-wide row (principal
      -- undefined). PRE-MIGRATION rows (E6 was new when the column landed) ⇒ NULL, i.e. read as session-wide.
      principal  VARCHAR(190) NULL,
-     rules      JSON         NOT NULL,
+     -- 会话规则(三只桶,引擎的规则条目文法)。列定义唯一属主 = src/plugins/session-rules-column.ts 的 SESSION_RULES_COLUMN(一列一文法:
+     -- 7.128.x 及以前这一列叫 rules、按整串工具名读;存量库由一次性迁移 M17 改名,带退役命令桶的行原样留着、读回判坏并逐行点名,见那份文件与 one-time-migrations.ts)。
+     ${SESSION_RULES_COLUMN.tidb},
      rev        BIGINT       NOT NULL,
      -- gen (core 7.25.0 StoredSessionRules.gen, S-529 二期):这一行的**血统**。rev 只在一条血统内计数,
      -- deleteBySession 终结血统并把下一代的号留在 session_policy_rev_mark.gen 上,于是活规则读者能把

package/dist/read-face-posture.d.ts

@@ -57,7 +57,8 @@ export declare function readFaceForPosture(singleUserTurnkey: boolean): ReadFace
  *  `web-admin-client/restart-signal.ts` 的 `read-face` 片也不再为它签重启理由(判据同源 =
  *  `CENTER_READ_FACE_LIVE_KEYS`,由 core 的 `isSwappableDepSeat` 派生)。本句此前逐字写着
  *  「(restart-to-apply)」—— G-7 抓获的那条过期断言,方向恰好是「让运维为一个已生效的变更重启 fleet」。
- *  ⚠️ 只说 `face` 这一席:三个 deny 键仍是 boot-baked,那半场的话不在这条读面上(它们没有来源位)。 */
+ *  ⚠️ 只说 `face` 这一席:三个 deny 键同样是热换席(core 7.51.0 起,落配与换席同一条腿),但它们没有来源位,
+ *  那半场的话不在这条读面上。 */
 export declare function readFaceSourceNote(source: ReadFaceSource): string;
 /** operator 诊断面的投影(`GET /v1/diagnostics/wiring`)。`face:null` = 本部署没钉档,引擎默认接管。 */
 export declare function buildReadFaceWiring(facts: ReadFacePostureFacts): {

package/dist/request-value-closure.js

@@ -25,7 +25,7 @@ export function singleMemberOffFieldIssue(raw) {
 }
 export const INHERIT_ENV_WORDS = ["all", "scrub"];
 export const INHERIT_ENV_VALUE_MESSAGE = `inheritEnv must be one of ${INHERIT_ENV_WORDS.map((w) => JSON.stringify(w)).join(" | ")} when present ` +
-    `("all" = the model-driven host shell inherits this machine's whole environment, honored only on a single-user host-lane deployment; ` +
+    `("all" = the model-driven host shell inherits this machine's whole environment except this deployment's own credentials (its configuration directory's secret-typed names), honored only on a single-user host-lane deployment; ` +
     `"scrub" = the default scrub of credential-shaped variables, accepted on every lane; absent = "scrub") — a name list is not a request value`;
 export function inheritEnvFieldIssue(raw) {
     if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw))

package/dist/retired-card-words.d.ts

@@ -0,0 +1,17 @@
+/** 改写涉及的座(读侧半场的响亮诊断用;只报座名,不报值)。 */
+export type RetiredCardWordSeat = "ruleOffersAbsence" | "askClass" | "classes";
+/** 一次改写的结论:`seats` 为空 = 这一只载体上没有退役词(`value` 就是传入的那一只,同一引用)。 */
+export interface RetiredCardWordsRewrite<T> {
+    readonly value: T;
+    readonly seats: readonly RetiredCardWordSeat[];
+}
+/**
+ * 载着卡两座的那一只对象(存卡的 `card`、停驻行的 `tool_approval` 臂)上的退役词改写。不改原对象:有改写时交一只浅拷贝(停驻行靠这一条保证读侧零写)。
+ * 非对象 / 数组 ⇒ 原样(这不是一只载体)。
+ */
+export declare function retireCardWords<T>(carrier: T): RetiredCardWordsRewrite<T>;
+/** 存卡信封(`{ schemaVersion, approvalId, card }`)上的改写:只改 `card` 那一只。 */
+export declare function retireStoredCardWords<T>(envelope: T): RetiredCardWordsRewrite<T>;
+/** 停驻行 `pendingAction` 上的改写:只认 `tool_approval` 臂(core:读工具字段之前先按 `kind` 分臂);别的臂原样。 */
+export declare function retireParkArmWords<T>(pendingAction: T): RetiredCardWordsRewrite<T>;
+//# sourceMappingURL=retired-card-words.d.ts.map

package/dist/retired-card-words.js

@@ -0,0 +1,49 @@
+import { ASK_CLASSES } from "@sema-agent/core";
+const RETIRED_RULE_OFFERS_ABSENCE = "shadowed";
+const RETIRED_ASK_CLASS = "governance_unavailable";
+const SUCCESSOR_ASK_CLASS = "rule_unreadable";
+const classOrder = (c) => {
+    const i = ASK_CLASSES.indexOf(c);
+    return i === -1 ? ASK_CLASSES.length : i;
+};
+export function retireCardWords(carrier) {
+    if (carrier === null || typeof carrier !== "object" || Array.isArray(carrier))
+        return { value: carrier, seats: [] };
+    const src = carrier;
+    const seats = [];
+    const next = { ...src };
+    if (Object.hasOwn(src, "ruleOffersAbsence") && src.ruleOffersAbsence === RETIRED_RULE_OFFERS_ABSENCE) {
+        delete next.ruleOffersAbsence;
+        seats.push("ruleOffersAbsence");
+    }
+    const classes = src.classes;
+    const classesCarryRetired = Array.isArray(classes) && classes.includes(RETIRED_ASK_CLASS);
+    if (classesCarryRetired) {
+        const mapped = [...new Set(classes.map((c) => (c === RETIRED_ASK_CLASS ? SUCCESSOR_ASK_CLASS : c)))];
+        mapped.sort((a, b) => classOrder(a) - classOrder(b));
+        next.classes = mapped;
+        seats.push("classes");
+        if (Object.hasOwn(src, "askClass")) {
+            next.askClass = mapped[0];
+            seats.push("askClass");
+        }
+    }
+    else if (src.askClass === RETIRED_ASK_CLASS) {
+        next.askClass = SUCCESSOR_ASK_CLASS;
+        seats.push("askClass");
+    }
+    return seats.length === 0 ? { value: carrier, seats } : { value: next, seats };
+}
+export function retireStoredCardWords(envelope) {
+    if (envelope === null || typeof envelope !== "object" || Array.isArray(envelope))
+        return { value: envelope, seats: [] };
+    const env = envelope;
+    const card = retireCardWords(env.card);
+    return card.seats.length === 0 ? { value: envelope, seats: [] } : { value: { ...env, card: card.value }, seats: card.seats };
+}
+export function retireParkArmWords(pendingAction) {
+    if (pendingAction === null || typeof pendingAction !== "object" || pendingAction.kind !== "tool_approval")
+        return { value: pendingAction, seats: [] };
+    return retireCardWords(pendingAction);
+}
+//# sourceMappingURL=retired-card-words.js.map

package/dist/rule-entry-list.js

@@ -31,6 +31,8 @@ export function inertRuleEntryGuidance(i) {
             return "this tool takes no content form here — name the tool itself, or use Bash(<command>) / Bash(<prefix>:*) for a shell command";
         case "grammar":
             return "the entry is not read as written (surrounding whitespace, an empty or unbalanced tool name, or an invisible or control character in the tool name) — write the tool name exactly, with no padding";
+        case "earlier_grammar":
+            throw new Error(`allow-entry inert reason ${JSON.stringify(reason)} belongs to the session-rule store's bucket reading (compileSessionRuleBucket), never to an allow-layer entry list — a caller handed a session-rule reading to the entry-list sentence`);
         default: {
             const unhandled = reason;
             throw new Error(`unhandled allow-entry inert reason: ${String(unhandled)}`);

package/dist/run-local.js

@@ -25,10 +25,10 @@ import { acquireLocalBackendWithWait } from "./plugins/store-lock-wait.js";
 import { configLocalRoot, configProviderKind, createConfigProvider } from "./config-provider.js";
 import { CONFIG_DOMAIN_INVALID_NOTE, buildCandidateRejectedFields, judgeConfigCandidate } from "./web-admin-client/candidate-gate.js";
 import { buildUnreadConfigFileFields } from "./web-admin-client/read-warnings.js";
-import { composeExecutionLane } from "./boot/execution-lane.js";
+import { composeExecutionLane, settleHostLaneShell } from "./boot/execution-lane.js";
 import { judgeConsolidationValve } from "./boot/memory-consolidation.js";
 import { logConfigDirMigration, migrateLocalConfigDirectory } from "./config-d-migration.js";
-import { applyEffective, applyCenterReadFace, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./web-admin-client/facade.js";
+import { applyEffective, applyCenterReadFace, applySkillsManifest, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./web-admin-client/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
 import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
 import { makeLoadProjectMemory, makeProbeInstructionSources } from "./project-memory.js";
@@ -60,6 +60,7 @@ import { createHostLspManager } from "./host-lsp-manager.js";
 import { buildDisplaySafeUrl } from "./trace/redact.js";
 import { installOutboundDispatcher } from "./outbound-dispatcher.js";
 import { provisionSemaConfigDir } from "./sema-config-dir.js";
+import { bindOwnCredentialsConfig, declareServerWithheldEnv } from "./server-secret-env.js";
 export function parseArgs(argv) {
     let objective;
     let root;
@@ -152,7 +153,6 @@ export const NO_TTY_ASK_CLASS_ROW = {
     unverifiable_shell_text: { remedy: "terminal_only", autoBudgetReleases: false },
     transcript_write: { remedy: "terminal_only", autoBudgetReleases: false },
     org_rule: { remedy: "terminal_only", autoBudgetReleases: false },
-    governance_unavailable: { remedy: "terminal_only", autoBudgetReleases: false },
     rule_unreadable: { remedy: "terminal_only", autoBudgetReleases: false },
     ask_rule: { remedy: "approval_lists", autoBudgetReleases: true },
     denial_limit_fallback: { remedy: "terminal_only", autoBudgetReleases: false },
@@ -327,7 +327,9 @@ export async function runLocal(argv, deps = {}) {
     process.env.REQUIRE_PRINCIPAL = "false";
     if (args.root)
         process.env.CONFIG_LOCAL_DIR = args.root;
+    declareServerWithheldEnv();
     const config = loadConfig();
+    bindOwnCredentialsConfig(config);
     const root = configLocalRoot(config);
     const logger = deps.logger ?? createLogger(config.logLevel);
     const metrics = createMetrics();
@@ -350,6 +352,7 @@ export async function runLocal(argv, deps = {}) {
     const configProvider = createConfigProvider(providerInput);
     let effective;
     let candidatePrompts;
+    let applying = false;
     try {
         const r = await configProvider.fetchEffective(undefined);
         if (r) {
@@ -364,9 +367,10 @@ export async function runLocal(argv, deps = {}) {
                     logger.warn("config_unread_file", buildUnreadConfigFileFields(f, configProvider.kind === "local" ? root : undefined));
                 for (const d of r.droppedEntries ?? [])
                     logger.warn("config_entry_dropped", { domain: d.domain, entry: d.entry, reasonCode: d.reasonCode, error: d.error, version: r.effective.version, phase: "boot", note: "this one entry failed its domain schema and was dropped on its own — the rest of the candidate applies (per-entry tolerance); fix the named entry to bring it back" });
+                applying = true;
+                applyEffective(config, r.effective, logger, { leg: "boot" });
                 effective = r.effective;
                 candidatePrompts = verdict.prompts;
-                applyEffective(config, r.effective, logger, { leg: "boot" });
                 if (effective?.mcp)
                     config.mcpServers = resolveMcpServers(effective.mcp, logger);
                 if (effective?.a2a)
@@ -377,7 +381,10 @@ export async function runLocal(argv, deps = {}) {
         }
     }
     catch (err) {
-        logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, err: String(err) });
+        if (applying)
+            logger.warn("config_apply_refused", { source: configProvider.kind, err: String(err), note: "the candidate failed to apply at boot — running on env (run-local has no LKG); none of the candidate's domains is adopted; this is not a reachability failure" });
+        else
+            logger.warn("config_source_unreachable_using_env", { source: configProvider.kind, err: String(err) });
     }
     const noDefaultModel = defaultModelRefusal(config, "env");
     if (noDefaultModel !== undefined)
@@ -436,6 +443,7 @@ export async function runLocal(argv, deps = {}) {
     const keyResolver = createKeyResolver(config.modelApiKeyEnv, process.env, config.modelApiKeys);
     const hostRx = config.remoteExec?.provider === "host" ? config.remoteExec : undefined;
     const workspaceDir = args.workspace ?? hostRx?.workspaceBase ?? process.cwd();
+    await settleHostLaneShell(config, logger);
     const executionEnvFactory = hostRx
         ? hostExecutionEnvFactory({
             workspaceDir,
@@ -595,7 +603,8 @@ export async function runLocal(argv, deps = {}) {
     const subRunnerDeps = { ...sharedRunnerDeps, sessionStore: new ForkRoutingSessionStore(sessionStore, new TtlSessionStore({ defaultTtlDays: 1 / 24 })), onError: engineOnError, onAsk };
     const subRunner = new Runner(subRunnerDeps);
     const handslessRunner = new Runner(withoutHands(runnerDeps));
-    const skills = loadDeploymentSkills(config);
+    const deploymentSkills = loadDeploymentSkills(config);
+    const skills = effective?.skills ? await applySkillsManifest(deploymentSkills, effective.skills, configProvider, logger) : deploymentSkills;
     const repoClient = config.gitApiBaseUrl ? createRepoClient(config.gitApiKind, config.gitApiBaseUrl, config.gitApiToken) : undefined;
     const webSearchCfg = webSearchConfigFromEnv();
     const webSearch = webSearchCfg ? createWebSearchBackend(webSearchCfg) : undefined;

package/dist/server-secret-env.d.ts

@@ -1,115 +1,107 @@
 /**
- * 7.99.0 合并复审 F7(web-admin [ref] 实测;安全轴;DEBTS S-684)—— 子进程 env 交出去之前的**本仓**密钥剥除;7.103.0(车OT,
- * S-684 残余按类收口)起也是本包**宿主子进程 env 的唯一组合点**。
+ * 宿主子进程 env 的**唯一组合点**(7.103.0 起,S-684 残余按类收口)+ 本进程**自有凭据名的唯一声明点**(7.129.0 起,core 7.51.1)。
  *
- * ## 病
- * 本仓的子进程腿 —— 模型可驱动的 host shell(`inheritEnv:"scrub"` 缺省腿,`plugins/remote-env-host.ts`)与
- * project-memory 的 git 子进程(`project-memory.ts`)—— 此前只调 core 的 `scrubSecretEnv`。它按键名**形状**判
- * (`*_KEY` / `*_TOKEN` / `*_SECRET` …),而本仓自己的凭据键里有形状规则认不出的:`SERVICE_AUTH_TOKENS`(复数,
- * per-system 凭据表)、`APPROVAL_HMAC_KEYS`(直连门 HMAC 密钥集)、`OTEL_EXPORTER_OTLP_HEADERS`(常载鉴权头)⇒
- * 原样进子进程,模型选的一句 `printenv` 就读得到。S-684 残余(7.103.0):另外三条宿主腿连 core 的形状剥都没过 —— leader 推送的
- * git(`leader/wire.ts`)、center-plugins 克隆的 git(`capabilities/center-plugins.ts`)、bake-runner 交给 build.sh 与主机命令的
- * env(`bake-runner/main.ts`,连 runner 自己的 `BAKE_RUNNER_TOKEN`)。
+ * ## 病(沿革)
+ * 7.99.0 合并复审 F7(web-admin [ref] 实测;安全轴;DEBTS S-684):core 的形状剥(`*_KEY` / `*_TOKEN` …)认不出本仓自己的凭据键
+ * (`SERVICE_AUTH_TOKENS` / `APPROVAL_HMAC_KEYS` / `OTEL_EXPORTER_OTLP_HEADERS`)⇒ 本仓在 `scrub` 腿上另加目录臂按名剥。7.129.0(web-client
+ * 实测):目录臂只在 `scrub` 腿施,`inheritEnv:"all"` 是 `{ ...process.env }` 零剥除、`[names]` 点到目录 secret 名照放 —— 单用户 host 上 cli 交互 lane
+ * 每次提交发 `"all"`,引擎自己的 `SERVICE_AUTH_TOKEN(S)` / `APPROVAL_HMAC_KEYS` / `MODEL_API_KEY` 逐字进模型 shell,模型一条 `curl` 可自批自己的 HITL 卡。
+ * 病根是本仓自判三个继承词、而只在其中一个词上减自有凭据。
  *
- * ## 规则(一句)
- * 本包任何进程在宿主上 spawn 的子进程:env = {@link hostSubprocessEnv} = {@link scrubServerSecrets}(process.env) ∪ 部署方点名放回的键
- * (只在运维真可能要传东西的腿上有旋钮),剥掉的键经一个登记过的 `SecretEnvScrubSite` 留痕;git 腿再叠 git 自己的两件
- * ({@link gitSubprocessEnv})。各腿只调这两只 —— 不许再有内联拼装(类级门在 `test/secret-env-scrub-host-legs.test.ts`)。
- *
- * {@link scrubServerSecrets} = core `scrubSecretEnv`(按形)∘ 本仓按名两臂:
- *  · 目录臂 —— 配置目录(`config-catalog.ts`)里 `type:"secret"` 的每一行,从目录机器派生,不手抄第二份名单;
- *  · 名单型旋钮臂 —— `ENV_NAME_ALLOWLIST_KNOBS` 的每一只(`env-name-allowlist-knobs.ts`,表键派生):名单**原文**可能夹着一枚被错展开进来
- *    的令牌,按凭据类对待。服务侧四只(`LSP_ENV_ALLOW` S-699 / `E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` S-713 / `K8S_SANDBOX_ENV`)同时是目录 secret 行,
- *    目录臂先认;本臂接住的是**不在服务目录里**的那一只 —— bake-runner 的 `BAKE_ENV_ALLOW`(它不是服务进程的配置)。
- * core 形状规则的缺口由 core 源头修 —— 7.30.1 #1072 补 `KEYS|TOKENS|PASSWORDS`(S-616),7.33.7 #1180 按名认 OTLP 头变量一族(7.103.2 车PM 提货;目录臂照旧点名
- * `OTEL_EXPORTER_OTLP_HEADERS` = 双保险,互证钉在 `test/secret-env-scrub-disclosure.test.ts`),目录臂独担的只剩名单型旋钮(值是变量名单,core 本来就不该认它们)。
- * 本层不改 core 的判据,也不自造第二份形状规则。目录里加一个 secret 型键 / 叶表加一只名单型旋钮,每条腿当场就剥它。
- *
- * ## 不变的面
- * `inheritEnv:"all"`(显式全继承)与显式 allowlist 两形不经本函数,行为逐字不变;调用方显式传入的 env
- * (`cfg.env` / 单次命令的 `env`)照旧原样覆盖在剥除结果之上。
+ * ## 律(一句;core #1753 定,本仓只传事实、不判)
+ * 本包任何进程在宿主上 spawn 的子进程:env = 引擎 `inheritedHostEnv(policy, findings)` ∪ 部署方点名放回的键(只在运维真可能要传东西的腿上有旋钮),
+ * 剥掉的键经一个登记过的 `SecretEnvScrubSite` 留痕;git 腿再叠 git 自己的两件({@link gitSubprocessEnv})。三个继承词只在引擎一处判:
+ *  · `"all"` = 整份环境 **减** 本进程声明的自有凭据名;`"scrub"`(缺省)= 形状剥 ∪ 该名单;`[names]` = 严格白名单,点到名单中的名 ⇒ 引擎响亮拒
+ *    (`inheritEnvPolicyProblem`:构造时与 spawn 时两格都拒,拒句带名;本仓不自判 withheld、不留第二读法)。
+ *  · 名单 = 配置目录(`config-catalog.ts`)全部 `type:"secret"` 名 ∪ 名单型旋钮名(`env-name-allowlist-knobs.ts`,其原文可能夹着被错展开的令牌)∪ **生效配置
+ *    模型条目的 `apiKeyEnv`**(key-resolver 取凭据的那张表 `config.modelApiKeyEnv` 的值 —— 本进程消费的凭据变量名,条目由中心热应用新增 / 改名),
+ *    **机器派生**、不手抄、不按「归谁消费」切({@link serverWithheldEnvNames} 一处)。声明两个时机、同一只 {@link declareServerWithheldEnv}:起服第一步(三个进程入口:
+ *    `boot/stage-01-config.ts` / `run-local.ts` / `bake-runner/main.ts`,在任何执行环境构造与 spawn 之前 —— 声明先于构造才有构造时拒;此时没有生效配置 = 空表),
+ *    与每次生效配置换代(`web-admin-client/apply-effective.ts` 本体:CAS 之后、Runner 换装与 commit 之前 —— 声明先于席位,旧世代不声明)。名单只随**落地**的世代
+ *    增长(本进程 env 是 boot 期输入:一个名字一旦指过本进程的凭据,条目改名 / 删掉之后它的值仍在 env 里 ⇒ 落地过的名不退出;没落地的候选不留痕 —— 换装拒 ⇒
+ *    {@link withdrawServerWithheldEnv} 撤回到换代前的集合)。声明失败(坏形名 / 运行时回填名)⇒ 引擎抛且声明保持原状:起服那次 = 拒启,换代那次 = 候选整拒(与 stage
+ *    抛同路)。能力词 `inherit_env.own_credentials_withheld` 在本进程的事实 =
+ *    {@link ownCredentialsWithheld}:最近一次成功声明的集合 ⊇ 当前生效配置应声明的集合(活配置经 {@link bindOwnCredentialsConfig} 在 `loadConfig()` 之后绑一次;
+ *    未绑 / 未声明 ⇒ false,事实读不到应声明集合就不答 true)。
+ *  · 调用方显式传入的 env(`cfg.env` / 单次命令的 `env` / 语言服务器与沙箱的点名放回)不是继承,照旧原样叠在组合结果之上 —— 那是适配器自己的凭据通道。
+ * 各腿只调 {@link hostSubprocessEnv} / {@link gitSubprocessEnv} —— 不许再有内联拼装、不许再有 `{ ...process.env }`、不许本仓再判任何一个继承词
+ * (类级门在 `test/secret-env-scrub-host-legs.test.ts`)。
  *
  * ## 点名放行(S-699 / S-713,一只谓词各处用)
- * {@link allowlistedEnv} 是本仓「一张名单点到哪些 env 键,就把它们从源 env **原样**交给子进程」的唯一实现。调用:
- * host shell 的 `inheritEnv:[names]`(`plugins/remote-env-host.ts`,hermetic 形)、{@link hostSubprocessEnv}(剥后放回形:本地语言服务器的
- * `LSP_ENV_ALLOW`、bake-runner 的 `BAKE_ENV_ALLOW`)、沙箱带外 env 的 `E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` / `K8S_SANDBOX_ENV`(`config.ts`,S-713 起)。
+ * {@link allowlistedEnv} 是本仓「一张名单点到哪些 env 键,就把它们从源 env **原样**交给子进程」的唯一实现。调用:{@link hostSubprocessEnv}(剥后放回形:
+ * 本地语言服务器的 `LSP_ENV_ALLOW`、bake-runner 的 `BAKE_ENV_ALLOW`)、沙箱带外 env 的 `E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` / `K8S_SANDBOX_ENV`(`config.ts`)。
+ * host shell 的 `inheritEnv:[names]`(hermetic 形)7.129.0 起由引擎读(与 core `NodeExecutionEnv` 同名选项同义,点到自有凭据名即拒),不经本谓词。
  * 名单型旋钮的**名单**另由 `config.ts` 的同一只解析器 `parseEnvNameAllowlist` 判形(形错拒启 / 源里没有的名按序号 warn),本函数只管取值。
  * 「点名」在各处同义:点到的键原样带值(空串值照带),密钥形也照过(点名 = 部署方显式承担);源里没有的名不产生条目。
- * 沙箱三腿不继承本进程环境:进沙箱的本进程值只有点到的键(与 host shell 的 hermetic 形同一侧)。
- * host shell 与「剥后放回」形**只在没点到的键上**不同,这是有意保留的差别:host shell 的 `string[]` 形是 hermetic 白名单(与 core
- * `NodeExecutionEnv` 同名选项同义,没点到的一律不继承);语言服务器 / bake-runner 在 {@link scrubServerSecrets} 的结果之上放回点名键
- * (没点到的照缺省剥,`PATH` / `HOME` 这类非密钥键照常在 —— hermetic 形会让子进程当场找不到自己的工具链)。
- * 两形都不放宽对方:把 host shell 改成「剥后放回」= 在模型可驱动的 shell 上放宽,把后者改成 hermetic = 功能当场失灵。
+ * ⚠️ 已知边界(不在本函数修):`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW` 点到自有凭据名会把它放回语言服务器 / 配方脚本(剥后放回形在引擎的减法之上);解析器今天只拒名单型旋钮名。
  */
-import { type SecretEnvFinding } from "@sema-agent/core";
+import { type InheritEnvPolicy, type SecretEnvFinding } from "@sema-agent/core";
+import type { ServiceConfig } from "./config-types.js";
 import { type SecretEnvScrubSite } from "./observability/secret-env-scrub.js";
-/** 目录派生臂的一条剥除记录(形同 core 的 `SecretEnvFinding`:键名 / 规则 / 置信度 / 来源;值永不携带)。
- *  `source` 用本仓自己的词 `server-config-catalog`,与 core 的 `secret-env` 分开 —— 读观测面的人要分得清
- *  「形状规则剥的」与「本仓目录点名剥的」(后者多出来的那部分正是 core 形状规则的缺口)。 */
-export interface CatalogSecretEnvFinding {
-    readonly key: string;
-    readonly kind: "config-catalog";
-    readonly confidence: "high";
-    readonly source: "server-config-catalog";
-}
-/** 名单型旋钮臂的一条剥除记录(形同上;`source` 用自己的词 —— 读观测面的人要分得清「目录点名剥的」与「名单型旋钮原文按凭据类剥的」)。 */
-export interface NameListKnobEnvFinding {
-    readonly key: string;
-    readonly kind: "name-list-knob";
-    readonly confidence: "high";
-    readonly source: "server-name-list-knob";
-}
-/** 本仓子进程腿的扣下记录:core 的形状臂 ∪ 本仓的目录臂 ∪ 名单型旋钮臂。 */
-export type ServerSecretEnvFinding = SecretEnvFinding | CatalogSecretEnvFinding | NameListKnobEnvFinding;
-/** 配置目录里 `type:"secret"` 的 env 名(大写 —— Windows 的 env 名不分大小写,按大写比才不会漏)。 */
+/** 配置目录里 `type:"secret"` 的 env 名(按目录原文 —— 引擎按平台比名:POSIX 逐字、Windows 不分大小写,本仓不再另折叠)。 */
 export declare const CATALOG_SECRET_ENV_NAMES: ReadonlySet<string>;
+/** 生效配置模型条目 name → `apiKeyEnv`(变量**名**,值从本进程 env 取)—— `ServiceConfig.modelApiKeyEnv` 的形,key-resolver 读凭据的那张表。 */
+export type ModelApiKeyEnvTable = Readonly<Record<string, string>>;
 /**
- * 先交 core 按形剥,再按目录名、名单型旋钮名剥它漏下的。`findings` 是调用方持有的收集器(交给 `recordSecretEnvScrub` 留痕):
- * 形状臂剥掉的记 core 的 finding;目录臂只记**形状臂漏下、被目录点名剥掉**的键 —— 于是既有的形状臂计数不变,
- * 目录臂的计数恰好就是 core 形状规则的缺口读数;名单型旋钮臂只记前两臂都漏下的(今天 = 不在服务目录里的 `BAKE_ENV_ALLOW`)。
- * 各腿不直接调它 —— 经 {@link hostSubprocessEnv}(剥 + 放回 + 留痕一只口)。
- *
- * **只为宿主子进程组合**。本包跑在别的平台上的子进程(ssh / k8s / adb / e2b / docker 车道)的 env 不经本函数:那些车道不继承本进程 env,只交
- * 调用方显式给的 env 与部署方点名的键(`E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` / `K8S_SANDBOX_ENV`,经 {@link allowlistedEnv})。(core 7.33.6 #1159 的平台尾参随
- * core 7.35.0 #1201 删除 —— git 的 env 配置族成了豁免族,不再有「按子进程平台读记录」这件事,S-877。)
+ * 本进程的自有凭据名(机器派生,三臂一处:目录 secret 名 ∪ 名单型旋钮名 ∪ `modelApiKeyEnv` 表的值;排序只为读数稳定)。纯函数:给哪张表就答哪张表的应声明
+ * 集合 —— 声明时给候选表、能力位给活表,同一只派生。名字按原文交引擎(目录臂同形),不在本仓折叠大小写。
+ */
+export declare function serverWithheldEnvNames(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
+/**
+ * 🔴 **唯一声明点**:把本进程自有凭据名向引擎声明(core `declareWithheldEnv`;重声明即替换,从下一次 spawn 起生效)。`modelApiKeyEnv` = 这一次要并进名单的模型条目表
+ * (起服第一步 = 空表;换代 = 候选表),名单 = 此前声明过的 ∪ 这张表的应声明集合 —— 名单只随**落地**的世代增长:落地过的名不再退出(改名 / 删条目之后它的值仍在
+ * 本进程 env 里),没落地的候选不留痕(旧世代在 CAS 处就拒、不到这里;换装拒 ⇒ {@link withdrawServerWithheldEnv})。引擎对坏形名 / 运行时回填名(`PATH` / `HOME` /
+ * `USER` …)响亮抛且声明保持原状 —— 本函数不接住:起服那次抛 = 拒启;换代那次抛 = 候选整拒(`applyEffective` 抛,与 stage 抛同路)。返回声明的名单(只名、不值)。
+ */
+export declare function declareServerWithheldEnv(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
+/**
+ * 席位拒 ⇒ 撤回最近一次声明(回到它之前的集合):`applyEffective` 在 Runner 换装抛时调,紧跟着那一次 {@link declareServerWithheldEnv} —— 没落地的候选不留痕。
+ * 退回去的集合是引擎之前接受过的(判名确定)⇒ 不抛;连撤两次是同一个结果(幂等)。
  */
-export declare function scrubServerSecrets(env: NodeJS.ProcessEnv, findings: ServerSecretEnvFinding[]): NodeJS.ProcessEnv;
+export declare function withdrawServerWithheldEnv(): void;
+/** 把活配置交给能力位读(stage-01 / run-local 在 `loadConfig()` 之后各一次;读的是 `config.modelApiKeyEnv` 这个**属性**,commit 整表重赋值之后看到的就是新表)。 */
+export declare function bindOwnCredentialsConfig(config: Pick<ServiceConfig, "modelApiKeyEnv">): void;
+/**
+ * 能力词 `inherit_env.own_credentials_withheld` 在本进程的事实:最近一次成功声明的集合 ⊇ 当前生效配置应声明的集合。是一次比较,不是「声明过」的旗 ——
+ * 活表若被谁绕过声明写了新名,这里立刻 false(位不替流程担保)。没绑活配置 / 没声明过 ⇒ false(fail-closed)。
+ */
+export declare function ownCredentialsWithheld(): boolean;
+/** 测试缝:撤回声明(引擎侧重声明为空)、忘掉声明集合(含撤回格)与活配置;生产代码从不调它。 */
+export declare function __resetServerWithheldEnvForTest(): void;
+/** 一条宿主腿要什么:现场(留痕)、继承策略(缺省 `"scrub"`;只有模型可驱动的 host shell 交非缺省词)、部署方点名放回的键。 */
+export interface HostSubprocessEnvRequest {
+    readonly site: SecretEnvScrubSite;
+    readonly policy?: InheritEnvPolicy | undefined;
+    readonly allow: readonly string[];
+}
 /**
- * 🔴 **宿主子进程 env 的唯一组合**(S-684 残余按类收口,7.103.0):{@link scrubServerSecrets}(env) ∪ `allow` 点到的键
- * (经 {@link allowlistedEnv} 从同一份源 env 原样放回),**没有按原样交给子进程**的键(剥掉 / 换成 core 占位半条)经 `site` 留痕(点名放回的键取回源值,
- * 不是剥除,不计数、不披露)。源 env 只在入参 `sourceEnv` 绑定一次(缺省 `process.env`):剥除源、放回源、谓词回读三处读的是同一份映射。`sourceEnv` 是测试缝 ——
- * `src/` 里的调用一律缺省(只带一个实参;钉:`test/secret-env-scrub-host-legs.test.ts` 类级门「opus 验修 L-1」格),平台尾参取缺省的推理只在源 = 本进程 env 时成立。
- * (入参不叫 `env`:D1 对账门按标识符名在全文件收 `= process.env` 缺省参数的别名,叫 `env` 会把 {@link allowlistedEnv} 的同名形参一并认成别名、多记一处动态读。)
+ * 🔴 **宿主子进程 env 的唯一组合**:{@link composeHostSubprocessEnv} + 留痕。**没有按原样交给子进程**的名字(剥掉的)经 `site` 留痕;点名放回的键取回源值,
+ * 不是剥除,不计数、不披露。源 env 恒为本进程 env(引擎只读 `process.env`,本仓没有第二个源)。
  *
- * 六条宿主腿都只经它(直接或经 {@link gitSubprocessEnv}):host shell 缺省 scrub 腿、project-memory / center-plugins / leader 三条 git 腿、
+ * 六条宿主腿都只经它(直接或经 {@link gitSubprocessEnv}):host shell(三个继承词原样交给 `policy`)、project-memory / center-plugins / leader 三条 git 腿、
  * 本地语言服务器、bake-runner 的每一只子进程组。`allow` 只在**有部署级出路**的现场非空(今天 = `LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`,
  * 它们的现场在 `SECRET_ENV_SCRUB_SITES` 里登记了 `remedy`,披露行因此是 warn + 放行名单 + 出路句);其余现场传 `[]`。
  * 返回 `NodeJS.ProcessEnv` 形(值可能是 `undefined` 的键本来就不会进子进程);调用方显式要交的键(`LC_ALL`、`cfg.env` …)叠在它之上。
  * 调用时机 = 每次要交 env 时现算一次(`process.env` 在本仓是 boot 期输入,各次同值;计数因此是「每组合一次」)。
+ * 引擎对坏策略 / 点到自有凭据名的白名单在这里**抛**(spawn 时的拒是不变量;构造时的拒由各构造点自己先问 `inheritEnvPolicyProblem`)。
  *
- * 🔴 **git 的 env 配置族与代理变量一族只有 core 一只写手**:core 7.35.0 #1201(S-877,CC 2.1.280 形)起它们是 core 的**豁免族** ——
- * `GIT_CONFIG_COUNT` / `GIT_CONFIG_PARAMETERS` / `GIT_CONFIG_KEY_<数字>` / `GIT_CONFIG_VALUE_<数字>`(大写)与 `http(s)_proxy` / `all_proxy` / `no_proxy` /
- * `npm_config_*proxy` …(任意大小写),名与值都不读、**原样交出,凭据在内**(7.33.2–7.33.8 的逐条扣 / 原位占位 `sema.withheld` / 整只扣全部退役;
- * 部署面:凭据不放本进程 env —— `docs/DEPLOY-PREREQS.md`)。本层 7.103.0 的「整组扣」与 7.103.1 中间态的「按 pair 扣留 + 重编号」(D-7)更早退役,
- * 本层不重判(同一语义面上不留第二只写手;在下游把 core 的豁免改回扣 = 源头修复宪法禁止的改写)。本仓按名两臂(目录 secret 名 / 名单型旋钮)不含
- * `GIT_CONFIG_` 这一族的名字(钉:`test/secret-env-git-config-pair.test.ts`「一只写手」格)。
- * 🔴 **披露谓词 = 「这个名字没有按原样交给子进程」**(输入值 vs 输出值)。core 对一个变量的动作恒为「整只删」(从不改写值,#1201),点名放回的名字
- * 取回源值 ⇒ 与输入同值 ⇒ 不是剥除。一只谓词盖住「剥掉」「点名放回」两形,不按形分臂(7.33.6–7.33.8 还有第三形「换占位」,随 #1201 消失)。
+ * 🔴 **git 的 env 配置族与代理变量一族只有 core 一只写手**:core 7.35.0 #1201(S-877)起它们是 core 的**豁免族** —— `GIT_CONFIG_COUNT` / `GIT_CONFIG_PARAMETERS` /
+ * `GIT_CONFIG_KEY_<数字>` / `GIT_CONFIG_VALUE_<数字>`(大写)与 `http(s)_proxy` / `all_proxy` / `no_proxy` / `npm_config_*proxy` …(任意大小写),名与值都不读、
+ * **原样交出,凭据在内**(部署面:凭据不放本进程 env —— `docs/DEPLOY-PREREQS.md`)。本仓不重判;本进程自有凭据名单不含这两族的名字
+ * (钉:`test/secret-env-git-config-pair.test.ts`「一只写手」格)。
+ * 🔴 **披露谓词 = 「这个名字没有按原样交给子进程」**(输入值 vs 输出值)。引擎对一个变量的动作恒为「整只删」(从不改写值),点名放回的名字取回源值 ⇒ 与输入同值 ⇒ 不是剥除。
  */
-export declare function hostSubprocessEnv(o: {
-    site: SecretEnvScrubSite;
-    allow: readonly string[];
-}, sourceEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function hostSubprocessEnv(o: HostSubprocessEnvRequest): NodeJS.ProcessEnv;
 /**
  * {@link hostSubprocessEnv} 的**组合本体**(不披露、不计数)—— 同一只组合,两个入口:真要交给子进程的现场经 `hostSubprocessEnv`(组合 + 披露);
  * 只想知道「子进程**会**拿到什么」的读者(core 7.49.0 #1554:host 车道的 `ExecutionEnv.cdPath` 要报子进程真拿到的 `CDPATH`)读这一只 ——
- * 既不另写一份组合(第二份会漂),也不把一次没发生的 spawn 记进剥除计数。
+ * 既不另写一份组合(第二份会漂),也不把一次没发生的 spawn 记进剥除计数。`findings` 是组合点自己的收集器(引擎把形状臂与自有凭据臂的每一条扣下都推进去)。
  */
-export declare function composeHostSubprocessEnv(allow: readonly string[], sourceEnv?: NodeJS.ProcessEnv, findings?: ServerSecretEnvFinding[]): NodeJS.ProcessEnv;
+export declare function composeHostSubprocessEnv(o: Omit<HostSubprocessEnvRequest, "site">, findings?: SecretEnvFinding[]): NodeJS.ProcessEnv;
 /** git 子进程腿的现场(闭集里名字带 `.git-` 的那几只 —— 编译期筛;它们都没有点名放行面)。 */
 export type GitSubprocessSite = Extract<SecretEnvScrubSite, `${string}.git-${string}`>;
 /**
- * 宿主 **git 子进程**的 env:{@link hostSubprocessEnv}(site, 不放回) + `GIT_TERMINAL_PROMPT=0`(恒:凭据缺席 ⇒ 响亮失败,绝不挂在交互
+ * 宿主 **git 子进程**的 env:{@link hostSubprocessEnv}(site, 缺省 scrub, 不放回) + `GIT_TERMINAL_PROMPT=0`(恒:凭据缺席 ⇒ 响亮失败,绝不挂在交互
  * prompt 上 —— 服务进程没有终端)+(`isolateConfig` ⇒ `GIT_CONFIG_GLOBAL` / `GIT_CONFIG_SYSTEM` = `/dev/null`:宿主全局 / 系统 git 配置
  * (insteadOf / credential helper / hooksPath / fsmonitor …)一概不继承)。
  *