@akagilnc/pi-workflow-roles 0.1.3749 → 0.1.3771

package/dist/public-cli/option-definitions.js

@@ -450,12 +450,13 @@ const COLLECTOR_OPTIONS = [
         canonical: "--pr",
         aliases: [],
         valueMetavar: "number",
-        required: true,
+        // #676 D1: optional when context uniquely determines the PR; ambiguous → require explicit.
+        required: false,
         repeatable: false,
         form: "option",
         description: {
-            en: "Required positive GitHub pull request number.",
-            zh: "必填；正整数 GitHub PR 号。",
+            en: "Positive GitHub pull request number. Optional when unique branch/HEAD association binds the PR, or when the Collector role can decide the target from task materials via bind-target; multi-candidate git context or a role that cannot decide requires an explicit value.",
+            zh: "正整数 GitHub PR 号。分支/HEAD 唯一关联可绑定时可省略；亦可由通进司从任务材料经 bind-target 判定。git 多候选或角色无法判定时必须显式提供。",
         },
     },
     {
@@ -971,9 +972,10 @@ const ROLE_COMMAND_HELP = {
     collector: {
         command: "collector",
         summary: "Collect GitHub PR review evidence.",
-        usage: ["ak-role collector --pr <number> [options] [instruction]"],
+        usage: ["ak-role collector [--pr <number>] [options] [instruction]"],
         examples: [
             "ak-role collector --pr 42 --repo owner/repository",
+            "ak-role collector --repo owner/repository \"Collect findings for #42\"",
             "ak-role collector --pr 42 --request-manifest ./requests.json",
         ],
     },

package/dist/public-cli/run-lifecycle.js

@@ -1313,8 +1313,8 @@ export async function loadResumableCollectorRun(home, runId, authority) {
         throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not collector`);
     }
     const { prNumber, repository, repositoryDisplay, manifestDigest } = loaded.admittedFields;
-    if (prNumber === undefined ||
-        repository === undefined ||
+    // #676 A: prNumber may be unbound at admission (role bind-target). Repository is required.
+    if (repository === undefined ||
         repositoryDisplay === undefined ||
         manifestDigest === undefined) {
         throw new CliUsageError(`role run admitted collector repository identity is missing: ${runId}`);
@@ -1333,7 +1333,7 @@ export async function loadResumableCollectorRun(home, runId, authority) {
     const admitted = {
         role: "collector",
         ...resumedBaseAdmitted(loaded),
-        prNumber,
+        ...(prNumber === undefined ? {} : { prNumber }),
         repository: parsedRepository,
         ...(loaded.admittedFields.requestManifestPath === undefined
             ? {}

package/dist/public-cli/settlement.js

@@ -19,7 +19,7 @@ import { RESUME_TRANSPORT_ENVELOPE, isV1ResumableProvider, readLatestTypedProvid
 import { AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE, AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, COMPLIANCE_RESPONSE_ENTRY_TYPE, readComplianceCandidate, } from "../compliance-transport.js";
 // COMPLIANCE_RESPONSE_ENTRY_TYPE remains for boundRetainedAuditResponse (call/result
 // interval binding on historical session bytes). Provider-stop retain authority is Sitian.
-import { COLLECTOR_OBSERVE_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, } from "../collector-ledger.js";
+import { COLLECTOR_BIND_TARGET_TOOL, COLLECTOR_OBSERVE_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, } from "../collector-ledger.js";
 import { ENGINE_DETOUR_TOOL_NAME } from "../engine-detour.js";
 import { JUDGE_OUTPUT_TOOL_NAME, } from "../package-contracts/judge-output.js";
 import { COLLECTOR_OUTPUT_TOOL, } from "../package-contracts/collector-output.js";
@@ -183,9 +183,34 @@ export function formatFailureStderrDiagnostic(failure) {
         .find((line) => line.length > 0) ?? "failure";
     return formatCliDiagnostic(boundConciseDiagnostic(oneLine));
 }
-/** Pre-admission structural rejection: stderr only, no run, no Terminal. */
+/**
+ * #676 B: one cause face for public stderr — Error.message, else object JSON with
+ * status/body/headers when present, else String. Never wash objects to [object Object].
+ */
+export function formatErrorCauseDetail(cause) {
+    if (cause instanceof Error)
+        return cause.message;
+    if (typeof cause === "object" && cause !== null) {
+        try {
+            return JSON.stringify(cause);
+        }
+        catch {
+            return String(cause);
+        }
+    }
+    return String(cause);
+}
+/** Pre-admission structural rejection: stderr only, no run, no Terminal. Cause retained when present. */
 export function presentStructuralRejection(error, io) {
-    io.stderr(formatCliDiagnostic(error.message));
+    let message = error.message;
+    const cause = error.cause;
+    if (cause !== undefined) {
+        const detail = formatErrorCauseDetail(cause);
+        if (detail.trim().length > 0) {
+            message = `${message}; cause: ${detail}`;
+        }
+    }
+    io.stderr(formatCliDiagnostic(message));
 }
 /** ControlledFailure face without admitted-run Terminal (stdout body + stderr line). */
 export function presentControlledFailure(failure, io) {
@@ -1093,6 +1118,35 @@ function toolResultText(message) {
         .join("")
         .trim();
 }
+/**
+ * #676 D1/J3: durable bind-target rejection on the current attempt → public no_receipt facts.
+ * Callers must learn they need explicit --pr without opening the session 正本.
+ * Authority is the latest bind-target toolResult only — a later success clears an earlier failure.
+ */
+function extractCollectorTargetBindRejection(entries) {
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry?.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message?.role !== "toolResult")
+            continue;
+        if (message.toolName !== COLLECTOR_BIND_TARGET_TOOL)
+            continue;
+        // Latest bind result wins: success means the attempt is no longer rejected.
+        if (message.isError !== true)
+            return undefined;
+        const diagnostic = toolResultText(message);
+        if (diagnostic.length === 0)
+            return undefined;
+        const details = message.details;
+        const code = isRecord(details) && typeof details.code === "string" && details.code.trim() !== ""
+            ? details.code
+            : undefined;
+        return code === undefined ? { diagnostic } : { diagnostic, code };
+    }
+    return undefined;
+}
 function boundErroredToolCandidate(entries, resultIndex, message, toolName) {
     if (message.toolName !== toolName || message.isError !== true)
         return undefined;
@@ -1208,7 +1262,9 @@ export function assertCollectorReceiptMatchesAdmitted(receipt, admitted) {
     if (receipt.repository !== admitted.repository.canonical) {
         throw collectorReceiptBindingFailure(`Collector receipt repository "${receipt.repository}" does not match admitted repository "${admitted.repository.canonical}"`);
     }
-    if (receipt.prNumber !== admitted.prNumber) {
+    // #676 A: when admission left the target unbound, receipt.prNumber is the role bind.
+    // When admission bound explicitly/head-commit, receipt must match.
+    if (admitted.prNumber !== undefined && receipt.prNumber !== admitted.prNumber) {
         throw collectorReceiptBindingFailure(`Collector receipt prNumber ${receipt.prNumber} does not match admitted prNumber ${admitted.prNumber}`);
     }
     if (receipt.manifestDigest !== admitted.manifestDigest) {
@@ -1994,7 +2050,7 @@ export async function publishCollectorArtifacts(admitted, roleOutcome, coordinat
     await writeFile(evidencePath, `${JSON.stringify({
         runId: admitted.runId,
         role: "collector",
-        prNumber: admitted.prNumber,
+        ...(admitted.prNumber === undefined ? {} : { prNumber: admitted.prNumber }),
         repository: admitted.repository.canonical,
         manifestDigest: admitted.manifestDigest,
         sessionDirectory: coordinates.sessionDirectory,
@@ -2841,7 +2897,19 @@ export async function settleFailureTerminalResult(admitted, failure, authority,
                 try {
                     const facts = parseNoReceiptLifecycleFacts(raw);
                     if (facts.runPointer === admitted.runDirectory && facts.attemptPointer === `current:${admitted.runDirectory}`) {
-                        const decisiveFacts = facts;
+                        let decisiveFacts = facts;
+                        // #676 D1/J3: project durable bind-target rejection onto public no_receipt facts.
+                        if (admitted.role === "collector") {
+                            const bindRejection = extractCollectorTargetBindRejection(entries.slice(attemptStart));
+                            if (bindRejection !== undefined) {
+                                decisiveFacts = {
+                                    ...facts,
+                                    targetBindRejected: true,
+                                    targetBindDiagnostic: bindRejection.diagnostic,
+                                    ...(bindRejection.code === undefined ? {} : { targetBindCode: bindRejection.code }),
+                                };
+                            }
+                        }
                         // #478: no_receipt is still a public Terminal — project accepted gate facts.
                         return withOptionalGateProjection({
                             roleOutcome: { kind: "no_receipt", role: admitted.role, status: "no-accepted-receipt", ...facts, decisiveFacts },
@@ -2927,6 +2995,15 @@ export function presentFailureTerminal(terminal, io) {
             cause: terminal.roleOutcome.cause,
             diagnostic: terminal.roleOutcome.diagnostic,
         }));
+        return;
+    }
+    // #676 D1/J3: no_receipt stays lawful exit 0; surface durable target-bind clarification on stderr.
+    const bindDiagnostic = terminal.roleOutcome.decisiveFacts.targetBindDiagnostic;
+    if (typeof bindDiagnostic === "string" && bindDiagnostic.trim() !== "") {
+        io.stderr(formatFailureStderrDiagnostic({
+            cause: "output",
+            diagnostic: bindDiagnostic,
+        }));
     }
 }
 function defaultNavigatorGraceSleep() {

package/dist/role-runtime.js

@@ -14,7 +14,7 @@ import { createToolExecutionObservationFace, systemToolExecutionObservationMonoN
 import { ENGINE_DETOUR_TOOL_NAME } from "./engine-detour.js";
 import { registerEngineDetourTool } from "./engine-detour-tool.js";
 import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT } from "./receipt-delivery-policy.js";
-import { COLLECTOR_OBSERVE_TOOL, COLLECTOR_OUTPUT_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, createCollectorRoleRuntime, } from "./collector-role.js";
+import { COLLECTOR_REQUIRED_TOOLS, COLLECTOR_TRANSPORT_FLAGS, createCollectorRoleRuntime, } from "./collector-role.js";
 import { createDoctorRoleRuntime } from "./doctor-role.js";
 import { createNotaryRoleRuntime, NOTARY_SESSION_BOUND_ENTRY, projectNotaryBoundFromFlags, readNotaryTicketFlag, } from "./notary-role.js";
 import { NOTARY_TICKET_FLAG } from "./notary-contracts.js";
@@ -670,6 +670,10 @@ export function createRoleRuntimeExtension(dependencies) {
         for (const flag of GLEANER_LEFT_TRANSPORT_FLAGS) {
             roleHost.registerFlag(flag.name, flag.definition);
         }
+        // Collector transport flags: shared envelope owns registration (ADR 0018 / #676 E).
+        for (const flag of COLLECTOR_TRANSPORT_FLAGS) {
+            roleHost.registerFlag(flag.name, flag.definition);
+        }
         let admitted = false;
         let selectedRole;
         /** Live Reviewer parent activation for envelope agent_start prompt assembly. */
@@ -818,11 +822,36 @@ export function createRoleRuntimeExtension(dependencies) {
                     }),
                 };
             }
+            // #676 E / J1: collector materials + drift gates share this envelope hook (no parallel register).
+            if (role === "collector" && activeCollector !== undefined) {
+                const options = event.systemPromptOptions;
+                if (options.skills && options.skills.length > 0) {
+                    failInfrastructure(activeCollector.ledger.latchFatal("通进司检测到系统提示中的环境 skills"), ctx);
+                }
+                if (options.contextFiles && options.contextFiles.length > 0) {
+                    failInfrastructure(activeCollector.ledger.latchFatal("通进司检测到系统提示中的环境 context files"), ctx);
+                }
+                if (typeof options.appendSystemPrompt === "string"
+                    && options.appendSystemPrompt.trim().length > 0) {
+                    failInfrastructure(activeCollector.ledger.latchFatal("通进司检测到 appendSystemPrompt 漂移"), ctx);
+                }
+                if (!collectorFirstDispatchDone) {
+                    collectorFirstDispatchDone = true;
+                    activeCollector.ledger.recordActivation(activeCollector.clock);
+                }
+                return {
+                    systemPrompt: collectorBusiness.assembleMaterials(activeCollector, event.systemPrompt),
+                };
+            }
         });
         roleHost.on("tool_result", async (event) => {
             const role = selectedRole;
             if (role === undefined)
                 return;
+            // #676 E / J1: collector operational bookkeeping on the shared tool_result seam.
+            if (role === "collector" && activeCollector !== undefined) {
+                collectorBusiness.onToolResult(activeCollector, event);
+            }
             const pendingInfra = pendingInfrastructureFailures.get(event.toolCallId);
             const isRoleInfrastructureFailure = pendingInfra !== undefined;
             if (pendingInfra !== undefined)
@@ -961,6 +990,14 @@ export function createRoleRuntimeExtension(dependencies) {
                 priorFetch = undefined;
                 fetchWrapped = false;
             }
+            // #676 J4: collector fatal latch must surface nonzero exit on shutdown (envelope-owned).
+            if (selectedRole === "collector"
+                && activeCollector !== undefined
+                && activeCollector.ledger.fatal) {
+                if (process.exitCode === undefined || process.exitCode === 0) {
+                    process.exitCode = 1;
+                }
+            }
             // Flush any still-pending affirmative attendance before teardown. Accepted
             // grace-timeout paths normally emit on agent_settled; abort can skip that hook.
             const presentation = pendingNavigatorPresentation;
@@ -1150,7 +1187,11 @@ export function createRoleRuntimeExtension(dependencies) {
                     throw new Error("Merger runtime dependencies are not configured"); return sessionMergerGitState.completedMerge(mergeCommitId, automaticMergeTreeId); },
             },
         }, hostActions);
-        const collector = createCollectorRoleRuntime(roleHost, {
+        // #676 E: shared envelope owns collector lifecycle (mode/fork, tool surface,
+        // event gates). Role module supplies business activate/tools/materials only.
+        let activeCollector;
+        let collectorFirstDispatchDone = false;
+        const collectorBusiness = createCollectorRoleRuntime(roleHost, {
             async loadSoul() {
                 if (dependencies.loadCollectorSoul === undefined) {
                     throw new Error("collector soul loader is not configured");
@@ -1182,12 +1223,101 @@ export function createRoleRuntimeExtension(dependencies) {
             ...(dependencies.createCollectorClock === undefined
                 ? {}
                 : { createClock: dependencies.createCollectorClock }),
-            ...(dependencies.collectorPackageExtensionPath === undefined
-                ? {}
-                : {
-                    packageExtensionPath: dependencies.collectorPackageExtensionPath,
-                }),
         }, hostActions);
+        // #676 J1: business tools + tool_call gate register only behind admission/activation.
+        // before_agent_start / tool_result collector branches live on the shared envelope hooks above.
+        //
+        // #676 J4 dispositions for guards removed from the role-private collector module:
+        // - skills/contextFiles/appendSystemPrompt fail-closed → shared before_agent_start (above).
+        // - ambient skill/prompt/template commands → activate (below).
+        // - session_shutdown fatal exitCode → shared session_shutdown (above).
+        // - subsequent-input latchFatal + fixed-kickoff rewrite → intentionally not migrated:
+        //   #676 materials-first multi-turn abolished the single-shot fixed kickoff; multi-turn
+        //   observe/request/wait requires later inputs. Judge r1: fixed-kickoff equality delete is authorized.
+        // - tool sourceInfo path override check → intentionally not migrated: depended on
+        //   packageExtensionPath deleted under ADR 0018 / #676 E envelope ownership; uniqueness
+        //   + setActiveTools inventory checks remain on activate.
+        let collectorToolCallRegistered = false;
+        const collector = {
+            async activate(context, event) {
+                activeCollector = undefined;
+                collectorFirstDispatchDone = false;
+                // Envelope-owned mode / fork-reload gates (not role-private lifecycle).
+                if (context.mode !== "print" && context.mode !== "json") {
+                    throw new Error(`Collector supports only print or json mode (got ${context.mode})`);
+                }
+                if (event.reason === "fork" || event.reason === "reload") {
+                    throw new Error(`Collector does not support session_start reason ${event.reason}`);
+                }
+                // #676 J4: ambient skill/prompt/template commands fail closed at activation.
+                const commands = roleHost.getCommands?.() ?? [];
+                const ambientCommands = commands.filter((command) => {
+                    const name = command.name.toLowerCase();
+                    return (name.includes("skill")
+                        || name.includes("prompt")
+                        || name.startsWith("template"));
+                });
+                if (ambientCommands.length > 0) {
+                    throw new Error(`Collector detected ambient instruction commands: ${ambientCommands.map((c) => c.name).join(", ")}`);
+                }
+                // Business tools behind admission barrier (inert-without-role invariant).
+                // First activation: fail closed if a required name is already occupied.
+                // Later activations reuse the once-registered tools (registerBusinessTools is idempotent).
+                const preExisting = roleHost.getAllTools();
+                const alreadyRegistered = COLLECTOR_REQUIRED_TOOLS.every((required) => preExisting.some((tool) => tool.name === required));
+                if (!alreadyRegistered) {
+                    for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                        const prior = preExisting.filter((tool) => tool.name === required);
+                        if (prior.length > 0) {
+                            throw new Error(`Collector required tool name collision: ${required}`);
+                        }
+                    }
+                }
+                collectorBusiness.registerBusinessTools(() => activeCollector);
+                const allTools = roleHost.getAllTools();
+                for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                    const matches = allTools.filter((tool) => tool.name === required);
+                    if (matches.length === 0) {
+                        throw new Error(`Collector required tool missing: ${required}`);
+                    }
+                    if (matches.length > 1) {
+                        throw new Error(`Collector required tool name collision: ${required}`);
+                    }
+                }
+                roleHost.setActiveTools([...COLLECTOR_REQUIRED_TOOLS]);
+                const active = new Set(roleHost.getActiveTools());
+                for (const required of COLLECTOR_REQUIRED_TOOLS) {
+                    if (!active.has(required)) {
+                        throw new Error(`Collector failed to activate required tool ${required}`);
+                    }
+                }
+                for (const name of active) {
+                    if (!COLLECTOR_REQUIRED_TOOLS.includes(name)) {
+                        throw new Error(`Collector active tool surface includes unexpected ${name}`);
+                    }
+                }
+                // Seat-scoped tool_call gate — registered only after collector admission (no install-time tool_call).
+                if (!collectorToolCallRegistered) {
+                    collectorToolCallRegistered = true;
+                    roleHost.on("tool_call", (toolEvent) => {
+                        if (activeCollector === undefined || selectedRole !== "collector")
+                            return;
+                        if (!COLLECTOR_REQUIRED_TOOLS.includes(toolEvent.toolName)) {
+                            return {
+                                block: true,
+                                reason: `通进司禁用工具 ${toolEvent.toolName}`,
+                            };
+                        }
+                        return collectorBusiness.onToolCall(activeCollector, toolEvent);
+                    });
+                }
+                const activation = await collectorBusiness.activate(context);
+                if (activation.ledger.activationRecorded) {
+                    collectorFirstDispatchDone = true;
+                }
+                activeCollector = activation;
+            },
+        };
         const clock = dependencies.activationClock ?? (() => new Date().toISOString());
         const writeTrace = dependencies.activationTraceWriter ?? writeActivationTraceRecord;
         const observationFace = createToolExecutionObservationFace({

package/dist/submission-correctable-error.js

@@ -20,3 +20,27 @@ export function isCorrectableExecuteError(error) {
         || error instanceof WorkerPrefixReminderError
         || error instanceof WorkerUnfinishedReasonReminderError);
 }
+/**
+ * One authority for correctable execute → diagnostic text + structured details.
+ * Consumed by the ACP envelope tool catch; host adapters wrap transport shape only.
+ */
+export function projectCorrectableExecuteRejection(error) {
+    const diagnostic = error instanceof Error ? error.message : String(error);
+    if (error instanceof GatekeeperDecisionError) {
+        return { diagnostic, details: { ...error.result } };
+    }
+    if (error instanceof WorkerCommitReminderError
+        || error instanceof WorkerPrefixReminderError
+        || error instanceof WorkerUnfinishedReasonReminderError) {
+        return { diagnostic, details: { code: error.code } };
+    }
+    if (typeof error.code === "string") {
+        return { diagnostic, details: { code: error.code } };
+    }
+    return {
+        diagnostic,
+        details: {
+            code: error instanceof Error && error.name ? error.name : "correctable-submission-error",
+        },
+    };
+}

package/extensions/role-runtime.ts

@@ -123,7 +123,6 @@ export default function roleRuntime(pi: ExtensionAPI): void {
     createReviewerIssueFetcher: () => createGhIssueSoftFetcher(),
     loadCollectorSoul: () => loadMainRoleSessionMaterials("collector"),
     createCollectorTransport: () => createGhCollectorGitHubTransport(),
-    collectorPackageExtensionPath: extensionPath,
     loadDoctorSoul: () => loadMainRoleSessionMaterials("doctor"),
     loadDoctorCase,
     // #590: auditors / navigator / reviewer consume HostContext directly (no Pi WeakMap recover).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.3749",
+  "version": "0.1.3771",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/souls/coder.md

@@ -1,10 +1,15 @@
 # Coder Soul（将作监）
 
 你负责把已授权任务实现为可验证的第一版，不负责独立评审、发布或最终裁决。
+第一步：立法
+读 全局宪法，仓内宪法，票面
+第二步：施工
+先核对派单文，输入prompt，你要做的任务有没有违法，如有，直接拒绝
+事实不成立或需要未授权设计时，据理拒绝并给出可核验证据；不猜测施工。
 
-- 先核对任务、适用 authority、当前代码和历史；主张必须有当前事实支撑。
-- 做最小垂直切片，优先复用已有 seam；不造平行机制，不借机扩大 scope。
-- 计划与施工都要说明真实刀口、行为边界和验证方法，不用空泛完成声明代替证据。
-- 切片验证只跑本片聚焦测试与 typecheck。
-- 派单与 authority 冲突、事实不成立或需要未授权设计时，据理拒绝并给出可核验证据；不猜测施工。
-- 不 amend、rewrite 或 push。Git 变化是证据之一，不取代角色报告。
+核对当前代码和历史；主张必须有当前事实支撑。
+做最小垂直切片，优先复用已有 seam；不造平行机制，不借机扩大 scope。
+计划与施工都要说明真实刀口、行为边界和验证方法，不用空泛完成声明代替证据。
+切片验证只跑本片聚焦测试与 typecheck。
+不 amend、rewrite 或 push。Git 变化是证据之一，不取代角色报告。
+做完自查是否违法，质量和复杂度，如有问题马上修正，没问题就commit交卷

package/souls/fixer.md

@@ -1,14 +1,15 @@
-# 修内司
-
-你是修内司。修类不修点，点名位置只是样本。
+# 修内司 Soul
 
+你是修内司。修类不修点。
 apply 按顺序执行：
 
-1. **归类**：读完全部 finding，沿用已有裁决类别，明确各类错误与正确行为。
-2. **扫类**：修改前查全授权范围内的同类实例、已有实现和失败修法。根因不明先取证。
-3. **整类修复**：在共同原因处一次修净，优先删除、简化、复用，随同删除失效旧物。
-4. **复扫**：按原类别重新扫描；有遗漏继续修，保留项说明依据。
-5. **自验**：依质量法，从现有真实入口验证行为；不以任意失败或绿灯冒充证明。
-6. **交卷**：按类报告根因、扫描范围、修复与验证结果、未结项。保护已有改动，只建新提交。
+1. 立法：读 全局宪法，仓内宪法，票面。
+2. 核对：先核对派单文，输入prompt，你要做的任务。有没有违法，如有，直接拒绝。 事实不成立或需要未授权设计时，据理拒绝并给出可核验证据；不猜测施工。
+3. 归类：读完全部 finding，沿用已有裁决类别，明确各类错误与正确行为。
+4. 扫类：修改前查全授权范围内的同类实例、已有实现和失败修法。根因不明先取证。
+5. 整类修复：在共同原因处一次修净，优先删除、简化、复用，随同删除失效旧物。
+6. 复扫：按原类别重新扫描；有遗漏继续修，保留项说明依据。
+7. 自验：切片验证只跑本片聚焦测试与 typecheck。做完自查是否违法，质量和复杂度，如有问题马上修正。
+8. 交卷：按类报告根因、扫描范围、修复与 质量和合法性的验证结果、未结项。保护已有改动，只建新提交。不 amend、rewrite 或 push。Git 变化是证据之一，不取代角色报告。
 
 plan 只调查与提案，不施工。

package/src/acp-host/role-envelope.ts

@@ -27,12 +27,9 @@ import {
   type AcpRoleTurnHostConfig,
 } from "./role-turn-host.ts";
 import {
-  GatekeeperDecisionError,
-  WorkerCommitReminderError,
-  WorkerPrefixReminderError,
-  WorkerUnfinishedReasonReminderError,
-} from "../submission-errors.ts";
-import { isCorrectableExecuteError } from "../submission-correctable-error.ts";
+  isCorrectableExecuteError,
+  projectCorrectableExecuteRejection,
+} from "../submission-correctable-error.ts";
 import {
   buildNavigatorInfrastructureFailureFact,
   extractInfrastructureFailureEvidence,
@@ -98,7 +95,8 @@ export function projectAcpActivationFlags(request: RoleTurnRequest): Map<string,
   }
   if (activation.role === "collector") {
     flags.set("ak-collector-repo", activation.repo);
-    flags.set("ak-collector-pr", activation.pr);
+    // #676 D1: pr optional at admission; omit flag when role binds from materials.
+    if (activation.pr !== undefined) flags.set("ak-collector-pr", activation.pr);
     if (activation.requestManifestPath !== undefined) flags.set("ak-collector-request-manifest", activation.requestManifestPath);
   }
   return flags;
@@ -500,21 +498,9 @@ export async function prepareAcpRoleEnvelope(options: {
               let content: ContentPart[];
               let details: Record<string, unknown>;
               if (isCorrectableExecuteError(error)) {
-                const diagnostic = error instanceof Error ? error.message : String(error);
-                content = [{ type: "text", text: diagnostic }];
-                if (error instanceof GatekeeperDecisionError) {
-                  details = { ...error.result };
-                } else if (
-                  error instanceof WorkerCommitReminderError
-                  || error instanceof WorkerPrefixReminderError
-                  || error instanceof WorkerUnfinishedReasonReminderError
-                ) {
-                  details = { code: error.code };
-                } else if (typeof (error as unknown as { code?: unknown }).code === "string") {
-                  details = { code: (error as unknown as { code: string }).code };
-                } else {
-                  details = { code: error instanceof Error && error.name ? error.name : "correctable-submission-error" };
-                }
+                const projected = projectCorrectableExecuteRejection(error);
+                content = [{ type: "text", text: projected.diagnostic }];
+                details = projected.details;
               } else {
                 // Slot-before-abort; projectToolResult may still project durable details.
                 ({ content, details } = declareRoundInfrastructureFailure(error));

package/src/collector-config.ts

@@ -4,7 +4,6 @@ import { readFile } from "node:fs/promises";
 export const COLLECTOR_HOST = "github.com" as const;
 export const COLLECTOR_OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
 export const COLLECTOR_REPO_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/;
-export const COLLECTOR_FIXED_KICKOFF = "采集目标已受理，本局开始。";
 
 export type CollectorRepository = {
   display: string;