@fitlab-ai/agent-infra 0.9.15 → 0.10.0

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

@@ -252,7 +252,7 @@ async function resolvedContext(taskRef, options) {
     const fact = factRead.status === 'valid' ? factRead.fact : null;
     let issueIdentity;
     try {
-        issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion);
+        issueIdentity = taskIssueIdentity(frontmatter);
     }
     catch (error) {
         return { ok: false, output: result('failed', resolved.taskId, null, null, { error: { ...taskIssueIdentityError(error), retryable: false } }) };
@@ -776,7 +776,7 @@ async function resolveExternalPullRequest(taskRef, options) {
         return externalResult(result('failed', base.resolved.taskId, null, base.prNumber, {
             platform: base.context.platform,
             capabilities: base.context.capabilities,
-            error: { code: 'EXTERNAL_DELIVERY_ISSUE_REQUIRED', message: 'External delivery requires a valid issue_number', retryable: false }
+            error: { code: 'EXTERNAL_DELIVERY_ISSUE_REQUIRED', message: 'External delivery requires a valid platform issue identity', retryable: false }
         }));
     const inspected = base.provider.changeRequests?.listClosing
         ? await base.provider.changeRequests.listClosing({
@@ -1285,7 +1285,7 @@ function skipPlatformPullRequestFactUnlocked(resolved, options) {
     }
     let issueIdentity;
     try {
-        issueIdentity = taskIssueIdentity(frontmatter, undefined, options.runtimeVersion);
+        issueIdentity = taskIssueIdentity(frontmatter);
     }
     catch (error) {
         return result('failed', resolved.taskId, null, null, { error: { ...taskIssueIdentityError(error), retryable: false } });

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

@@ -1,7 +1,6 @@
 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) {
+function taskIssueIdentity(frontmatter) {
     const serialized = frontmatter.platform_issue_identity;
     if (typeof serialized === 'string' && serialized.trim()) {
         try {
@@ -12,13 +11,7 @@ function taskIssueIdentity(frontmatter, _declaration, runtimeVersion = VERSION)
             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;
+    return null;
 }
 function taskIssueIdentityError(error) {
     const value = error && typeof error === 'object' ? error : {};

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

@@ -10,6 +10,7 @@ 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";
+import { isTaskCommentTooLarge } from "./issue-comments.js";
 import { CONTROL_MARKER_PATTERN, canonicalizeCommentBody, renderSafeCodeFence, sanitizeMarkdownDocument } from "./comment-safety.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
@@ -96,8 +97,8 @@ async function buildSyncContext({ taskDir, config, artifactFile }, shared) {
     }
     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: shared.passResult(CHECK_TYPE, "Skipped: task has no issue_number") };
+    if (config.when === "platform_issue_identity_exists" && !issueIdentity) {
+        return { earlyReturn: shared.passResult(CHECK_TYPE, "Skipped: task has no platform_issue_identity") };
     }
     if (config.when === "pr_fact_bound" && !prIdentity) {
         return { earlyReturn: shared.passResult(CHECK_TYPE, "Skipped: task has no verified bound pull request") };
@@ -427,6 +428,9 @@ function checkTaskCommentContent(context, remoteData, shared) {
     if (!context.config.verify_task_comment_content) {
         return null;
     }
+    if (isTaskCommentTooLarge(context.task.content)) {
+        return null;
+    }
     const taskMarker = `<!-- sync-issue:${context.task.metadata.id}:task -->`;
     const comment = findCommentByMarker(remoteData.comments, taskMarker);
     if (!comment) {

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

@@ -12,10 +12,6 @@ export class HostResolutionError extends Error {
         this.code = code;
     }
 }
-function toPositiveNumber(value) {
-    const n = Number(value);
-    return Number.isInteger(n) && n > 0 ? n : null;
-}
 /**
  * Parse the PR body for closing-issue references. Handles the conventional
  * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
@@ -41,7 +37,7 @@ export function extractClosingIssueNumbers(body) {
 /**
  * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
  * PR number or to one of the PR's closing issues. A task is emitted at most once;
- * a verified fact identity hit takes priority over the issue-number reverse lookup.
+ * a verified fact identity hit takes priority over the issue-identity reverse lookup.
  */
 export function collectHostCandidates(input) {
     const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
@@ -73,7 +69,7 @@ export function collectHostCandidates(input) {
             continue;
         }
         const issueIdentity = taskIssueIdentity(frontmatter);
-        const issueNumber = resourceIdentityNumber(issueIdentity) ?? toPositiveNumber(frontmatter.issue_number);
+        const issueNumber = resourceIdentityNumber(issueIdentity);
         const fact = readPrDeliveryFact(frontmatter);
         const prIdentity = fact.status === 'valid' && fact.fact.state === 'bound' ? fact.fact.identity.resource : null;
         const prNumber = resourceIdentityNumber(prIdentity);
@@ -133,8 +129,8 @@ function isTrusted(head) {
 /**
  * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
  * resolved data: a unique host is trusted on the issue dimension only when the
- * task's bound issue_number is among the PR's closing issues. Ambiguous/none
- * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * task's bound issue identity is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a numeric issue identity cannot be confirmed -> false
  * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
  * does not derive the trust factor ad hoc (CD-2).
  */

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

@@ -2,11 +2,27 @@ import { parseArgs } from 'node:util';
 import { loadConfig } from '../config.js';
 import { createSandboxCapabilityPlan } from '../agent-client-reconciler.js';
 import { resolveSandboxCleanupTarget } from '../workspace-identity.js';
+import { detectEngine } from '../engine.js';
+import { sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel } from '../constants.js';
+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 completed task-bound and branch-only sandboxes and verified auxiliary state; active, blocked, and archive tasks are protected
+  ai sandbox rm --unbound [--dry-run] [--yes] Remove discovered task-bound and branch-only sandboxes
   ai sandbox rm --purge                     Tear down ALL sandboxes for the project (containers, worktrees, image, VM)`;
+function resolveMissingTaskSandboxBranch(taskId, config) {
+    const engine = detectEngine(config);
+    const listed = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) });
+    const branches = new Set([...listed.running, ...listed.nonRunning]
+        .filter((row) => row.workspaceMode === 'task-bound' && row.taskId === taskId && row.branch)
+        .map((row) => row.branch));
+    if (branches.size === 0)
+        return null;
+    if (branches.size > 1) {
+        throw new Error(`SANDBOX_CLEANUP_TASK_ID_AMBIGUOUS: task ${taskId} matches multiple sandbox branches`);
+    }
+    return branches.values().next().value ?? null;
+}
 export async function rm(args) {
     const { values, positionals } = parseArgs({
         args,
@@ -53,7 +69,10 @@ export async function rm(args) {
         });
         return;
     }
-    const cleanupTarget = resolveSandboxCleanupTarget(positionals[0] ?? '', config.repoRoot);
+    const cleanupTarget = resolveSandboxCleanupTarget(positionals[0] ?? '', config.repoRoot, {
+        allowProtected: true,
+        resolveMissingTask: (taskId) => resolveMissingTaskSandboxBranch(taskId, config)
+    });
     await rmOne(config, tools, cleanupTarget.branch, { cleanupTarget });
 }
 //# sourceMappingURL=rm.js.map

package/dist/lib/sandbox/control/server.js

@@ -14,6 +14,7 @@ import { requestAuditFields, resultAuditFields, appendCriticalAudit, appendDiagn
 import { parseTaskControlOperation } from '../../task/control-authority.js';
 import { parseControlOutput, classifySandboxControlRecovery, findSandboxControlRecoveryOperation, operationRecoveryBinding, SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES } from '../../task/control-recovery.js';
 import { readRun } from '../../task/orchestration.js';
+import { readLifecycleRecoveryDomainEvidence } from '../../task/lifecycle-recovery.js';
 import { captureRepositorySnapshot } from '../../task/workspace-snapshot.js';
 import { parseTypedTaskFrontmatter } from '../../task/frontmatter.js';
 import { readLifecycleJournalEvidence } from '../../task/lifecycle.js';
@@ -256,7 +257,7 @@ function outputMatchesEvidence(output, bytes, sha256) {
     return Buffer.byteLength(output, 'utf8') === bytes
         && createHash('sha256').update(output, 'utf8').digest('hex') === sha256;
 }
-function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery') {
+export function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery', warning = null) {
     const outputUnavailable = request.family === 'task-create' && !payload;
     return {
         version: 2,
@@ -264,9 +265,11 @@ function genericRecoveryResponse(request, exitCode, payload, cause = 'recovery')
         phase: 'completed',
         exitCode,
         stdout: outputUnavailable ? `${JSON.stringify(taskCreateOutputUnavailableResult(request.id))}\n` : '',
-        stderr: payload ? '' : cause === 'publish'
-            ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
-            : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
+        stderr: payload ? '' : warning
+            ? `${warning.code}: ${warning.message}\nAction: ${warning.action}\n`
+            : cause === 'publish'
+                ? 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: output payload was not retained\n'
+                : 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: broker restarted after executor completion\n',
         error: null,
         outputState: payload ? 'available' : 'unavailable',
         payload: payload ? payloadReference(payload) : null
@@ -365,6 +368,23 @@ function readRecoveryDomain(manifest, manifestPath, request, operation, terminal
         return { domain: null };
     }
     if (operation.family === 'task-lifecycle') {
+        if (operation.intent === 'recover-started') {
+            try {
+                if (!('args' in request))
+                    return { domain: null };
+                const parsed = parseTaskControlOperation('task-lifecycle', request.args);
+                if (parsed.family !== 'task-lifecycle' || parsed.request.intent !== 'recover-started') {
+                    return { domain: null };
+                }
+                return {
+                    domain: readLifecycleRecoveryDomainEvidence(manifest.repoRoot, parsed.request, terminalResult),
+                    journal: readLifecycleJournalEvidence(manifest.repoRoot, taskRef)
+                };
+            }
+            catch {
+                return { domain: null };
+            }
+        }
         if (!taskRef || !terminalResult.targetState)
             return { domain: null };
         const journal = readLifecycleJournalEvidence(manifest.repoRoot, taskRef);
@@ -441,7 +461,7 @@ function readCommittedCriticalPhases(manifest, requestId) {
         }
     });
 }
-function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
+export function recoveryResponse(manifest, manifestPath, request, evidence, payload, terminalResult) {
     const operationName = recoveryOperationKey(request, terminalResult, payload?.stdout);
     const operation = operationName ? findSandboxControlRecoveryOperation(request.family, operationName) : null;
     if (!operation)
@@ -503,7 +523,7 @@ function recoveryResponse(manifest, manifestPath, request, evidence, payload, te
             return null;
         return finalization.response ?? null;
     }
-    return genericRecoveryResponse(request, evidence.exitCode, payload);
+    return genericRecoveryResponse(request, evidence.exitCode, payload, 'recovery', terminalResult.warning ?? null);
 }
 function terminalMatchesEvidence(manifest, manifestPath, request, response, evidence, payload, payloadInvalid, terminalResult) {
     if (request.family === 'task-finalization' && evidence.exitCode === 0) {
@@ -538,7 +558,7 @@ function terminalMatchesEvidence(manifest, manifestPath, request, response, evid
     if (response.outputState === 'unavailable') {
         const causes = ['recovery', 'publish'];
         const valid = causes.some((cause) => JSON.stringify(response)
-            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause)));
+            === JSON.stringify(genericRecoveryResponse(request, evidence.exitCode, null, cause, terminalResult?.warning ?? null)));
         return { valid, payloadReferenced: false };
     }
     return {
@@ -550,7 +570,7 @@ function terminalMatchesEvidence(manifest, manifestPath, request, response, evid
 }
 function publishExecutionResult(manifest, request, result, broker, brokerOwns) {
     const normalized = sanitizeSandboxControlResult(manifest, result);
-    writeSandboxControlTerminalResult(manifest, {
+    const terminalResult = writeSandboxControlTerminalResult(manifest, {
         id: request.id,
         family: request.family,
         operation: operationKey(request, normalized.stdout)
@@ -590,7 +610,7 @@ function publishExecutionResult(manifest, request, result, broker, brokerOwns) {
             catch {
                 payload = null;
             }
-            terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish');
+            terminal = genericRecoveryResponse(request, normalized.exitCode, payload, 'publish', terminalResult.warning ?? null);
         }
     }
     if (!brokerOwns())

package/dist/lib/sandbox/control/state.js

@@ -1,5 +1,6 @@
 import { isCompletionEvidence } from '../../task/orchestration.js';
 import { parseControlOutput } from '../../task/control-recovery.js';
+import { isRecoveryWarning } from '../../task/recovery-warning.js';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -83,6 +84,7 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         ? nested.run : null;
     const rawCompletion = nested.completionEvidence ?? run?.completionEvidence;
     const operation = request.operation ?? (typeof nested.intent === 'string' ? nested.intent : null) ?? '';
+    const warning = isRecoveryWarning(nested.warning) ? nested.warning : null;
     return {
         version: 1,
         requestId: request.id,
@@ -92,7 +94,8 @@ export function createSandboxControlTerminalResult(manifest, request, output) {
         targetState: typeof nested.targetState === 'string' ? nested.targetState : null,
         status: typeof nested.status === 'string' ? nested.status : 'completed',
         changed: typeof nested.changed === 'boolean' ? nested.changed : null,
-        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null
+        completionEvidence: isCompletionEvidence(rawCompletion) ? rawCompletion : null,
+        ...(warning ? { warning } : {})
     };
 }
 export function writeSandboxControlTerminalResult(manifest, request, output) {
@@ -123,6 +126,9 @@ export function readSandboxControlTerminalResult(filePath) {
     if (value.completionEvidence !== null && !isCompletionEvidence(value.completionEvidence)) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }
+    if (value.warning !== undefined && value.warning !== null && !isRecoveryWarning(value.warning)) {
+        throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
+    }
     if (value.changed === undefined) {
         throw new Error('SANDBOX_CONTROL_TERMINAL_RESULT_INVALID');
     }

package/dist/lib/sandbox/control/workflow-executor.js

@@ -7,7 +7,7 @@ import { withTaskExecutionLock } from '../../task/task-execution-lock.js';
 import { dispatchHostControlCommand } from '../../host-control/command.js';
 import { assertSandboxTaskSource } from '../workspace-view.js';
 import { appendDiagnosticAudit } from './audit.js';
-import { readTaskArtifact, writeTaskArtifact } from './task-workflow.js';
+import { readTaskArtifact } from './task-workflow.js';
 import { applyTaskEvent } from '../../task/events.js';
 import { parseTaskEventRequest } from '../../internal/task-event.js';
 function executionResult(result) {
@@ -43,7 +43,7 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
         if (command === 'task-artifact' && 'operation' in input && input.operation === 'inspect') {
             return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot }));
         }
-        if ('operation' in input && (input.operation === 'init' || input.operation === 'repair')) {
+        if ('operation' in input && input.operation === 'init') {
             return executionResult(executeArtifactCommand(input, { repoRoot: manifest.repoRoot, artifactDir: taskDir }));
         }
         return await withTaskExecutionLock(manifest.repoRoot, request.taskId, `sandbox-control.${request.operation}`, async () => {
@@ -54,32 +54,22 @@ export async function executeTaskWorkflow(manifest, request, lifecycleRecoveryAt
                 const { family } = input;
                 if (family !== 'analysis' && family !== 'plan' && family !== 'code')
                     throw new Error('ARTIFACT_IDENTITY_INVALID');
-                const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot };
+                const local = { taskRef: request.taskId, family, artifact: input.artifact, repoRoot: manifest.repoRoot, recoveryId: input.recoveryId, lockAlreadyHeld: true };
                 const prepared = prepareLocalArtifact(local, content, lifecycleRecoveryAttestation ?? undefined);
                 if (prepared.result.status === 'failed')
                     return executionResult(commitLocalArtifactProvenance(prepared));
                 publicationStarted = true;
-                await writeTaskArtifact(taskDir, {
-                    artifact: artifact.artifact,
-                    bytes: artifact.bytes,
-                    expectedSha256: artifact.sha256
-                });
                 result = commitLocalArtifactProvenance(prepared);
             }
             else {
                 if (input.overrideTicket)
                     throw new Error('TASK_WORKFLOW_OVERRIDE_UNSUPPORTED');
-                const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot });
+                const prepared = prepareReviewSummaryCandidate(input, content, { repoRoot: manifest.repoRoot, lockAlreadyHeld: true, startRecovery: true });
                 if (input.dryRun || prepared.result.status === 'planned')
                     return executionResult(prepared.result);
                 if (prepared.result.status === 'failed')
                     return executionResult(commitReviewSummaryProvenance(prepared, manifest.repoRoot));
                 publicationStarted = true;
-                await writeTaskArtifact(taskDir, {
-                    artifact: input.artifact,
-                    bytes: Buffer.from(prepared.content, 'utf8'),
-                    expectedSha256: artifact.sha256
-                });
                 result = commitReviewSummaryProvenance(prepared, manifest.repoRoot);
             }
             if (result.status !== 'failed')

package/dist/lib/sandbox/index.js

@@ -19,8 +19,7 @@ Commands:
   rm <branch | TASK-id> | --unbound | --purge
                                Remove one sandbox; use a full TASK-id for task-bound
                                cleanup and a branch for branch-only cleanup. --unbound
-                               removes completed task-bound and branch-only sandboxes
-                               plus verified auxiliary state; active, blocked, and archive tasks are protected.
+                               removes discovered task-bound and branch-only sandboxes.
   start [--recreate] <branch | TASK-id | N>
                                Verify or recover an existing sandbox container;
                                optionally replace only the container on failure