@akagilnc/pi-workflow-roles 0.1.5241 → 0.1.5252

package/src/collector-tool-schemas.ts

@@ -2,136 +2,26 @@ import { Type, type Static } from "typebox";
 import { openToolObject } from "./open-tool-schema.ts";
 import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.ts";
 
-// #836 r16 class 3: execute() reads no params for this tool
-// (src/collector-role.ts:431-459) — a closed root only rejects the role for
-// saying more; no reader consumes extra fields.
-export const collectorObserveArgsSchema = Type.Object({}, { additionalProperties: true });
-// #836 r16 class 4: the regex was a real provider shape rejection ahead of the
-// ledger's own identity check — src/collector-ledger.ts:911-972 already trims
-// and enforces non-empty/lookup/marker/attemptKey identity on requestId once
-// the tool receives it, so the duplicate pattern-based rejection is deleted
-// (r15b decision, not reopened here).
-export const collectorRequestArgsSchema = Type.Object({
-  requestId: Type.String({
-    minLength: 1,
-    description: "请求身份（配置 id 或角色判定的稳定 id；首尾无空白）",
-  }),
-  snapshotId: Type.String({ minLength: 1, description: "最新留存观察快照" }),
-  // #836 r16 class 3: body.minLength deleted — manifest-configured requestId
-  // ignores body, and the unknown-requestId non-empty condition is a real
-  // branch in src/collector-ledger.ts:922-951, not a provider shape gate.
-  body: Type.Optional(Type.String({
-    description: "角色判定的请求正文；request-manifest 未收录该 requestId 时必填",
-  })),
-}, { additionalProperties: true });
-/** 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: true });
-export const collectorReadArgsSchema = Type.Object({
-  evidenceId: Type.String({ minLength: 1, description: "observe 返回的材料证据 id（evidenceId）" }),
-}, { additionalProperties: true });
-export const collectorWaitArgsSchema = Type.Object({
-  durationMs: Type.Integer({
-    minimum: 1,
-    description: "等待毫秒；实际睡眠不超过剩余等待窗（#678；无包内单次任意上限）",
-  }),
-}, { additionalProperties: true });
-
 /**
- * #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.
- */
-// #836 r16 class 3: startedAt.minLength deleted — an empty string is already
-// handled as omission by src/collector-role.ts:586-597, so the provider
-// nonblank gate is not load-bearing for any branch.
-export const collectorOpenWaitWindowArgsSchema = Type.Object({
-  startedAt: Type.Optional(Type.String({
-    description: "等待窗起点 ISO 时间；新建 PR 用创建成功时刻；省略＝现在（触发阶段结束）",
-  })),
-}, { additionalProperties: true });
-
-/**
- * #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: Type.Optional(Type.Unknown({
-    description: "本仓 issue 号（正整数）。",
-  })),
-}, { 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。",
-    },
-  );
-  (item as unknown as { required: string[] }).required = [];
-  return item;
-})();
-
-/**
- * Field declarations + descriptions are guidance for the model — host must not
- * pure-shape-reject the envelope (第 0 条 / ADR 0057).
+ * #1088: LLM gathers evidence via host CLI and submits the receipt.
+ * Field declarations guide the model — host must not pure-shape-reject (第 0 条 / ADR 0057).
+ * Presence of `groups` remains the Collector terminal discriminator for settlement/analyst.
  */
 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({
+    groups: Type.Unsafe({
       description:
-        "本次收集到的逐条 findings 指针。",
-      items: collectorFindingItemDeclaration,
+        "按机器身份归组的出席、材料与逐条 findings（LLM 自行从宿主 CLI 取证整理；代码不代收不归并）。",
     }),
     unfinishedReasons: Type.Unknown({
-      description:
-        "未完成原因。",
+      description: "未完成原因；取证受限时如实报告。",
     }),
   }),
 );
 
-/** Runtime owns the observed evidence; the model submits findings and signals sole-final submission. */
+/** Runtime does not enrich findings; the model submits the receipt and signals sole-final. */
 export const collectorOutputArgsSchema = withTerminatingOutputDeclarations(
   collectorOutputBaseSchema,
 );
 
-export type CollectorObserveArgs = Static<typeof collectorObserveArgsSchema>;
-export type CollectorRequestArgs = Static<typeof collectorRequestArgsSchema>;
-export type CollectorReadArgs = Static<typeof collectorReadArgsSchema>;
-export type CollectorWaitArgs = Static<typeof collectorWaitArgsSchema>;
-export type CollectorOpenWaitWindowArgs = Static<typeof collectorOpenWaitWindowArgsSchema>;
-export type CollectorBindTargetArgs = Static<typeof collectorBindTargetArgsSchema>;
 export type CollectorOutputArgs = Static<typeof collectorOutputArgsSchema>;

package/src/gh-api-runner.ts

@@ -0,0 +1,102 @@
+import { spawn } from "node:child_process";
+
+export type GhApiRunOptions = {
+  signal?: AbortSignal;
+};
+
+export type GhApiResponse = {
+  status: number;
+  headers: Record<string, string>;
+  bodyText: string;
+};
+
+export type GhApiRunner = (
+  args: readonly string[],
+  options?: GhApiRunOptions,
+) => Promise<GhApiResponse>;
+
+export function createGhApiRunner(
+  options: {
+    spawnImpl?: typeof spawn;
+    env?: NodeJS.ProcessEnv;
+  } = {},
+): GhApiRunner {
+  const spawnImpl = options.spawnImpl ?? spawn;
+  return async (args, runOptions = {}) => {
+    return await new Promise<GhApiResponse>((resolve, reject) => {
+      const signal = runOptions.signal;
+      if (signal?.aborted) {
+        reject(signal.reason ?? new Error("aborted"));
+        return;
+      }
+      const child = spawnImpl("gh", args, {
+        env: options.env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const settle = (fn: () => void) => {
+        if (settled) return;
+        settled = true;
+        if (signal !== undefined) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        fn();
+      };
+      const onAbort = () => {
+        try {
+          child.kill("SIGTERM");
+        } catch (error) {
+          settle(() => reject(error));
+          return;
+        }
+        settle(() => {
+          reject(signal?.reason ?? new Error("aborted"));
+        });
+      };
+      if (signal !== undefined) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      child.stdout.setEncoding("utf8").on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.setEncoding("utf8").on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.on("error", (error) => {
+        settle(() => reject(error));
+      });
+      child.on("close", (code, signal) => {
+        settle(() => {
+          // gh api --include prints: HTTP/ headers blank-line body
+          const match = stdout.match(/^HTTP\/[\d.]+\s+(\d+)[^\n]*\r?\n([\s\S]*?)\r?\n\r?\n([\s\S]*)$/);
+          if (match) {
+            const status = Number(match[1]);
+            const headerText = match[2] ?? "";
+            const bodyText = match[3] ?? "";
+            const headers: Record<string, string> = {};
+            for (const line of headerText.split(/\r?\n/)) {
+              const idx = line.indexOf(":");
+              if (idx === -1) continue;
+              const name = line.slice(0, idx).trim().toLowerCase();
+              const value = line.slice(idx + 1).trim();
+              headers[name] = value;
+            }
+            resolve({ status, headers, bodyText });
+            return;
+          }
+          if (code === 0) {
+            resolve({ status: 200, headers: {}, bodyText: stdout });
+            return;
+          }
+          const failure = new Error(
+            `gh api failed without a parseable HTTP response (code=${String(code)}): ${stderr || stdout}`,
+            { cause: { code, signal, stderr, stdout } },
+          );
+          reject(failure);
+        });
+      });
+    });
+  };
+}

package/src/navigator-invocation-identity.ts

@@ -1,5 +1,5 @@
 /**
- * Exact current-invocation principal for Navigator attendance correlation.
+ * Exact current-invocation principal for shared role lifecycle (#1087).
  * Shared role lifecycle owns one opaque uuidv7 per Role invocation and persists
  * it on the role session via Pi's guaranteed `pi.appendEntry` boundary.
  *
@@ -7,21 +7,14 @@
  * unfinished exact-session resume reuses the latest valid marker only when its
  * role/phase/subjectKey still match the expected identity; a packaged role
  * terminal completing that marker starts the next invocation (fresh mint).
- * Terminal settlement binds the nearest independent marker strictly before the
- * current durable packaged role terminal and compares equality — never attendance
- * self-shape, markers after the terminal, or stale older markers behind a
- * malformed nearest. Non-UUIDv7 principals are never accepted.
+ * Public settlement does not re-correlate attendance against this principal
+ * (ADR 0042); lifecycle dispose/grace owns call-boundary isolation (ADR 0084).
  *
  * One shared typed terminal classifier owns durable completion for lifecycle,
  * publicNavigatorSettlement, and every public CLI Receipt extractor:
  *   - accepted/human: isError exactly false and no infrastructure-failure fact
  *   - infrastructure: isError exactly true plus base kind/source/reasonCode identity
  *   - retryable/missing/nonboolean/contradictory/malformed: nonterminal
- *
- * One truth table also owns marker↔terminal cardinality:
- *   - a marker binds exactly one durable packaged role terminal
- *   - multiple durable terminals after the same marker → ambiguous / fail-closed
- *   - marker role/phase/subjectKey must match the terminal + independent expected
  */
 
 import { LEGACY_REVIEW_OUTPUT_ROLES, PACKAGED_ROLE_REGISTRY } from "./packaged-role-registry.ts";
@@ -147,7 +140,7 @@ export type InvocationMarkerIdentity = {
   readonly subjectKey: string;
 };
 
-/** Independently admitted / registry / cwd expected identity for resume and correlation. */
+/** Independently admitted / registry / cwd expected identity for lifecycle resume. */
 export type ExpectedInvocationIdentity = {
   readonly role: string;
   readonly phase?: InvocationPhase;
@@ -342,83 +335,6 @@ export function findLatestDurablePackagedRoleTerminal(
   return undefined;
 }
 
-/**
- * Truth-table binding of the current durable packaged role terminal to its
- * owning invocation marker. Singleton cardinality: multiple durable terminals
- * after the same marker are ambiguous and fail closed.
- */
-export type DurableTerminalMarkerBinding =
-  | {
-      readonly kind: "bound";
-      readonly terminal: DurablePackagedRoleTerminalRef;
-      readonly marker: InvocationMarkerIdentity & { readonly index: number };
-    }
-  | {
-      readonly kind: "unbound";
-      readonly terminal: DurablePackagedRoleTerminalRef;
-    }
-  | { readonly kind: "absent" }
-  | { readonly kind: "ambiguous" };
-
-export function bindCurrentDurableTerminalToMarker(
-  entries: readonly NavigatorInvocationEntryLike[],
-): DurableTerminalMarkerBinding {
-  const terminal = findLatestDurablePackagedRoleTerminal(entries);
-  if (terminal === undefined) return { kind: "absent" };
-
-  let markerIndex = -1;
-  for (let i = terminal.index - 1; i >= 0; i -= 1) {
-    if (isInvocationMarkerEntry(entries[i])) {
-      markerIndex = i;
-      break;
-    }
-  }
-  if (markerIndex < 0) {
-    return { kind: "unbound", terminal };
-  }
-
-  const marker = parseInvocationMarkerIdentity(entries[markerIndex]?.data);
-  if (marker === undefined) {
-    // Malformed nearest marker: no stale fallback; terminal exists but is unbound.
-    return { kind: "unbound", terminal };
-  }
-
-  let windowEnd = entries.length;
-  for (let i = markerIndex + 1; i < entries.length; i += 1) {
-    if (isInvocationMarkerEntry(entries[i])) {
-      windowEnd = i;
-      break;
-    }
-  }
-
-  let durableCount = 0;
-  for (let i = markerIndex + 1; i < windowEnd; i += 1) {
-    if (durableTerminalAt(entries, i) !== undefined) durableCount += 1;
-  }
-  if (durableCount !== 1) return { kind: "ambiguous" };
-  // Current terminal must be the singleton inside this marker window.
-  if (terminal.index <= markerIndex || terminal.index >= windowEnd) {
-    return { kind: "ambiguous" };
-  }
-
-  return {
-    kind: "bound",
-    terminal,
-    marker: { ...marker, index: markerIndex },
-  };
-}
-
-/**
- * Whether public Receipt settlement may proceed for the current durable terminal.
- * Only ambiguous multi-terminal bindings fail closed; attendance mismatch does not
- * pollute an otherwise legal single Receipt.
- */
-export function isReceiptSettlementBindingClear(
-  entries: readonly NavigatorInvocationEntryLike[],
-): boolean {
-  return bindCurrentDurableTerminalToMarker(entries).kind !== "ambiguous";
-}
-
 export type LifecycleInvocationPrincipal = {
   readonly invocationId: string;
   /** True when the principal is already on the admitted session (resume; do not re-append). */
@@ -463,36 +379,3 @@ export function resolveLifecycleInvocationPrincipal(
 
   return { invocationId: marker.invocationId, resume: true };
 }
-
-/**
- * Exact current invocation principal already present on the role session.
- * `beforeIndex` is the current packaged role terminal index: only the nearest
- * marker strictly before that bound is applicable. A malformed nearest marker
- * fails closed (undefined) — never falls back to a stale older valid marker.
- * Markers at/after the terminal (future prepare/event) are never considered.
- * Non-UUIDv7 values are rejected.
- */
-export function currentInvocationPrincipalFromSession(
-  entries: readonly NavigatorInvocationEntryLike[],
-  beforeIndex: number = entries.length,
-): string | undefined {
-  return currentInvocationMarkerFromSession(entries, beforeIndex)?.invocationId;
-}
-
-/**
- * Full marker identity nearest before `beforeIndex` (current durable terminal).
- * Malformed nearest fails closed — no stale older fallback.
- */
-export function currentInvocationMarkerFromSession(
-  entries: readonly NavigatorInvocationEntryLike[],
-  beforeIndex: number = entries.length,
-): InvocationMarkerIdentity | undefined {
-  const limit = Math.min(Math.max(beforeIndex, 0), entries.length);
-  for (let i = limit - 1; i >= 0; i -= 1) {
-    const entry = entries[i];
-    if (!isInvocationMarkerEntry(entry)) continue;
-    // Nearest marker only — parse full identity or fail closed.
-    return parseInvocationMarkerIdentity(entry?.data);
-  }
-  return undefined;
-}

package/src/package-contracts/collector-output.ts

@@ -1,188 +1,29 @@
 /** Package-owned Collector receipt leaf — no role registration surface. */
 
 export const COLLECTOR_OUTPUT_TOOL = "ak_collector_output";
-export const COLLECTOR_HOST = "github.com";
 
+/**
+ * One identity group on the LLM-submitted receipt.
+ * #1088: code no longer builds ledger projections; the model submits groups.
+ */
 export type CollectorIdentityGroup = {
   identity: Record<string, unknown> | null;
   displayLogin?: string;
-  attendance: true;
-  materials: Array<Record<string, unknown>>;
-  findings: Array<Record<string, unknown>>;
-};
-
-export type CollectorRequestAttempt = {
-  attemptId: string;
-  requestId: string;
-  observedHead: string;
-  snapshotId: string;
-  marker: string;
-  body: string;
-  startedAt: string;
-  status: "started" | "succeeded" | "rejected" | "ambiguous_loss" | "recovered";
-  responseDiagnostics?: string;
-  commentEvidenceId?: string;
-  recoverySnapshotId?: string;
-};
-
-export type CollectorSnapshot = {
-  snapshotId: string;
-  observedAt: string;
-  completedAt: string;
-  completedMono: number;
-  host: "github.com";
-  repository: string;
-  prNumber: number;
-  prState: string;
-  headOid: string;
-  complete: boolean;
-  evidenceIds: string[];
-  pageDiagnostics: Array<Record<string, unknown>>;
-  normalizedByteLength: number;
+  attendance?: true;
+  materials?: Array<Record<string, unknown>>;
+  findings?: Array<Record<string, unknown>>;
 };
 
 /**
- * #641 chain① receipt evidence record: pointer/integrity facts only. Bodies and
- * raw payloads stay in the volume (observe details + GitHub pointer) and are
- * never transcribed into the receipt.
+ * Collector receipt as submitted. Presence of `groups` is the terminal
+ * discriminator for settlement/analyst (#836: original object is the receipt).
  */
-export type CollectorEvidenceRecord = {
-  evidenceId: string;
-  kind: string;
-  versionId: string;
-  contentDigest: string;
-  firstObservedAt: string;
-  githubId?: number;
-  authorLogin?: string;
-  htmlUrl?: string;
-  authoritativeTime?: string | null;
-};
-
-/**
- * #676 C: sole structured projection-fact type (builder + package leaf).
- * Builder always emits the full object; package leaf keeps it optional so old
- * volumes without the field stay readable — missing is unknown, never defaulted.
- */
-export type CollectorSubmissionProjection = {
-  findingsSource: "absent" | "array" | "unreadable";
-  findingsProjectedCount: number;
-  findingsUnprojected: boolean;
-  unfinishedReasonsSource: "absent" | "array" | "unreadable";
-  unfinishedReasonsProjectedCount: number;
-  unfinishedReasonsUnprojected: boolean;
-};
-
 export type CollectorReceipt = {
-  host: "github.com";
-  repository: string;
-  prNumber: number;
-  /**
-   * Final observed PR state; non-OPEN still delivers materials (#676 D6).
-   * Absent/unreadable on old volumes is unknown — never defaulted to OPEN.
-   */
+  groups: CollectorIdentityGroup[] | ReadonlyArray<Record<string, unknown>>;
+  unfinishedReasons?: unknown;
+  host?: string;
+  repository?: string;
+  prNumber?: number;
   prState?: string;
-  manifestDigest: string;
-  activationTime: string;
-  deadlineTime: string;
-  finalObservationTime: string;
-  finalSnapshotId: string;
-  targetHead: string;
-  groups: CollectorIdentityGroup[];
-  unfinishedReasons?: string[];
-  /**
-   * Distinguishes readable-empty from unprojected original submission content (#676 C).
-   * Package leaf may carry a partial projection when some sibling keys are unreadable —
-   * missing keys stay absent (never defaulted false/0/OPEN).
-   */
-  submissionProjection?: Partial<CollectorSubmissionProjection>;
-  requestAttempts: CollectorRequestAttempt[];
-  snapshots: CollectorSnapshot[];
-  evidenceRecords: CollectorEvidenceRecord[];
+  manifestDigest?: string;
 };
-
-function safeGet(value: unknown, key: string): unknown {
-  if ((typeof value !== "object" && typeof value !== "function") || value === null) return undefined;
-  try { return (value as Record<string, unknown>)[key]; } catch { return undefined; }
-}
-function records(value: unknown): Record<string, unknown>[] {
-  return Array.isArray(value) ? value.filter((item): item is Record<string, unknown> => item !== null && typeof item === "object") : [];
-}
-function strings(value: unknown): string[] {
-  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
-}
-
-/** Settlement projection. Presence of the canonical groups array is the one Collector terminal discriminator. */
-export function validateAcceptedCollectorReceipt(value: unknown): CollectorReceipt {
-  const rawGroups = safeGet(value, "groups");
-  if (!Array.isArray(rawGroups)) throw new Error("Collector receipt has no typed groups terminal discriminator");
-  const groups = records(rawGroups).map((group) => ({
-    identity: (safeGet(group, "identity") ?? null) as Record<string, unknown> | null,
-    ...(typeof safeGet(group, "displayLogin") === "string" ? { displayLogin: safeGet(group, "displayLogin") as string } : {}),
-    attendance: true as const,
-    materials: records(safeGet(group, "materials")),
-    findings: records(safeGet(group, "findings")),
-  }));
-  const unfinishedRaw = safeGet(value, "unfinishedReasons");
-  const unfinishedReasons = strings(unfinishedRaw);
-  // #676 C: project readable submissionProjection fields independently — do not
-  // drop the whole block when one sibling key is the wrong type (left-拾遗1).
-  const submissionProjection = projectSubmissionProjection(safeGet(value, "submissionProjection"));
-  const prStateRaw = safeGet(value, "prState");
-  const prState = typeof prStateRaw === "string" ? prStateRaw : undefined;
-  return {
-    host: safeGet(value, "host") as "github.com",
-    repository: safeGet(value, "repository") as string,
-    prNumber: safeGet(value, "prNumber") as number,
-    ...(prState === undefined ? {} : { prState }),
-    manifestDigest: safeGet(value, "manifestDigest") as string,
-    activationTime: safeGet(value, "activationTime") as string,
-    deadlineTime: safeGet(value, "deadlineTime") as string,
-    finalObservationTime: safeGet(value, "finalObservationTime") as string,
-    finalSnapshotId: safeGet(value, "finalSnapshotId") as string,
-    targetHead: safeGet(value, "targetHead") as string,
-    groups,
-    ...(unfinishedReasons.length > 0 ? { unfinishedReasons } : {}),
-    ...(submissionProjection === undefined ? {} : { submissionProjection }),
-    requestAttempts: records(safeGet(value, "requestAttempts")) as unknown as CollectorRequestAttempt[],
-    snapshots: records(safeGet(value, "snapshots")).map((snapshot) => ({
-      snapshotId: safeGet(snapshot, "snapshotId"), observedAt: safeGet(snapshot, "observedAt"), completedAt: safeGet(snapshot, "completedAt"), completedMono: safeGet(snapshot, "completedMono"), host: safeGet(snapshot, "host"), repository: safeGet(snapshot, "repository"), prNumber: safeGet(snapshot, "prNumber"), prState: safeGet(snapshot, "prState"), headOid: safeGet(snapshot, "headOid"), complete: safeGet(snapshot, "complete"), evidenceIds: strings(safeGet(snapshot, "evidenceIds")), pageDiagnostics: records(safeGet(snapshot, "pageDiagnostics")), normalizedByteLength: safeGet(snapshot, "normalizedByteLength"),
-    } as CollectorSnapshot)),
-    evidenceRecords: records(safeGet(value, "evidenceRecords")).map((record) => ({ evidenceId: safeGet(record, "evidenceId"), kind: safeGet(record, "kind"), versionId: safeGet(record, "versionId"), contentDigest: safeGet(record, "contentDigest"), firstObservedAt: safeGet(record, "firstObservedAt"), githubId: safeGet(record, "githubId"), authorLogin: safeGet(record, "authorLogin"), htmlUrl: safeGet(record, "htmlUrl"), authoritativeTime: safeGet(record, "authoritativeTime") } as CollectorEvidenceRecord)),
-  };
-}
-
-/** Readable projection facts only; omit keys that are the wrong type — never fabricate defaults. */
-function projectSubmissionProjection(
-  raw: unknown,
-): Partial<CollectorSubmissionProjection> | undefined {
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return undefined;
-  const p = raw as Record<string, unknown>;
-  const out: Partial<CollectorSubmissionProjection> = {};
-  if (
-    p["findingsSource"] === "absent" ||
-    p["findingsSource"] === "array" ||
-    p["findingsSource"] === "unreadable"
-  ) {
-    out.findingsSource = p["findingsSource"];
-  }
-  if (typeof p["findingsProjectedCount"] === "number") {
-    out.findingsProjectedCount = p["findingsProjectedCount"];
-  }
-  if (typeof p["findingsUnprojected"] === "boolean") {
-    out.findingsUnprojected = p["findingsUnprojected"];
-  }
-  if (
-    p["unfinishedReasonsSource"] === "absent" ||
-    p["unfinishedReasonsSource"] === "array" ||
-    p["unfinishedReasonsSource"] === "unreadable"
-  ) {
-    out.unfinishedReasonsSource = p["unfinishedReasonsSource"];
-  }
-  if (typeof p["unfinishedReasonsProjectedCount"] === "number") {
-    out.unfinishedReasonsProjectedCount = p["unfinishedReasonsProjectedCount"];
-  }
-  if (typeof p["unfinishedReasonsUnprojected"] === "boolean") {
-    out.unfinishedReasonsUnprojected = p["unfinishedReasonsUnprojected"];
-  }
-  return Object.keys(out).length > 0 ? out : undefined;
-}

package/src/package-contracts/terminating-tools.ts

@@ -5,7 +5,6 @@
 
 import {
   COLLECTOR_OUTPUT_TOOL,
-  validateAcceptedCollectorReceipt,
   type CollectorReceipt,
 } from "./collector-output.ts";
 import {
@@ -44,7 +43,6 @@ export {
   JUDGE_OUTPUT_TOOL_NAME,
   REVIEWER_OUTPUT_TOOL_NAME,
   MERGER_OUTPUT_TOOL_NAME,
-  validateAcceptedCollectorReceipt,
   validateReviewerIntent,
   validateAcceptedWorkerDetails,
   validateDoctorSubmissionShape,

package/src/packaged-role-registry.ts

@@ -1,6 +1,5 @@
 /** Composition-root unique authoritative public-role records (#509 / #524). */
 import { COLLECTOR_OUTPUT_TOOL } from "./package-contracts/collector-output.ts";
-import { COLLECTOR_WAIT_TOOL } from "./collector-ledger.ts";
 import { GATEKEEPER_OUTPUT_TOOL_NAME } from "./package-contracts/gatekeeper-output.ts";
 import { NAVIGATOR_OUTPUT_TOOL_NAME } from "./package-contracts/navigator-output.ts";
 import { JUDGE_OUTPUT_TOOL_NAME } from "./package-contracts/judge-output.ts";
@@ -232,23 +231,18 @@ export const PUBLIC_ROLE_RECORDS = [
     ],
   },
   // ak-collector-repo is GitHub owner/repo identity, not a local material path (#438).
+  // #1088: seat + request-manifest kept; code no longer collects — LLM uses host CLI.
   {
     role: "collector",
     inCallAutoResume: false,
     presentSettled: "always",
     summonResume: false,
     admission: "collect-target",
-    /** Public no_receipt projects a durable bind-target rejection. */
-    projectTargetBindRejection: true,
     sameParent: "none",
     phases: [null],
     bareCommand: false,
     outputTool: COLLECTOR_OUTPUT_TOOL,
-    settlement: "residual",
-    /** #633: a prior wait-tool residual must not mask this attempt. */
-    residualScan: "current-attempt",
-    residualTool: COLLECTOR_WAIT_TOOL,
-    runnerFailure: "collector-known-first",
+    settlement: "sealed",
     artifactFace: {
       evidenceRole: true,
       leaves: [
@@ -264,10 +258,13 @@ export const PUBLIC_ROLE_RECORDS = [
       { field: "repo", from: "repository.display", flag: "ak-collector-repo" },
       { field: "pr", from: "prNumber", text: true, flag: "ak-collector-pr" },
       { field: "requestManifestPath", flag: "ak-collector-request-manifest" },
-      { field: "waitMs", from: "waitWindowMs", text: true, flag: "ak-collector-wait-ms" },
     ],
     activationStage: "load-and-install",
-    sessionMaterials: ["CLAUDE.md", "souls/collector.md"],
+    sessionMaterials: [
+      "CLAUDE.md",
+      "souls/collector.md",
+      "resources/collector-bot-handbook.md",
+    ],
   },
   {
     role: "doctor",