@akagilnc/pi-workflow-roles 0.1.3749 → 0.1.3771

package/dist/collector-target.js

@@ -0,0 +1,169 @@
+/**
+ * #676 D1: Collector admission target recognition on structured git context.
+ * Explicit PR wins (no association queries). Otherwise gather online candidates
+ * from structured upstream head and HEAD commit association only. Deduped unique
+ * → bind; many → require explicit --pr; zero → unbound so the role can decide
+ * from task materials via the bind-target business tool. No task-text scrape,
+ * no second state machine. Git/config/transport failures keep true cause.
+ */
+import { execFileSync } from "node:child_process";
+import { createGhApiRunner, listPullRequestNumbersByCommit, listPullRequestNumbersByHead, } from "./collector-github.js";
+import { CliUsageError } from "./public-cli/cli-errors.js";
+import { ownerFromGitHubRemoteUrl, ownerRepoFromGitHubRemoteUrl, } from "./public-cli/github-remote.js";
+function ambiguousTarget(detail, cause) {
+    throw new CliUsageError(`collector target is ambiguous: ${detail}; pass an explicit --pr`, cause === undefined ? undefined : { cause });
+}
+/** Real git failure — not target ambiguity. Propagates with true cause on exit 1. */
+function gitFailure(detail, cause) {
+    throw new Error(`collector git failed: ${detail}`, {
+        cause: cause instanceof Error ? cause : new Error(String(cause)),
+    });
+}
+function gitText(projectRoot, args) {
+    return execFileSync("git", [...args], {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+/** git config --get exit 1 = key absent; other failures keep true cause. */
+function isGitConfigMissing(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const status = error.status;
+    return status === 1;
+}
+function readCurrentBranch(projectRoot) {
+    try {
+        return gitText(projectRoot, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    }
+    catch (error) {
+        gitFailure("cannot read current git branch", error);
+    }
+}
+function readHeadSha(projectRoot) {
+    try {
+        return gitText(projectRoot, ["rev-parse", "HEAD"]);
+    }
+    catch (error) {
+        gitFailure("cannot read current HEAD", error);
+    }
+}
+/**
+ * Head ref short name from branch.<name>.merge (refs/heads/<ref> or bare ref).
+ * Non-heads merge forms are not a structured head binding.
+ */
+function headRefFromMerge(merge) {
+    const trimmed = merge.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (trimmed.startsWith("refs/heads/")) {
+        const ref = trimmed.slice("refs/heads/".length);
+        return ref.length > 0 ? ref : undefined;
+    }
+    // Reject other refs/* (e.g. refs/remotes/…) — not a PR head ref binding.
+    if (trimmed.startsWith("refs/"))
+        return undefined;
+    return trimmed;
+}
+/**
+ * Real upstream head owner + head ref from branch.<name>.remote/merge when configured.
+ * Missing config keys = not configured (undefined). Config/remote execution failures
+ * throw with true cause — never swallowed as "no upstream, keep fallback".
+ */
+function readUpstreamHeadBinding(projectRoot, branch) {
+    let remote;
+    try {
+        remote = gitText(projectRoot, ["config", "--get", `branch.${branch}.remote`]);
+    }
+    catch (error) {
+        if (isGitConfigMissing(error))
+            remote = undefined;
+        else
+            gitFailure(`cannot read branch.${branch}.remote`, error);
+    }
+    if (remote === undefined || remote.length === 0)
+        return undefined;
+    let merge;
+    try {
+        merge = gitText(projectRoot, ["config", "--get", `branch.${branch}.merge`]);
+    }
+    catch (error) {
+        if (isGitConfigMissing(error))
+            merge = undefined;
+        else
+            gitFailure(`cannot read branch.${branch}.merge`, error);
+    }
+    if (merge === undefined || merge.length === 0)
+        return undefined;
+    const headRef = headRefFromMerge(merge);
+    if (headRef === undefined)
+        return undefined;
+    let remoteUrl;
+    try {
+        remoteUrl = gitText(projectRoot, ["remote", "get-url", remote]);
+    }
+    catch (error) {
+        gitFailure(`cannot read remote URL for ${remote}`, error);
+    }
+    const headOwner = ownerFromGitHubRemoteUrl(remoteUrl);
+    if (headOwner === undefined)
+        return undefined;
+    return { headOwner, headRef };
+}
+/**
+ * Resolve the Collector PR target without guessing from task text.
+ * - Explicit `--pr` → that number (no association queries).
+ * - Otherwise: full online candidates (upstream head + HEAD commit), deduped.
+ * - Exactly 1 → bound. >1 → require explicit `--pr`. 0 → unbound (role bind tool).
+ * - Git/config/transport/HTTP/JSON failures propagate with true cause.
+ */
+export async function resolveCollectorTarget(input) {
+    if (input.explicitPrNumber !== undefined) {
+        return { kind: "bound", prNumber: input.explicitPrNumber };
+    }
+    const branch = readCurrentBranch(input.projectRoot);
+    const detached = branch.length === 0 || branch === "HEAD";
+    // Detached HEAD cannot associate via branch head; commit association still runs.
+    const runner = createGhApiRunner();
+    const { owner, repo } = input.repository;
+    const numbers = [];
+    if (!detached) {
+        const headSha = readHeadSha(input.projectRoot);
+        const upstream = readUpstreamHeadBinding(input.projectRoot, branch);
+        // Prefer structured head owner:ref from real upstream merge binding (fork-safe).
+        if (upstream !== undefined) {
+            numbers.push(...(await listPullRequestNumbersByHead(runner, {
+                owner,
+                repo,
+                headOwner: upstream.headOwner,
+                headRef: upstream.headRef,
+            })));
+        }
+        // Always also take commit association — never let a sole upstream hit hide a conflict.
+        numbers.push(...(await listPullRequestNumbersByCommit(runner, {
+            owner,
+            repo,
+            commitSha: headSha,
+        })));
+    }
+    else {
+        // Detached: commit association only (no branch head).
+        const headSha = readHeadSha(input.projectRoot);
+        numbers.push(...(await listPullRequestNumbersByCommit(runner, {
+            owner,
+            repo,
+            commitSha: headSha,
+        })));
+    }
+    const unique = [...new Set(numbers)];
+    if (unique.length === 1) {
+        return { kind: "bound", prNumber: unique[0] };
+    }
+    if (unique.length > 1) {
+        ambiguousTarget(`multiple PRs associated with context: ${unique.join(", ")}`);
+    }
+    // Zero structured git hits — leave unbound so the role can decide from materials.
+    return { kind: "unbound" };
+}
+export { ownerRepoFromGitHubRemoteUrl, ownerFromGitHubRemoteUrl };

package/dist/collector-tool-schemas.js

@@ -1,5 +1,6 @@
 import { Type } from "typebox";
 import { COLLECTOR_ELIGIBILITY_MS } from "./collector-evidence.js";
+import { openToolObject } from "./open-tool-schema.js";
 import { withInfrastructureFailureDeclaration } from "./package-contracts/terminating-infrastructure.js";
 export const collectorObserveArgsSchema = Type.Object({}, { additionalProperties: false });
 export const collectorRequestArgsSchema = Type.Object({
@@ -13,21 +14,57 @@ export const collectorWaitArgsSchema = Type.Object({
     durationMs: Type.Integer({ minimum: 1, maximum: COLLECTOR_ELIGIBILITY_MS, description: "等待毫秒；单次上限五分钟且不超剩余资格" }),
 }, { additionalProperties: false });
 /**
- * #641 chain①: the collector LLM does the splitting/classification (#245:
- * 他自己就是llm为什么不能读不能拆). Findings are submitted as pointer refs into
- * the stored evidence; the runtime enriches each with the machine pointer
- * (repo/PR/comment id/url/author/kind/时间) and validates resolvability.
- * Category is a short LLM classification label, never a body transcription.
+ * #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 collectorFindingArgsSchema = Type.Object({
-    evidenceId: Type.String({ minLength: 1, description: "observe 返回的材料证据 id（evidenceId）" }),
-    category: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "该 finding 的简短归类标签；需要头部之外的正文时先用 ak_collector_read 开卷再判读，不得誊写评论正文" })),
-}, { additionalProperties: false });
-export const collectorOutputBaseSchema = Type.Object({
-    findings: Type.Optional(Type.Array(collectorFindingArgsSchema, {
-        description: "本次收集到的逐条 findings；零 finding 的模板通知不得进入。正常完工无 finding 时省略。",
+export const collectorBindTargetArgsSchema = Type.Object({
+    prNumber: Type.Optional(Type.Unknown({
+        description: "角色判定的本仓 PR 号（正整数）。与 issueNumber 二选一或同指唯一目标。形状指引，非 schema 闸。",
     })),
-}, { additionalProperties: true, description: "正常完工提交空对象 {}；仅在基础设施真实失败时才填写 infrastructureFailure，无失败时必须省略该字段。" });
+    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);
-collectorOutputArgsSchema.required = [];

package/dist/package-contracts/collector-output.js

@@ -25,10 +25,16 @@ function validateAcceptedCollectorReceipt(value) {
     materials: records(safeGet(group, "materials")),
     findings: records(safeGet(group, "findings"))
   }));
+  const unfinishedRaw = safeGet(value, "unfinishedReasons");
+  const unfinishedReasons = strings(unfinishedRaw);
+  const submissionProjection = projectSubmissionProjection(safeGet(value, "submissionProjection"));
+  const prStateRaw = safeGet(value, "prState");
+  const prState = typeof prStateRaw === "string" ? prStateRaw : void 0;
   return {
     host: safeGet(value, "host"),
     repository: safeGet(value, "repository"),
     prNumber: safeGet(value, "prNumber"),
+    ...prState === void 0 ? {} : { prState },
     manifestDigest: safeGet(value, "manifestDigest"),
     activationTime: safeGet(value, "activationTime"),
     deadlineTime: safeGet(value, "deadlineTime"),
@@ -36,6 +42,8 @@ function validateAcceptedCollectorReceipt(value) {
     finalSnapshotId: safeGet(value, "finalSnapshotId"),
     targetHead: safeGet(value, "targetHead"),
     groups,
+    ...unfinishedReasons.length > 0 ? { unfinishedReasons } : {},
+    ...submissionProjection === void 0 ? {} : { submissionProjection },
     requestAttempts: records(safeGet(value, "requestAttempts")),
     snapshots: records(safeGet(value, "snapshots")).map((snapshot) => ({
       snapshotId: safeGet(snapshot, "snapshotId"),
@@ -55,6 +63,30 @@ function validateAcceptedCollectorReceipt(value) {
     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") }))
   };
 }
+function projectSubmissionProjection(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const p = raw;
+  const out = {};
+  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 : void 0;
+}
 export {
   COLLECTOR_ACCEPTED_TEXT,
   COLLECTOR_HOST,

package/dist/package-contracts/terminating-infrastructure.js

@@ -1,20 +1,21 @@
 import { Type } from "typebox";
 const INFRASTRUCTURE_FAILURE_DECLARATION_KEY = "infrastructureFailure";
 const INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY = "diagnostic";
+const infrastructureFailureNested = Type.Object(
+  {
+    [INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY]: Type.Unknown({
+      description: "\u975E\u7A7A\u57FA\u7840\u8BBE\u65BD\u5931\u8D25\u8BCA\u65AD\u5B57\u7B26\u4E32\u3002\u65E0\u5931\u8D25\u65F6\u5FC5\u987B\u7701\u7565\u6574\u4E2A infrastructureFailure\u3002\u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\u3002"
+    })
+  },
+  {
+    additionalProperties: true,
+    description: "\u57FA\u7840\u8BBE\u65BD\u771F\u5B9E\u5931\u8D25\u58F0\u660E\uFF08\u5982\u9700\uFF09\u3002\u89C4\u8303\u5F62\uFF1A{ diagnostic: \u975E\u7A7A\u8BCA\u65AD\u5B57\u7B26\u4E32 }\uFF1B\u65E0\u5931\u8D25\u65F6\u5FC5\u987B\u7701\u7565\u3002\u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\u3002"
+  }
+);
+infrastructureFailureNested.required = [];
 const infrastructureFailureDeclarationSchema = Type.Object(
   {
-    [INFRASTRUCTURE_FAILURE_DECLARATION_KEY]: Type.Object(
-      {
-        [INFRASTRUCTURE_FAILURE_DIAGNOSTIC_KEY]: Type.String({
-          minLength: 1,
-          description: "\u975E\u7A7A\u57FA\u7840\u8BBE\u65BD\u5931\u8D25\u8BCA\u65AD"
-        })
-      },
-      {
-        additionalProperties: true,
-        description: "\u57FA\u7840\u8BBE\u65BD\u5931\u8D25\u58F0\u660E"
-      }
-    )
+    [INFRASTRUCTURE_FAILURE_DECLARATION_KEY]: infrastructureFailureNested
   },
   { additionalProperties: true }
 );

package/dist/pi/role-turn-host.js

@@ -91,8 +91,7 @@ function buildActivationFlagArgs(activation) {
                 "collector",
                 "--ak-collector-repo",
                 activation.repo,
-                "--ak-collector-pr",
-                activation.pr,
+                ...(activation.pr === undefined ? [] : ["--ak-collector-pr", activation.pr]),
                 ...(activation.requestManifestPath === undefined
                     ? []
                     : ["--ak-collector-request-manifest", activation.requestManifestPath]),

package/dist/public-cli/github-remote.js

@@ -0,0 +1,45 @@
+/**
+ * Shared github.com remote URL → owner/repo parse (#676 B/D7).
+ * One authority for collector admission origin and upstream head owner.
+ */
+/** Parse owner from a github.com remote URL; undefined when not a GitHub owner/repo remote. */
+export function ownerFromGitHubRemoteUrl(remoteUrl) {
+    const ownerRepo = ownerRepoFromGitHubRemoteUrl(remoteUrl);
+    if (ownerRepo === undefined)
+        return undefined;
+    return ownerRepo.split("/")[0].toLowerCase();
+}
+/** Parse owner/repo identity from a github.com remote URL; undefined when not exact. */
+export function ownerRepoFromGitHubRemoteUrl(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    // git@github.com:owner/repo.git — exact owner/repo identity only.
+    const scp = /^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i.exec(trimmed);
+    if (scp) {
+        return `${scp[1]}/${stripGitSuffix(scp[2])}`;
+    }
+    // ssh://git@github.com/owner/repo(.git) — exact owner/repo identity only.
+    const ssh = /^ssh:\/\/git@github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i.exec(trimmed);
+    if (ssh) {
+        return `${ssh[1]}/${stripGitSuffix(ssh[2])}`;
+    }
+    // https://github.com/owner/repo(.git) and git://github.com/... — exact two-segment path.
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+    if (!/^github\.com$/i.test(parsed.hostname))
+        return undefined;
+    // Non-identity URL material (query/hash/extra path) is not a repository remote.
+    if (parsed.search !== "" || parsed.hash !== "")
+        return undefined;
+    const parts = parsed.pathname.split("/").filter((p) => p.length > 0);
+    if (parts.length !== 2)
+        return undefined;
+    return `${parts[0]}/${stripGitSuffix(parts[1])}`;
+}
+function stripGitSuffix(name) {
+    return name.toLowerCase().endsWith(".git") ? name.slice(0, -4) : name;
+}

package/dist/public-cli/invocation.js

@@ -10,7 +10,9 @@ import { activationBookDirectory, ensureRealDirectoryTree, homeFromRunDirectory,
 import { resolveBookKeyFromGit } from "../activation-ledger-git.js";
 import { readRunTicketNumber } from "../run-ticket-number.js";
 import { loadDoctorCase, } from "../doctor-evidence.js";
-import { COLLECTOR_FIXED_KICKOFF, emptyCollectorManifest, loadCollectorManifest, parseCollectorPrNumber, parseCollectorRepository, } from "../collector-config.js";
+import { emptyCollectorManifest, loadCollectorManifest, parseCollectorPrNumber, parseCollectorRepository, } from "../collector-config.js";
+import { resolveCollectorTarget } from "../collector-target.js";
+import { ownerRepoFromGitHubRemoteUrl } from "./github-remote.js";
 import { FixerPacketValidationError, parseFixerPrerequisites, } from "../package-contracts/fixer-packet.js";
 import { createProductionMergerGitState } from "../merger-git-state.js";
 import { validateMergerInput, } from "../merger-contracts.js";
@@ -1020,10 +1022,11 @@ export function parseCollectorArgv(args) {
         }
         positional.push(token);
     }
-    // Unconditional required (e.g. --pr) from typed table via shared consumer (#342).
+    // Unconditional required from typed table via shared consumer (#342).
+    // #676 D1: --pr is optional; ambiguous targets reject at admission, not by guessing.
     options.assertRequired();
     return {
-        prNumber: prNumber,
+        ...(prNumber === undefined ? {} : { prNumber }),
         instruction: positional.join(" "),
         attachmentPaths,
         ...(project === undefined ? {} : { project }),
@@ -1034,6 +1037,7 @@ export function parseCollectorArgv(args) {
 /**
  * Resolve owner/repo from the project's `origin` remote (github.com only).
  * Supports https and SSH GitHub URL shapes; never scrapes instruction prose.
+ * Missing origin / non-github remote → usage. Git execution failure → true cause (exit 1).
  */
 export function resolveGitHubRemoteRepository(projectRoot) {
     let remoteUrl;
@@ -1045,7 +1049,13 @@ export function resolveGitHubRemoteRepository(projectRoot) {
         }).trim();
     }
     catch (error) {
-        throw new CliUsageError("collector requires a github.com origin remote or an explicit --repo owner/repo", { cause: error });
+        // git remote get-url exit 2 = no such remote; other failures keep true cause.
+        if (isGitRemoteMissing(error)) {
+            throw new CliUsageError("collector requires a github.com origin remote or an explicit --repo owner/repo", { cause: error });
+        }
+        throw new Error("collector git failed: cannot read origin remote URL", {
+            cause: error instanceof Error ? error : new Error(String(error)),
+        });
     }
     if (remoteUrl.length === 0) {
         throw new CliUsageError("collector requires a github.com origin remote or an explicit --repo owner/repo");
@@ -1062,55 +1072,34 @@ export function resolveGitHubRemoteRepository(projectRoot) {
         throw new CliUsageError(detail, { cause: error });
     }
 }
-function ownerRepoFromGitHubRemoteUrl(remoteUrl) {
-    const trimmed = remoteUrl.trim();
-    // git@github.com:owner/repo.git — exact owner/repo identity only.
-    const scp = /^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i.exec(trimmed);
-    if (scp) {
-        return `${scp[1]}/${stripGitSuffix(scp[2])}`;
-    }
-    // ssh://git@github.com/owner/repo(.git) — exact owner/repo identity only.
-    const ssh = /^ssh:\/\/git@github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i.exec(trimmed);
-    if (ssh) {
-        return `${ssh[1]}/${stripGitSuffix(ssh[2])}`;
-    }
-    // https://github.com/owner/repo(.git) and git://github.com/... — exact two-segment path.
-    let parsed;
-    try {
-        parsed = new URL(trimmed);
-    }
-    catch {
-        return undefined;
-    }
-    if (!/^github\.com$/i.test(parsed.hostname))
-        return undefined;
-    // Non-identity URL material (query/hash/extra path) is not a repository remote.
-    if (parsed.search !== "" || parsed.hash !== "")
-        return undefined;
-    const parts = parsed.pathname.split("/").filter((p) => p.length > 0);
-    if (parts.length !== 2)
-        return undefined;
-    return `${parts[0]}/${stripGitSuffix(parts[1])}`;
-}
-function stripGitSuffix(name) {
-    return name.toLowerCase().endsWith(".git") ? name.slice(0, -4) : name;
+/**
+ * git remote get-url: exit 2 = no such remote on common git (missing config).
+ * Other statuses keep true cause — do not broaden into usage (#676 B).
+ */
+function isGitRemoteMissing(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const status = error.status;
+    return status === 2;
 }
 /**
  * Admit a Collector Role run: assemble the retained leg manifest from typed
- * declarations, resolve repository identity, and place the session under #78.
- * Does not preflight PR/author existence against GitHub.
+ * declarations, resolve repository + PR target (#676 D1), and place the session under #78.
+ * Explicit PR is not preflighted for existence; context resolution uses online association.
  */
 export async function admitCollectorInvocation(options) {
     if (options.project !== undefined) {
         requireOptionPath("--project", options.project);
     }
-    let prNumber;
-    try {
-        prNumber = parseCollectorPrNumber(options.prNumber);
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        throw new CliUsageError(detail, { cause: error });
+    let explicitPrNumber;
+    if (options.prNumber !== undefined) {
+        try {
+            explicitPrNumber = parseCollectorPrNumber(options.prNumber);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new CliUsageError(detail, { cause: error });
+        }
     }
     const projectRoot = resolve(options.project ?? options.cwd);
     let repository;
@@ -1149,14 +1138,23 @@ export async function admitCollectorInvocation(options) {
     const attachmentsDirectory = join(runDirectory, "attachments");
     ensureRealDirectoryTree(ledgerHome, sessionDirectory);
     ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
+    // #676 A: freeze task materials BEFORE target resolution so the role receives
+    // real instruction + attachments. Admission binds only explicit --pr or unique
+    // head/commit association — task-text scrape is not a target lock.
     const attachments = await freezeAttachments(options.attachmentPaths ?? [], attachmentsDirectory);
+    const instruction = options.instruction ?? "";
+    const instructionEmpty = instruction.trim() === "";
+    const target = await resolveCollectorTarget({
+        projectRoot,
+        repository,
+        ...(explicitPrNumber === undefined ? {} : { explicitPrNumber }),
+    });
+    const prNumber = target.kind === "bound" ? target.prNumber : undefined;
     let requestManifestPath;
     if (manifestCanonicalJson !== undefined) {
         requestManifestPath = join(runDirectory, "request-manifest.json");
         await writeFile(requestManifestPath, manifestCanonicalJson, "utf8");
     }
-    const instruction = options.instruction ?? "";
-    const instructionEmpty = instruction.trim() === "";
     const admitted = {
         role: "collector",
         runId,
@@ -1166,7 +1164,7 @@ export async function admitCollectorInvocation(options) {
         principal,
         instruction,
         instructionEmpty,
-        prNumber,
+        ...(prNumber === undefined ? {} : { prNumber }),
         repository: repository.canonical,
         repositoryDisplay: repository.display,
         ...(requestManifestPath === undefined ? {} : { requestManifestPath }),
@@ -1196,19 +1194,20 @@ export async function admitCollectorInvocation(options) {
         runDirectory,
         principal,
         admittedRequestPath,
-        prNumber,
+        ...(prNumber === undefined ? {} : { prNumber }),
         repository,
         ...(requestManifestPath === undefined ? {} : { requestManifestPath }),
         manifestDigest,
     };
 }
 /**
- * Collector always consumes the fixed packaged kickoff (one-shot observation).
- * Optional public instruction is retained only in the admitted request.
+ * #676 A: Collector consumes the real call task + frozen attachments so the role
+ * can identify issue/PR from materials via ak_collector_bind_target. Explicit --pr
+ * still wins at admission; unique head/commit association also binds. No fixed
+ * kickoff rewrite of the caller task; no mechanical task-text target lock.
  */
-export function buildCollectorTransportPrompt(_admitted, engineMaterial) {
-    // Exact historical fixed kickoff bytes (one-shot observation).
-    return appendEngineSessionMaterial([COLLECTOR_FIXED_KICKOFF], engineMaterial).join("\n");
+export function buildCollectorTransportPrompt(admitted, engineMaterial) {
+    return buildInstructionTransportPrompt(admitted, engineMaterial);
 }
 /** Positive Issue number grammar shared with Doctor case path identity. */
 const DOCTOR_ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/;