@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/platform/task-identities.js

@@ -0,0 +1,31 @@
+import { parseResourceIdentity } from './resource-identity.js';
+import { isLegacyCompatibilityEnabled, legacyCompatibilityError, VERSION } from '../version.js';
+import { parse as parseYaml } from 'yaml';
+function taskIssueIdentity(frontmatter, _declaration, runtimeVersion = VERSION) {
+    const serialized = frontmatter.platform_issue_identity;
+    if (typeof serialized === 'string' && serialized.trim()) {
+        try {
+            const decoded = parseYaml(serialized);
+            return parseResourceIdentity(JSON.parse(typeof decoded === 'string' ? decoded : serialized), 'platform_issue_identity');
+        }
+        catch {
+            return null;
+        }
+    }
+    const legacy = frontmatter.issue_number;
+    const number = typeof legacy === 'number' ? legacy : typeof legacy === 'string' && /^[1-9]\d*$/u.test(legacy) ? Number(legacy) : NaN;
+    // TODO(compat): Remove the numeric issue_number fallback before the first stable v1.0.0 release.
+    if (Number.isSafeInteger(number) && number > 0 && !isLegacyCompatibilityEnabled(runtimeVersion)) {
+        throw legacyCompatibilityError('issue_number', runtimeVersion);
+    }
+    return Number.isSafeInteger(number) && number > 0 ? { kind: 'number', value: number } : null;
+}
+function taskIssueIdentityError(error) {
+    const value = error && typeof error === 'object' ? error : {};
+    return {
+        code: typeof value.code === 'string' ? value.code : 'PLATFORM_IDENTITY_INVALID',
+        message: error instanceof Error ? error.message : String(error)
+    };
+}
+export { taskIssueIdentity, taskIssueIdentityError };
+//# sourceMappingURL=task-identities.js.map

package/dist/lib/platform/verification-required.js

@@ -1,17 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
-import { hasPlatformCapability } from "./adapters.js";
 import { inspectRequiredChecks } from "./pr-checks.js";
-import { resolvePlatformContext } from "./context.js";
+import { resolvePlatformProviderContext } from "./context.js";
 import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
+import { resourceIdentityNumber } from "./resource-identity.js";
 const CHECK_TYPE = "required-checks";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
-function validPrNumber(value) {
-    const parsed = Number(value);
-    return Number.isInteger(parsed) && parsed > 0;
-}
 function readPrFlow(repoRoot) {
     try {
         const config = JSON.parse(fs.readFileSync(path.join(repoRoot, ".agents", ".airc.json"), "utf8"));
@@ -36,8 +32,9 @@ export function evaluateRequiredChecks(context, shared) {
         return shared.failResult(CHECK_TYPE, factRead.error.message, "check_failed");
     }
     const fact = factRead.status === "valid" ? factRead.fact : null;
-    const prNumber = fact?.state === "bound" ? fact.identity.number : null;
-    if (prFlow === "disabled" || fact?.state === "skipped" || !validPrNumber(prNumber)) {
+    const prIdentity = fact?.state === "bound" ? fact.identity.resource : null;
+    const prNumber = resourceIdentityNumber(prIdentity);
+    if (prFlow === "disabled" || fact?.state === "skipped" || !prIdentity) {
         return shared.passResult(CHECK_TYPE, "Skipped: required checks are not applicable to this task");
     }
     const reviewedHead = String(metadata.last_reviewed_commit || "");
@@ -80,7 +77,7 @@ export function evaluateRequiredChecks(context, shared) {
     }
     return shared.failResult(CHECK_TYPE, inspection.error?.message || `Required checks are ${state || "unavailable"}`, "check_failed");
 }
-export function check({ taskDir }, shared) {
+export async function check({ taskDir }, shared) {
     const task = shared.loadTask(taskDir);
     if (!task.ok)
         return shared.failResult(CHECK_TYPE, task.message);
@@ -92,14 +89,16 @@ export function check({ taskDir }, shared) {
     if (prFlow === "disabled" || (factRead.status === "valid" && factRead.fact.state === "skipped") || !bound) {
         return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
     }
-    const platform = resolvePlatformContext({ cwd: shared.repoRoot });
-    if (!hasPlatformCapability(platform.platform.type, "required-checks")) {
+    const loaded = await resolvePlatformProviderContext({ cwd: shared.repoRoot });
+    const platform = loaded.ok ? loaded.value.context : loaded.context;
+    const supportsChecks = loaded.ok && Boolean(loaded.value.provider.checks?.inspectRequired);
+    if (!supportsChecks) {
         return shared.blockedResult(CHECK_TYPE, `Platform '${platform.platform.type || "none"}' does not provide required-checks inspection`, "dependency_error");
     }
     const localHead = readHead(shared.repoRoot);
     if (!localHead)
         return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection: null, prFlow }, shared);
-    const inspection = inspectRequiredChecks(task.metadata.id, { cwd: shared.repoRoot });
+    const inspection = await inspectRequiredChecks(task.metadata.id, { cwd: shared.repoRoot });
     return evaluateRequiredChecks({
         metadata: task.metadata,
         localHead,

package/dist/lib/platform/verification-sync.js

@@ -2,14 +2,14 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { execFileSync } from "node:child_process";
-import { createGitHubClient } from "./github-client.js";
-import { resolvePlatformContext } from "./context.js";
+import { resolvePlatformProviderContext } from "./context.js";
 import { hasCheckedRequirement, resolveRequirementSection } from "./issue-metadata.js";
-import { inspectGitHubIssueMetadata, requirementSectionAnchors } from "./issues.js";
-import { listRemoteComments } from "./issue-comments.js";
+import { requirementSectionAnchors } from "./issues.js";
 import { taskTypeLabel } from "./metadata-labels.js";
-import { inspectGitHubPullRequest } from "./pull-requests.js";
+import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.js";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
+import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.js";
+import { taskIssueIdentity } from "./task-identities.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
 const FRONTMATTER_FIELD_MAP = {
@@ -26,7 +26,6 @@ const OPTION_LOCALIZATION = {
 };
 let activeShared = null;
 let repoRoot = "";
-const githubClient = createGitHubClient();
 export function getDefaults() {
     return {
         statusLabels: {
@@ -79,20 +78,14 @@ function blockedResult(...args) {
 function safeStat(...args) {
     return getShared().safeStat(...args);
 }
-function parseIssueNumber(...args) {
-    return getShared().parseIssueNumber(...args);
-}
-function parsePrNumber(...args) {
-    return getShared().parsePrNumber(...args);
-}
-export function check({ taskDir, config, artifactFile }, shared) {
+export async function check({ taskDir, config, artifactFile }, shared) {
     activeShared = shared;
     repoRoot = shared.repoRoot;
-    const context = buildSyncContext({ taskDir, config, artifactFile });
+    const context = await buildSyncContext({ taskDir, config, artifactFile });
     if (context.earlyReturn) {
         return context.earlyReturn;
     }
-    const remoteData = fetchRemoteData(context);
+    const remoteData = await fetchRemoteData(context);
     if (remoteData.earlyReturn) {
         return remoteData.earlyReturn;
     }
@@ -120,29 +113,32 @@ export function check({ taskDir, config, artifactFile }, shared) {
             return result;
         }
     }
-    return passResult(CHECK_TYPE, `GitHub sync checks passed for Issue #${context.issueNumber}`);
+    return passResult(CHECK_TYPE, `Platform sync checks passed for Issue ${context.issueNumber || "identity"}`);
 }
-function buildSyncContext({ taskDir, config, artifactFile }) {
+async function buildSyncContext({ taskDir, config, artifactFile }) {
     const task = loadTask(taskDir);
     if (!task.ok) {
         return { earlyReturn: failResult(CHECK_TYPE, task.message) };
     }
-    const issueNumber = parseIssueNumber(task.metadata.issue_number);
+    const issueIdentity = taskIssueIdentity(task.metadata);
+    const issueNumber = resourceIdentityNumber(issueIdentity);
     const fact = readPrDeliveryFact(task.metadata);
     if (fact.status === "invalid") {
         return { earlyReturn: failResult(CHECK_TYPE, fact.error.message, "check_failed") };
     }
-    const prNumber = fact.status === "valid" && fact.fact.state === "bound" ? fact.fact.identity.number : null;
-    if (config.when === "issue_number_exists" && !issueNumber) {
+    const prIdentity = fact.status === "valid" && fact.fact.state === "bound" ? fact.fact.identity.resource : null;
+    const prNumber = resourceIdentityNumber(prIdentity);
+    if (config.when === "issue_number_exists" && !issueIdentity) {
         return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no issue_number") };
     }
-    if (config.when === "pr_fact_bound" && !prNumber) {
+    if (config.when === "pr_fact_bound" && !prIdentity) {
         return { earlyReturn: passResult(CHECK_TYPE, "Skipped: task has no verified bound pull request") };
     }
-    if (!issueNumber) {
+    if (!issueIdentity) {
         return { earlyReturn: passResult(CHECK_TYPE, "Skipped: platform-sync not required for this task") };
     }
-    const platformContext = resolvePlatformContext({ cwd: repoRoot, client: githubClient });
+    const loaded = await resolvePlatformProviderContext({ cwd: repoRoot });
+    const platformContext = loaded.ok ? loaded.value.context : loaded.context;
     if (platformContext.status === "failed") {
         return { earlyReturn: failResult(CHECK_TYPE, platformContext.error?.message || "Platform context failed", "check_failed") };
     }
@@ -155,7 +151,6 @@ function buildSyncContext({ taskDir, config, artifactFile }) {
         }
         return { earlyReturn: passResult(CHECK_TYPE, `Skipped: ${platformContext.error?.message || "platform unavailable"}`) };
     }
-    const repoOwnerType = detectRepoOwnerType(platformContext.platform.repository, taskDir);
     const expectedValues = resolveExpectedValues(config);
     if (!expectedValues.ok) {
         return { earlyReturn: failResult(CHECK_TYPE, expectedValues.message, "check_failed") };
@@ -173,15 +168,19 @@ function buildSyncContext({ taskDir, config, artifactFile }) {
         config,
         artifactFile,
         artifactPath,
+        issueIdentity,
+        prIdentity,
         issueNumber,
         prNumber,
-        upstreamRepo: platformContext.platform.repository,
-        repoOwnerType,
+        repoOwnerType: String(loaded.ok ? loaded.value.snapshot.metadata?.ownerType || "unknown" : "unknown"),
         hasTriage: platformContext.capabilities.triage,
         hasPush: platformContext.capabilities.push,
         expectedStatusLabel: expectedValues.statusLabel,
         marker,
-        prMarker
+        prMarker,
+        provider: loaded.ok ? loaded.value.provider : null,
+        providerType: loaded.ok ? loaded.value.providerType : null,
+        loadedContext: loaded.ok ? loaded.value : null
     };
 }
 function resolveExpectedValues(config) {
@@ -230,139 +229,93 @@ function resolveDefaultValue({ collection, key, value, configKey }) {
     }
     return { ok: true, value: resolvedValue };
 }
-function fetchRemoteData(context) {
-    const sharedIssue = inspectGitHubIssueMetadata(githubClient, context.upstreamRepo, context.issueNumber, context.taskDir);
-    const issueResult = sharedIssue.ok
-        ? {
-            ok: true,
-            value: {
-                state: sharedIssue.value.state.toUpperCase(),
-                labels: sharedIssue.value.labels.map((name) => ({ name })),
-                body: sharedIssue.value.body,
-                milestone: sharedIssue.value.milestone ? { title: sharedIssue.value.milestone } : null
-            }
-        }
-        : {
-            ok: false,
-            type: sharedIssue.error.retryable ? "network_error" : "check_failed",
-            message: sharedIssue.error.message
-        };
-    if (!issueResult.ok) {
+async function fetchRemoteData(context) {
+    const provider = context.provider;
+    const operationContext = providerOperationContext(context.loadedContext, context.taskDir);
+    const facts = provider?.verification?.fetchRemoteFacts
+        ? await provider.verification.fetchRemoteFacts({
+            context: operationContext,
+            taskId: context.task?.metadata?.id || context.task?.id || "",
+            ...(context.issueIdentity ? { issue: context.issueIdentity } : {}),
+            ...(context.prIdentity ? { changeRequest: context.prIdentity } : {}),
+            includeComments: shouldFetchComments(context.config),
+            includeFields: Boolean(context.config.verify_issue_fields)
+        })
+        : unsupportedProviderOperation(provider, "verification.fetchRemoteFacts");
+    if (!facts.ok) {
         return {
-            earlyReturn: issueResult.type === "check_failed"
-                ? failResult(CHECK_TYPE, issueResult.message, issueResult.type)
-                : blockedResult(CHECK_TYPE, issueResult.message, issueResult.type)
+            earlyReturn: facts.error.retryable
+                ? blockedResult(CHECK_TYPE, providerError(facts.error, "PLATFORM_PROVIDER_OPERATION_FAILED").message, "network_error")
+                : failResult(CHECK_TYPE, providerError(facts.error, "PLATFORM_PROVIDER_OPERATION_FAILED").message, "check_failed")
         };
     }
-    const issue = issueResult.value;
-    if (context.config.issue_must_exist !== false && !issue) {
-        return {
-            earlyReturn: failResult(CHECK_TYPE, `Issue #${context.issueNumber} not found`, "check_failed")
-        };
-    }
-    let comments = null;
-    if (shouldFetchComments(context.config)) {
-        const commentsResult = withRetry(() => ghPaginatedJson([
-            "api",
-            "--paginate",
-            "--slurp",
-            `repos/${context.upstreamRepo}/issues/${context.issueNumber}/comments?per_page=100`
-        ], context.taskDir));
-        if (!commentsResult.ok) {
-            return {
-                earlyReturn: commentsResult.type === "check_failed"
-                    ? failResult(CHECK_TYPE, commentsResult.message, commentsResult.type)
-                    : blockedResult(CHECK_TYPE, commentsResult.message, commentsResult.type)
-            };
-        }
-        comments = flattenComments(commentsResult.value);
-    }
-    let prComments = null;
-    if (context.prMarker) {
-        if (!context.prNumber) {
-            return {
-                earlyReturn: failResult(CHECK_TYPE, "Expected a verified bound pull request for PR comment verification", "check_failed")
-            };
-        }
-        const prCommentsResult = listRemoteComments(githubClient, context.upstreamRepo, context.prNumber, context.taskDir);
-        if (!prCommentsResult.ok) {
-            return {
-                earlyReturn: prCommentsResult.error.retryable
-                    ? blockedResult(CHECK_TYPE, prCommentsResult.error.message, "network_error")
-                    : failResult(CHECK_TYPE, prCommentsResult.error.message, "check_failed")
-            };
-        }
-        prComments = prCommentsResult.value;
-    }
-    let issueType;
-    if (context.config.verify_issue_type && context.hasPush) {
-        const issueTypeResult = withRetry(() => ghText([
-            "api",
-            `repos/${context.upstreamRepo}/issues/${context.issueNumber}`,
-            "--jq",
-            ".type.name // empty"
-        ], context.taskDir));
-        if (issueTypeResult.ok) {
-            issueType = issueTypeResult.value || null;
+    const issueSnapshot = facts.value.issue;
+    const issue = issueSnapshot
+        ? {
+            state: issueSnapshot.state.toUpperCase(),
+            labels: issueSnapshot.labels.map((name) => ({ name })),
+            body: issueSnapshot.body,
+            milestone: issueSnapshot.milestone ? { title: issueSnapshot.milestone } : null
         }
-    }
+        : null;
     let issueFields;
-    if (context.config.verify_issue_fields && context.hasPush) {
-        const [owner, name] = context.upstreamRepo.split("/");
-        const issueFieldsResult = withRetry(() => ghJson([
-            "api",
-            "graphql",
-            "-f",
-            `query=${ISSUE_FIELDS_QUERY}`,
-            "-F",
-            `owner=${owner}`,
-            "-F",
-            `name=${name}`,
-            "-F",
-            `number=${context.issueNumber}`
-        ], context.taskDir));
-        if (issueFieldsResult.ok) {
-            issueFields = normalizeIssueFields(issueFieldsResult.value);
-        }
+    if (context.config.verify_issue_fields && issueSnapshot?.issueType) {
+        const fieldKinds = new Map(issueSnapshot.issueType.fields.map((field) => [field.name, field.kind]));
+        issueFields = {
+            pinnedNames: new Set(issueSnapshot.issueType.fields.map((field) => field.name)),
+            values: new Map(Object.entries(issueSnapshot.fields).map(([name, value]) => [name, { kind: fieldKinds.get(name) || (typeof value === "number" ? "number" : "single-select"), value }]))
+        };
     }
-    let prLabels = null;
-    let prMilestone;
-    let prAssignees;
-    let prHeadSha;
-    if (((context.config.verify_in_labels_match_pr && context.hasTriage)
-        || (context.config.verify_pr_type_label && context.hasTriage)
-        || (context.config.verify_milestone && context.hasTriage)
-        || (context.config.verify_pr_assignee && context.hasPush)
-        || context.config.verify_pr_comment_last_commit_matches_head) && context.prNumber) {
-        const prResult = inspectGitHubPullRequest(githubClient, context.upstreamRepo, context.prNumber, context.taskDir);
-        if (!prResult.ok) {
+    let prComments = null;
+    if (context.prMarker && context.prIdentity && shouldFetchComments(context.config) && provider?.comments?.list) {
+        const listed = await provider.comments.list({ context: operationContext, parent: context.prIdentity });
+        if (!listed.ok)
             return {
-                earlyReturn: prResult.error.retryable
-                    ? blockedResult(CHECK_TYPE, prResult.error.message, "network_error")
-                    : failResult(CHECK_TYPE, prResult.error.message, "check_failed")
+                earlyReturn: listed.error.retryable
+                    ? blockedResult(CHECK_TYPE, listed.error.message, "network_error")
+                    : failResult(CHECK_TYPE, listed.error.message, "check_failed")
             };
+        prComments = listed.value.map((comment) => ({ id: comment.id, body: comment.body }));
+    }
+    const changeRequest = facts.value.changeRequest;
+    let inLabelMapping = {};
+    let repositoryLabels = [];
+    if (context.config.verify_in_labels_computed && context.hasTriage) {
+        const mapping = loadInLabelMapping();
+        if (!mapping.ok)
+            return { earlyReturn: failResult(CHECK_TYPE, mapping.message, "check_failed") };
+        inLabelMapping = mapping.value;
+        if (Object.keys(inLabelMapping).length > 0) {
+            const labels = provider?.issues?.listLabels
+                ? await provider.issues.listLabels({ context: operationContext })
+                : unsupportedProviderOperation(provider, "issues.listLabels");
+            if (!labels.ok) {
+                const error = providerError(labels.error, "PLATFORM_PROVIDER_OPERATION_FAILED");
+                return {
+                    earlyReturn: error.retryable
+                        ? blockedResult(CHECK_TYPE, `${error.code}: ${error.message}`, "network_error")
+                        : failResult(CHECK_TYPE, `${error.code}: ${error.message}`, "check_failed")
+                };
+            }
+            repositoryLabels = labels.value;
         }
-        prLabels = (context.config.verify_in_labels_match_pr || context.config.verify_pr_type_label)
-            ? prResult.value.labels
-            : null;
-        prMilestone = context.config.verify_milestone
-            ? prResult.value.milestone ? { title: prResult.value.milestone } : null
-            : undefined;
-        prAssignees = context.config.verify_pr_assignee
-            ? prResult.value.assignees
-            : undefined;
-        prHeadSha = prResult.value.head.sha;
     }
     return {
         issue,
-        comments,
+        comments: facts.value.comments.map((comment) => ({ id: comment.id, body: comment.body })),
         prComments,
-        prLabels,
-        issueType,
+        prLabels: changeRequest?.labels || null,
+        issueType: issueSnapshot
+            ? (issueSnapshot.issueType ? issueSnapshot.issueType.name : null)
+            : undefined,
         issueFields,
-        prMilestone,
-        prAssignees,
-        prHeadSha
+        prMilestone: changeRequest
+            ? (changeRequest.milestone ? { title: changeRequest.milestone } : null)
+            : undefined,
+        prAssignees: changeRequest?.assignees,
+        prHeadSha: changeRequest?.headSha,
+        inLabelMapping,
+        repositoryLabels
     };
 }
 function mapTaskTypeToLabel(taskType) {
@@ -377,12 +330,6 @@ function shouldFetchComments(config) {
         || config.verify_comment_content
         || config.verify_task_comment_content);
 }
-function flattenComments(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.flatMap((page) => Array.isArray(page) ? page : []);
-}
 function checkStatusLabel(context, remoteData) {
     if (!context.expectedStatusLabel || !context.hasTriage) {
         return null;
@@ -541,7 +488,7 @@ function checkInLabelsComputed(context, remoteData) {
     if (!context.config.verify_in_labels_computed || !context.hasTriage) {
         return null;
     }
-    const expectedInLabels = computeExpectedInLabels(context.taskDir);
+    const expectedInLabels = computeExpectedInLabels(context.taskDir, remoteData.repositoryLabels, remoteData.inLabelMapping);
     if (!expectedInLabels.ok) {
         return expectedInLabels.type === "check_failed"
             ? failResult(CHECK_TYPE, expectedInLabels.message, expectedInLabels.type)
@@ -781,7 +728,6 @@ function mapTaskTypeToIssueType(taskType) {
     };
     return mapping[taskType] || "Task";
 }
-const ISSUE_FIELDS_QUERY = `query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){issue(number:$number){issueType{name pinnedFields{__typename ... on IssueFieldSingleSelect{id name} ... on IssueFieldDate{id name} ... on IssueFieldText{id name} ... on IssueFieldNumber{id name}}} issueFieldValues(first:50){nodes{__typename ... on IssueFieldSingleSelectValue{name optionId field{... on IssueFieldSingleSelect{name}}} ... on IssueFieldDateValue{value field{... on IssueFieldDate{name}}} ... on IssueFieldTextValue{value field{... on IssueFieldText{name}}} ... on IssueFieldNumberValue{value field{... on IssueFieldNumber{name}}}}}}}}`;
 function normalizeIssueFields(payload) {
     const issue = payload?.data?.repository?.issue;
     const pinnedFields = Array.isArray(issue?.issueType?.pinnedFields)
@@ -842,58 +788,37 @@ function arraysEqual(left, right) {
 function formatLabelList(labels) {
     return labels.length > 0 ? labels.join(", ") : "none";
 }
-function computeExpectedInLabels(taskDir) {
-    const changedFilesResult = gitText(["diff", "main...HEAD", "--name-only"], taskDir);
+function computeExpectedInLabels(taskDir, repositoryLabels = [], mappingOverride) {
+    const task = loadTask(taskDir);
+    if (!task.ok) {
+        return task;
+    }
+    const baseRef = String(task.metadata?.delivery_base_ref || "").trim();
+    if (!baseRef) {
+        return { ok: false, type: "check_failed", message: "Task has no delivery_base_ref for in-label evidence" };
+    }
+    const changedFilesResult = gitText(["diff", `${baseRef}...HEAD`, "--name-only"], taskDir);
     if (!changedFilesResult.ok) {
-        return changedFilesResult;
+        return { ...changedFilesResult, type: "network_error" };
     }
     const changedFiles = String(changedFilesResult.value || "")
         .split(/\r?\n/)
         .map((value) => value.trim())
         .filter(Boolean);
-    const mapping = loadInLabelMapping();
-    if (!mapping.ok) {
-        return mapping;
-    }
-    if (Object.keys(mapping.value ?? {}).length > 0) {
-        const labels = new Set();
-        for (const file of changedFiles) {
-            for (const [label, prefixes] of Object.entries(mapping.value ?? {})) {
-                if (prefixes.some((prefix) => file.startsWith(prefix))) {
-                    labels.add(`in: ${label}`);
-                }
-            }
-        }
-        return { ok: true, labels: Array.from(labels).sort(), mode: "mapped" };
-    }
-    const repoLabelsResult = withRetry(() => ghJson([
-        "label",
-        "list",
-        "--limit",
-        "200",
-        "--json",
-        "name"
-    ], taskDir));
-    if (!repoLabelsResult.ok) {
-        return repoLabelsResult;
-    }
-    const repoInLabels = new Set(extractLabelNames(repoLabelsResult.value)
-        .filter((label) => label.startsWith("in:")));
-    if (repoInLabels.size === 0) {
-        return { ok: true, labels: [], mode: "fallback" };
-    }
-    const labels = new Set();
-    for (const file of changedFiles) {
-        const topLevel = file.split("/")[0];
-        if (!topLevel) {
-            continue;
-        }
-        const candidate = `in: ${topLevel}`;
-        if (repoInLabels.has(candidate)) {
-            labels.add(candidate);
-        }
+    const mapping = mappingOverride ?? {};
+    if (Object.keys(mapping).length === 0) {
+        return { ok: true, labels: [], mode: "mapped" };
+    }
+    const planned = planInLabelUpdate({
+        changedFiles,
+        currentLabels: [],
+        mapping,
+        repositoryLabels: new Set(repositoryLabels)
+    });
+    if (planned.error) {
+        return { ok: false, type: "check_failed", message: planned.error.message };
     }
-    return { ok: true, labels: Array.from(labels).sort(), mode: "fallback" };
+    return { ok: true, labels: planned.target, mode: "mapped" };
 }
 function loadInLabelMapping() {
     const configPath = path.join(repoRoot, ".agents", ".airc.json");
@@ -902,60 +827,16 @@ function loadInLabelMapping() {
     }
     try {
         const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        const mapping = config?.labels?.in;
-        if (!mapping || typeof mapping !== "object" || Array.isArray(mapping)) {
-            return { ok: true, value: {} };
-        }
-        const normalized = {};
-        for (const [label, prefixes] of Object.entries(mapping)) {
-            if (!Array.isArray(prefixes)) {
-                continue;
-            }
-            const cleaned = prefixes
-                .map((value) => String(value || "").trim())
-                .filter(Boolean);
-            if (cleaned.length > 0) {
-                normalized[label] = cleaned;
-            }
-        }
-        return { ok: true, value: normalized };
+        const mapping = validateInLabelMapping(config?.labels?.in);
+        return mapping.ok
+            ? { ok: true, value: mapping.value }
+            : { ok: false, type: "check_failed", message: mapping.error.message };
     }
     catch (error) {
         return { ok: false, type: "check_failed", message: `Unable to parse .agents/.airc.json: ${error.message}` };
     }
 }
-// === GitHub API ===
-function detectRepoOwnerType(upstreamRepo, taskDir) {
-    const ownerTypeResult = withRetry(() => ghText([
-        "api",
-        `repos/${upstreamRepo}`,
-        "--jq",
-        ".owner.type // empty"
-    ], taskDir));
-    if (!ownerTypeResult.ok) {
-        return "unknown";
-    }
-    return ownerTypeResult.value || "unknown";
-}
-function ghJson(args, cwd) {
-    return mapClientResult(githubClient.json(args, { cwd }));
-}
-function ghText(args, cwd) {
-    return mapClientResult(githubClient.text(args, { cwd }));
-}
-function ghPaginatedJson(args, cwd) {
-    return ghJson(args, cwd);
-}
-function mapClientResult(result) {
-    if (result.ok)
-        return result;
-    const checkFailed = ["RESOURCE_NOT_FOUND", "PERMISSION_DENIED", "PLATFORM_REQUEST_INVALID"].includes(result.error.code);
-    return {
-        ok: false,
-        type: checkFailed ? "check_failed" : "network_error",
-        message: result.error.message
-    };
-}
+// === Git working tree ===
 function gitText(args, cwd) {
     try {
         const value = execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });

package/dist/lib/pr-review/evidence-grading.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
+import { resourceIdentityEquals, resourceIdentityNumber } from '../platform/resource-identity.js';
+import { taskIssueIdentity } from '../platform/task-identities.js';
 export class HostResolutionError extends Error {
     code;
     constructor(code, message) {
@@ -70,14 +72,23 @@ export function collectHostCandidates(input) {
         catch {
             continue;
         }
-        const issueNumber = toPositiveNumber(frontmatter.issue_number);
+        const issueIdentity = taskIssueIdentity(frontmatter);
+        const issueNumber = resourceIdentityNumber(issueIdentity) ?? toPositiveNumber(frontmatter.issue_number);
         const fact = readPrDeliveryFact(frontmatter);
-        const prNumber = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.number : null;
-        if (prNumber === input.prNumber) {
-            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        const prIdentity = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
+        const prNumber = resourceIdentityNumber(prIdentity);
+        const matchesPr = input.prIdentity
+            ? Boolean(prIdentity && resourceIdentityEquals(prIdentity, input.prIdentity))
+            : input.prNumber !== undefined && prNumber === input.prNumber;
+        const identityDetails = {
+            ...(issueIdentity && issueIdentity.kind !== 'number' ? { issueIdentity } : {}),
+            ...(prIdentity && prIdentity.kind !== 'number' ? { prIdentity } : {})
+        };
+        if (matchesPr) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber, ...identityDetails });
         }
         else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {
-            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber, ...identityDetails });
         }
     }
     return candidates;
@@ -97,7 +108,9 @@ export function resolveHostFromCandidates(candidates) {
             taskId: candidate.taskId,
             taskDir: candidate.taskDir,
             issueNumber: candidate.issueNumber ?? 0,
-            prNumber: candidate.prNumber ?? 0
+            prNumber: candidate.prNumber ?? 0,
+            ...(candidate.issueIdentity ? { issueIdentity: candidate.issueIdentity } : {}),
+            ...(candidate.prIdentity ? { prIdentity: candidate.prIdentity } : {})
         };
     }
     return {