@fitlab-ai/agent-infra 0.11.7 → 0.11.8

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

@@ -0,0 +1,74 @@
+import { recoverPlatformOperations } from '../task/platform-operation-recovery.js';
+import { recordPlatformOperation } from '../task/platform-operation-journal.js';
+async function coordinatePlatformWrite(input) {
+    let operationId;
+    try {
+        const queued = recordPlatformOperation({ ...input.operation, state: 'queued' });
+        operationId = queued.id;
+    }
+    catch (error) {
+        const value = error;
+        return input.persistenceFailure({
+            code: value.code || 'PLATFORM_OPERATION_JOURNAL_WRITE_FAILED',
+            message: value.message || 'Unable to queue platform operation',
+            retryable: true
+        });
+    }
+    const selection = 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)
+        : await recoverPlatformOperations(input.operation.taskRef, selection, {
+            agent: input.agent,
+            client: input.client,
+            cwd: input.operation.cwd,
+            excludeId: operationId
+        });
+    if (drained.status !== 'applied' && drained.status !== 'no-op') {
+        return input.block(drained.error ?? {
+            code: 'PLATFORM_OPERATION_QUEUE_BLOCKED',
+            message: 'A previous platform operation is still unresolved; the current write remains queued',
+            retryable: true
+        });
+    }
+    try {
+        recordPlatformOperation({ ...input.operation, state: 'pending' });
+    }
+    catch (error) {
+        const value = error;
+        return input.persistenceFailure({
+            code: value.code || 'PLATFORM_OPERATION_JOURNAL_WRITE_FAILED',
+            message: value.message || 'Unable to mark platform operation as started',
+            retryable: true
+        });
+    }
+    let output;
+    try {
+        output = await input.execute();
+    }
+    catch (error) {
+        const value = error;
+        output = input.block({ code: value.code || 'PLATFORM_WRITE_FAILED', message: value.message || String(error), retryable: true });
+    }
+    const succeeded = (output.status === 'applied' || output.status === 'no-op')
+        && !output.error && !(output.warnings?.length);
+    const state = succeeded ? 'succeeded' : output.status === 'failed' && output.error?.retryable === false ? 'failed' : 'unknown';
+    try {
+        recordPlatformOperation({
+            ...input.operation,
+            state,
+            lastCode: output.error?.code ?? output.warnings?.[0]?.code ?? null
+        });
+    }
+    catch (error) {
+        const value = error;
+        return input.persistenceFailure({
+            code: value.code || 'PLATFORM_OPERATION_JOURNAL_WRITE_FAILED',
+            message: value.message || 'Unable to persist platform operation outcome',
+            retryable: true
+        });
+    }
+    return output;
+}
+export { coordinatePlatformWrite };
+//# sourceMappingURL=operation-coordinator.js.map

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

@@ -1,7 +1,12 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { coordinatePlatformWrite } from './operation-coordinator.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
-import { isResourceIdentity, resourceIdentityNumber, reviewMarker as resourceReviewMarker } from './resource-identity.js';
+import { isResourceIdentity, resourceIdentityEquals, resourceIdentityNumber, reviewMarker as resourceReviewMarker } from './resource-identity.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
 const REVIEW_EVENTS = ['COMMENT', 'APPROVE', 'REQUEST_CHANGES'];
 // Marker-safe scope: a task id (`TASK-YYYYMMDD-HHMMSS`) or a bare PR number
 // (`pr{N}`). Any other value (e.g. one containing `\r\n` or `-->`) would break
@@ -19,6 +24,34 @@ export function reviewedCommitMarker(sha) {
 function normalizeBody(body) {
     return String(body || '').replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
 }
+function canonicalReviewBody(body) {
+    return normalizeBody(body).replace(/\n$/u, '');
+}
+function reviewArtifactName(round, artifactFile) {
+    return path.basename(artifactFile) === artifactFile
+        && (artifactFile === 'pr-review.md' && round === 1 || artifactFile === `pr-review-r${round}.md`);
+}
+export function readReviewBodyFile(taskRef, round, artifactFile, bodyDigest, cwd) {
+    if (!/^TASK-\d{8}-\d{6}$/u.test(taskRef) || path.basename(artifactFile) !== artifactFile
+        || !reviewArtifactName(round, artifactFile)) {
+        throw Object.assign(new Error('Pull-request review artifact identity is invalid'), { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID' });
+    }
+    const task = resolveTaskRef(taskRef, cwd ? { repoRoot: cwd } : {});
+    if (!task.ok)
+        throw Object.assign(new Error(task.message), { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID' });
+    const bodyFile = artifactFile.replace(/^pr-review/u, 'pr-review-body');
+    const report = fs.readFileSync(path.join(task.taskDir, artifactFile), 'utf8');
+    const bodyReferences = [...report.matchAll(/^\*\*(?:正文文件|Body file)\*\*(?:：|:)\s*`([^`]+)`[^\r\n]*$/gmu)]
+        .map((match) => match[1]);
+    if (bodyReferences.length !== 1 || bodyReferences[0] !== bodyFile) {
+        throw Object.assign(new Error('Pull-request review artifact does not reference its canonical body file'), { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID' });
+    }
+    const body = canonicalReviewBody(fs.readFileSync(path.join(task.taskDir, bodyFile), 'utf8'));
+    if (!body || createHash('sha256').update(body).digest('hex') !== bodyDigest) {
+        throw Object.assign(new Error('Canonical pull-request review body does not match its persisted digest'), { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID' });
+    }
+    return body;
+}
 function firstLine(body) {
     return normalizeBody(String(body || '')).split('\n', 1)[0] || '';
 }
@@ -74,6 +107,13 @@ export async function publishPrReview(options) {
     if (!hasUsableContext(context)) {
         return platformResult(context.status, { platform: context.platform, capabilities: context.capabilities, error: context.error });
     }
+    const providerScopeId = loaded.ok ? loaded.value.snapshot.scope.id : null;
+    if (options.expectedProviderScopeId && providerScopeId !== options.expectedProviderScopeId) {
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            error: { code: 'PLATFORM_OPERATION_IDENTITY_MISMATCH', message: 'Current provider scope differs from the persisted operation target', retryable: false }
+        });
+    }
     const identity = loaded.ok ? (() => { try {
         return providerResourceToken(loaded.value.provider, 'pull-request', String(options.prNumber));
     }
@@ -87,6 +127,13 @@ export async function publishPrReview(options) {
         });
     }
     const identityNumber = resourceIdentityNumber(identity);
+    if (options.expectedResource && !resourceIdentityEquals(identity, options.expectedResource)) {
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: identityNumber, identity },
+            error: { code: 'PLATFORM_OPERATION_IDENTITY_MISMATCH', message: 'Current pull request identity differs from the persisted operation target', retryable: false }
+        });
+    }
     if (!REVIEW_EVENTS.includes(options.event)) {
         return platformResult('failed', {
             platform: context.platform, capabilities: context.capabilities,
@@ -101,6 +148,65 @@ export async function publishPrReview(options) {
             error: { code: 'REVIEW_IDENTITY_INVALID', message: 'review scope must be a task id or pr{N}; commitSha is required', retryable: false }
         });
     }
+    if (/^TASK-\d{8}-\d{6}$/u.test(options.identity.scope) && !options.skipQueue && !options.dryRun) {
+        if (!options.agent)
+            return platformResult('failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: identityNumber, identity },
+                error: { code: 'PR_REVIEW_AGENT_REQUIRED', message: 'task-scoped review publication requires an agent token', retryable: false }
+            });
+        if (!options.recoveryArtifact || !reviewArtifactName(options.identity.round, options.recoveryArtifact))
+            return platformResult('failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: identityNumber, identity },
+                error: { code: 'PR_REVIEW_ARTIFACT_REQUIRED', message: 'task-scoped review publication requires its canonical review artifact', retryable: false }
+            });
+        const body = canonicalReviewBody(options.body);
+        const bodyDigest = createHash('sha256').update(body).digest('hex');
+        try {
+            if (readReviewBodyFile(options.identity.scope, options.identity.round, options.recoveryArtifact, bodyDigest, options.cwd) !== body)
+                throw new Error('body mismatch');
+        }
+        catch {
+            return platformResult('failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: identityNumber, identity },
+                error: { code: 'PR_REVIEW_ARTIFACT_MISMATCH', message: 'Review body must match the canonical review body file', retryable: false }
+            });
+        }
+        const pullRequestReview = {
+            prNumber: String(options.prNumber),
+            resource: identity,
+            providerScopeId: providerScopeId,
+            scope: options.identity.scope,
+            round: options.identity.round,
+            commitSha: options.identity.commitSha,
+            event: options.event,
+            artifactFile: options.recoveryArtifact,
+            bodyDigest
+        };
+        return coordinatePlatformWrite({
+            operation: {
+                taskRef: options.identity.scope,
+                cwd: options.cwd || process.cwd(),
+                kind: 'pull-request-review',
+                target: JSON.stringify(identity),
+                expectedDigest: createHash('sha256').update(JSON.stringify(pullRequestReview)).digest('hex'),
+                dependency: 'deferred',
+                pullRequestReview
+            },
+            agent: options.agent,
+            execute: () => publishPrReview({ ...options, expectedProviderScopeId: providerScopeId, skipQueue: true }),
+            block: (error) => platformResult('blocked', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: identityNumber, identity }, error
+            }),
+            persistenceFailure: (error) => platformResult('failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: identityNumber, identity }, error
+            })
+        });
+    }
     const marker = reviewMarker({ ...options.identity, resource: identity });
     const listed = await listPrReviews(options.prNumber, { cwd: options.cwd, client: options.client });
     if (listed.status === 'failed' || listed.status === 'blocked')

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

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { enumerateArtifacts } from '../task/artifacts.js';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
@@ -9,6 +10,7 @@ import { resolvePlatformProviderContext } from './context.js';
 import { normalizeCommentContent } from './issue-comments.js';
 import { CONTROL_MARKER_PATTERN, sanitizeMarkdownDocument, splitDocumentPlaceholder } from './comment-safety.js';
 import { platformResult } from './types.js';
+import { coordinatePlatformWrite } from './operation-coordinator.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityEquals } from './resource-identity.js';
 import { buildPrChangeReport, CANONICAL_REPORT_PLACEHOLDER, readPrChangeReport, replaceCanonicalReportPlaceholder, runMechanicalChangeReport, taskIntentDigest, validateMechanicalReport, validatePrecheckCandidate, writePrChangeReportAtomic } from './pr-change-report.js';
@@ -609,74 +611,94 @@ async function syncPullRequestSummary(taskRef, options) {
                     operations: [{ name: `summary:${reconciliation.action}`, status: 'planned', reasonCode: null }],
                     result: null, warnings: [], ...info
                 };
-            const existingComment = reconciliation.commentId === null
-                ? undefined
-                : providerResourceToken(loaded.value.provider, 'comment', String(reconciliation.commentId));
-            const written = loaded.value.provider.comments?.write
-                ? await loaded.value.provider.comments.write({
-                    context: providerOperationContext(loaded.value),
-                    parent: prIdentity,
-                    body: desired,
-                    ...(existingComment ? { existingComment } : {}),
-                    mutation: { idempotencyKey: `pr-summary:${resolved.taskId}` }
-                })
-                : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
-            if (!written.ok)
-                return fail(providerStatus(written.error) === 'blocked' ? 'blocked' : 'failed', context, providerError(written.error, 'PLATFORM_PROVIDER_OPERATION_FAILED'), prNumber);
-            const after = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
-            const id = /^\d+$/.test(written.value.remoteId) ? Number(written.value.remoteId) : written.value.remoteId;
-            const compensateWrittenSummary = async () => reconciliation.action === 'create'
-                ? written.value.remoteId && loaded.value.provider.comments?.delete
-                    ? await loaded.value.provider.comments.delete({
-                        context: providerOperationContext(loaded.value),
-                        parent: prIdentity,
-                        comment: providerResourceToken(loaded.value.provider, 'comment', written.value.remoteId),
-                        mutation: { idempotencyKey: `pr-summary-delete:${resolved.taskId}:${written.value.remoteId}` }
-                    })
-                    : { ok: false, error: { code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED', message: 'Created summary comment has no valid id', retryable: true } }
-                : reconciliation.commentId && previousBody !== null && loaded.value.provider.comments?.write
+            const publish = async () => {
+                const existingComment = reconciliation.commentId === null
+                    ? undefined
+                    : providerResourceToken(loaded.value.provider, 'comment', String(reconciliation.commentId));
+                const written = loaded.value.provider.comments?.write
                     ? await loaded.value.provider.comments.write({
                         context: providerOperationContext(loaded.value),
                         parent: prIdentity,
-                        body: previousBody,
-                        existingComment: providerResourceToken(loaded.value.provider, 'comment', String(reconciliation.commentId)),
-                        mutation: { idempotencyKey: `pr-summary-restore:${resolved.taskId}` }
+                        body: desired,
+                        ...(existingComment ? { existingComment } : {}),
+                        mutation: { idempotencyKey: `pr-summary:${resolved.taskId}` }
                     })
-                    : { ok: false, error: { code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED', message: 'Previous summary body is unavailable for restoration', retryable: true } };
-            if (!after.ok) {
-                const compensated = await compensateWrittenSummary();
-                if (!compensated.ok)
+                    : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
+                if (!written.ok)
+                    return fail(providerStatus(written.error) === 'blocked' ? 'blocked' : 'failed', context, providerError(written.error, 'PLATFORM_PROVIDER_OPERATION_FAILED'), prNumber);
+                const after = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
+                const id = /^\d+$/.test(written.value.remoteId) ? Number(written.value.remoteId) : written.value.remoteId;
+                const compensateWrittenSummary = async () => reconciliation.action === 'create'
+                    ? written.value.remoteId && loaded.value.provider.comments?.delete
+                        ? await loaded.value.provider.comments.delete({
+                            context: providerOperationContext(loaded.value),
+                            parent: prIdentity,
+                            comment: providerResourceToken(loaded.value.provider, 'comment', written.value.remoteId),
+                            mutation: { idempotencyKey: `pr-summary-delete:${resolved.taskId}:${written.value.remoteId}` }
+                        })
+                        : { ok: false, error: { code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED', message: 'Created summary comment has no valid id', retryable: true } }
+                    : reconciliation.commentId && previousBody !== null && loaded.value.provider.comments?.write
+                        ? await loaded.value.provider.comments.write({
+                            context: providerOperationContext(loaded.value),
+                            parent: prIdentity,
+                            body: previousBody,
+                            existingComment: providerResourceToken(loaded.value.provider, 'comment', String(reconciliation.commentId)),
+                            mutation: { idempotencyKey: `pr-summary-restore:${resolved.taskId}` }
+                        })
+                        : { ok: false, error: { code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED', message: 'Previous summary body is unavailable for restoration', retryable: true } };
+                if (!after.ok) {
+                    const compensated = await compensateWrittenSummary();
+                    if (!compensated.ok)
+                        return fail('blocked', context, {
+                            code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED',
+                            message: `Summary post-write verification failed and compensation failed: ${compensated.error.message}`,
+                            retryable: true
+                        }, prNumber);
                     return fail('blocked', context, {
-                        code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED',
-                        message: `Summary post-write verification failed and compensation failed: ${compensated.error.message}`,
+                        code: 'PR_SUMMARY_POSTWRITE_VERIFY_FAILED',
+                        message: `Summary was written but pull-request verification failed: ${after.error?.message || 'unknown verification error'}; the previous summary was restored or the new comment was deleted`,
                         retryable: true
                     }, prNumber);
-                return fail('blocked', context, {
-                    code: 'PR_SUMMARY_POSTWRITE_VERIFY_FAILED',
-                    message: `Summary was written but pull-request verification failed: ${after.error?.message || 'unknown verification error'}; the previous summary was restored or the new comment was deleted`,
-                    retryable: true
-                }, prNumber);
-            }
-            if (!sameIdentity(initial.value, after.value)) {
-                const compensated = await compensateWrittenSummary();
-                if (!compensated.ok)
+                }
+                if (!sameIdentity(initial.value, after.value)) {
+                    const compensated = await compensateWrittenSummary();
+                    if (!compensated.ok)
+                        return fail('blocked', context, {
+                            code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED',
+                            message: `Pull-request head changed and summary compensation failed: ${compensated.error.message}`,
+                            retryable: true
+                        }, prNumber);
                     return fail('blocked', context, {
-                        code: 'PR_SUMMARY_RACE_COMPENSATION_FAILED',
-                        message: `Pull-request head changed and summary compensation failed: ${compensated.error.message}`,
+                        code: 'PR_SUMMARY_HEAD_RACE',
+                        message: 'Pull-request head changed while publishing; the previous summary was restored or the new comment was deleted; rerun report and summary sync',
                         retryable: true
                     }, prNumber);
-                return fail('blocked', context, {
-                    code: 'PR_SUMMARY_HEAD_RACE',
-                    message: 'Pull-request head changed while publishing; the previous summary was restored or the new comment was deleted; rerun report and summary sync',
-                    retryable: true
-                }, prNumber);
-            }
-            return {
-                ...basePlatformResult('applied', context, resolved.taskId, prNumber),
-                comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 },
-                operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }],
-                result: null, warnings: [], ...info
+                }
+                return {
+                    ...basePlatformResult('applied', context, resolved.taskId, prNumber),
+                    comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 },
+                    operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }],
+                    result: null, warnings: [], ...info
+                };
+            };
+            const operation = {
+                taskRef: resolved.taskId,
+                cwd: resolved.repoRoot,
+                kind: 'pull-request-summary',
+                target: JSON.stringify(prIdentity),
+                expectedDigest: createHash('sha256').update(desired).digest('hex'),
+                dependency: 'deferred',
+                pullRequestSummary: { body: options.body, changeReportFile: options.changeReportFile }
             };
+            if (options.skipQueue)
+                return publish();
+            return coordinatePlatformWrite({
+                operation,
+                agent: options.agent,
+                execute: publish,
+                block: (error) => fail('blocked', context, error, prNumber),
+                persistenceFailure: (error) => fail('failed', context, error, prNumber)
+            });
         };
         return await (options.lockAlreadyHeld
             ? execute()

package/dist/lib/platform/pull-requests.js

@@ -1,6 +1,7 @@
 import { normalizePullRequest } from './github-data.js';
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
@@ -19,6 +20,7 @@ import { buildBoundFact, buildSkippedFact, factFrontmatterMutation, readPrDelive
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, providerResourceIdentity, resourceIdentity, unsupportedProviderOperation } from './provider-bridge.js';
 import { isResourceIdentity, resourceIdentityEquals, resourceIdentityNumber, serializeResourceIdentity } from './resource-identity.js';
 import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js';
+import { coordinatePlatformWrite } from './operation-coordinator.js';
 function warningResultForPrimary(primaryResult) {
     if (primaryResult === 'pr_created')
         return 'pr_created_with_warnings';
@@ -52,6 +54,25 @@ function externalResult(base, overrides = {}) {
 function withCreation(output, creation) {
     return { ...output, creation };
 }
+async function journalPullRequestOperation(taskRef, options, intent, target, identityInput, execute) {
+    if (options.dryRun)
+        return execute();
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return execute();
+    const expectedDigest = createHash('sha256').update(JSON.stringify({ taskId: resolved.taskId, intent, identityInput })).digest('hex');
+    const operation = { kind: 'pull-request', target: intent.action === 'sync' ? `bound-pr:${resolved.taskId}` : target, expectedDigest };
+    const dependency = intent.action === 'sync' ? 'deferred' : 'required';
+    if (options.skipQueue)
+        return execute();
+    return coordinatePlatformWrite({
+        operation: { taskRef: resolved.taskId, cwd: resolved.repoRoot, ...operation, pullRequest: intent, dependency },
+        agent: options.agent,
+        execute,
+        block: (error) => result('blocked', resolved.taskId, null, null, { error }),
+        persistenceFailure: (error) => result('failed', resolved.taskId, null, null, { error })
+    });
+}
 const PRECONDITION_NOT_CREATED = {
     kind: 'not-created', reason: 'precondition-failed', createdByCurrentOperation: false
 };
@@ -681,7 +702,7 @@ function bindIdentity(base, pullRequest, agent, source, dryRun = false, expected
         ]
     }, { repoRoot: base.resolved.repoRoot, metadataProvider: () => metadata });
 }
-async function bindPlatformPullRequest(taskRef, options) {
+async function bindPlatformPullRequestImpl(taskRef, options) {
     const base = await resolvedContext(taskRef, options);
     if (!base.ok)
         return base.output;
@@ -723,6 +744,10 @@ async function bindPlatformPullRequest(taskRef, options) {
         operations: [{ name: 'task:bind-pr', status: options.dryRun ? 'planned' : written.status === 'no-op' ? 'no-op' : 'applied', reasonCode: null }], error: null
     });
 }
+async function bindPlatformPullRequest(taskRef, options) {
+    const intent = { action: 'bind', prToken: String(options.pr) };
+    return journalPullRequestOperation(taskRef, options, intent, `pr:${options.pr}`, { pr: String(options.pr) }, () => bindPlatformPullRequestImpl(taskRef, options));
+}
 function externalEvidenceNote(issueIdentity, source, pullRequest) {
     return [
         `authorization=${source}`,
@@ -915,7 +940,7 @@ async function resolveExternalPullRequest(taskRef, options) {
         error: null
     }), { mode: 'external', authorization: selected.source, candidates: selected.candidates, eligible: selected.eligible, selected: selectedPullRequest });
 }
-async function createPlatformPullRequest(taskRef, options) {
+async function createPlatformPullRequestImpl(taskRef, options) {
     const base = await resolvedContext(taskRef, options);
     if (!base.ok)
         return withCreation(base.output, PRECONDITION_NOT_CREATED);
@@ -946,6 +971,67 @@ async function createPlatformPullRequest(taskRef, options) {
         }), PRECONDITION_NOT_CREATED);
     }
 }
+async function recoverCreatedPullRequest(taskRef, options) {
+    const base = await resolvedContext(taskRef, options);
+    if (!base.ok)
+        return base.output;
+    if (!base.issueIdentity)
+        return result('failed', base.resolved.taskId, base.issueNumber, base.prNumber, {
+            error: { code: 'PLATFORM_OPERATION_ISSUE_REQUIRED', message: 'Pull-request recovery requires a bound Issue identity', retryable: false }
+        });
+    const head = base.provider.changeRequests?.verifyHead
+        ? await base.provider.changeRequests.verifyHead({ context: providerOperationContext(base.loadedContext), head: options.head })
+        : unsupportedProviderOperation(base.provider, 'changeRequests.verifyHead');
+    if (!head.ok)
+        return providerPullRequestError(base, head.error, base.prNumber);
+    if (base.prIdentity) {
+        const inspected = await inspectExternalPullRequest(base, base.prIdentity);
+        if (!inspected.pullRequest || inspected.status === 'failed' || inspected.status === 'blocked'
+            || inspected.pullRequest.base.repository !== base.context.platform.repository
+            || inspected.pullRequest.base.ref !== options.base || inspected.pullRequest.head.ref !== options.head
+            || inspected.pullRequest.head.sha !== head.value.sha) {
+            return result('blocked', base.resolved.taskId, base.issueNumber, base.prNumber, {
+                error: inspected.error ?? { code: 'PLATFORM_OPERATION_PR_NOT_CONFIRMED', message: 'Bound pull request does not match the pending create intent', retryable: true }
+            });
+        }
+        return inspected;
+    }
+    const candidates = base.provider.changeRequests?.listClosing
+        ? await base.provider.changeRequests.listClosing({ context: providerOperationContext(base.loadedContext), issue: base.issueIdentity })
+        : unsupportedProviderOperation(base.provider, 'changeRequests.listClosing');
+    if (!candidates.ok)
+        return providerPullRequestError(base, candidates.error, null);
+    const matches = candidates.value.map((candidate) => normalizeProviderPullRequest(candidate, base.context.platform.repository, candidate.number || 0))
+        .filter((candidate) => candidate.base.repository === base.context.platform.repository
+        && candidate.base.ref === options.base
+        && candidate.head.repository === base.context.platform.repository
+        && candidate.head.ref === options.head
+        && candidate.head.sha === head.value.sha);
+    if (matches.length !== 1 || !matches[0]?.number)
+        return result('blocked', base.resolved.taskId, base.issueNumber, null, {
+            error: { code: matches.length > 1 ? 'PLATFORM_OPERATION_PR_AMBIGUOUS' : 'PLATFORM_OPERATION_PR_NOT_CONFIRMED',
+                message: 'Pending pull-request creation does not resolve to one exact repository/base/head identity', retryable: true }
+        });
+    const bound = await bindPlatformPullRequest(base.resolved.taskId, { agent: options.agent, cwd: base.resolved.repoRoot, pr: matches[0].number });
+    if (!bound.pullRequest || (bound.status !== 'applied' && bound.status !== 'no-op') || bound.error)
+        return bound;
+    if (bound.pullRequest.base.repository !== base.context.platform.repository || bound.pullRequest.base.ref !== options.base
+        || bound.pullRequest.head.repository !== base.context.platform.repository || bound.pullRequest.head.ref !== options.head
+        || bound.pullRequest.head.sha !== head.value.sha)
+        return result('blocked', base.resolved.taskId, base.issueNumber, bound.task.prNumber, {
+            error: { code: 'PLATFORM_OPERATION_PR_NOT_CONFIRMED', message: 'Bound pull request changed while recovering the create intent', retryable: true }
+        });
+    return bound;
+}
+async function createPlatformPullRequest(taskRef, options) {
+    const intent = { action: 'create', baseRef: options.base, headRef: options.head };
+    const identityInput = {
+        title: createHash('sha256').update(options.title).digest('hex'),
+        body: createHash('sha256').update(options.body).digest('hex'),
+        draft: options.draft === true
+    };
+    return journalPullRequestOperation(taskRef, options, intent, `head:${options.head}:base:${options.base}`, identityInput, () => createPlatformPullRequestImpl(taskRef, options));
+}
 async function createExternalPullRequest(taskRef, options, base) {
     if (!base.fact)
         return withCreation(result('failed', base.resolved.taskId, base.issueNumber, null, {
@@ -1104,7 +1190,7 @@ async function createExternalPullRequest(taskRef, options, base) {
         error: null
     }), { kind: 'created', createdByCurrentOperation: true });
 }
-async function syncPlatformPullRequest(taskRef, options) {
+async function syncPlatformPullRequestImpl(taskRef, options) {
     const warningResult = warningResultForPrimary(options.primaryResult);
     const softenFailure = (output) => {
         const authorityError = output.error?.code.startsWith('IN_LABEL_SYNC') || output.error?.code.startsWith('PR_IDENTITY');
@@ -1288,6 +1374,12 @@ async function syncPlatformPullRequest(taskRef, options) {
         }));
     }
 }
+async function syncPlatformPullRequest(taskRef, options) {
+    const intent = { action: 'sync', metadata: options.metadata === true, closingIssue: options.closingIssue === true };
+    return journalPullRequestOperation(taskRef, options, intent, `bound-pr:${taskRef}`, {
+        metadata: options.metadata === true, closingIssue: options.closingIssue === true
+    }, () => syncPlatformPullRequestImpl(taskRef, options));
+}
 function readProjectPrFlow(repoRoot) {
     try {
         const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
@@ -1386,6 +1478,6 @@ async function skipPlatformPullRequestFact(taskRef, options) {
         });
     }
 }
-export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, selectPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
+export { bindPlatformPullRequest, createPlatformPullRequest, inspectPlatformPullRequest, inspectPlatformPullRequestByNumber, recoverCreatedPullRequest, resolveExternalPullRequest, skipPlatformPullRequestFact, selectExternalPullRequest, selectPullRequest, syncPlatformPullRequest, syncPlatformPullRequestInLabels };
 export { warningResultForPrimary };
 //# sourceMappingURL=pull-requests.js.map

package/dist/lib/sandbox/commands/create.js

@@ -22,6 +22,7 @@ import { atomicWriteJson } from '../control/state.js';
 import { inspectSandboxControlContainer } from '../control/container-identity.js';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from '../mounts.js';
+import { materializeSandboxGitMetadata } from '../git-metadata.js';
 import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTargets, sandboxControlPaths, } from '../workspace-view.js';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
 import { validateSelinuxDisableEnv } from '../engines/selinux.js';
@@ -630,7 +631,8 @@ function runSandboxAuthoritySafeCommand(authority, args) {
 // tmpfs. containerMount is an in-container path, so it is NOT engine-converted.
 export function buildTmpfsRunArgs(containerMount, tmpfs) {
     const size = tmpfs.size ?? '512m';
-    return ['--tmpfs', `${containerMount}:rw,size=${size}`];
+    const options = ['rw', ...(tmpfs.exec ? ['exec'] : []), `size=${size}`];
+    return ['--tmpfs', `${containerMount}:${options.join(',')}`];
 }
 export function buildImage(config, tools, dockerfilePath, imageSignature, { engine, runFn = runEngine, runSafeFn = runSafeEngine, runVerboseFn = runVerboseEngine, env = process.env, refresh = false, lastRefresh, buildProxyArgs = [], buildEnv } = {}) {
     const selectedEngine = engine ?? detectEngine({ engine: config.engine });
@@ -1050,6 +1052,7 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                 engine,
                                 replacementLease,
                             });
+                            const gitMetadata = materializeSandboxGitMetadata(worktree, control.channelDir);
                             hostShellConfig = prepareHostShellConfig({
                                 home: effectiveConfig.home,
                                 project: effectiveConfig.project,
@@ -1057,6 +1060,8 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                 repoRoot: effectiveConfig.repoRoot
                             });
                             const coreVolumes = sandboxCoreBindMounts(effectiveConfig, branch, {
+                                gitCommonDir: gitMetadata.commonDir,
+                                worktreeGitFile: gitMetadata.worktreeGitFile,
                                 worktree,
                                 shellConfigHostDir: hostShellConfig.hostDir,
                                 workspaceViewRoot: workspaceView.root,
@@ -1153,8 +1158,6 @@ export async function create(args, { runProjectInitCommand = true } = {}) {
                                     `${sandboxRuntimeCapabilityLabel(effectiveConfig)}=${capabilityPlan.runtimeSignature}`,
                                     ...coreVolumes,
                                     ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
-                                    '-v',
-                                    volumeArg(engine, path.join(effectiveConfig.repoRoot, '.git'), `${toEnginePath(engine, effectiveConfig.repoRoot)}/.git`),
                                     ...dotfilesMount,
                                     ...toolVolumes,
                                     ...tmpfsArgs,

package/dist/lib/sandbox/commands/ls.js

@@ -15,8 +15,9 @@ display-only row number; the 'SHORT' column shows the active task short
 id bound to each container's branch (via
 .agents/workspace/active/.short-ids.json), or '-' if no active task is
 bound. Pass the SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').
-A '-' means no active task is bound to that branch, so the sandbox is free
-to remove with "ai sandbox rm <branch>".
+A SHORT value of '-' means this container has no active task short id and may
+be eligible for "ai sandbox rm --unbound" cleanup. Use a full TASK-id to
+remove a specific task-bound sandbox.
 
 Use "ai sandbox show <ref>" for a single sandbox's worktree and per-tool
 state paths.`;
@@ -63,7 +64,7 @@ export function ls(args = []) {
             process.stdout.write(`  ${row.name}: health=${controlStatus?.state ?? 'unavailable'} task-view=${controlStatus?.taskView.state ?? 'unavailable'}\n`);
         }
         if (tableRows.some((r) => r.shortId === '-')) {
-            process.stdout.write(`  SHORT '-' = no active task bound; that sandbox is free to remove with 'ai sandbox rm <branch>'.\n`);
+            process.stdout.write(`  SHORT '-' = no active task short id is displayed; --unbound may clean this sandbox if its branch is not tied to an active task.\n`);
         }
     }
 }

package/dist/lib/sandbox/commands/rm.js

@@ -8,7 +8,7 @@ import { fetchSandboxRows } from './list-running.js';
 import { rmOne, rmPurge, rmUnbound } from '../removal.js';
 const USAGE = `Usage:
   ai sandbox rm <branch | TASK-id | short id> Remove one sandbox; use a full TASK-id for a task-bound sandbox and a branch for branch-only sandboxes
-  ai sandbox rm --unbound [--dry-run] [--yes] Remove discovered task-bound and branch-only sandboxes
+  ai sandbox rm --unbound [--dry-run] [--yes] Remove sandboxes not bound to an active task short id
   ai sandbox rm --purge                     Tear down ALL sandboxes for the project (containers, worktrees, image, VM)`;
 function resolveMissingTaskSandboxBranch(taskId, config) {
     const engine = detectEngine(config);