@akagilnc/pi-workflow-roles 0.1.3932 → 0.1.3975

package/dist/collector-role.js

@@ -1,566 +0,0 @@
-import { emptyCollectorManifest, loadCollectorManifest, parseCollectorPrNumber, parseCollectorRepository, } from "./collector-config.js";
-import { COLLECTOR_DEFAULT_WAIT_WINDOW_MS, createSystemCollectorClock, } from "./collector-evidence.js";
-import { createGhApiRunner, listPullRequestNumbersByTicket, } from "./collector-github.js";
-import { createCollectorHandbookStore, resolveCollectorHandbookRoot, } from "./collector-handbook.js";
-import { COLLECTOR_BIND_TARGET_TOOL, COLLECTOR_HANDBOOK_WRITE_TOOL, COLLECTOR_OBSERVE_TOOL, COLLECTOR_OPEN_WAIT_WINDOW_TOOL, COLLECTOR_OUTPUT_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, projectEvidenceEntryView, } from "./collector-ledger.js";
-import { buildCollectorReceipt, } from "./collector-receipt.js";
-import { collectorBindTargetArgsSchema, collectorHandbookWriteArgsSchema, collectorObserveArgsSchema, collectorOpenWaitWindowArgsSchema, collectorOutputArgsSchema, collectorReadArgsSchema, collectorRequestArgsSchema, collectorWaitArgsSchema, } from "./collector-tool-schemas.js";
-import { COLLECTOR_ACCEPTED_TEXT } from "./package-contracts/collector-output.js";
-import { CorrectableSubmissionError, isCorrectableExecuteError } from "./submission-correctable-error.js";
-import { CollectorUnknownEvidenceError } from "./collector-identity.js";
-export { CollectorUnknownEvidenceError } from "./collector-identity.js";
-/**
- * #641 chain②: normal completion must never declare `infrastructureFailure`.
- * When the runtime can machine-verify a lawful receipt assembly, a declaration
- * is model misuse — bounce it as correctable guidance instead of host failure.
- */
-export class CollectorNormalCompletionDeclarationError extends CorrectableSubmissionError {
-    constructor() {
-        super("runtime 已按机器状态核验本局为正常完工（回执可合法组装）：正常完工的交件不得填 infrastructureFailure，请省略该字段后重新提交。");
-        this.name = "CollectorNormalCompletionDeclarationError";
-    }
-}
-/** #676 A: role-chosen target could not bind uniquely — correctable, not host failure. */
-export class CollectorTargetBindError extends CorrectableSubmissionError {
-    constructor(message) {
-        super(message);
-        this.name = "CollectorTargetBindError";
-    }
-}
-export { COLLECTOR_BIND_TARGET_TOOL, COLLECTOR_HANDBOOK_WRITE_TOOL, COLLECTOR_OBSERVE_TOOL, COLLECTOR_OPEN_WAIT_WINDOW_TOOL, COLLECTOR_OUTPUT_TOOL, COLLECTOR_READ_TOOL, COLLECTOR_REQUEST_TOOL, COLLECTOR_WAIT_TOOL, };
-export const COLLECTOR_REQUIRED_TOOLS = [
-    COLLECTOR_BIND_TARGET_TOOL,
-    COLLECTOR_OBSERVE_TOOL,
-    COLLECTOR_READ_TOOL,
-    COLLECTOR_REQUEST_TOOL,
-    COLLECTOR_OPEN_WAIT_WINDOW_TOOL,
-    COLLECTOR_WAIT_TOOL,
-    COLLECTOR_HANDBOOK_WRITE_TOOL,
-    COLLECTOR_OUTPUT_TOOL,
-];
-/** Envelope-owned transport flags (ADR 0018 / #676 E). */
-export const COLLECTOR_TRANSPORT_FLAGS = Object.freeze([
-    Object.freeze({
-        name: "ak-collector-repo",
-        definition: Object.freeze({
-            description: "GitHub owner/repo target for Collector (github.com only; conservative ASCII grammar).",
-            type: "string",
-        }),
-    }),
-    Object.freeze({
-        name: "ak-collector-pr",
-        definition: Object.freeze({
-            description: "Optional positive safe-integer pull request number for Collector. Omit when the role will bind from task materials.",
-            type: "string",
-        }),
-    }),
-    Object.freeze({
-        name: "ak-collector-request-manifest",
-        definition: Object.freeze({
-            description: "Path to the Collector v1 request manifest JSON file.",
-            type: "string",
-        }),
-    }),
-    Object.freeze({
-        name: "ak-collector-wait-ms",
-        definition: Object.freeze({
-            description: `Collector wait-window duration in milliseconds (default ${COLLECTOR_DEFAULT_WAIT_WINDOW_MS}). Caller-configurable; opens at a work step, not session start (#678 D4).`,
-            type: "string",
-        }),
-    }),
-]);
-const observeSchema = collectorObserveArgsSchema;
-const readSchema = collectorReadArgsSchema;
-const requestSchema = collectorRequestArgsSchema;
-const openWaitWindowSchema = collectorOpenWaitWindowArgsSchema;
-const waitSchema = collectorWaitArgsSchema;
-const bindSchema = collectorBindTargetArgsSchema;
-const handbookWriteSchema = collectorHandbookWriteArgsSchema;
-const outputSchema = collectorOutputArgsSchema;
-function parseWaitWindowMsFlag(raw) {
-    if (raw === undefined || raw === null || raw === "")
-        return COLLECTOR_DEFAULT_WAIT_WINDOW_MS;
-    if (typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1)
-        return raw;
-    if (typeof raw === "string" && /^[1-9]\d*$/.test(raw.trim())) {
-        const value = Number(raw.trim());
-        if (Number.isSafeInteger(value) && value >= 1)
-            return value;
-    }
-    throw new Error("Collector --ak-collector-wait-ms must be a positive safe-integer millisecond string");
-}
-function buildMethodContext(activation) {
-    const pr = activation.ledger.config.prNumber;
-    const handbook = activation.handbookView;
-    const lines = [
-        "<collector_method>",
-        `host: github.com`,
-        `repository: ${activation.repository.canonical}`,
-        `prNumber: ${pr === undefined ? "未绑定" : String(pr)}`,
-        `waitWindowMs: ${String(activation.ledger.config.waitWindowMs)}`,
-        `requests: ${JSON.stringify(activation.manifest.requests.map((request) => ({ id: request.id })))}`,
-        `handbookGeneralSource: ${handbook.generalSource}`,
-        `handbookRepoSource: ${handbook.repoSource}`,
-        "</collector_method>",
-    ];
-    // Opaque working memory only — no directional instructions (ADR 0073).
-    // JSON + `<` → \u003c keeps bodies from forging the delivery close tag (#677).
-    if (handbook.general.length > 0 || handbook.repo.length > 0) {
-        const payload = JSON.stringify({
-            general: handbook.general,
-            repo: handbook.repo,
-            generalSource: handbook.generalSource,
-            repoSource: handbook.repoSource,
-            repository: activation.repository.canonical,
-        }).replaceAll("<", "\\u003c");
-        lines.push("", "<collector_handbook>", payload, "</collector_handbook>");
-    }
-    return lines.join("\n");
-}
-function parsePositiveTicket(raw, label) {
-    if (raw === undefined || raw === null)
-        return undefined;
-    if (typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1)
-        return raw;
-    if (typeof raw === "string" && /^[1-9]\d*$/.test(raw.trim()))
-        return Number(raw.trim());
-    throw new CollectorTargetBindError(`通进司绑定 ${label} 须为正安全整数`);
-}
-/**
- * Shared envelope installs business tools and material callback after lifecycle gates.
- * Role module does not self-hook events, setActiveTools, or mode/fork checks (ADR 0018 / #676 E).
- */
-export function createCollectorRoleRuntime(pi, dependencies, hostActions) {
-    let toolsRegistered = false;
-    return {
-        async activate(ctx) {
-            const soul = (await dependencies.loadSoul()).trim();
-            if (soul.length === 0)
-                throw new Error("Collector soul is empty");
-            // Flags registered by the shared envelope (COLLECTOR_TRANSPORT_FLAGS).
-            const repoFlag = pi.getFlag("ak-collector-repo");
-            const prFlag = pi.getFlag("ak-collector-pr");
-            const requestManifestFlag = pi.getFlag("ak-collector-request-manifest");
-            const waitMsFlag = pi.getFlag("ak-collector-wait-ms");
-            if (typeof repoFlag !== "string" || repoFlag.trim().length === 0) {
-                throw new Error("Collector requires --ak-collector-repo");
-            }
-            const repository = parseCollectorRepository(repoFlag);
-            // #676 A: PR may be unbound — role binds via ak_collector_bind_target from materials.
-            let prNumber;
-            if (typeof prFlag === "string" && prFlag.trim().length > 0) {
-                prNumber = parseCollectorPrNumber(prFlag);
-            }
-            else if (typeof prFlag === "number") {
-                prNumber = parseCollectorPrNumber(prFlag);
-            }
-            const manifest = typeof requestManifestFlag === "string" && requestManifestFlag.trim().length > 0
-                ? await loadCollectorManifest(requestManifestFlag)
-                : emptyCollectorManifest();
-            const waitWindowMs = parseWaitWindowMsFlag(waitMsFlag);
-            const clock = dependencies.createClock?.() ?? createSystemCollectorClock();
-            const transport = dependencies.createTransport();
-            const ledger = dependencies.createLedger({ repository, prNumber, manifest, waitWindowMs }, clock, ctx);
-            // #677: handbook under admitted book topology (session path → books/<key>/collector-handbook).
-            const sessionPath = ctx.sessionManager?.getSessionFile?.()
-                ?? ctx.sessionManager?.getSessionDir?.();
-            if (typeof sessionPath !== "string" || sessionPath.length === 0) {
-                throw new Error("通进司手册要求 session 路径位于 books/<bookKey>/");
-            }
-            const placement = resolveCollectorHandbookRoot(sessionPath);
-            const seedGeneral = dependencies.loadHandbookSeed === undefined
-                ? undefined
-                : (await dependencies.loadHandbookSeed()).trim();
-            const handbook = createCollectorHandbookStore({
-                ledgerHome: placement.ledgerHome,
-                handbookRoot: placement.root,
-                repositoryCanonical: repository.canonical,
-                ...(seedGeneral === undefined || seedGeneral.length === 0
-                    ? {}
-                    : { seedGeneral }),
-            });
-            const handbookView = await handbook.read();
-            return {
-                soul,
-                repository,
-                manifest,
-                ledger,
-                transport,
-                clock,
-                handbook,
-                handbookView,
-            };
-        },
-        assembleMaterials(activation, baseSystemPrompt) {
-            return [
-                baseSystemPrompt,
-                "",
-                "<collector_soul>",
-                activation.soul,
-                "</collector_soul>",
-                "",
-                buildMethodContext(activation),
-            ].join("\n");
-        },
-        onToolCall(activation, event) {
-            // Business ledger facts only — allowed-tool / mode gates live on the envelope.
-            if (activation.ledger.fatal) {
-                return {
-                    block: true,
-                    reason: activation.ledger.fatalReason ?? "通进司致命状态",
-                };
-            }
-            if (event.toolName === COLLECTOR_OUTPUT_TOOL) {
-                activation.ledger.beginOperational(COLLECTOR_OUTPUT_TOOL, event.toolCallId);
-            }
-            if (activation.ledger.outputCandidate &&
-                event.toolName !== COLLECTOR_OUTPUT_TOOL) {
-                return {
-                    block: true,
-                    reason: "通进司已产出输出候选，本局不再受理操作",
-                };
-            }
-            return undefined;
-        },
-        onToolResult(activation, event) {
-            activation.ledger.completeOperational(event.toolCallId);
-        },
-        registerBusinessTools(getActivation) {
-            if (toolsRegistered)
-                return;
-            toolsRegistered = true;
-            pi.registerTool({
-                name: COLLECTOR_BIND_TARGET_TOOL,
-                label: "通进司认票绑定",
-                description: "角色判定任务材料后绑定本仓唯一 PR 目标。可提交 prNumber 或 issueNumber（线上关联唯一 PR）；显式 --pr 已绑定时无需再调。多义或无法确定时会正确驳回，要求调用方明确 --pr。",
-                promptSnippet: "绑定角色判定的 issue/PR 目标",
-                parameters: bindSchema,
-                async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_BIND_TARGET_TOOL, toolCallId);
-                        const prNumber = parsePositiveTicket(params.prNumber, "prNumber");
-                        const issueNumber = parsePositiveTicket(params.issueNumber, "issueNumber");
-                        if (prNumber === undefined && issueNumber === undefined) {
-                            throw new CollectorTargetBindError("通进司绑定须由角色判定 prNumber 与/或 issueNumber");
-                        }
-                        let bound = prNumber;
-                        if (issueNumber !== undefined) {
-                            const associated = await listPullRequestNumbersByTicket(createGhApiRunner(), {
-                                owner: activation.repository.owner,
-                                repo: activation.repository.repo,
-                                ticketNumber: issueNumber,
-                            });
-                            if (associated.length === 0) {
-                                throw new CollectorTargetBindError(`${activation.repository.canonical} 的 issue #${issueNumber} 无关联 PR；请改用明确 --pr 或其他 issueNumber`);
-                            }
-                            if (associated.length > 1) {
-                                throw new CollectorTargetBindError(`issue #${issueNumber} 关联多个 PR：${associated.join("、")}；请改用明确 prNumber 或 --pr`);
-                            }
-                            const fromIssue = associated[0];
-                            if (prNumber !== undefined && prNumber !== fromIssue) {
-                                throw new CollectorTargetBindError(`prNumber ${prNumber} 与 issue #${issueNumber} 关联 PR ${fromIssue} 冲突`);
-                            }
-                            bound = fromIssue;
-                        }
-                        activation.ledger.bindTarget(bound);
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `目标已绑定：${activation.repository.canonical}#${bound}`,
-                                }],
-                            details: {
-                                repository: activation.repository.canonical,
-                                prNumber: bound,
-                                ...(issueNumber === undefined ? {} : { issueNumber }),
-                            },
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                    finally {
-                        try {
-                            activation.ledger.completeOperational(toolCallId);
-                        }
-                        catch {
-                            // already completed or not begun
-                        }
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_OBSERVE_TOOL,
-                label: "通进司观察",
-                description: "抓取配置目标的完整 GitHub PR 证据，存不可变快照入卷。正文在上下文中只给头部摘录加指针；需要头部之外的正文时，用 ak_collector_read 按 evidenceId 开卷；findings 的拆分与归类由你在交件时完成。目标未绑定前须先 ak_collector_bind_target。",
-                promptSnippet: "抓取配置目标 PR 证据",
-                parameters: observeSchema,
-                async execute(toolCallId, _params, signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_OBSERVE_TOOL, toolCallId);
-                        const { snapshot, contextView } = await activation.ledger.observe(activation.transport, activation.clock, signal);
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify(contextView),
-                                }],
-                            details: contextView,
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_READ_TOOL,
-                label: "通进司开卷",
-                description: "按 evidenceId 开卷读取一条已观测材料的全量正文与指针；只在观察头部摘录不足以判读时调用。",
-                promptSnippet: "按指针开卷读材料",
-                parameters: readSchema,
-                async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_READ_TOOL, toolCallId);
-                        const record = activation.ledger.getEvidence(params.evidenceId);
-                        if (record === undefined ||
-                            (record.kind !== "review" && record.kind !== "issue_comment" && record.kind !== "review_comment" && record.kind !== "reaction") ||
-                            typeof record.body !== "string") {
-                            throw new CollectorUnknownEvidenceError(params.evidenceId);
-                        }
-                        const material = projectEvidenceEntryView(record);
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify(material),
-                                }],
-                            details: material,
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_REQUEST_TOOL,
-                label: "通进司请求",
-                description: "在所引最新快照 HEAD 发一次请求。requestId 可取配置清单，或角色依手册/现场判定的稳定 id；后者须同时提供 body。",
-                promptSnippet: "发一次评审请求",
-                parameters: requestSchema,
-                async execute(toolCallId, params, signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_REQUEST_TOOL, toolCallId);
-                        const details = await activation.ledger.request({
-                            requestId: params.requestId,
-                            snapshotId: params.snapshotId,
-                            ...(typeof params.body === "string" ? { body: params.body } : {}),
-                        }, activation.transport, activation.clock, signal);
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `请求尝试已记录：request ${params.requestId}`,
-                                }],
-                            details,
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_HANDBOOK_WRITE_TOOL,
-                label: "通进司手册写入",
-                description: "写入通用手册或当前仓库差异全文（整份替换）。",
-                promptSnippet: "更新 bot 手册",
-                parameters: handbookWriteSchema,
-                async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_HANDBOOK_WRITE_TOOL, toolCallId);
-                        // scope/body shape authority = collectorHandbookWriteArgsSchema (host parameters).
-                        const details = await activation.handbook.write(params.scope, params.body);
-                        activation.handbookView = await activation.handbook.read();
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `手册已写入：${details.scope}`,
-                                }],
-                            details: {
-                                scope: details.scope,
-                                path: details.path,
-                                byteLength: details.byteLength,
-                                generalSource: activation.handbookView.generalSource,
-                                repoSource: activation.handbookView.repoSource,
-                            },
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                    finally {
-                        try {
-                            activation.ledger.completeOperational(toolCallId);
-                        }
-                        catch {
-                            // already completed or not begun
-                        }
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_OPEN_WAIT_WINDOW_TOOL,
-                label: "通进司开启等待窗",
-                description: "在工作步骤上开启等待窗：新建并自动触发的 PR 传创建成功时刻；已有 PR 在触发阶段结束后省略 startedAt（=现在）。窗长由使用方配置，默认十分钟；开启后不因 PR 更新重置。",
-                promptSnippet: "按工作步骤开启等待窗",
-                parameters: openWaitWindowSchema,
-                async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_OPEN_WAIT_WINDOW_TOOL, toolCallId);
-                        let startedAt;
-                        if (typeof params.startedAt === "string" && params.startedAt.trim().length > 0) {
-                            const parsed = new Date(params.startedAt);
-                            if (Number.isNaN(parsed.getTime())) {
-                                throw new Error("通进司等待窗 startedAt 须为有效 ISO 时间");
-                            }
-                            startedAt = parsed;
-                        }
-                        activation.ledger.openWaitWindow(activation.clock, startedAt === undefined ? undefined : { startedAt });
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: "等待窗已开启",
-                                }],
-                            details: {
-                                activationTime: activation.ledger.activationTime?.toISOString(),
-                                deadlineTime: activation.ledger.deadlineTime?.toISOString(),
-                                waitWindowMs: activation.ledger.config.waitWindowMs,
-                            },
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                    finally {
-                        try {
-                            activation.ledger.completeOperational(toolCallId);
-                        }
-                        catch {
-                            // already completed or not begun
-                        }
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_WAIT_TOOL,
-                label: "通进司等待",
-                description: "再观察前等待；实际睡眠不超过剩余等待窗。",
-                promptSnippet: "等待窗内等待",
-                parameters: waitSchema,
-                async execute(toolCallId, params, signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_WAIT_TOOL, toolCallId);
-                        const details = await activation.ledger.wait(params, activation.clock, signal);
-                        activation.ledger.completeOperational(toolCallId);
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `已等待 ${String(details.effectiveMs)}ms`,
-                                }],
-                            details,
-                        };
-                    }
-                    catch (error) {
-                        if (isCorrectableExecuteError(error))
-                            throw error;
-                        hostActions.failInfrastructure(error, ctx, toolCallId);
-                    }
-                },
-            });
-            pi.registerTool({
-                name: COLLECTOR_OUTPUT_TOOL,
-                label: "通进司输出",
-                description: "观察完成后提交；回执由 runtime 组装。正常完工提交空对象 {}（如需报 finding，填 findings 指针数组）；仅在基础设施真实失败时才可填 infrastructureFailure，无失败时必须省略该字段。",
-                promptSnippet: "提交通进司回执",
-                bounceInfrastructureDeclaration(params) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        return undefined;
-                    try {
-                        buildCollectorReceipt(activation.ledger, params, activation.clock);
-                    }
-                    catch {
-                        return undefined;
-                    }
-                    return new CollectorNormalCompletionDeclarationError();
-                },
-                parameters: outputSchema,
-                async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-                    const activation = getActivation();
-                    if (activation === undefined)
-                        throw new Error("通进司未激活");
-                    try {
-                        activation.ledger.beginOperational(COLLECTOR_OUTPUT_TOOL, toolCallId);
-                        const receipt = buildCollectorReceipt(activation.ledger, params, activation.clock);
-                        activation.ledger.recordOutputCandidate();
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: COLLECTOR_ACCEPTED_TEXT,
-                                }],
-                            details: receipt,
-                            terminate: true,
-                        };
-                    }
-                    catch (error) {
-                        if (error instanceof Error &&
-                            error.collectorFatal === true) {
-                            hostActions.failInfrastructure(error, ctx, toolCallId);
-                        }
-                        throw error;
-                    }
-                    finally {
-                        activation.ledger.completeOperational(toolCallId);
-                    }
-                },
-            });
-        },
-    };
-}

package/dist/collector-tool-schemas.js

@@ -1,107 +0,0 @@
-import { Type } from "typebox";
-import { openToolObject } from "./open-tool-schema.js";
-import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
-export const collectorObserveArgsSchema = Type.Object({}, { additionalProperties: false });
-/**
- * Stable request identity: non-empty after trim, no leading/trailing whitespace.
- * Host schema + ledger identity seam share this contract (#677 / D2 dedup).
- */
-export const COLLECTOR_REQUEST_ID_PATTERN = /^\S(?:.*\S)?$/;
-export const collectorRequestArgsSchema = Type.Object({
-    requestId: Type.String({
-        minLength: 1,
-        pattern: COLLECTOR_REQUEST_ID_PATTERN.source,
-        description: "请求身份（配置 id 或角色判定的稳定 id；首尾无空白）",
-    }),
-    snapshotId: Type.String({ minLength: 1, description: "最新留存观察快照" }),
-    body: Type.Optional(Type.String({
-        minLength: 1,
-        description: "角色判定的请求正文；request-manifest 未收录该 requestId 时必填",
-    })),
-}, { additionalProperties: false });
-/** UTF-8 byte ceiling per handbook body — keeps next activation materials inside context budget. */
-export const COLLECTOR_HANDBOOK_MAX_BYTES = 64 * 1024;
-export const collectorHandbookWriteArgsSchema = Type.Object({
-    scope: Type.Union([
-        Type.Literal("general"),
-        Type.Literal("repo"),
-    ], { description: "general＝通用手册；repo＝当前仓库差异" }),
-    body: Type.String({
-        description: `手册全文（opaque 工作记忆；整份替换；UTF-8 至多 ${COLLECTOR_HANDBOOK_MAX_BYTES} 字节）`,
-    }),
-}, { 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,
-        description: "等待毫秒；实际睡眠不超过剩余等待窗（#678；无包内单次任意上限）",
-    }),
-}, { additionalProperties: false });
-/**
- * #678 D4: open the wait window at a work step.
- * Omit startedAt for existing-PR trigger-phase end (= now).
- * Pass PR creation success time for new-PR auto-trigger rounds.
- */
-export const collectorOpenWaitWindowArgsSchema = Type.Object({
-    startedAt: Type.Optional(Type.String({
-        minLength: 1,
-        description: "等待窗起点 ISO 时间；新建 PR 用创建成功时刻；省略＝现在（触发阶段结束）",
-    })),
-}, { additionalProperties: false });
-/**
- * #676 A: role-decided target bind. The model judges task materials and submits
- * the chosen PR and/or issue identity; runtime only performs online association
- * for the role-chosen ticket — never scrapes task text to lock a target.
- */
-export const collectorBindTargetArgsSchema = Type.Object({
-    prNumber: Type.Optional(Type.Unknown({
-        description: "角色判定的本仓 PR 号（正整数）。与 issueNumber 二选一或同指唯一目标。形状指引，非 schema 闸。",
-    })),
-    issueNumber: Type.Optional(Type.Unknown({
-        description: "角色判定的本仓 issue 号（正整数）；runtime 经线上关联解析唯一 PR。形状指引，非 schema 闸。",
-    })),
-}, { additionalProperties: true });
-/**
- * #641 chain① / #676 C / ADR 0057: nested finding item declarations for model
- * guidance. Host must not pure-shape-reject the envelope (第 0 条). Runtime binds
- * resolvable evidence pointers only; unprojected content stays distinguishable.
- */
-const collectorFindingItemDeclaration = (() => {
-    // Nested declarations for model guidance only — open required so host cannot
-    // pure-shape-reject missing optional fields (第 0 条 / ADR 0057 / #676 C).
-    const item = Type.Object({
-        evidenceId: Type.Unknown({
-            description: "observe 返回的材料指针（必填语义）",
-        }),
-        category: Type.Unknown({
-            description: "简短归类标签，不是摘要",
-        }),
-        summary: Type.Unknown({
-            description: "哪个 bot、什么问题的摘要；不誊抄正文",
-        }),
-    }, {
-        additionalProperties: true,
-        description: "单条 finding 指针：evidenceId + 可选 category/summary。形状指引，非 schema 闸。",
-    });
-    item.required = [];
-    return item;
-})();
-/**
- * Field declarations + descriptions are guidance for the model — host must not
- * pure-shape-reject the envelope (第 0 条 / ADR 0057).
- */
-export const collectorOutputBaseSchema = openToolObject(Type.Object({
-    // No root type:array — host must not shape-reject non-array findings (#676 C).
-    // Nested item declarations ride `items` for registration preservation (ADR 0057).
-    findings: Type.Unsafe({
-        description: "本次收集到的逐条 findings（指针数组为规范形）。零 finding 的模板通知不得进入；正常完工无 finding 时省略。形状指引，非 schema 闸。",
-        items: collectorFindingItemDeclaration,
-    }),
-    unfinishedReasons: Type.Unknown({
-        description: "未完成原因字符串数组（额度/故障/等待届满等现场依据）；不得把未完成表述为无问题。无可报告时省略。形状指引，非 schema 闸。",
-    }),
-}));
-/** Runtime owns the observed evidence; the model submits findings and signals sole-final submission. */
-export const collectorOutputArgsSchema = withInfrastructureFailureDeclaration(collectorOutputBaseSchema);