@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/internal/manual-validation.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { locateActivityLog, pairEntries } from '../task/activity-log.js';
+import { activityWarnings } from '../task/activity-log.js';
+import { lifecycleExecutions } from '../task/lifecycle-execution.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { prepareAndRenderPrSummaryContent } from '../platform/pr-summary.js';
 import { applyTaskEvent } from '../task/events.js';
@@ -39,17 +40,14 @@ function openManualValidationStarted(taskMdPath) {
     catch {
         return { present: false, transactionId: null };
     }
-    const section = locateActivityLog(content);
-    if (!section)
-        return { present: false, transactionId: null };
-    const row = pairEntries(section.entries)
-        .filter((item) => item.step === 'Complete Manual Validation' && item.started && !item.done)
+    const row = lifecycleExecutions(content)
+        .filter((item) => item.family === 'manual-validation')
         .at(-1);
     if (!row)
         return { present: false, transactionId: null };
     return {
         present: true,
-        transactionId: /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(row.note)?.[1] ?? null
+        transactionId: row.transactionId ?? null
     };
 }
 async function executeManualValidationTransaction(taskRef, values, cwd, options = {}) {
@@ -106,7 +104,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
     if (!transactionResult.ok && transactionResult.error.code !== 'MANUAL_VALIDATION_TRANSACTION_MISSING')
         return result('failed', transactionResult.error);
     if (transactionResult.ok && transactionResult.value.phase === 'committed')
-        return result('applied', null, { transaction: transactionResult.value, receipt: transactionResult.value.committedReceipt, idempotent: true });
+        return result('applied', null, { transaction: transactionResult.value, receipt: transactionResult.value.committedReceipt, idempotent: true, warnings: activityWarnings(taskContent) });
     const openStarted = transactionResult.ok ? { present: false, transactionId: null } : openManualValidationStarted(resolved.taskMdPath);
     if (openStarted.present && !openStarted.transactionId) {
         return result('failed', { code: 'MANUAL_VALIDATION_TRANSACTION_RECOVERY_REQUIRED', message: 'open manual-validation started event has no recoverable transactionId' });
@@ -134,12 +132,17 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
     });
     let transaction;
     const idempotent = transactionResult.ok;
+    const warnings = [];
+    const currentWarnings = () => warnings.length
+        ? warnings.filter((warning, index) => warnings.findIndex((item) => item.code === warning.code && item.message === warning.message) === index)
+        : activityWarnings(taskContent);
     let startedEventApplied = false;
     if (!transactionResult.ok) {
         transaction = createTransaction();
         const started = applyTaskEvent({ taskRef, event: 'manual-validation.started', agent, initiator: 'model', requestId: transactionId, reasonCode: 'user-request', transactionId }, { repoRoot: cwd });
         if (started.status === 'failed')
             return result('failed', started.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation started event failed' });
+        warnings.push(...(started.warnings ?? []));
         startedEventApplied = true;
         if (previousTransaction) {
             try {
@@ -165,9 +168,10 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
         const started = applyTaskEvent({ taskRef, event: 'manual-validation.started', agent, initiator: 'model', requestId: transaction.transactionId, reasonCode: 'user-request', transactionId: transaction.transactionId }, { repoRoot: cwd });
         if (started.status === 'failed')
             return result('failed', started.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation started event failed' });
+        warnings.push(...(started.warnings ?? []));
     }
     if (prepareOnly)
-        return result('applied', null, { transaction, prepared: true, idempotent });
+        return result('applied', null, { transaction, prepared: true, idempotent, warnings: currentWarnings() });
     const transactionFailure = (failure) => {
         throw new Error(`${failure.code}: ${failure.message}`);
     };
@@ -224,6 +228,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
             const completed = applyTaskEvent({ taskRef, event: 'manual-validation.completed', agent, initiator: 'model', requestId: transaction.transactionId, reasonCode: 'user-request', artifact: values.artifact, summaryResult: 'human-confirmed validation and committed receipt', transactionId: transaction.transactionId, receiptDigest: receipt.receiptDigest, prHeadSha: receipt.prHeadSha }, { repoRoot: cwd });
             if (completed.status === 'failed')
                 transactionFailure(completed.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation completion event failed' });
+            warnings.push(...(completed.warnings ?? []));
             transitionAndPersist('receipt-committed', { eventAppended: true });
         }
         if (transaction.phase === 'receipt-committed') {
@@ -239,7 +244,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
         if (!/^###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)\s*$/mu.test(postWrite.comment?.body ?? '') || postWrite.pullRequest?.head.sha !== receipt.prHeadSha || !manualValidationFinalSummaryProjectionMatches(postWrite.comment?.body ?? '', receipt))
             transactionFailure({ code: 'MANUAL_VALIDATION_TRANSACTION_RECOVERY_REQUIRED', message: 'final summary post-write verification failed' });
         transitionAndPersist('committed', { postWriteVerified: true });
-        return result('applied', null, { transaction, receipt, idempotent: false });
+        return result('applied', null, { transaction, receipt, idempotent: false, warnings: currentWarnings() });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -309,6 +314,9 @@ async function manualValidation(args = []) {
     const format = values.format === 'text' ? 'text' : 'json';
     const output = await executeManualValidationTransaction(taskRef, values, path.resolve(values.cwd ?? process.cwd()));
     process.stdout.write(format === 'json' ? `${JSON.stringify(output)}\n` : `${output.status === 'applied' ? 'Manual validation transaction committed.' : `${output.error?.code}: ${output.error?.message}`}\n`);
+    if (format === 'text' && Array.isArray(output.warnings))
+        for (const warning of output.warnings)
+            process.stderr.write(`${warning.code}: ${warning.message}\n`);
     if (output.status === 'failed')
         process.exitCode = 1;
 }

package/dist/lib/internal/task-create.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { requestSandboxTaskCreate, SandboxControlClientError } from '../sandbox/control/client.js';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.js';
 import { validateTaskCreateCandidate } from '../task/create.js';
-import { createTask, parseTaskCreateResult, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../task/create-service.js';
+import { createTask, parseTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../task/create-service.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 function failed(code, message, retryable = false, control) {
     return taskCreateFailure({ code, message, retryable }, control);

package/dist/lib/internal/task-event.js

@@ -2,7 +2,7 @@ import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.j
 import { applyTaskEvent, eventCatalog } from '../task/events.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
+const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
 Events: ${eventCatalog.join(', ')}
@@ -31,13 +31,6 @@ export function parseTaskEventRequest(args) {
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--orchestrated') {
-            if (seen.has(flag))
-                throw new Error(`duplicate option '${flag}'`);
-            seen.add(flag);
-            request.orchestrated = true;
-            continue;
-        }
         if (flag === '--dry-run') {
             if (seen.has(flag))
                 throw new Error(`duplicate option '${flag}'`);

package/dist/lib/internal/task-finalization.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';

package/dist/lib/internal/task-lifecycle.js

@@ -3,7 +3,7 @@ import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { loadSandboxControlLocation } from '../sandbox/config.js';
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\nrecover-started: --auto\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\n`;
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -56,7 +56,7 @@ async function taskLifecycle(args = []) {
     const controlLocation = loadSandboxControlLocation(repoRoot);
     const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }), operation);
     process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict')
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskLifecycle };

package/dist/lib/internal/task-operation-registry.js

@@ -1,9 +1,8 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { accessSandboxTaskView, parseSandboxTaskView, taskViewFromStatus } from '../sandbox/control/task-view.js';
+import { accessSandboxTaskView, taskViewFromStatus } from '../sandbox/control/task-view.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { PUBLIC_CLI_COMMAND_ALIASES, PUBLIC_CLI_SELECTOR_ALIASES, internalRouteSelector } from './cli-route-inventory.js';
-import { hasSandboxControlMarker, resolveSandboxControlTransport, sandboxTaskMarkerState } from '../sandbox/environment.js';
+import { hasSandboxControlMarker, sandboxTaskMarkerState } from '../sandbox/environment.js';
 export { resolveSandboxControlTransport } from '../sandbox/environment.js';
 const descriptor = (dispatcher, command, selector, scope, effect, taskRefSource = scope === 'non-task' ? 'none' : 'argv') => ({ dispatcher, command, selector, scope, effect, taskRefSource, guardBeforeImport: true });
 function internalTaskRoutes() {
@@ -19,12 +18,6 @@ function internalTaskRoutes() {
         descriptor('internal', 'sandbox-control', 'client', 'conditional', 'progress', 'delegated'),
         descriptor('internal', 'agent-client', 'next-steps', 'non-task', 'diagnostic', 'none'),
         descriptor('internal', 'agent-client', 'model-selection', 'non-task', 'diagnostic', 'none'),
-        descriptor('internal', 'agent-client', 'launch-carrier', 'non-task', 'diagnostic', 'none'),
-        descriptor('internal', 'codex-lifecycle', 'preflight', 'non-task', 'diagnostic', 'none'),
-        descriptor('internal', 'codex-lifecycle', 'hook-event', 'conditional', 'progress'),
-        descriptor('internal', 'codex-lifecycle', 'resolve-start', 'conditional', 'progress'),
-        descriptor('internal', 'codex-lifecycle', 'resolve-stop', 'conditional', 'progress'),
-        descriptor('internal', 'codex-lifecycle', 'consume', 'conditional', 'progress'),
         descriptor('internal', 'git-workflow', 'inspect', 'conditional', 'diagnostic'),
         descriptor('internal', 'git-workflow', 'preview-tree', 'conditional', 'diagnostic'),
         descriptor('internal', 'git-workflow', 'snapshot', 'conditional', 'diagnostic'),
@@ -97,8 +90,6 @@ function internalTaskRoutes() {
         descriptor('internal', 'task-artifact', 'init', 'task-bound', 'artifact-write'),
         descriptor('internal', 'task-artifact', 'preflight', 'task-bound', 'artifact-write'),
         descriptor('internal', 'task-artifact', 'finalize-local', 'task-bound', 'artifact-write'),
-        descriptor('internal', 'task-orchestration', 'status', 'task-bound', 'diagnostic'),
-        descriptor('internal', 'task-orchestration', 'progress', 'task-bound', 'progress'),
         descriptor('internal', 'task-review', 'preflight', 'task-bound', 'artifact-write'),
         descriptor('internal', 'task-review', 'finalize-summary', 'task-bound', 'progress'),
         descriptor('internal', 'task-event', 'event', 'task-bound', 'progress'),
@@ -174,11 +165,11 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
     ...PUBLIC_OPERATION_DESCRIPTORS
 ]);
 export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
-    'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle',
+    'task-create', 'task-qualification', 'sandbox-control', 'agent-client',
     'git-workflow', 'task-delivery', 'release-workflow', 'platform-release-notes', 'platform-security', 'platform-metadata', 'platform-context',
     'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
     'platform-checks', 'task-context', 'task-workspace', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
-    'task-orchestration', 'task-review', 'task-event', 'task-lifecycle',
+    'task-review', 'task-event', 'task-lifecycle',
     'task-finalization', 'task-platform-recovery', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);
 export const PUBLIC_DISPATCHER_ROUTES = Object.freeze([
@@ -228,8 +219,6 @@ export function resolveDelegatedTaskOperation(args) {
     const [operation, ...rest] = args;
     if (operation !== 'client' || !rest[0])
         return null;
-    if (rest[0] === 'task-orchestration')
-        return null;
     return resolveTaskOperation('internal', rest[0], rest.slice(1));
 }
 function explicitTaskRefForOperation(dispatcher, command, args, selected) {
@@ -253,8 +242,6 @@ function explicitTaskRefForOperation(dispatcher, command, args, selected) {
         }
         return command === 'merge' ? null : first(args) || null;
     }
-    if (command === 'codex-lifecycle')
-        return optionValue(args, '--task-id') ?? null;
     if (command === 'platform-comment' || command === 'platform-issue') {
         return first(args) === 'list' ? null : args[1] ?? null;
     }
@@ -391,7 +378,4 @@ export function guardTaskOperation(dispatcher, command, args = [], options = {})
     }
     return { descriptor: selected, taskView };
 }
-export function assertTaskViewStatus(value) {
-    return parseSandboxTaskView(value);
-}
 //# sourceMappingURL=task-operation-registry.js.map

package/dist/lib/internal/task-review.js

@@ -2,7 +2,7 @@ import { parseReviewCommand } from '../task/review-command.js';
 import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--dry-run]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -28,7 +28,7 @@ async function taskReview(args = []) {
         failUsage(error instanceof Error ? error.message : String(error));
         return;
     }
-    const { stage, artifact, dryRun, orchestrated } = request;
+    const { stage, artifact, dryRun } = request;
     const operation = args[1];
     const resolved = resolveTaskRef(args[0]);
     if (!resolved.ok) {
@@ -36,8 +36,8 @@ async function taskReview(args = []) {
         return;
     }
     const result = operation === 'preflight'
-        ? preflightReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun })
-        : finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun });
+        ? preflightReviewSummary({ taskRef: args[0], stage, artifact, dryRun })
+        : finalizeReviewSummary({ taskRef: args[0], stage, artifact, dryRun });
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

package/dist/lib/platform/comment-safety.js

@@ -75,12 +75,6 @@ function escapeHtml(value) {
 function escapeHtmlText(value) {
     return escapeHtml(value);
 }
-function escapeHtmlAttribute(value) {
-    return escapeHtml(value);
-}
-function escapeMarkdownLiteral(value) {
-    return value.replace(/[\\`*_{}\[\]()#+.!|<>-]/g, '\\$&');
-}
 function markerSafe(value, markers) {
     let result = value;
     for (const marker of markers) {
@@ -231,5 +225,5 @@ function splitDocumentPlaceholder(value, placeholder) {
     }
     return ok({ prefix: source.slice(0, position), suffix: source.slice(position + placeholder.length) });
 }
-export { CONTROL_MARKER_PATTERN, escapeHtmlAttribute, escapeHtmlText, escapeMarkdownLiteral, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, canonicalizeSummaryBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
+export { CONTROL_MARKER_PATTERN, escapeHtmlText, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, canonicalizeSummaryBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
 //# sourceMappingURL=comment-safety.js.map

package/dist/lib/platform/in-label-sync.js

@@ -129,16 +129,6 @@ function flattenPages(value) {
         return [];
     return value.flatMap((page) => Array.isArray(page) ? page : [page]);
 }
-function extractRepositoryLabelNames(value) {
-    return flattenPages(value).flatMap((entry) => {
-        if (typeof entry === 'string')
-            return [entry];
-        if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
-            return [entry.name];
-        }
-        return [];
-    }).filter(Boolean).sort();
-}
 function extractPullRequestFileNames(value) {
     const entries = flattenPages(value);
     if (!Array.isArray(value) || entries.some((entry) => !entry || typeof entry !== 'object'))
@@ -148,8 +138,5 @@ function extractPullRequestFileNames(value) {
         return null;
     return [...new Set(names)].sort();
 }
-function resourceSnapshot(kind, number, labels) {
-    return { kind, number, labels: [...labels].sort() };
-}
-export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, inLabelMappingDigest, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
+export { extractPullRequestFileNames, flattenPages, inLabels, inLabelMappingDigest, labelDelta, mergeInLabels, planInLabelUpdate, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
 //# sourceMappingURL=in-label-sync.js.map

package/dist/lib/platform/issue-comments.js

@@ -101,9 +101,6 @@ function renderTaskCommentResult(content, taskId, language = '') {
 function renderTaskComment(content, taskId, _agent, language = '') {
     return renderTaskCommentResult(content, taskId, language).body;
 }
-function isTaskCommentTooLarge(content, taskId = 'TASK-UNKNOWN', _agent = 'codex') {
-    return renderTaskCommentResult(content, taskId).byteLength > COMMENT_BYTE_LIMIT;
-}
 function taskCommentLanguage(repoRoot) {
     try {
         const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
@@ -301,18 +298,6 @@ function chunkArtifactComment(input) {
 function findMarkerComments(comments, marker) {
     return comments.filter((comment) => normalizeCommentContent(String(comment.body || '')).split('\n', 1)[0] === marker);
 }
-function flattenComments(value) {
-    if (!Array.isArray(value))
-        return [];
-    const flattened = value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
-    return flattened.filter((entry) => Boolean(entry && typeof entry === 'object' && (typeof entry.id === 'number' || typeof entry.id === 'string') && typeof entry.body === 'string'));
-}
-function listRemoteComments(client, repo, issue, cwd) {
-    const result = client.json([
-        'api', '--paginate', '--slurp', `repos/${repo}/issues/${issue}/comments?per_page=100`
-    ], { cwd });
-    return result.ok ? { ok: true, value: flattenComments(result.value) } : result;
-}
 function contextFields(context) {
     return {
         platform: context.platform,
@@ -872,5 +857,5 @@ async function checkPlatformCommentOwner(taskRef, options = {}) {
     }
     return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity }, error: null });
 }
-export { COMMENT_BYTE_LIMIT, MARKERS, chunkArtifactComment, inspectPlatformCommentOperation, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, renderTaskCommentResult, syncCommentPlan, isTaskCommentTooLarge, syncPlatformComment, validateRelatedMarkerSet };
+export { COMMENT_BYTE_LIMIT, MARKERS, chunkArtifactComment, inspectPlatformCommentOperation, findMarkerComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, renderTaskCommentResult, syncCommentPlan, syncPlatformComment, validateRelatedMarkerSet };
 //# sourceMappingURL=issue-comments.js.map

package/dist/lib/platform/issues.js

@@ -11,7 +11,7 @@ import { writeTask } from '../task/write.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { DEFAULT_REQUIREMENT_SECTION_ANCHORS, chooseMilestone, desiredIssueType, normalizeOption, planIssueMetadata } from './issue-metadata.js';
 import { platformResult } from './types.js';
-import { labelDelta, inLabelMappingDigest, planInLabelUpdate, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload } from './in-label-sync.js';
+import { labelDelta, inLabelMappingDigest, planInLabelUpdate, validateInLabelMapping, } from './in-label-sync.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceIdentity, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityEquals, resourceIdentityNumber, resourceIdentityString, serializeResourceIdentity } from './resource-identity.js';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js';

package/dist/lib/platform/operation-coordinator.js

@@ -14,7 +14,8 @@ async function coordinatePlatformWrite(input) {
             retryable: true
         });
     }
-    const selection = input.operation.kind === 'issue-metadata' && input.operation.issueMetadata?.state === 'closed'
+    const boundedPr = input.operation.kind === 'pull-request' && input.operation.dependency === 'required';
+    const selection = boundedPr || input.operation.kind === 'issue-metadata' && input.operation.issueMetadata?.state === 'closed'
         ? 'all' : input.operation.dependency;
     const drained = input.drain
         ? await input.drain(input.operation.taskRef, operationId, input.agent, input.operation.cwd)
@@ -22,7 +23,8 @@ async function coordinatePlatformWrite(input) {
             agent: input.agent,
             client: input.client,
             cwd: input.operation.cwd,
-            excludeId: operationId
+            excludeId: operationId,
+            ...(boundedPr ? { beforeId: operationId } : {})
         });
     if (drained.status !== 'applied' && drained.status !== 'no-op') {
         return input.block(drained.error ? { ...drained.error, retryable: true } : {

package/dist/lib/platform/pr-change-report.js

@@ -435,9 +435,6 @@ function buildPrChangeReport(identity, taskIntentSha256, mechanical, candidate)
         precheck
     });
 }
-function reportFilePath(taskDir) {
-    return path.join(taskDir, REPORT_FILE_NAME);
-}
 function readPrChangeReport(file) {
     try {
         const stat = fs.lstatSync(file);
@@ -698,5 +695,5 @@ function replaceCanonicalReportPlaceholder(body, report) {
         return invalid('summary contains a reserved control marker', 'PR_SUMMARY_RENDER_INVALID');
     return { ok: true, value };
 }
-export { CANONICAL_REPORT_HEADING, CANONICAL_REPORT_PLACEHOLDER, PRECHECK_IDS, REPORT_FILE_NAME, REPORT_VERSION, buildPrChangeReport, readPrChangeReport, renderCanonicalChangeReport, replaceCanonicalReportPlaceholder, reportFilePath, runMechanicalChangeReport, taskIntentDigest, taskIntentProjection, validateMechanicalReport, validatePrecheckCandidate, validatePrChangeReport, writePrChangeReportAtomic };
+export { CANONICAL_REPORT_HEADING, CANONICAL_REPORT_PLACEHOLDER, PRECHECK_IDS, REPORT_FILE_NAME, REPORT_VERSION, buildPrChangeReport, readPrChangeReport, renderCanonicalChangeReport, replaceCanonicalReportPlaceholder, runMechanicalChangeReport, taskIntentDigest, taskIntentProjection, validateMechanicalReport, validatePrecheckCandidate, validatePrChangeReport, writePrChangeReportAtomic };
 //# sourceMappingURL=pr-change-report.js.map

package/dist/lib/platform/pr-checks.js

@@ -6,7 +6,7 @@ import { resolvePlatformProviderContext } from './context.js';
 import { inspectPlatformPullRequest } from './pull-requests.js';
 import { platformResult } from './types.js';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
-import { providerError, providerOperationContext, providerStatus, resourceIdentity, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.js';
+import { providerError, providerOperationContext, providerStatus, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.js';
 function classifyRequiredChecks(required) {
     if (required.length === 0)
         return { state: 'no-required', required };
@@ -27,12 +27,6 @@ function classifyPullRequestReadiness(input) {
         return { state: 'pending', headSha: input.headSha };
     return { state: 'ready', headSha: input.headSha };
 }
-function resolveRunCandidate(candidates, headSha, checkName) {
-    const matches = candidates.filter((candidate) => candidate.headSha === headSha && candidate.name === checkName);
-    if (matches.length === 1)
-        return { status: 'resolved', runId: matches[0].id, jobId: matches[0].jobId || null };
-    return { status: matches.length === 0 ? 'missing' : 'ambiguous', runId: null, jobId: null };
-}
 function checksResult(status, overrides = {}) {
     return {
         ...platformResult(status),
@@ -228,5 +222,5 @@ async function fetchPlatformCheckLogs(taskRef, options) {
         });
     }
 }
-export { classifyPullRequestReadiness, classifyRequiredChecks, fetchPlatformCheckLogs, inspectRequiredChecks, inspectPullRequestReadiness, resolvePlatformCheckRun, resolveRunCandidate, watchPullRequestReadiness };
+export { classifyPullRequestReadiness, classifyRequiredChecks, fetchPlatformCheckLogs, inspectRequiredChecks, inspectPullRequestReadiness, resolvePlatformCheckRun, watchPullRequestReadiness };
 //# sourceMappingURL=pr-checks.js.map

package/dist/lib/platform/provider-validation.js

@@ -290,15 +290,6 @@ function validateSecurityAlert(value) {
         data: jsonValue(item.data, 'security alert.data')
     };
 }
-function validateLabelDefinition(value, label) {
-    const item = record(value, label);
-    exactKeys(item, ['name', 'color', 'description'], label);
-    return {
-        name: stringValue(item.name, `${label}.name`),
-        color: stringValue(item.color, `${label}.color`),
-        description: stringValue(item.description, `${label}.description`, true)
-    };
-}
 function validateLabelReconciliation(value) {
     const item = record(value, 'label reconciliation');
     exactKeys(item, ['changed', 'created', 'updated', 'removed', 'skipped'], 'label reconciliation');
@@ -311,17 +302,6 @@ function validateLabelReconciliation(value) {
         skipped: names('skipped')
     };
 }
-function validateMilestoneDefinition(value, label) {
-    const item = record(value, label);
-    exactKeys(item, ['title', 'description', 'state'], label);
-    if (item.state !== 'open' && item.state !== 'closed')
-        throw new Error(`${label}.state is invalid`);
-    return {
-        title: stringValue(item.title, `${label}.title`),
-        description: stringValue(item.description, `${label}.description`, true),
-        state: item.state
-    };
-}
 function validateMilestoneInitialization(value) {
     const item = record(value, 'milestone initialization');
     exactKeys(item, ['changed', 'created', 'skipped'], 'milestone initialization');