@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/dist/collector-tool-schemas.js

@@ -0,0 +1,33 @@
+import { Type } from "typebox";
+import { COLLECTOR_ELIGIBILITY_MS } from "./collector-evidence.js";
+import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
+export const collectorObserveArgsSchema = Type.Object({}, { additionalProperties: false });
+export const collectorRequestArgsSchema = Type.Object({
+    requestId: Type.String({ minLength: 1, description: "配置请求身份" }),
+    snapshotId: Type.String({ minLength: 1, description: "最新留存观察快照" }),
+}, { additionalProperties: false });
+export const collectorReadArgsSchema = Type.Object({
+    evidenceId: Type.String({ minLength: 1, description: "observe 返回的材料证据 id（evidenceId）" }),
+}, { additionalProperties: false });
+export const collectorWaitArgsSchema = Type.Object({
+    durationMs: Type.Integer({ minimum: 1, maximum: COLLECTOR_ELIGIBILITY_MS, description: "等待毫秒；单次上限五分钟且不超剩余资格" }),
+}, { additionalProperties: false });
+/**
+ * #641 chain①: the collector LLM does the splitting/classification (#245:
+ * 他自己就是llm为什么不能读不能拆). Findings are submitted as pointer refs into
+ * the stored evidence; the runtime enriches each with the machine pointer
+ * (repo/PR/comment id/url/author/kind/时间) and validates resolvability.
+ * Category is a short LLM classification label, never a body transcription.
+ */
+export const collectorFindingArgsSchema = Type.Object({
+    evidenceId: Type.String({ minLength: 1, description: "observe 返回的材料证据 id（evidenceId）" }),
+    category: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "该 finding 的简短归类标签；需要头部之外的正文时先用 ak_collector_read 开卷再判读，不得誊写评论正文" })),
+}, { additionalProperties: false });
+export const collectorOutputBaseSchema = Type.Object({
+    findings: Type.Optional(Type.Array(collectorFindingArgsSchema, {
+        description: "本次收集到的逐条 findings；零 finding 的模板通知不得进入。正常完工无 finding 时省略。",
+    })),
+}, { additionalProperties: true, description: "正常完工提交空对象 {}；仅在基础设施真实失败时才填写 infrastructureFailure，无失败时必须省略该字段。" });
+/** Runtime owns the observed evidence; the model submits findings and signals sole-final submission. */
+export const collectorOutputArgsSchema = withInfrastructureFailureDeclaration(collectorOutputBaseSchema);
+collectorOutputArgsSchema.required = [];

package/dist/compliance-transport.js

@@ -1,8 +1,6 @@
 import { Type } from "typebox";
-import {
-  executeAuditorChild
-} from "./evidence-child-executor.js";
-import { createAuditorDossierTool } from "./auditor-dossier-tool.js";
+import { auditorRunDirectory } from "./auditor-dossier-tool.js";
+import { retainedShapeUnreadable } from "./shape-unreadable-failure.js";
 class ComplianceCandidateUnreadableError extends Error {
   observation;
   candidate;
@@ -20,43 +18,39 @@ const AUDITOR_DOSSIER_PROMPT = "\u672C run \u5377\u5B97\u5DF2\u5C31\u7EEA\u3002"
 const nonblank = Type.String({ minLength: 1, pattern: "\\S" });
 const decisionGateSchema = Type.Object({ question: nonblank, options: Type.Array(nonblank, { minItems: 1 }) }, { additionalProperties: false });
 const complianceDecisionSchema = Type.Object({ status: Type.Unknown({ description: "pass | revise | escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }), violations: Type.Array(nonblank, { description: "\u89C2\u5BDF\u5230\u7684\u5408\u89C4\u8FDD\u89C4" }), conflicts: Type.Array(nonblank, { description: "\u672A\u51B3\u6743\u5A01\u6216\u6267\u884C\u51B2\u7A81" }), decisionGate: Type.Union([decisionGateSchema, Type.Null()], { description: "\u5347\u7EA7\u95EE\u9898\u4E0E\u53EF\u9009\u9009\u9879" }) }, { additionalProperties: true, required: [] });
-function createComplianceDecisionTool(name, description) {
-  return { name, description, parameters: complianceDecisionSchema, async execute(_id, params) {
-    return { content: [{ type: "text", text: "\u5BA1\u8BA1\u51B3\u8BAE\u5DF2\u6536" }], details: params, terminate: true };
-  } };
-}
 const COMPLIANCE_RESPONSE_ENTRY_TYPE = "ak_compliance_response";
 const AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
 const AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE = "ak_auditor_compliance_failure";
-import { attachDirectErrnoCode, sitianReport } from "./sitian-facade.js";
 class ComplianceResponseRetentionError extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "ComplianceResponseRetentionError";
-    attachDirectErrnoCode(this, options?.cause);
-  }
-}
-function retainComplianceResponse(context, response) {
-  try {
-    sitianReport({
-      level: "event",
-      kind: "auditor",
-      cwd: context.cwd,
-      sessionParent: context.sessionManager.getSessionFile(),
-      payload: { version: 1, response },
-      source: "compliance-transport"
-    });
-  } catch (error) {
-    throw new ComplianceResponseRetentionError(
-      `compliance response retention failed: ${error instanceof Error ? error.message : String(error)}`,
-      { cause: error }
-    );
   }
 }
 function readListField(value) {
   return Array.isArray(value) ? value : value === void 0 ? [] : [value];
 }
+function tryReadComplianceCandidate(arguments_, usage) {
+  if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) {
+    return void 0;
+  }
+  const args = arguments_;
+  const status = args.status;
+  if (status === "pass") return { status, ...usage === void 0 ? {} : { usage } };
+  if (status === "revise") return { status, violations: readListField(args.violations), ...usage === void 0 ? {} : { usage } };
+  if (status === "escalate") {
+    return {
+      status,
+      ...Object.hasOwn(args, "conflicts") ? { conflicts: args.conflicts } : {},
+      ...Object.hasOwn(args, "decisionGate") ? { decisionGate: args.decisionGate } : {},
+      ...usage === void 0 ? {} : { usage }
+    };
+  }
+  return void 0;
+}
 function readComplianceCandidate(arguments_, usage) {
+  const projected = tryReadComplianceCandidate(arguments_, usage);
+  if (projected !== void 0) return projected;
   if (typeof arguments_ !== "object" || arguments_ === null || Array.isArray(arguments_)) {
     throw new ComplianceCandidateUnreadableError(
       { kind: "non-object-arguments", type: arguments_ === null ? "null" : Array.isArray(arguments_) ? "array" : typeof arguments_ },
@@ -64,38 +58,96 @@ function readComplianceCandidate(arguments_, usage) {
       usage
     );
   }
-  const args = arguments_;
-  const status = args.status;
-  if (status === "pass") return { status, ...usage === void 0 ? {} : { usage } };
-  if (status === "revise") return { status, violations: readListField(args.violations), ...usage === void 0 ? {} : { usage } };
-  if (status === "escalate") return { status, ...Object.hasOwn(args, "conflicts") ? { conflicts: args.conflicts } : {}, ...Object.hasOwn(args, "decisionGate") ? { decisionGate: args.decisionGate } : {}, ...usage === void 0 ? {} : { usage } };
+  const status = arguments_.status;
   throw new ComplianceCandidateUnreadableError(
     { kind: "object-status-unreadable", status: status === void 0 ? "missing" : "unknown" },
     arguments_,
     usage
   );
 }
-async function runComplianceAudit(options) {
-  const prompt = options.serializedInput ?? AUDITOR_DOSSIER_PROMPT;
-  const receipt = await executeAuditorChild({
-    tool: options.tool,
-    dossierTool: createAuditorDossierTool(options.runDirectory),
-    systemPrompt: options.systemPrompt,
-    prompt,
-    roleLabel: options.roleLabel,
-    context: options.context,
-    retainResponse: (response) => retainComplianceResponse(options.context, response),
-    ...options.runDirectory === void 0 ? {} : { runDirectory: options.runDirectory },
-    ...options.signal === void 0 ? {} : { signal: options.signal }
-  });
-  if (receipt.noReceiptLifecycle !== void 0) {
+async function usageFromSummonedSession(summoned) {
+  const { usageFromPublicSummon } = await import("./session-assistant-usage.js");
+  return usageFromPublicSummon(summoned);
+}
+function observationFromUnreadableCandidate(candidate) {
+  if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+    return {
+      kind: "non-object-arguments",
+      type: candidate === null ? "null" : Array.isArray(candidate) ? "array" : typeof candidate
+    };
+  }
+  const status = candidate.status;
+  return {
+    kind: "object-status-unreadable",
+    status: status === void 0 ? "missing" : "unknown"
+  };
+}
+function unreadableDecision(candidate, usage) {
+  return {
+    status: "unreadable",
+    observation: observationFromUnreadableCandidate(candidate),
+    candidate,
+    ...usage === void 0 ? {} : { usage }
+  };
+}
+async function projectAuditorTerminal(summoned) {
+  const outcome = summoned.terminal?.roleOutcome;
+  if (outcome === void 0) {
+    throw new Error(`Auditor public summon produced no terminal (exit ${summoned.exitCode})`);
+  }
+  const usage = await usageFromSummonedSession(summoned);
+  if (outcome.kind === "no_receipt") {
+    const { status: _ignored, kind: _kind, role: _role, decisiveFacts: _facts, ...facts } = outcome;
     return {
       status: "no-receipt",
-      ...receipt.noReceiptLifecycle,
-      ...receipt.response.usage === void 0 ? {} : { usage: receipt.response.usage }
+      ...facts,
+      ...usage === void 0 ? {} : { usage }
     };
   }
-  return readComplianceCandidate(receipt.decision, receipt.response.usage);
+  if (outcome.kind === "failure") {
+    const shape = retainedShapeUnreadable(outcome.decisiveFacts);
+    if (shape !== void 0) {
+      return unreadableDecision(shape.candidate, usage);
+    }
+    throw new Error(outcome.diagnostic);
+  }
+  if (outcome.kind === "accepted") {
+    const candidate = {
+      status: outcome.status,
+      ...outcome.decisiveFacts
+    };
+    const projected = tryReadComplianceCandidate(candidate, usage);
+    if (projected !== void 0) return projected;
+    return unreadableDecision(candidate, usage);
+  }
+  throw new Error("Auditor public summon returned unusable terminal kind");
+}
+async function runComplianceAudit(options) {
+  const runDirectory = options.runDirectory ?? auditorRunDirectory(options.context);
+  if (runDirectory === void 0) {
+    throw new Error("Compliance audit requires a parent run directory pointer");
+  }
+  const subject = options.subject;
+  const summon = options.summonAuditor ?? (async (auditSubject, sourceRunDirectory, auditSignal) => {
+    const { summonPublicRole } = await import("./public-role-summons.js");
+    const { homeFromRunDirectory } = await import("./activation-ledger-topology.js");
+    const home = homeFromRunDirectory(sourceRunDirectory);
+    return await summonPublicRole({
+      role: "auditor",
+      argv: [
+        "--subject",
+        auditSubject,
+        "--source-run",
+        sourceRunDirectory,
+        AUDITOR_DOSSIER_PROMPT
+      ],
+      cwd: options.context.cwd ?? process.cwd(),
+      home,
+      ...auditSignal === void 0 ? {} : { signal: auditSignal }
+    });
+  });
+  const summoned = await summon(subject, runDirectory, options.signal);
+  return await projectAuditorTerminal(summoned);
 }
 export {
   AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE,
@@ -105,7 +157,7 @@ export {
   ComplianceCandidateUnreadableError,
   ComplianceResponseRetentionError,
   complianceDecisionSchema,
-  createComplianceDecisionTool,
   readComplianceCandidate,
-  runComplianceAudit
+  runComplianceAudit,
+  tryReadComplianceCandidate
 };

package/dist/diarist-mechanical.js

@@ -0,0 +1,411 @@
+/**
+ * 起居郎 mechanical safeguard band — ADR 0075 / #582.
+ * Deterministic: source enum helpers, candidate anchors, dedup, notification
+ * filter, and verbatim quote reverse-verify. Never a production relevance gate.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { pathContainedIn, physicallyContainedIn, } from "./activation-ledger-topology.js";
+export const DEFAULT_QUOTE_MIN = 6;
+export class DiaristSourceReadError extends Error {
+    code = "diarist-source-read";
+    reason;
+    sourcePath;
+    constructor(reason, sourcePath, message, options) {
+        super(message, options);
+        this.name = "DiaristSourceReadError";
+        this.reason = reason;
+        this.sourcePath = sourcePath;
+    }
+}
+/**
+ * Extract 「」 quotes from ticket face text for mechanical anchors.
+ * Only quotes meeting min length are kept.
+ */
+export function extractCornerQuotes(text, minLength = DEFAULT_QUOTE_MIN) {
+    const out = [];
+    const re = /「([^」]+)」/g;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        const q = match[1].trim();
+        if (q.length >= minLength)
+            out.push(q);
+    }
+    return out;
+}
+/** Build the mechanical anchor set from ticket number + face body. */
+export function buildDiaristAnchors(input) {
+    const fromBody = input.ticketBody === undefined ? [] : extractCornerQuotes(input.ticketBody);
+    const quotes = [...fromBody, ...(input.extraQuotes ?? [])];
+    const seen = new Set();
+    const uniqueQuotes = [];
+    for (const q of quotes) {
+        if (seen.has(q))
+            continue;
+        seen.add(q);
+        uniqueQuotes.push(q);
+    }
+    return {
+        ticketNumber: input.ticketNumber,
+        quotes: uniqueQuotes,
+    };
+}
+/** Drop notification/system noise blocks (typed flags only — no prose match). */
+export function filterNotifications(blocks) {
+    return blocks.filter((b) => !b.isNotification);
+}
+function blockKey(block) {
+    const r = block.sourceRef;
+    return [
+        block.sourceKind,
+        r.sessionFile ?? "",
+        r.entryId === undefined ? "" : String(r.entryId),
+        r.path ?? "",
+        r.url ?? "",
+        createHash("sha256").update(block.transcript, "utf8").digest("hex").slice(0, 16),
+    ].join("|");
+}
+/** Dedup by source pointer + transcript digest (compression replay ×N). */
+export function dedupeSourceBlocks(blocks) {
+    const seen = new Set();
+    const out = [];
+    for (const block of blocks) {
+        const key = blockKey(block);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(block);
+    }
+    return out;
+}
+export function verifyQuotesVerbatim(sourceText, quotes) {
+    const failed = [];
+    for (const q of quotes) {
+        if (q.length === 0)
+            continue;
+        if (!sourceText.includes(q))
+            failed.push(q);
+    }
+    if (failed.length === 0)
+        return { ok: true };
+    return { ok: false, failedQuotes: failed };
+}
+/**
+ * Mechanical safeguard only — never a relevance gate (ADR 0075 / 锚定宪法).
+ * filter notifications (typed) → dedupe. Semantic selection is LLM-only.
+ */
+export function mechanicalSafeguardPipeline(blocks) {
+    return dedupeSourceBlocks(filterNotifications(blocks));
+}
+/** Claude Code project-dir encoding: abs path with / → -. */
+export function encodeClaudeProjectDir(cwd) {
+    const abs = cwd.startsWith("/") ? cwd : `/${cwd}`;
+    return abs.replace(/\//g, "-");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageText(message) {
+    if (typeof message === "string")
+        return message;
+    if (!isRecord(message))
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        if (typeof part === "string") {
+            parts.push(part);
+            continue;
+        }
+        if (!isRecord(part))
+            continue;
+        if (typeof part.text === "string")
+            parts.push(part.text);
+        else if (typeof part.content === "string")
+            parts.push(part.content);
+    }
+    return parts.join("\n");
+}
+function isNotificationRow(type, text) {
+    if (type === "queue-operation" || type === "system" || type === "progress") {
+        return true;
+    }
+    if (type === "user") {
+        // Local command / meta noise common in cc transcripts.
+        if (text.startsWith("<command-name>") || text.startsWith("<local-command-")) {
+            return true;
+        }
+        if (text.startsWith("<command-message>") || text.startsWith("<command-args>")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Enumerate cc session user/assistant turns and human queued-command attachments under Claude projects roots.
+ * cc-sessions-first source family (ADR 0075).
+ * Directory/file/non-empty JSONL line failures throw DiaristSourceReadError
+ * (失败诚实：不得把未读懂洗成没有来源块).
+ */
+export function readCcSessionBlocks(options) {
+    const root = options.projectsRoot ?? join(homedir(), ".claude", "projects");
+    if (!existsSync(root))
+        return [];
+    const blocks = [];
+    const dirs = new Set();
+    for (const cwd of options.cwds) {
+        dirs.add(join(root, encodeClaudeProjectDir(cwd)));
+    }
+    // Also accept already-encoded folder names passed as cwd (test convenience).
+    for (const cwd of options.cwds) {
+        if (cwd.includes("projects"))
+            continue;
+        const direct = join(root, cwd);
+        if (existsSync(direct))
+            dirs.add(direct);
+    }
+    for (const dir of dirs) {
+        if (!existsSync(dir))
+            continue;
+        let dirStat;
+        try {
+            dirStat = statSync(dir);
+        }
+        catch (error) {
+            throw new DiaristSourceReadError("readdir-failed", dir, `diarist cc session dir unstatable (${dir})`, { cause: error });
+        }
+        if (!dirStat.isDirectory())
+            continue;
+        let files;
+        try {
+            files = readdirSync(dir).filter((name) => name.endsWith(".jsonl"));
+        }
+        catch (error) {
+            throw new DiaristSourceReadError("readdir-failed", dir, `diarist cc session dir unreadable (${dir})`, { cause: error });
+        }
+        for (const name of files) {
+            const sessionFile = join(dir, name);
+            let text;
+            try {
+                text = readFileSync(sessionFile, "utf8");
+            }
+            catch (error) {
+                throw new DiaristSourceReadError("file-unreadable", sessionFile, `diarist cc session file unreadable (${sessionFile})`, { cause: error });
+            }
+            const lines = text.split("\n");
+            for (let lineNo = 0; lineNo < lines.length; lineNo += 1) {
+                const line = lines[lineNo];
+                if (!line.trim())
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch (error) {
+                    throw new DiaristSourceReadError("jsonl-line-unparseable", sessionFile, `diarist cc session JSONL line ${lineNo + 1} unparseable (${sessionFile})`, { cause: error });
+                }
+                // Unknown row shape (not user/assistant or a human queued-command attachment) is ignored — not a read failure.
+                if (!isRecord(parsed))
+                    continue;
+                const type = typeof parsed.type === "string" ? parsed.type : "";
+                const queuedCommand = type === "attachment" &&
+                    isRecord(parsed.attachment) &&
+                    parsed.attachment.type === "queued_command" &&
+                    isRecord(parsed.attachment.origin) &&
+                    parsed.attachment.origin.kind === "human" &&
+                    typeof parsed.attachment.prompt === "string"
+                    ? parsed.attachment.prompt
+                    : undefined;
+                if (type !== "user" && type !== "assistant" && queuedCommand === undefined) {
+                    continue;
+                }
+                const transcript = queuedCommand ?? messageText(parsed.message ?? parsed);
+                if (transcript.trim() === "")
+                    continue;
+                const entryId = typeof parsed.uuid === "string"
+                    ? parsed.uuid
+                    : typeof parsed.id === "string"
+                        ? parsed.id
+                        : `${basename(sessionFile)}:${lineNo + 1}`;
+                const timestamp = typeof parsed.timestamp === "string"
+                    ? parsed.timestamp
+                    : new Date(0).toISOString();
+                const notification = isNotificationRow(type, transcript);
+                blocks.push({
+                    sourceKind: "cc-session",
+                    sourceRef: { sessionFile, entryId },
+                    transcript,
+                    timestamp,
+                    isUserTurn: type === "user" || queuedCommand !== undefined,
+                    isNotification: notification,
+                });
+            }
+        }
+    }
+    return blocks;
+}
+/**
+ * Issue body + comments + 「」 decree spans as typed source blocks.
+ * Each block keeps its own sourceRef (url / comment id) — never merge attachments here.
+ */
+export function readIssueFaceBlocks(input) {
+    const fallbackTs = input.timestamp ?? new Date(0).toISOString();
+    const blocks = [];
+    const body = input.face.body;
+    if (body.trim() !== "") {
+        blocks.push({
+            sourceKind: "issue-body-comment",
+            sourceRef: { url: input.face.bodyUrl, entryId: "body" },
+            transcript: body,
+            timestamp: fallbackTs,
+            isUserTurn: true,
+            isNotification: false,
+        });
+        const quotes = extractCornerQuotes(body);
+        for (let i = 0; i < quotes.length; i += 1) {
+            const q = quotes[i];
+            blocks.push({
+                sourceKind: "ticket-decree-block",
+                sourceRef: { url: input.face.bodyUrl, entryId: `decree-${i + 1}` },
+                transcript: q,
+                timestamp: fallbackTs,
+                isUserTurn: true,
+                isNotification: false,
+            });
+        }
+    }
+    for (const comment of input.face.comments) {
+        if (comment.body.trim() === "")
+            continue;
+        blocks.push({
+            sourceKind: "issue-body-comment",
+            sourceRef: {
+                url: comment.htmlUrl,
+                entryId: comment.id,
+            },
+            transcript: comment.body,
+            timestamp: comment.createdAt || fallbackTs,
+            isUserTurn: true,
+            isNotification: false,
+        });
+    }
+    return blocks;
+}
+/** Relative root every ADR decision-key read must stay under (ADR 0038). */
+export const DIARIST_ADR_ROOT_REL = "docs/adr";
+/**
+ * Read applicable ADR files as decision-key source blocks.
+ * Real IO seam owns lexical + physical containment under cwd/docs/adr (ADR 0038).
+ * Missing / unreadable / escape → typed DiaristSourceReadError (失败诚实).
+ */
+export function readAdrDecisionKeyBlocks(input) {
+    const timestamp = input.timestamp ?? new Date(0).toISOString();
+    const blocks = [];
+    const cwdAbs = resolve(input.cwd);
+    const adrRootAbs = resolve(cwdAbs, DIARIST_ADR_ROOT_REL);
+    let adrRootReal;
+    try {
+        // Prefer the real ADR root when it exists; otherwise fall back to cwd real
+        // so physical checks still have a stable anchor before the first ADR file.
+        adrRootReal = existsSync(adrRootAbs)
+            ? realpathSync(adrRootAbs)
+            : resolve(realpathSync(cwdAbs), DIARIST_ADR_ROOT_REL);
+    }
+    catch (error) {
+        throw new DiaristSourceReadError("adr-unreadable", cwdAbs, `diarist ADR root is not resolvable (${adrRootAbs})`, { cause: error });
+    }
+    for (const rel of input.adrPaths) {
+        const segments = rel.split(/[/\\]/);
+        // Claimed path must sit under docs/adr/ with no traversal segments.
+        if (segments[0] !== "docs" ||
+            segments[1] !== "adr" ||
+            segments.length < 3 ||
+            segments.some((part) => part === "" || part === "." || part === "..")) {
+            throw new DiaristSourceReadError("adr-escape", resolve(cwdAbs, rel), `diarist referenced ADR escapes docs/adr (${rel})`);
+        }
+        const abs = resolve(cwdAbs, rel);
+        // Lexical containment under docs/adr before any read (ADR 0038).
+        if (abs !== adrRootAbs && !pathContainedIn(adrRootAbs, abs)) {
+            throw new DiaristSourceReadError("adr-escape", abs, `diarist referenced ADR escapes docs/adr (${rel})`);
+        }
+        if (!existsSync(abs)) {
+            throw new DiaristSourceReadError("adr-missing", abs, `diarist referenced ADR missing (${rel})`);
+        }
+        let realAbs;
+        try {
+            realAbs = realpathSync(abs);
+        }
+        catch (error) {
+            throw new DiaristSourceReadError("adr-unreadable", abs, `diarist ADR path is not resolvable (${abs})`, { cause: error });
+        }
+        if (realAbs !== adrRootReal && !physicallyContainedIn(adrRootReal, realAbs)) {
+            throw new DiaristSourceReadError("adr-escape", abs, `diarist referenced ADR escapes docs/adr physically (${rel})`);
+        }
+        let text;
+        try {
+            text = readFileSync(realAbs, "utf8");
+        }
+        catch (error) {
+            throw new DiaristSourceReadError("adr-unreadable", realAbs, `diarist ADR file unreadable (${realAbs})`, { cause: error });
+        }
+        if (text.trim() === "")
+            continue;
+        blocks.push({
+            sourceKind: "adr-decision-key",
+            sourceRef: { path: rel },
+            transcript: text,
+            timestamp,
+            isUserTurn: true,
+            isNotification: false,
+        });
+    }
+    return blocks;
+}
+/**
+ * Build an llm-semantic entry after reverse-verify succeeds.
+ * `quotes` are the LLM-claimed quotes that must be verbatim in transcript.
+ * basis.anchors record ticket # + mechanical/claimed quotes for audit only.
+ * Failure returns failedQuotes only — caller records a single diagnostic (not a
+ * disguised diary entry / dead basis.method).
+ */
+export function blockToLlmEntry(block, input) {
+    const verify = verifyQuotesVerbatim(block.transcript, input.quotes);
+    if (!verify.ok) {
+        return {
+            ok: false,
+            failedQuotes: verify.failedQuotes,
+            cause: `verbatim verify failed: ${verify.failedQuotes.join(" | ")}`,
+        };
+    }
+    // Ticket + mechanical face quotes + claimed quotes — reference/反验 only.
+    const anchorNotes = [`#${input.anchors.ticketNumber}`];
+    const seen = new Set(anchorNotes);
+    for (const q of [...input.anchors.quotes, ...input.quotes]) {
+        if (seen.has(q))
+            continue;
+        seen.add(q);
+        anchorNotes.push(q);
+        if (anchorNotes.length >= 12)
+            break;
+    }
+    return {
+        ok: true,
+        entry: {
+            basis: {
+                method: "llm-semantic",
+                anchors: anchorNotes,
+                ...(input.note === undefined ? {} : { note: input.note }),
+            },
+            sourceKind: block.sourceKind,
+            sourceRef: block.sourceRef,
+            transcript: block.transcript,
+            timestamp: block.timestamp,
+        },
+    };
+}