@akagilnc/pi-workflow-roles 0.1.3873 → 0.1.3886

package/dist/merger-contracts.js

@@ -1,29 +1,23 @@
 import { Type } from "typebox";
-import { isFullGitObjectId } from "./git-object-id.js";
 import { exactUtf8 } from "./exact-utf8.js";
-import { sha256Hex } from "./sha256.js";
 import { openToolObjectFromUnion } from "./open-tool-schema.js";
 import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
-const oidPattern = "^(?:[0-9a-f]{40}|[0-9a-f]{64})$";
 const materialSchema = Type.Object({ bytesBase64: Type.String(), sha256: Type.String() }, { additionalProperties: false });
 const checkSchema = Type.Object({ name: Type.String({ minLength: 1 }), argv: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }) }, { additionalProperties: false });
 const mergerInputSchema = Type.Object({
-  version: Type.Literal(1),
-  attemptId: Type.String({ minLength: 1 }),
-  targetObjectId: Type.String({ pattern: oidPattern }),
-  sourceObjectId: Type.String({ pattern: oidPattern }),
+  attemptId: Type.String({ minLength: 1, description: "\u5BF9\u8D26 attempt \u8EAB\u4EFD\uFF08transport\uFF09" }),
+  targetObjectId: Type.String({ description: "\u6750\u6599\uFF1Atarget parent OID\uFF1B\u53EF\u7A7A" }),
+  sourceObjectId: Type.String({ description: "\u6750\u6599\uFF1Asource parent OID\uFF1B\u53EF\u7A7A" }),
   materials: Type.Object({ task: materialSchema, authority: materialSchema, targetIntent: materialSchema, sourceIntent: materialSchema }, { additionalProperties: false }),
-  expectedConflictPaths: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-  resolutionScope: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+  expectedConflictPaths: Type.Array(Type.String(), { description: "\u6750\u6599\uFF1A\u5F53\u524D\u672A\u5408\u5E76\u8DEF\u5F84\uFF1B\u53EF\u7A7A" }),
+  resolutionScope: Type.Array(Type.String(), { description: "\u6750\u6599\uFF1A\u89E3\u6790\u8303\u56F4\u63D0\u793A\uFF1B\u53EF\u7A7A" }),
   authorizedChecks: Type.Array(checkSchema)
 }, { additionalProperties: false });
 const mergerOutputVariants = Type.Union([
-  Type.Object({ status: Type.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }), attemptId: Type.String({ minLength: 1, description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }), report: Type.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }), mergeCommitId: Type.String({ pattern: oidPattern, description: "\u5DF2\u6838\u9A8C\u7684\u5B8C\u6210\u5408\u5E76 commit object ID" }) }, { additionalProperties: false }),
-  Type.Object({ status: Type.Literal("escalate", { description: "escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }), attemptId: Type.String({ minLength: 1, description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }), diagnosis: Type.String({ minLength: 1, description: "\u5408\u5E76\u5B8C\u6210\u9700\u5347\u7EA7\u7684\u539F\u56E0" }), report: Type.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }) }, { additionalProperties: false })
+  Type.Object({ status: Type.Literal("completed", { description: "completed \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }), attemptId: Type.String({ minLength: 1, description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }), report: Type.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }), mergeCommitId: Type.String({ description: "\u5B8C\u6210\u5408\u5E76 commit object ID" }) }, { additionalProperties: false }),
+  Type.Object({ status: Type.Literal("escalate", { description: "escalate \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8" }), attemptId: Type.String({ minLength: 1, description: "\u5DF2\u53D7\u7406\u5408\u5E76 attempt \u8EAB\u4EFD" }), diagnosis: Type.String({ minLength: 1, description: "\u5408\u5E76\u65E0\u6CD5\u6216\u4E0D\u5E94\u7531\u672C\u5E2D\u5B8C\u6210\u7684\u539F\u56E0\uFF08\u542B\u65E0\u8FDB\u884C\u4E2D\u5408\u5E76\u3001\u65E0\u6D3B\u53EF\u5E72\u3001\u9700\u65B0\u7684\u4EA7\u54C1/\u6743\u529B\u51B3\u5B9A\uFF09" }), report: Type.String({ minLength: 1, description: "\u5982\u5B9E\u7ED3\u679C\u62A5\u544A" }) }, { additionalProperties: false })
 ]);
-const mergerOutputSchema = withInfrastructureFailureDeclaration(
-  openToolObjectFromUnion(mergerOutputVariants)
-);
+const mergerOutputSchema = withInfrastructureFailureDeclaration(openToolObjectFromUnion(mergerOutputVariants));
 const MERGER_OUTPUT_TOOL_NAME = "ak_merger_output";
 const MERGER_ACCEPTED_TEXT = "\u5408\u5E76\u56DE\u6267\u5DF2\u63A5\u53D7";
 const record = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -37,19 +31,6 @@ class MergerInputContractError extends Error {
 function fail(message = "Merger input violates its exact contract") {
   throw new MergerInputContractError(message);
 }
-function canonicalPath(path) {
-  return typeof path === "string" && path.length > 0 && !path.startsWith("/") && !path.includes("\0") && path.split("/").every((part) => part !== "" && part !== "." && part !== "..");
-}
-function validatePathSet(value, label) {
-  if (!Array.isArray(value) || value.length === 0 || !value.every(canonicalPath)) fail(`Merger ${label} must be a non-empty canonical path set`);
-  return value;
-}
-function validateMaterial(value, label) {
-  if (!record(value) || typeof value.bytesBase64 !== "string" || typeof value.sha256 !== "string") fail(`Merger ${label} material is malformed`);
-  const bytes = Buffer.from(value.bytesBase64, "base64");
-  exactUtf8(bytes, `Merger ${label} material`);
-  if (sha256Hex(bytes) !== value.sha256) fail(`Merger ${label} material digest mismatch`);
-}
 function deepFreeze(value) {
   if (value && typeof value === "object") {
     for (const child of Object.values(value)) deepFreeze(child);
@@ -57,24 +38,24 @@ function deepFreeze(value) {
   }
   return value;
 }
+const asString = (v) => typeof v === "string" ? v : "";
+const asStringArray = (v) => Array.isArray(v) ? v.filter((item) => typeof item === "string") : [];
+function readMaterial(value, label) {
+  if (!record(value) || typeof value.bytesBase64 !== "string") fail(`Merger ${label} material is malformed`);
+  exactUtf8(Buffer.from(value.bytesBase64, "base64"), `Merger ${label} material`);
+  return { bytesBase64: value.bytesBase64, sha256: typeof value.sha256 === "string" ? value.sha256 : "" };
+}
 function validateMergerInput(value) {
-  if (!record(value) || blank(value.attemptId) || !isFullGitObjectId(value.targetObjectId) || !isFullGitObjectId(value.sourceObjectId) || value.targetObjectId.length !== value.sourceObjectId.length) fail("Merger input has invalid identity or object ID");
-  if (!record(value.materials)) fail();
-  for (const key of ["task", "authority", "targetIntent", "sourceIntent"]) validateMaterial(value.materials[key], key);
-  const conflicts = validatePathSet(value.expectedConflictPaths, "expected conflict paths");
-  const scope = validatePathSet(value.resolutionScope, "resolution scope");
-  if (!conflicts.every((path) => scope.includes(path))) fail("Merger resolution scope must contain the complete conflict set");
-  if (!Array.isArray(value.authorizedChecks)) fail("Merger authorized checks are malformed");
-  for (const check of value.authorizedChecks) {
-    if (!record(check) || !Array.isArray(check.argv) || check.argv.length === 0 || check.argv.some(blank)) fail("Merger authorized check is malformed");
-  }
-  return deepFreeze(structuredClone(value));
+  if (!record(value) || blank(value.attemptId)) fail("Merger input requires a non-empty attemptId for accounting");
+  if (!record(value.materials)) fail("Merger materials are missing");
+  const materials = { task: readMaterial(value.materials.task, "task"), authority: readMaterial(value.materials.authority, "authority"), targetIntent: readMaterial(value.materials.targetIntent, "targetIntent"), sourceIntent: readMaterial(value.materials.sourceIntent, "sourceIntent") };
+  const authorizedChecks = Array.isArray(value.authorizedChecks) ? value.authorizedChecks.filter((check) => record(check)).map((c) => ({ name: asString(c.name), argv: asStringArray(c.argv).filter((a) => a.trim().length > 0) })).filter((c) => c.name.trim().length > 0 && c.argv.length > 0) : [];
+  return deepFreeze(structuredClone({ attemptId: value.attemptId.trim(), targetObjectId: asString(value.targetObjectId), sourceObjectId: asString(value.sourceObjectId), materials, expectedConflictPaths: asStringArray(value.expectedConflictPaths), resolutionScope: asStringArray(value.resolutionScope), authorizedChecks }));
 }
-function validateMergerOutput(value, expectedAttemptId) {
-  if (!record(value) || expectedAttemptId !== void 0 && value.attemptId !== expectedAttemptId) throw new Error("\u5408\u5E76\u56DE\u6267 attempt \u4E0D\u5339\u914D");
+function validateMergerOutput(value) {
+  if (!record(value)) throw new Error("\u5408\u5E76\u56DE\u6267\u65E0\u5DF2\u8BC6\u522B\u7684\u6267\u884C\u5224\u522B");
   const status = typeof value.status === "string" ? value.status : void 0;
-  if (status === "completed" && isFullGitObjectId(value.mergeCommitId)) return structuredClone(value);
-  if (status === "escalate") return structuredClone(value);
+  if (status === "completed" || status === "escalate") return structuredClone(value);
   throw new Error("\u5408\u5E76\u56DE\u6267\u65E0\u5DF2\u8BC6\u522B\u7684\u6267\u884C\u5224\u522B");
 }
 export {

package/dist/merger-git-state.js

@@ -1,4 +1,7 @@
 import { execFile } from "node:child_process";
+import { access, readFile } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 import { promisify } from "node:util";
 import { exactUtf8 } from "./exact-utf8.js";
 import { isFullGitObjectId } from "./git-object-id.js";
@@ -13,11 +16,37 @@ function line(bytes, label) {
         throw new Error(`${label} is empty`);
     return value;
 }
-function nulPaths(bytes, label) {
-    const raw = exactUtf8(bytes, label);
-    if (raw.length > 0 && !raw.endsWith("\0"))
-        throw new Error(`${label} is not NUL terminated`);
-    return raw.split("\0").filter(Boolean).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+async function pathExists(path) {
+    try {
+        await access(path, fsConstants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function requireInsideWorkTree(cwd) {
+    const stdout = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    if (exactUtf8(stdout, "Git worktree check").trim() !== "true")
+        throw new Error("Assigned path is not inside a Git work tree");
+}
+async function tryResolveCommit(cwd, rev) {
+    let stdout;
+    try {
+        const res = await execFileAsync("git", ["rev-parse", "--verify", "--quiet", `${rev}^{commit}`], { cwd, encoding: "buffer", maxBuffer: 16 * 1024 * 1024 });
+        stdout = new Uint8Array(res.stdout);
+    }
+    catch (error) {
+        if (error.code === 1)
+            return undefined;
+        throw error;
+    }
+    const oid = line(stdout, `Git ${rev}`);
+    if (!isFullGitObjectId(oid))
+        throw new Error(`Git ${rev} identity is unavailable or invalid`);
+    return oid;
 }
 async function unmerged(cwd) {
     const raw = exactUtf8(await git(cwd, ["ls-files", "-u", "-z"]), "Git unmerged index");
@@ -32,47 +61,45 @@ async function unmerged(cwd) {
     }
     return [...paths].sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
 }
+async function resolveHeadMaterial(cwd) {
+    const commit = await tryResolveCommit(cwd, "HEAD");
+    if (commit !== undefined)
+        return commit;
+    try {
+        await execFileAsync("git", ["rev-parse", "--verify", "--quiet", "HEAD"], { cwd, encoding: "buffer", maxBuffer: 16 * 1024 * 1024 });
+    }
+    catch (error) {
+        if (error.code === 1)
+            return "";
+        throw error;
+    }
+    throw new Error("Git HEAD identity is unavailable or invalid");
+}
 export function createProductionMergerGitState(repositoryRoot = process.cwd()) {
     return {
         async activeMerge() {
-            const targetObjectId = line(await git(repositoryRoot, ["rev-parse", "--verify", "HEAD"]), "Git HEAD");
-            let mergeHeadRaw;
-            try {
-                mergeHeadRaw = await git(repositoryRoot, ["rev-parse", "--verify", "MERGE_HEAD"]);
-            }
-            catch {
-                throw new Error("Assigned repository does not have one ordinary in-progress merge");
+            await requireInsideWorkTree(repositoryRoot);
+            const targetObjectId = await resolveHeadMaterial(repositoryRoot);
+            const mergeHeadReported = line(await git(repositoryRoot, ["rev-parse", "--git-path", "MERGE_HEAD"]), "Git MERGE_HEAD path");
+            const mergeHeadPath = isAbsolute(mergeHeadReported) ? mergeHeadReported : resolve(repositoryRoot, mergeHeadReported);
+            let sourceObjectId = "";
+            if (await pathExists(mergeHeadPath)) {
+                const raw = exactUtf8(await readFile(mergeHeadPath), "Git MERGE_HEAD");
+                const mergeHeads = raw.trim().split(/\r?\n/).map((row) => row.trim()).filter(Boolean);
+                if (mergeHeads.length === 0)
+                    throw new Error("Git MERGE_HEAD is empty");
+                if (mergeHeads.length !== 1)
+                    throw new Error("Assigned repository does not have one ordinary in-progress merge");
+                const source = mergeHeads[0];
+                if (!isFullGitObjectId(source))
+                    throw new Error("Git MERGE_HEAD identity is unavailable or invalid");
+                const resolved = await tryResolveCommit(repositoryRoot, source);
+                if (resolved === undefined || (targetObjectId !== "" && resolved.length !== targetObjectId.length)) {
+                    throw new Error("Git MERGE_HEAD identity is unavailable or invalid");
+                }
+                sourceObjectId = resolved;
             }
-            const mergeHeads = exactUtf8(mergeHeadRaw, "Git MERGE_HEAD").trim().split(/\r?\n/).filter(Boolean);
-            if (mergeHeads.length !== 1 || !isFullGitObjectId(targetObjectId) || !isFullGitObjectId(mergeHeads[0]) || targetObjectId.length !== mergeHeads[0].length)
-                throw new Error("Assigned repository does not have one ordinary in-progress merge");
-            let automaticMergeTreeRaw;
-            try {
-                automaticMergeTreeRaw = await git(repositoryRoot, ["rev-parse", "--verify", "AUTO_MERGE^{tree}"]);
-            }
-            catch {
-                throw new Error("Git automatic merge tree identity is unavailable or invalid");
-            }
-            const automaticMergeTreeId = line(automaticMergeTreeRaw, "Git automatic merge tree");
-            if (!isFullGitObjectId(automaticMergeTreeId) || automaticMergeTreeId.length !== targetObjectId.length)
-                throw new Error("Git automatic merge tree identity is unavailable or invalid");
-            return { targetObjectId, sourceObjectId: mergeHeads[0], unmergedPaths: await unmerged(repositoryRoot), automaticMergeTreeId };
-        },
-        async completedMerge(mergeCommitId, automaticMergeTreeId) {
-            if (!isFullGitObjectId(mergeCommitId) || !isFullGitObjectId(automaticMergeTreeId) || mergeCommitId.length !== automaticMergeTreeId.length)
-                throw new Error("Merger completion object ID is invalid");
-            const identity = exactUtf8(await git(repositoryRoot, ["show", "-s", "--format=%H%x00%P", mergeCommitId]), "Git merge commit").trimEnd().split("\0");
-            if (identity.length !== 2 || identity[0] !== mergeCommitId)
-                throw new Error("Git merge completion identity drifted");
-            const parentObjectIds = identity[1].split(" ").filter(Boolean);
-            const currentHead = line(await git(repositoryRoot, ["rev-parse", "--verify", "HEAD"]), "Git HEAD");
-            const status = await git(repositoryRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
-            const frozenTree = line(await git(repositoryRoot, ["rev-parse", "--verify", `${automaticMergeTreeId}^{tree}`]), "Git frozen automatic merge tree");
-            if (frozenTree !== automaticMergeTreeId)
-                throw new Error("Git frozen automatic merge tree identity drifted");
-            const mergeTree = line(await git(repositoryRoot, ["rev-parse", "--verify", `${mergeCommitId}^{tree}`]), "Git completed merge tree");
-            const resolutionChangedPaths = nulPaths(await git(repositoryRoot, ["diff-tree", "--no-commit-id", "--name-only", "-r", "-z", "--no-renames", automaticMergeTreeId, mergeTree]), "Git resolution path delta");
-            return { mergeCommitId: currentHead, parentObjectIds, unmergedPaths: await unmerged(repositoryRoot), worktreeClean: status.byteLength === 0 && currentHead === mergeCommitId, resolutionChangedPaths };
+            return { targetObjectId, sourceObjectId, unmergedPaths: await unmerged(repositoryRoot) };
         },
     };
 }

package/dist/merger-role.js

@@ -1,16 +1,22 @@
-import { MERGER_ACCEPTED_TEXT, MERGER_OUTPUT_TOOL_NAME, mergerOutputSchema, validateMergerInput, validateMergerOutput } from "./merger-contracts.js";
+import { MERGER_ACCEPTED_TEXT, MERGER_OUTPUT_TOOL_NAME, mergerOutputSchema, validateMergerInput, } from "./merger-contracts.js";
 import { exactUtf8 } from "./exact-utf8.js";
-import { isFullGitObjectId } from "./git-object-id.js";
 export { MERGER_OUTPUT_TOOL_NAME };
-export const MERGER_INPUT_FLAG = { name: "ak-merger-input", definition: { description: "Path to an immutable digest-bound Merger v1 input JSON file", type: "string" } };
-function same(a, b) { return a.length === b.length && a.every((value, i) => value === b[i]); }
-function materialText(input, key) { return exactUtf8(Buffer.from(input.materials[key].bytesBase64, "base64"), `Merger ${key}`); }
-export function createMergerRoleRuntime(pi, dependencies, host) {
+export const MERGER_INPUT_FLAG = { name: "ak-merger-input", definition: { description: "Path to Merger assignment materials JSON", type: "string" } };
+function materialText(input, key) {
+    return exactUtf8(Buffer.from(input.materials[key].bytesBase64, "base64"), `Merger ${key}`);
+}
+/**
+ * Merger (校书郎) role runtime.
+ * Code admits one submission and terminates the round (第 0 条).
+ * Git state / completion verification are not attendance or rejection gates (#827).
+ */
+export function createMergerRoleRuntime(pi, dependencies) {
     let activation;
     let registered = false;
     let accepted = false;
     pi.registerFlag(MERGER_INPUT_FLAG.name, MERGER_INPUT_FLAG.definition);
-    return { async activate() {
+    return {
+        async activate() {
             const path = pi.getFlag(MERGER_INPUT_FLAG.name);
             if (typeof path !== "string" || path.trim().length === 0)
                 throw new Error("Merger requires --ak-merger-input");
@@ -18,49 +24,32 @@ export function createMergerRoleRuntime(pi, dependencies, host) {
             if (!soul)
                 throw new Error("Merger soul is empty");
             const input = validateMergerInput(await dependencies.loadInput(path));
-            const state = await dependencies.gitState.activeMerge();
-            if (state.targetObjectId !== input.targetObjectId || state.sourceObjectId !== input.sourceObjectId || !same(state.unmergedPaths, input.expectedConflictPaths) || state.unmergedPaths.length === 0 || !isFullGitObjectId(state.automaticMergeTreeId) || state.automaticMergeTreeId.length !== input.targetObjectId.length)
-                throw new Error("Merger activation rejected repository parent, merge, automatic-result, or complete conflict-set drift");
-            activation = { soul, input, automaticMergeTreeId: state.automaticMergeTreeId };
+            activation = { soul, input };
             accepted = false;
             if (!registered) {
                 registered = true;
-                pi.registerTool({ name: MERGER_OUTPUT_TOOL_NAME, label: "合并输出", description: "提交合并结果；输出分支为 completed 与 escalate；基础设施及 Git 失败由 abort 通道承接。", promptSnippet: "提交合并结果", parameters: mergerOutputSchema,
-                    async execute(id, params, _signal, _update, ctx) {
+                pi.registerTool({
+                    name: MERGER_OUTPUT_TOOL_NAME, label: "合并输出", description: "提交合并结果；输出分支为 completed 与 escalate。", promptSnippet: "提交合并结果", parameters: mergerOutputSchema,
+                    async execute(_id, params, _signal, _update, _ctx) {
                         if (!activation)
                             throw new Error("校书郎未激活");
                         if (accepted)
                             throw new Error("合并回执已受理");
-                        let output;
-                        try {
-                            output = validateMergerOutput(params, activation.input.attemptId);
-                        }
-                        catch (error) {
-                            host.failInfrastructure(error, ctx, id);
-                        }
-                        if (output.status === "completed") {
-                            let state;
-                            try {
-                                state = await dependencies.gitState.completedMerge(output.mergeCommitId, activation.automaticMergeTreeId);
-                            }
-                            catch (error) {
-                                host.failInfrastructure(error, ctx, id);
-                            }
-                            const scope = new Set(activation.input.resolutionScope);
-                            if (state.mergeCommitId !== output.mergeCommitId || !same(state.parentObjectIds, [activation.input.targetObjectId, activation.input.sourceObjectId]) || state.unmergedPaths.length !== 0 || !state.worktreeClean || state.resolutionChangedPaths.some(path => !scope.has(path)))
-                                host.failInfrastructure(new Error("Merger completed-state verification failed"), ctx, id);
-                        }
                         accepted = true;
-                        const acceptedDetails = output;
-                        return { content: [{ type: "text", text: MERGER_ACCEPTED_TEXT }], details: acceptedDetails, terminate: true };
-                    } });
-                pi.on("before_agent_start", (event) => { if (!activation)
-                    throw new Error("校书郎未激活"); const admitted = { attemptId: activation.input.attemptId, targetObjectId: activation.input.targetObjectId, sourceObjectId: activation.input.sourceObjectId, task: materialText(activation.input, "task"), authority: materialText(activation.input, "authority"), targetIntent: materialText(activation.input, "targetIntent"), sourceIntent: materialText(activation.input, "sourceIntent"), expectedConflictPaths: activation.input.expectedConflictPaths, resolutionScope: activation.input.resolutionScope, authorizedChecks: activation.input.authorizedChecks }; return { systemPrompt: `${event.systemPrompt}\n\n<merger_soul>\n${activation.soul}\n</merger_soul>\n\n<merger_assignment>\n${JSON.stringify(admitted)}\n</merger_assignment>` }; });
+                        return { content: [{ type: "text", text: MERGER_ACCEPTED_TEXT }], details: params, terminate: true };
+                    },
+                });
+                pi.on("before_agent_start", (event) => {
+                    if (!activation)
+                        throw new Error("校书郎未激活");
+                    const admitted = { attemptId: activation.input.attemptId, targetObjectId: activation.input.targetObjectId, sourceObjectId: activation.input.sourceObjectId, task: materialText(activation.input, "task"), authority: materialText(activation.input, "authority"), targetIntent: materialText(activation.input, "targetIntent"), sourceIntent: materialText(activation.input, "sourceIntent"), expectedConflictPaths: activation.input.expectedConflictPaths, resolutionScope: activation.input.resolutionScope, authorizedChecks: activation.input.authorizedChecks };
+                    return { systemPrompt: `${event.systemPrompt}\n\n<merger_soul>\n${activation.soul}\n</merger_soul>\n\n<merger_assignment>\n${JSON.stringify(admitted)}\n</merger_assignment>` };
+                });
             }
-            // Host-neutral AK output only (ADR 0018 fail-closed); no host-builtin name hard-require.
-            const all = pi.getAllTools().map(tool => tool.name);
-            if (all.filter(item => item === MERGER_OUTPUT_TOOL_NAME).length !== 1) {
+            const all = pi.getAllTools().map((tool) => tool.name);
+            if (all.filter((item) => item === MERGER_OUTPUT_TOOL_NAME).length !== 1) {
                 throw new Error(`Merger required tool collision or missing: ${MERGER_OUTPUT_TOOL_NAME}`);
             }
-        } };
+        },
+    };
 }

package/dist/public-cli/invocation.js

@@ -299,16 +299,6 @@ function parseInstructionArgv(args, owner) {
         ...(sourceRun === undefined ? {} : { sourceRun }),
     };
 }
-/** Honest activation-class failure while deriving the active-merge envelope. */
-export class MergerEnvelopeDerivationError extends Error {
-    code = "merger-envelope-derivation";
-    /** Typed cause for #107 classifyPostAdmissionFailure (isTypedActivationError). */
-    knownCause = "activation";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "MergerEnvelopeDerivationError";
-    }
-}
 /** Reject missing/blank path values so empty overrides cannot silently degrade. */
 function requireOptionPath(flag, value) {
     if (value === undefined || value.trim() === "") {
@@ -1875,7 +1865,7 @@ export function parseMergerArgv(args) {
             token.startsWith("--expectedConflictPaths=") ||
             token === "--resolutionScope" ||
             token.startsWith("--resolutionScope=")) {
-            throw new CliUsageError("merger does not accept public packet fields; the adapter derives the active-merge envelope");
+            throw new CliUsageError("merger does not accept public packet fields; the adapter reads Git merge materials");
         }
         if (token.startsWith("-") && token !== "-") {
             throw new CliUsageError(`unknown merger option: ${token}`);
@@ -1897,39 +1887,26 @@ function mergerMaterialFromUtf8(text) {
     });
 }
 /**
- * Derive the mechanical Merger envelope from an already-active ordinary merge.
- * Uses the production Git seam (HEAD, sole MERGE_HEAD, AUTO_MERGE, unmerged set).
- * Failures are activation-class facts — not CLI semantic guesses.
+ * Read merger materials from current Git state.
+ * No in-progress merge / empty conflict set still yields materials (possibly empty);
+ * code does not gate attendance on merge state (#827).
  */
 export async function deriveMergerEnvelopeFromActiveMerge(projectRoot, gitState = createProductionMergerGitState(projectRoot)) {
-    let state;
-    try {
-        state = await gitState.activeMerge();
-    }
-    catch (error) {
-        const message = error instanceof Error && error.message.trim() !== ""
-            ? error.message
-            : "Assigned repository does not have one ordinary in-progress merge";
-        throw new MergerEnvelopeDerivationError(message, { cause: error });
-    }
-    if (state.unmergedPaths.length === 0) {
-        throw new MergerEnvelopeDerivationError("Assigned repository does not have one ordinary in-progress merge with a complete conflict set");
-    }
+    const state = await gitState.activeMerge();
     const expectedConflictPaths = Object.freeze([...state.unmergedPaths]);
-    // Scope is derived as the complete conflict set; the role may not broaden it.
     const resolutionScope = Object.freeze([...state.unmergedPaths]);
     return Object.freeze({
         targetObjectId: state.targetObjectId,
         sourceObjectId: state.sourceObjectId,
-        automaticMergeTreeId: state.automaticMergeTreeId,
         expectedConflictPaths,
         resolutionScope,
     });
 }
 /**
  * Admit a Merger Role run on the common Invocation request.
- * Mechanical envelope (parents, AUTO_MERGE, conflicts, scope) is derived from
- * the active merge — callers never supply public packet fields for those facts.
+ * Git materials (parents, conflicts, scope) are read from the worktree and
+ * handed to the role as assignment materials — including when empty (#827).
+ * Callers never supply public packet fields for those facts.
  */
 export async function admitMergerInvocation(options) {
     if (options.project !== undefined) {
@@ -1940,8 +1917,6 @@ export async function admitMergerInvocation(options) {
         throw new CliUsageError("merger requires a nonblank task instruction");
     }
     const projectRoot = resolve(options.project ?? options.cwd);
-    // Derive mechanical envelope before placing a run identity so no-merge/drift
-    // fails honestly without orphan ledger rows or guessed packet fields.
     const derived = await deriveMergerEnvelopeFromActiveMerge(projectRoot, options.gitState ?? createProductionMergerGitState(projectRoot));
     const runId = (options.createRunId ?? uuidv7)();
     const { principal, sessionDirectory, sessionFile, runDirectory, ledgerHome, bookKey, } = issueAdmissionPlacement(options.principalAuthority, {
@@ -1955,13 +1930,13 @@ export async function admitMergerInvocation(options) {
     ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
     const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
     // Intent materials seed primary-source investigation; the method owns the work.
-    const targetIntent = mergerMaterialFromUtf8(`Investigate primary sources for target parent ${derived.targetObjectId}. Do not invent intent.`);
-    const sourceIntent = mergerMaterialFromUtf8(`Investigate primary sources for source parent ${derived.sourceObjectId}. Do not invent intent.`);
+    const targetLabel = derived.targetObjectId === "" ? "(none observed)" : derived.targetObjectId;
+    const sourceLabel = derived.sourceObjectId === "" ? "(none observed)" : derived.sourceObjectId;
+    const targetIntent = mergerMaterialFromUtf8(`Investigate primary sources for target parent ${targetLabel}. Do not invent intent.`);
+    const sourceIntent = mergerMaterialFromUtf8(`Investigate primary sources for source parent ${sourceLabel}. Do not invent intent.`);
     const taskMaterial = mergerMaterialFromUtf8(instruction);
     const authorityMaterial = mergerMaterialFromUtf8(instruction);
-    // Validate merger envelope before placing admitted identity.
     const mergerInput = validateMergerInput({
-        version: 1,
         attemptId: runId,
         targetObjectId: derived.targetObjectId,
         sourceObjectId: derived.sourceObjectId,
@@ -1973,7 +1948,6 @@ export async function admitMergerInvocation(options) {
         },
         expectedConflictPaths: [...derived.expectedConflictPaths],
         resolutionScope: [...derived.resolutionScope],
-        // Authorized checks remain available on the assignment; default none.
         authorizedChecks: [],
     });
     const mergerInputPath = join(runDirectory, "merger-input.json");
@@ -1991,7 +1965,6 @@ export async function admitMergerInvocation(options) {
         derived: {
             targetObjectId: derived.targetObjectId,
             sourceObjectId: derived.sourceObjectId,
-            automaticMergeTreeId: derived.automaticMergeTreeId,
             expectedConflictPaths: [...derived.expectedConflictPaths],
             resolutionScope: [...derived.resolutionScope],
         },