@sema-agent/server 7.131.0 → 7.133.0

package/dist/project-identity.d.ts

@@ -1,4 +1,5 @@
-import type { MemoryProjectKey, MemoryProjectKeyAbsentReason } from "@sema-agent/core";
+import { type MemoryProjectKey, type MemoryProjectKeyAbsentReason } from "@sema-agent/core";
+import { type ProjectLayerIdentity } from "./project-layer-key.js";
 /** core 的项目身份声明席(`TaskSpec.memory.projectKey`)—— core 包根导出的型,原样转出(本仓调用方从这里取)。 */
 export type { MemoryProjectKey };
 /** 本仓会说的缺席词。`not_git` 刻意排除:裁 D 起非 git 目录按目录键控,不是缺席(core 闭集仍收它,本仓不铸)。 */
@@ -16,12 +17,50 @@ export type ProjectIdentity = {
  * 一次向上走,规则三条按优先序:最近的 `.git`(① ② ③)> 链上最近的裸仓布局(④ bare)> 非 git 按目录键控(④)。
  */
 export declare function resolveProjectIdentity(taskRoot: string): ProjectIdentity;
-/** 本仓**唯一**的 `repo:` 键铸点([ref] ①:`repo:` + sha256 hex 前 24;`root` 为 realpath 字符串,不加尾斜杠、不折大小写)。 */
+/**
+ * 退役 `repo:` 键的**唯一**铸点([ref] ①:`repo:` + sha256 hex 前 24;`root` 为 realpath 字符串,不加尾斜杠、不折大小写)。
+ * S-640 起它只是一次性迁移的来源(`memory-project-layer.ts` 把这一层的条目折进新键;窗见 `plugins/one-time-migrations.ts` 登记表)。
+ */
 export declare function mintRepoScopeKey(projectRoot: string): string;
+/** 这把键是不是本仓铸的项目键族(现行 `userrepo:` 或退役的 `repo:`)—— 运维不许把它们点名成全局层 / 同步层。 */
+export declare function isServerMintedProjectKey(key: string): boolean;
+/**
+ * 起服判据:这个全局层(或同步层)能不能拥有项目层 —— 不是本仓铸的族,且属主段编码得出来(core 段编码 ≤ 64)。不能 ⇒ 抛一句点名出路的配置错。
+ * 调用方:`config.ts` 记忆域(单用户 + 记忆引擎开着时问 `MEMORY_SCOPE`;开同步时问同步层)。
+ */
+export declare function assertProjectLayerOwnable(scope: string, envName: string): void;
+/**
+ * 远端 URL 归一(`r` 档的输入)—— 同一个仓的不同写法收成同一串,两个仓**不许**并成一串,凭据不进串:
+ *  · scp 形 `[user@]host:path`(主机至少两个字符 —— 单字母是 Windows 盘符)与 scheme 形 `scheme://[userinfo@]host[:port]/path` ⇒ `host[:port]/path`
+ *    (去 userinfo;主机小写;端口是该 scheme 的缺省值才去掉;路径大小写保留:不同托管对大小写的读法不同,折了会把两个仓合成一个);
+ *  · 本地路径远端(`file://`、绝对 / 相对路径)⇒ `undefined`:它不是跨设备身份(相对路径还取决于 checkout 在哪),调用方落本 checkout 的 `p` 档;
+ *  · 路径去首尾 `/`、去尾 `.git`、连续 `/` 收成一个;主机为空 ⇒ `undefined`。
+ */
+export declare function normalizeGitRemoteUrl(url: string): string | undefined;
+/**
+ * 任务根 → 项目层身份(S-640):当前档(`r` 优先,没有 origin 退 `p`)+ 本 checkout 的低档(`r` 档时 = 它的 `p` 档)。
+ * 缺席形与 {@link resolveProjectIdentity} 同;git 配置在而读不了 ⇒ `unreadable`。
+ */
+export declare function projectLayerIdentityOf(taskRoot: string): {
+    readonly root: string;
+    readonly identity: ProjectLayerIdentity;
+    readonly lowerTiers: readonly ProjectLayerIdentity[];
+} | {
+    readonly absent: ProjectIdentityAbsentReason;
+};
+/** 一个任务的项目层:core 声明席 + 本 checkout 要折进来的低档 / 退役层(按序,`memory-project-layer.ts` 折)。 */
+export interface ProjectLayerOfTask {
+    readonly key: MemoryProjectKey;
+    readonly foldFrom: readonly string[];
+}
 /**
- * 任务根 → core 声明席 `TaskSpec.memory.projectKey`。
- * `taskRoot === undefined` = 调用方**此刻不知道**任务根在本机哪里(根在沙箱/设备盘上;或 host 车道会话没登记 cwd、
- * 手落在 factory 现铸的临时目录)⇒ `unreadable` —— 「我看不到」,不是「这里没有项目」。
+ * 任务根 → 项目层(S-640:`userrepo:<属主段>/<档>.<摘要>`,属主 = `owner`,调用方由 `projectLayerOwnerOf(全局层)` 求得)。
+ * `foldFrom` = 同一 checkout 能推出的旧层:退役 `repo:<同一路径哈希>`(一次性迁移,窗见 `plugins/one-time-migrations.ts` 登记表 M25)
+ * + 当前档是 `r` 时它的 `p` 档(常设律)。
+ * `taskRoot === undefined` = 调用方**此刻不知道**任务根在本机哪里(根在沙箱/设备盘上;或 host 车道会话没登记 cwd、手落在 factory 现铸的
+ * 临时目录)⇒ `unreadable` —— 「我看不到」,不是「这里没有项目」。
  */
-export declare function projectKeyForTaskRoot(taskRoot: string | undefined): MemoryProjectKey;
+export declare function projectLayerForTaskRoot(taskRoot: string | undefined, owner: string): ProjectLayerOfTask;
+/** {@link projectLayerForTaskRoot} 的声明席投影(core `TaskSpec.memory.projectKey`)。 */
+export declare function projectKeyForTaskRoot(taskRoot: string | undefined, owner: string): MemoryProjectKey;
 //# sourceMappingURL=project-identity.d.ts.map

package/dist/project-identity.js

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
+import { encodeScopeSegment } from "@sema-agent/core";
+import { mintProjectLayerKey, PROJECT_LAYER_KEY_PREFIX, projectLayerOwnerOf } from "./project-layer-key.js";
 const UNREADABLE = { absent: "unreadable" };
 const BARE = { absent: "bare" };
 function isMissing(err) {
@@ -53,7 +55,7 @@ function identityOfGitFile(dir) {
     const gitDir = gitDirFact.ok;
     const commonText = readTextFact(join(gitDir, "commondir"));
     if (commonText === "missing")
-        return { root: dir };
+        return { root: dir, gitConfig: join(gitDir, "config") };
     if (commonText === "unreadable")
         return UNREADABLE;
     const commonFact = realpathFact(resolve(gitDir, commonText.ok));
@@ -68,7 +70,7 @@ function identityOfGitFile(dir) {
     const backFact = realpathFact(resolve(gitDir, back.ok));
     if (typeof backFact !== "object" || backFact.ok !== join(dir, ".git"))
         return UNREADABLE;
-    return { root: basename(common) !== ".git" ? common : dirname(common) };
+    return { root: basename(common) !== ".git" ? common : dirname(common), gitConfig: join(common, "config") };
 }
 function canonicalTaskRoot(taskRoot) {
     const rest = [];
@@ -86,6 +88,10 @@ function canonicalTaskRoot(taskRoot) {
     }
 }
 export function resolveProjectIdentity(taskRoot) {
+    const located = locateProject(taskRoot);
+    return "root" in located ? { root: located.root } : located;
+}
+function locateProject(taskRoot) {
     const root = canonicalTaskRoot(taskRoot);
     if (root === "unreadable")
         return UNREADABLE;
@@ -96,7 +102,7 @@ export function resolveProjectIdentity(taskRoot) {
             return UNREADABLE;
         if (typeof dotGit === "object") {
             if (dotGit.ok === "dir")
-                return { root: dir };
+                return { root: dir, gitConfig: join(dir, ".git", "config") };
             if (dotGit.ok === "file")
                 return identityOfGitFile(dir);
         }
@@ -108,13 +114,161 @@ export function resolveProjectIdentity(taskRoot) {
         dir = parent;
     }
 }
+function digest24(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 24);
+}
+const RETIRED_PROJECT_KEY_PREFIX = "repo:";
 export function mintRepoScopeKey(projectRoot) {
-    return `repo:${createHash("sha256").update(projectRoot, "utf8").digest("hex").slice(0, 24)}`;
+    return `${RETIRED_PROJECT_KEY_PREFIX}${digest24(projectRoot)}`;
+}
+export function isServerMintedProjectKey(key) {
+    return key.startsWith(PROJECT_LAYER_KEY_PREFIX) || key.startsWith(RETIRED_PROJECT_KEY_PREFIX);
+}
+export function assertProjectLayerOwnable(scope, envName) {
+    if (isServerMintedProjectKey(scope)) {
+        throw new Error(`${envName}=${JSON.stringify(scope)} names a server-minted project-layer key (the "${PROJECT_LAYER_KEY_PREFIX}" family, or the retired "${RETIRED_PROJECT_KEY_PREFIX}" family) — ` +
+            "project layers are derived per task from the project identity and cannot be named as a deployment scope. Use a user key (user:<principal>) or a plain name.");
+    }
+    const owner = ownerSegmentFact(scope);
+    if (!owner.ok) {
+        throw new Error(`${envName}=${JSON.stringify(scope)} cannot own per-project memory layers: ${owner.why} — ` +
+            "the layer owner (the principal of a user: key, otherwise the name itself) must encode to at most 64 scope-segment characters.");
+    }
+}
+function ownerSegmentFact(scope) {
+    try {
+        encodeScopeSegment(projectLayerOwnerOf(scope));
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, why: err instanceof Error ? err.message : String(err) };
+    }
+}
+const GIT_CONFIG_MAX_BYTES = 256 * 1024;
+function readOriginRemoteUrl(configPath) {
+    const st = statFact(configPath);
+    if (st === "missing")
+        return "missing";
+    if (st === "unreadable" || st.ok !== "file")
+        return "unreadable";
+    let size;
+    try {
+        size = statSync(configPath).size;
+    }
+    catch (err) {
+        return isMissing(err) ? "missing" : "unreadable";
+    }
+    if (size > GIT_CONFIG_MAX_BYTES)
+        return "unreadable";
+    const text = readTextFact(configPath);
+    if (typeof text !== "object")
+        return text;
+    let inOrigin = false;
+    for (const raw of gitConfigLogicalLines(text.ok)) {
+        const line = raw.trim();
+        if (line.startsWith("[")) {
+            const header = /^\[\s*([A-Za-z0-9.-]+)(?:\s+"((?:[^"\\]|\\.)*)")?\s*\]/.exec(line);
+            inOrigin = header !== null && header[1].toLowerCase() === "remote" && header[2] !== undefined && header[2].replace(/\\(.)/g, "$1") === "origin";
+            continue;
+        }
+        if (!inOrigin)
+            continue;
+        const kv = /^([A-Za-z][A-Za-z0-9-]*)\s*=\s*(.*)$/.exec(line);
+        if (kv === null || kv[1].toLowerCase() !== "url")
+            continue;
+        const value = gitConfigValue(kv[2]);
+        if (value !== "")
+            return { ok: value };
+    }
+    return { ok: undefined };
+}
+function gitConfigLogicalLines(text) {
+    const out = [];
+    let pending = "";
+    for (const physical of text.split(/\r?\n/)) {
+        const trailing = /\\*$/.exec(physical)[0].length;
+        if (trailing % 2 === 1) {
+            pending += physical.slice(0, -1);
+            continue;
+        }
+        out.push(pending + physical);
+        pending = "";
+    }
+    if (pending !== "")
+        out.push(pending);
+    return out;
+}
+function gitConfigValue(raw) {
+    let out = "";
+    let quoted = false;
+    for (let i = 0; i < raw.length; i++) {
+        const c = raw[i];
+        if (c === "\\" && i + 1 < raw.length) {
+            out += raw[++i];
+            continue;
+        }
+        if (c === '"') {
+            quoted = !quoted;
+            continue;
+        }
+        if (!quoted && (c === "#" || c === ";"))
+            break;
+        out += c;
+    }
+    return out.trim();
+}
+const DEFAULT_REMOTE_PORTS = { ssh: "22", "git+ssh": "22", "ssh+git": "22", https: "443", http: "80", git: "9418" };
+export function normalizeGitRemoteUrl(url) {
+    const u = url.trim();
+    const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(.*)$/.exec(u);
+    if (scheme !== null) {
+        const name = scheme[1].toLowerCase();
+        if (name === "file")
+            return undefined;
+        const rest = scheme[2];
+        const slash = rest.indexOf("/");
+        const authority = slash < 0 ? rest : rest.slice(0, slash);
+        const hostPort = authority.slice(authority.lastIndexOf("@") + 1);
+        const port = /:(\d*)$/.exec(hostPort);
+        const host = (port === null ? hostPort : hostPort.slice(0, port.index)).toLowerCase();
+        if (host === "")
+            return undefined;
+        const keptPort = port !== null && port[1] !== "" && port[1] !== DEFAULT_REMOTE_PORTS[name] ? `:${port[1]}` : "";
+        return `${host}${keptPort}/${cleanRemotePath(slash < 0 ? "" : rest.slice(slash))}`;
+    }
+    const scp = /^(?:[^@/]+@)?([^:/]{2,}):(.*)$/.exec(u);
+    if (scp !== null)
+        return `${scp[1].toLowerCase()}/${cleanRemotePath(scp[2])}`;
+    return undefined;
 }
-export function projectKeyForTaskRoot(taskRoot) {
+function cleanRemotePath(p) {
+    return p.replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+}
+export function projectLayerIdentityOf(taskRoot) {
+    const located = locateProject(taskRoot);
+    if (!("root" in located))
+        return located;
+    const path = { tier: "p", digest: digest24(located.root) };
+    const origin = located.gitConfig !== undefined ? readOriginRemoteUrl(located.gitConfig) : "missing";
+    if (origin === "unreadable")
+        return UNREADABLE;
+    const remote = origin === "missing" || origin.ok === undefined ? undefined : normalizeGitRemoteUrl(origin.ok);
+    if (remote === undefined)
+        return { root: located.root, identity: path, lowerTiers: [] };
+    return { root: located.root, identity: { tier: "r", digest: digest24(remote) }, lowerTiers: [path] };
+}
+export function projectLayerForTaskRoot(taskRoot, owner) {
     if (taskRoot === undefined)
-        return { absent: "unreadable" };
-    const id = resolveProjectIdentity(taskRoot);
-    return "root" in id ? { scope: mintRepoScopeKey(id.root) } : { absent: id.absent };
+        return { key: UNREADABLE, foldFrom: [] };
+    const id = projectLayerIdentityOf(taskRoot);
+    if (!("identity" in id))
+        return { key: { absent: id.absent }, foldFrom: [] };
+    return {
+        key: { scope: mintProjectLayerKey(owner, id.identity) },
+        foldFrom: [mintRepoScopeKey(id.root), ...id.lowerTiers.map((tier) => mintProjectLayerKey(owner, tier))],
+    };
+}
+export function projectKeyForTaskRoot(taskRoot, owner) {
+    return projectLayerForTaskRoot(taskRoot, owner).key;
 }
 //# sourceMappingURL=project-identity.js.map

package/dist/project-layer-key.d.ts

@@ -0,0 +1,28 @@
+/** 项目层键的前缀(改名链的前缀词表也读它)。 */
+export declare const PROJECT_LAYER_KEY_PREFIX = "userrepo:";
+/** 身份档:`r` = 仓库身份(origin 远端,跨设备),`p` = 项目根路径(本机)。 */
+export type ProjectIdentityTier = "r" | "p";
+/** 一个项目的身份段(档 + 24 位小写十六进制摘要)。 */
+export interface ProjectLayerIdentity {
+    readonly tier: ProjectIdentityTier;
+    readonly digest: string;
+}
+/** 解出的项目层键。 */
+export interface ParsedProjectLayerKey {
+    /** 解码后的属主(主体名,或不透明全局层名本身)。 */
+    readonly owner: string;
+    readonly identity: ProjectLayerIdentity;
+}
+/**
+ * 全局层 → 它的属主(见文件头文法)。`user:` 形用 core 的解析(段解码、规范形校验);坏的 `user:` 形照 core 原样抛
+ * (`config.memory_scope_key`)—— 起服经 `project-identity.ts` `assertProjectLayerOwnable` 在第一刻接住,不留到任务期。
+ */
+export declare function projectLayerOwnerOf(globalScope: string): string;
+/** 铸项目层键。属主编码超长 / 空 ⇒ core 段编码原样抛(起服已由 `assertProjectLayerOwnable` 拦住)。 */
+export declare function mintProjectLayerKey(owner: string, identity: ProjectLayerIdentity): string;
+/**
+ * 解项目层键。**严格**:前缀 + 恰好一个 `/` + 规范形属主段(`%41` 这类第二种拼法不认 —— 一个属主不许有两把键)+ 档文法。
+ * 不合任何一条 ⇒ `undefined`(调用方读作「不是项目层」;属主门据此答与其余拒绝同体的 404)。
+ */
+export declare function parseProjectLayerKey(key: string): ParsedProjectLayerKey | undefined;
+//# sourceMappingURL=project-layer-key.d.ts.map

package/dist/project-layer-key.js

@@ -0,0 +1,29 @@
+import { decodeScopeSegment, encodeScopeSegment, parseScopeKey } from "@sema-agent/core";
+export const PROJECT_LAYER_KEY_PREFIX = "userrepo:";
+const DIGEST = /^[0-9a-f]{24}$/;
+const KEY = /^userrepo:((?:[A-Za-z0-9._-]|%[0-9A-F]{2})+)\/([rp])\.([0-9a-f]{24})$/;
+export function projectLayerOwnerOf(globalScope) {
+    const parsed = parseScopeKey(globalScope);
+    return parsed.kind === "user" ? parsed.principal : globalScope;
+}
+export function mintProjectLayerKey(owner, identity) {
+    if (!DIGEST.test(identity.digest))
+        throw new Error(`project layer identity digest must be 24 lowercase hex characters, got ${JSON.stringify(identity.digest)}`);
+    return `${PROJECT_LAYER_KEY_PREFIX}${encodeScopeSegment(owner)}/${identity.tier}.${identity.digest}`;
+}
+export function parseProjectLayerKey(key) {
+    const m = KEY.exec(key);
+    if (m === null)
+        return undefined;
+    const owner = decodeOwnerSegment(m[1]);
+    return owner.ok ? { owner: owner.owner, identity: { tier: m[2], digest: m[3] } } : undefined;
+}
+function decodeOwnerSegment(segment) {
+    try {
+        return { ok: true, owner: decodeScopeSegment(segment) };
+    }
+    catch (err) {
+        return { ok: false, why: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=project-layer-key.js.map

package/dist/prompts-domain-validate.d.ts

@@ -1,66 +1,22 @@
-import { type PromptTextDeclaration, type PublishedPromptArtifactEnvelope } from "@sema-agent/core";
-/** [ref]⓪ 下发形(remote effective 的 additive key,JSON verbatim 面——不经 registry-core parse,所以
- *  cli 补位前 center 发的 `contentHash` 也原样到达)。 */
-export interface EffectiveCenterPrompts {
-    /** `center:<contentDigest 前 12>` — 纯内容寻址(同内容重发布=同 packId,epoch 不误重 pin)。 */
-    packId: string;
-    /** canonical JSON 全量 sha256(非盐化,operator 对账位 [ref]②)。 */
-    contentDigest: string;
-    /** covering 已在 center 走完的基线终形(层信息不下发,worker 零解析义务)。 */
-    sections: PromptTextDeclaration[];
-    /** per-scenario 完整重算终形(整包替换基线,非增量);无键=用基线。 */
-    scenarioOverrides?: Record<string, PromptTextDeclaration[]>;
-}
 /**
- * 结构判形(防炸底线,非语义复检)。`ok:false` 时调用方拒绝采用该候选的 prompts 面并 warn——绝不让
- * 一个坏 pack 把每个任务的 prepare 炸掉。校验与 core assemble 的 THROW 条件同形(id 规范/长度/core/
- * 保留、slot 闭集)+ 下发信封两键形;`contentHash` 只查形(值的校验归 core 1.315,错值 core 丢弃+warn)。
+ * prompts 域候选门 —— 中心提示层的**唯一判官**(中立叶子:只依赖 `@sema-agent/core` 与契约包 `@sema-agent/settings-schema`,
+ * 不依赖 capabilities / config 任何东西;候选判官 `web-admin-client/candidate-gate.ts` 是它唯一的调用点,LKG 读回经同一只候选判官)。
+ *
+ * 律:中心层只有一种 wire 形 —— `{ schemaVersion: 2, artifact }`(契约包 `EffectivePromptsWire`;artifact 是引擎当期 schema 的发布形)。
+ * 判法两步一线:先过契约包的 wire 形(外壳、键闭集、结构与上界;旧两轴 / v2 artifact 的拒句是契约包的原句),再交引擎
+ * `verifyPromptArtifact`(语义:每条 overlay 在中心类的档权内、锁定文本、requires 复算、同目标冲突、digest —— 拒句是引擎的原句)。
+ * 本模块不写任何形判、不铸任何句子、不归一任何别的形:中心不带 prompts 键 = 不下发中心层(调用方据此撤下);带了就必须是这一种形,
+ * 否则整份候选拒(一个域都不应用)。
  */
-export declare function validateCenterPrompts(raw: unknown): {
-    ok: true;
-    value: EffectiveCenterPrompts;
+import { type PublishedPromptArtifact } from "@sema-agent/core";
+/** 判官的结论:收下 ⇒ 引擎 verify 过的发布形 artifact(调用方交给引擎的中心源采用);拒 ⇒ 拒因(契约包 / 引擎的原句)。 */
+export type PromptsWireVerdict = {
+    readonly ok: true;
+    readonly artifact: PublishedPromptArtifact;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 };
-/** core 引擎版本(verifyPromptArtifact 的 compatibleCore range 输入)——经 exports map 解析包根读
- *  package.json(`require('@sema-agent/core/package.json')` 被 exports 封死,ERR_PACKAGE_PATH_NOT_EXPORTED
- *  第一手教训)。解析失败回 "0.0.0" = range-gated artifact 被诚实拒(fail-closed 响,绝不静默采用)。 */
-export declare const CORE_ENGINE_VERSION: string;
-/** validatePromptsDomain 的归一产物:两轴的已判形面 + 变更检测身份(adopt 去重键,跨轴稳定)。 */
-export interface PromptsDomainFaces {
-    /** A 形(declaration 轴)——centerPromptProvider 继续消费(现行链路零改动)。 */
-    declarations?: EffectiveCenterPrompts;
-    /** B 形(catalog 轴)——core S1 verify 已过(digest 复算/上限/range 全管线);server 不解释内容,
-     *  原样交 core artifact 仓(e/b 班车接线位)。 */
-    catalog?: PublishedPromptArtifactEnvelope;
-    /** 采用去重键:两轴 digest 拼接(轴缺席记 "-")。 */
-    identity: string;
-    /** 观测面([ref]a §3:`center_prompts_adopted` 增 axes,看两轴共存窗)。 */
-    axes: Array<"declarations" | "catalog">;
-}
-/**
- * prompts 域候选门 v2(validateCenterPrompts 的双轴升级;整拒语义不变=任一在场轴坏形 ⇒ 整个 prompts
- * 面拒绝采用,LKG/内置继续服务)。唯一认可形=`{schemaVersion:1, declarations?, catalog?}`
- * (registry-core `EffectivePromptsWire`)至少一轴。[ref]B-9(5.0.0):legacy 平铺兼容窗到期删——
- * 0.13.0 起 EffectivePromptsWire 首字段是 `schemaVersion: z.ZodLiteral<1>`,与 server 共用 ^0.13.0 的
- * 合规 center 不可能再发平铺;非合规体=响亮拒绝(整拒落 LKG/内置),不再静默吸收。
- * catalog 轴的语义权威=core `verifyPromptArtifact`(形/digest 逐位复算/ARTIFACT_LIMITS/compatibleCore
- * range 全在 core 一处——[ref]③ a 解,上限单真源永不漂)。
- */
-export declare function validatePromptsDomain(raw: unknown): {
-    ok: true;
-    value: PromptsDomainFaces;
-} | {
-    ok: false;
-    error: string;
-};
-/** [ref](docs/R100-PROMPTS-LANE-FIX.md §V2-B)worker 腿 effective 上 `prompts` 键的**形-肯定**判别:
- *  消费形特征(v2 `schemaVersion` 键,或 legacy 三键 packId/contentDigest/sections)⇒ 原样返回交
- *  {@link validatePromptsDomain}(收或拒,方向不变);其余=center 存储原文(global lane [ref]①e 下发
- *  存储形是合法输入)——catalog 在场则投影 `{schemaVersion:1, catalog}`(config-provider 本地腿先例),
- *  否则视为「center 未发」⇒ undefined。null=有意 cleared 语义([ref] 前 null 走拒,方向为宽是设计变更,
- *  留痕于设计档)。垃圾标量原样返回(fail-loud 归 validate)。
- *  属主放本中立叶:config-lkg 与 boot/refresh 同吃,capabilities 层会重开 S6 刚消的反向依赖边。 */
-export declare function centerPromptsFromEffective(eff: unknown): unknown | undefined;
+/** 一份候选 `prompts` 键的值(在场才调)→ 判官结论。 */
+export declare function judgePromptsWire(raw: unknown): PromptsWireVerdict;
 //# sourceMappingURL=prompts-domain-validate.d.ts.map

package/dist/prompts-domain-validate.js

@@ -1,122 +1,12 @@
-import { createHash } from "node:crypto";
-import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
 import { verifyPromptArtifact } from "@sema-agent/core";
-import { PROMPT_SLOTS } from "@sema-agent/settings-schema";
-import { SHA256_DIGEST_RE } from "./digest-form.js";
-const ID_RE = /^[a-z0-9][a-z0-9/._-]*$/;
-const SLOTS = PROMPT_SLOTS;
-function declarationIssue(d, where) {
-    if (d === null || typeof d !== "object")
-        return `${where}: declaration is not an object`;
-    const o = d;
-    if (typeof o.id !== "string" || o.id.length === 0 || o.id.length > 128 || !ID_RE.test(o.id))
-        return `${where}: bad id`;
-    if (o.id.startsWith("core/"))
-        return `${where}: id in the reserved core/ namespace`;
-    if (typeof o.slot !== "string" || !SLOTS.includes(o.slot))
-        return `${where}: bad slot`;
-    if (typeof o.text !== "string" || o.text.length === 0)
-        return `${where}: text must be a non-empty string`;
-    if (typeof o.contentHash !== "string" || !SHA256_DIGEST_RE.test(o.contentHash))
-        return `${where}: contentHash is required (sha256:<64hex> — the epoch declaration axis needs it for byte-level change detection)`;
-    const expected = `sha256:${createHash("sha256").update(o.text).digest("hex")}`;
-    if (o.contentHash !== expected)
-        return `${where}: contentHash does not match sha256(text) — stale or altered declaration`;
-    return undefined;
-}
-export function validateCenterPrompts(raw) {
-    if (raw === null || typeof raw !== "object")
-        return { ok: false, error: "prompts is not an object" };
-    const p = raw;
-    if (typeof p.packId !== "string" || !/^center:[0-9a-f]{12}$/.test(p.packId))
-        return { ok: false, error: "bad packId form (center:<digest12>)" };
-    if (typeof p.contentDigest !== "string" || !SHA256_DIGEST_RE.test(p.contentDigest))
-        return { ok: false, error: "bad contentDigest form" };
-    const arrayIssue = (decls, where) => {
-        if (!Array.isArray(decls))
-            return `${where} is not an array`;
-        if (decls.length === 0)
-            return `${where} is empty (an empty replacement set is not a v1 semantic — omit the key instead)`;
-        const seen = new Set();
-        for (let i = 0; i < decls.length; i++) {
-            const issue = declarationIssue(decls[i], `${where}[${i}]`);
-            if (issue)
-                return issue;
-            const id = decls[i].id;
-            if (seen.has(id))
-                return `${where}[${i}]: duplicate id "${id}" (core composer throws on duplicates)`;
-            seen.add(id);
-        }
-        return undefined;
-    };
-    const sectionsIssue = arrayIssue(p.sections, "sections");
-    if (sectionsIssue)
-        return { ok: false, error: sectionsIssue };
-    if (p.scenarioOverrides !== undefined) {
-        if (p.scenarioOverrides === null || typeof p.scenarioOverrides !== "object" || Array.isArray(p.scenarioOverrides)) {
-            return { ok: false, error: "scenarioOverrides is not an object" };
-        }
-        for (const [name, decls] of Object.entries(p.scenarioOverrides)) {
-            const issue = arrayIssue(decls, `scenarioOverrides[${name}]`);
-            if (issue)
-                return { ok: false, error: issue };
-        }
-    }
-    return { ok: true, value: raw };
-}
-export const CORE_ENGINE_VERSION = (() => {
-    try {
-        const entry = createRequire(import.meta.url).resolve("@sema-agent/core");
-        return JSON.parse(readFileSync(join(dirname(entry), "..", "package.json"), "utf8")).version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-})();
-export function validatePromptsDomain(raw) {
-    if (raw === null || typeof raw !== "object")
-        return { ok: false, error: "prompts is not an object" };
-    const w = raw;
-    if (w.schemaVersion === undefined) {
-        return { ok: false, error: "prompts payload has no schemaVersion — the legacy flat shape was retired in 5.0.0; wrap as {schemaVersion:1, declarations:{...}} (registry-core EffectivePromptsWire)" };
-    }
-    if (w.schemaVersion !== 1)
-        return { ok: false, error: `unsupported prompts schemaVersion ${String(w.schemaVersion)}` };
-    if (w.declarations === undefined && w.catalog === undefined)
-        return { ok: false, error: "dual-axis prompts carries neither axis (at least one of declarations|catalog required)" };
-    const value = { identity: "", axes: [] };
-    if (w.declarations !== undefined) {
-        const d = validateCenterPrompts(w.declarations);
-        if (!d.ok)
-            return { ok: false, error: `declarations axis: ${d.error}` };
-        value.declarations = d.value;
-        value.axes.push("declarations");
-    }
-    if (w.catalog !== undefined) {
-        const c = verifyPromptArtifact(w.catalog, { engineVersion: CORE_ENGINE_VERSION });
-        if (!c.ok)
-            return { ok: false, error: `catalog axis: ${c.code}: ${c.reason}` };
-        value.catalog = w.catalog;
-        value.axes.push("catalog");
-    }
-    value.identity = `${value.declarations?.contentDigest ?? "-"}+${value.catalog?.artifact.artifactDigest ?? "-"}`;
-    return { ok: true, value };
-}
-export function centerPromptsFromEffective(eff) {
-    const prompts = eff?.prompts;
-    if (prompts === undefined || prompts === null)
-        return undefined;
-    if (typeof prompts !== "object" || Array.isArray(prompts))
-        return prompts;
-    const o = prompts;
-    if ("schemaVersion" in o)
-        return prompts;
-    if ("packId" in o && "contentDigest" in o && "sections" in o)
-        return prompts;
-    if (o.catalog !== undefined)
-        return { schemaVersion: 1, catalog: o.catalog };
-    return undefined;
+import { EffectivePromptsWire, formatConfigPath, sanitizeZodError } from "@sema-agent/settings-schema";
+export function judgePromptsWire(raw) {
+    const wire = EffectivePromptsWire.safeParse(raw);
+    if (!wire.success) {
+        const issues = sanitizeZodError(wire.error).issues.map((i) => `${i.path.length === 0 ? "prompts" : `prompts.${formatConfigPath(i.path.map((s) => (typeof s === "number" ? s : String(s))))}`}: ${i.message}`);
+        return { ok: false, error: issues.join("; ") };
+    }
+    const verified = verifyPromptArtifact(wire.data.artifact);
+    return verified.ok ? { ok: true, artifact: verified.artifact } : { ok: false, error: `prompts.artifact refused by the engine (${verified.code}): ${verified.reason}` };
 }
 //# sourceMappingURL=prompts-domain-validate.js.map

package/dist/question.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { uuidv7 } from "@sema-agent/core";
 import { redactDeep } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
+import { refusalBody } from "./http/refusal-body.js";
 const MAX_QUESTIONS_BYTES = 16384;
 function isFaceReachable(ctx) {
     if (ctx.deliverable === undefined)
@@ -150,10 +151,10 @@ export class QuestionCoordinator {
     respond(id, principal, body) {
         const parsed = parseQuestionResponse(body);
         if (!parsed.ok)
-            return { status: 400, body: { error: parsed.error, errorCode: "request.body_shape" } };
+            return { status: 400, body: refusalBody({ errorCode: "request.body_shape", message: parsed.error }) };
         const entry = this.pending.get(id);
         if (!entry || (entry.owner !== null && entry.owner !== principal)) {
-            return { status: 404, body: { error: "no pending question for this id (answered, expired, or not on this replica)", errorCode: "question.not_pending" } };
+            return { status: 404, body: refusalBody({ errorCode: "question.not_pending", message: "no pending question for this id (answered, expired, or not on this replica)" }) };
         }
         entry.settle(parsed.value, "answered");
         return { status: 200, body: { questionId: id, delivery: "applied" } };

package/dist/read-deny-entry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * **读拒模式条目的归一**(全仓唯一一只读法)—— `READ_DENY_PATTERNS` 的 env 腿(`config.ts`)、中心下发 `readFace.denyPatterns` 的腿(`web-admin-client/read-face.ts`)、
+ * 请求 `settings.readDenyPatterns` 的腿(`tighten-only-seats.ts`)三处读同一份元素文法:`"pattern"` 裸串简写 ≡ `{ pattern, caseSensitive: false }`,
+ * 对象形 `{ pattern: string, caseSensitive?: boolean }`(与 core `ReadDenyEntry = string | {…}` 同宽)。三份手抄的元素读法就是三个会各自漂的真源,所以收成这一只。
+ *
+ * 只管**元素形**(串 / 带串 `pattern` 的对象 / 布尔 `caseSensitive`);模式编不编得过由调用方交给 core 的 `compileReadDeny`(引擎同一套规则,宿主不自造第二份校验语义)。
+ * 返回的是**接在坐标后面的原因尾巴**(` must be a string or an object with a string 'pattern'` / `.caseSensitive must be boolean when present`),不带坐标 —— 调用方自己前缀坐标
+ * (`READ_DENY_PATTERNS[2]` / `readFace.denyPatterns[2]` / `settings.readDenyPatterns[2]`),各腿既有的拒句字节不变。叶模块,零 import。
+ */
+/** 归一后的一行(core `compileReadDeny` 收的对象形)。 */
+export interface NormalizedReadDenyEntry {
+    readonly pattern: string;
+    readonly caseSensitive: boolean;
+}
+/** 一个元素的读数:归一后的行,或接在调用方坐标后面成句的原因尾巴(`after` 自带连接符:空格或点)。 */
+export type ReadDenyEntryReading = {
+    readonly ok: true;
+    readonly entry: NormalizedReadDenyEntry;
+} | {
+    readonly ok: false;
+    readonly after: string;
+};
+/** 读一个元素。裸串 ⇒ 大小写默认不敏感(与对象形缺席 `caseSensitive` 一致);坏形 ⇒ 原因子句,不抛、不丢。 */
+export declare function readReadDenyEntry(it: unknown): ReadDenyEntryReading;
+//# sourceMappingURL=read-deny-entry.d.ts.map

package/dist/read-deny-entry.js

@@ -0,0 +1,12 @@
+export function readReadDenyEntry(it) {
+    if (typeof it === "string")
+        return { ok: true, entry: { pattern: it, caseSensitive: false } };
+    if (typeof it !== "object" || it === null || typeof it.pattern !== "string") {
+        return { ok: false, after: " must be a string or an object with a string 'pattern'" };
+    }
+    const cs = it.caseSensitive;
+    if (cs !== undefined && typeof cs !== "boolean")
+        return { ok: false, after: ".caseSensitive must be boolean when present" };
+    return { ok: true, entry: { pattern: it.pattern, caseSensitive: cs === true } };
+}
+//# sourceMappingURL=read-deny-entry.js.map