@fitlab-ai/agent-infra 0.11.9 → 0.11.10

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

@@ -5,6 +5,7 @@ import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { coordinatePlatformWrite } from './operation-coordinator.js';
 import { resolvePlatformProviderContext } from './context.js';
+import { providerErrorRetryable } from './provider-validation.js';
 import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityNumber } from './resource-identity.js';
@@ -12,6 +13,9 @@ import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js'
 import { recordForArtifact, recordForCancel, recordForSummary, recordForTask, renderActivityRecoveryMetadata } from './activity-recovery.js';
 import { projectTaskComment } from './task-comment-projection.js';
 import { canonicalizeCommentBody, escapeHtmlText, fenceRanges, renderSafeCodeFence } from './comment-safety.js';
+function isRetryable(error) {
+    return error.retryable ?? providerErrorRetryable(error.code);
+}
 function providerCommentId(id, provider) {
     return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
 }
@@ -482,7 +486,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
     const issue = resourceIdentityNumber(issueIdentityFromTask);
     const listed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
     if (!listed.ok) {
-        return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
+        return platformResult(isRetryable(listed.error) ? 'blocked' : 'failed', {
             ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
         });
     }
@@ -548,10 +552,10 @@ async function syncPlatformCommentImpl(taskRef, options) {
             })
             : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
         if (!written.ok) {
-            if (!current && written.error.retryable) {
+            if (!current && isRetryable(written.error)) {
                 // A provider owns reconciliation because only it knows how to address the resource.
             }
-            return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+            return platformResult(isRetryable(written.error) ? 'blocked' : 'failed', {
                 ...contextFields(context),
                 resource: { kind: 'issue', number: issue },
                 operations,
@@ -573,7 +577,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
             })
             : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
         if (!deleted.ok) {
-            return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+            return platformResult(isRetryable(deleted.error) ? 'blocked' : 'failed', {
                 ...contextFields(context),
                 resource: { kind: 'issue', number: issue },
                 operations,
@@ -585,7 +589,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
     if (options.kind === 'summary') {
         const refreshed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
         if (!refreshed.ok) {
-            return platformResult(refreshed.error.retryable ? 'blocked' : 'failed', {
+            return platformResult(isRetryable(refreshed.error) ? 'blocked' : 'failed', {
                 ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: refreshed.error
             });
         }
@@ -613,7 +617,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
                 })
                 : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
             if (!deleted.ok) {
-                return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+                return platformResult(isRetryable(deleted.error) ? 'blocked' : 'failed', {
                     ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: deleted.error
                 });
             }
@@ -624,7 +628,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
                 })
                 : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
             if (!written.ok) {
-                return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+                return platformResult(isRetryable(written.error) ? 'blocked' : 'failed', {
                     ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: written.error
                 });
             }
@@ -635,7 +639,7 @@ async function syncPlatformCommentImpl(taskRef, options) {
                 const error = reconciled.ok
                     ? { code: 'SUMMARY_POSITION_UNVERIFIED', message: 'Summary comment is not provably last among task-managed comments', retryable: true }
                     : reconciled.error;
-                return platformResult(error.retryable ? 'blocked' : 'failed', {
+                return platformResult(isRetryable(error) ? 'blocked' : 'failed', {
                     ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error
                 });
             }
@@ -748,7 +752,7 @@ async function checkPlatformCommentOwner(taskRef, options = {}) {
             : response)
         : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
     if (!listed.ok)
-        return platformResult(listed.error.retryable ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
+        return platformResult(isRetryable(listed.error) ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
     const matches = findMarkerComments(listed.value, MARKERS.task(resolved.taskId));
     if (matches.length > 1)
         return platformResult('failed', { ...contextFields(context), error: { code: 'COMMENT_MARKER_CONFLICT', message: 'Multiple task comments use the registered marker', retryable: false } });

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

@@ -25,7 +25,7 @@ async function coordinatePlatformWrite(input) {
             excludeId: operationId
         });
     if (drained.status !== 'applied' && drained.status !== 'no-op') {
-        return input.block(drained.error ?? {
+        return input.block(drained.error ? { ...drained.error, retryable: true } : {
             code: 'PLATFORM_OPERATION_QUEUE_BLOCKED',
             message: 'A previous platform operation is still unresolved; the current write remains queued',
             retryable: true

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

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { coordinatePlatformWrite } from './operation-coordinator.js';
 import { resolvePlatformProviderContext } from './context.js';
+import { providerErrorRetryable } from './provider-validation.js';
 import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
 import { isResourceIdentity, resourceIdentityEquals, resourceIdentityNumber, reviewMarker as resourceReviewMarker } from './resource-identity.js';
@@ -253,7 +254,7 @@ export async function publishPrReview(options) {
             })
             : unsupportedProviderOperation(loaded.value.provider, 'reviews.publish');
         if (!published.ok) {
-            if (published.error.retryable) {
+            if (published.error.retryable || providerErrorRetryable(published.error.code)) {
                 const reconciled = await listPrReviews(options.prNumber, { cwd: options.cwd, client: options.client });
                 const found = reconciled.reviews.find((review) => firstLine(review.body) === marker);
                 if (found)

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { identityFromRemoteValue, parseResourceIdentity, parseResourceToken, resourceIdentityNumber } from './resource-identity.js';
+import { providerErrorRetryable } from './provider-validation.js';
 function providerOperationContext(loaded, workingDirectory = loaded.workingDirectory, scopeId = loaded.snapshot.scope.id) {
     return {
         repositoryRoot: loaded.repositoryRoot,
@@ -12,11 +13,11 @@ function providerError(error, fallbackCode) {
     return {
         code: error.code || fallbackCode,
         message: error.message || 'Platform provider operation failed',
-        retryable: error.retryable
+        retryable: 'retryable' in error ? error.retryable : providerErrorRetryable(error.code)
     };
 }
 function providerStatus(error) {
-    return error.retryable ? 'blocked' : 'failed';
+    return ('retryable' in error ? error.retryable : providerErrorRetryable(error.code)) ? 'blocked' : 'failed';
 }
 function unsupportedProviderOperation(provider, operation) {
     return {
@@ -24,9 +25,7 @@ function unsupportedProviderOperation(provider, operation) {
         error: {
             code: 'PLATFORM_CAPABILITY_UNSUPPORTED',
             message: `Platform '${provider.type}' does not provide ${operation}`,
-            retryable: false,
-            providerType: provider.type,
-            phase: 'operation'
+            retryable: false
         }
     };
 }

package/dist/lib/platform/provider-contract.d.ts

@@ -2,19 +2,16 @@ import type { ProviderIdentityDeclaration, ResourceIdentity } from './resource-i
 type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
-type PlatformError = {
+type ProviderError = {
     code: string;
     message: string;
-    retryable: boolean;
-    providerType?: string;
-    phase?: string;
 };
 type ProviderResult<T> = {
     ok: true;
     value: T;
 } | {
     ok: false;
-    error: PlatformError;
+    error: ProviderError;
     value?: T;
 };
 type ProviderOperationContext = {
@@ -575,4 +572,4 @@ declare const PLATFORM_PROVIDER_CONTRACT_VERSION: 2;
 declare function isPlatformProviderFactory(value: unknown): value is PlatformProviderFactory;
 declare function validatePlatformProvider(value: unknown, providerType: string): ProviderResult<PlatformProvider>;
 export { PLATFORM_PROVIDER_CONTRACT_VERSION, isPlatformProviderFactory, validatePlatformProvider };
-export type { ChangeRequestSnapshot, CheckLogSnapshot, CheckRunSnapshot, GitEvidenceSnapshot, IssueSnapshot, JsonValue, MilestoneReconciliation, MilestoneDefinition, MilestoneInitialization, LabelDefinition, LabelReconciliation, MutationIdentity, MutationReceipt, PlatformCapabilities, PlatformContextSnapshot, PlatformError, PlatformProvider, PlatformProviderFactory, PlatformProviderFactoryInput, ProviderOperationContext, ProviderResult, ReleaseSnapshot, RemoteCommentSnapshot, RequiredCheckSnapshot, RepositoryMetadataSnapshot, ReleaseNotesFacts, ReleaseNoteAuthor, ReleaseNoteIssue, ReleaseNotePullRequest, ResourceIdentity, SecurityAlertKind, SecurityAlertSnapshot, ReviewSnapshot, VerificationRemoteFacts };
+export type { ChangeRequestSnapshot, CheckLogSnapshot, CheckRunSnapshot, GitEvidenceSnapshot, IssueSnapshot, JsonValue, MilestoneReconciliation, MilestoneDefinition, MilestoneInitialization, LabelDefinition, LabelReconciliation, MutationIdentity, MutationReceipt, PlatformCapabilities, PlatformContextSnapshot, ProviderError, PlatformProvider, PlatformProviderFactory, PlatformProviderFactoryInput, ProviderOperationContext, ProviderResult, ReleaseSnapshot, RemoteCommentSnapshot, RequiredCheckSnapshot, RepositoryMetadataSnapshot, ReleaseNotesFacts, ReleaseNoteAuthor, ReleaseNoteIssue, ReleaseNotePullRequest, ResourceIdentity, SecurityAlertKind, SecurityAlertSnapshot, ReviewSnapshot, VerificationRemoteFacts };

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

@@ -37,10 +37,7 @@ function validatePlatformProvider(value, providerType) {
             ok: false,
             error: {
                 code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-                message: 'Provider must expose matching type, contractVersion, and context.resolve',
-                retryable: false,
-                providerType,
-                phase: 'provider-validation'
+                message: 'Provider must expose matching type, contractVersion, and context.resolve'
             }
         };
     }
@@ -51,10 +48,7 @@ function validatePlatformProvider(value, providerType) {
                 ok: false,
                 error: {
                     code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-                    message: 'Provider identity declaration is invalid',
-                    retryable: false,
-                    providerType,
-                    phase: 'provider-validation'
+                    message: 'Provider identity declaration is invalid'
                 }
             };
         }
@@ -68,10 +62,7 @@ function validatePlatformProvider(value, providerType) {
                 ok: false,
                 error: {
                     code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
-                    message: `Provider operation group ${groupName} is incomplete`,
-                    retryable: false,
-                    providerType,
-                    phase: 'provider-validation'
+                    message: `Provider operation group ${groupName} is incomplete`
                 }
             };
         }
@@ -84,9 +75,6 @@ function validatePlatformProvider(value, providerType) {
                         error: {
                             code: 'PLATFORM_PROVIDER_CONTRACT_INVALID',
                             message: `Provider operation group ${groupName} requires an identity declaration for ${resourceKind}`,
-                            retryable: false,
-                            providerType,
-                            phase: 'provider-validation'
                         }
                     };
                 }

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

@@ -462,9 +462,11 @@ const PROVIDER_ERROR_CATALOG = {
     REMOTE_INVALID: { message: 'The platform remote is invalid', retryable: false },
     UPSTREAM_UNRESOLVED: { message: 'The platform upstream repository could not be resolved', retryable: false },
     RESOURCE_NOT_FOUND: { message: 'The platform resource was not found', retryable: false },
+    COMMENT_LIST_FAILED: { message: 'Comments could not be listed', retryable: true },
     PR_NOT_FOUND: { message: 'The pull request was not found', retryable: false },
     ISSUE_NOT_FOUND: { message: 'The issue was not found', retryable: false },
     REMOTE_BUSY: { message: 'Platform provider is temporarily busy', retryable: true },
+    IN_LABEL_SYNC_PARTIAL: { message: 'In-label synchronization is partial or unknown', retryable: true },
     NETWORK_TRANSIENT: { message: 'The platform request failed temporarily', retryable: true },
     NETWORK_RETRY: { message: 'The platform request failed temporarily', retryable: true },
     NETWORK_RETRY_EXHAUSTED: { message: 'The platform request retries were exhausted', retryable: true },
@@ -505,11 +507,14 @@ function safeProviderError(providerType, operation, value) {
     return {
         code: definition ? item.code : 'PLATFORM_PROVIDER_OPERATION_FAILED',
         message: definition?.message || PROVIDER_ERROR_CATALOG.PLATFORM_PROVIDER_OPERATION_FAILED.message,
-        retryable: definition?.retryable || false,
+        retryable: definition?.retryable ?? false,
         providerType,
         phase: operation
     };
 }
+function providerErrorRetryable(code) {
+    return PROVIDER_ERROR_CATALOG[code]?.retryable ?? false;
+}
 function validators(providerType, declaration) {
     return {
         'context.resolve': (value) => validateContext(value, providerType),
@@ -608,8 +613,8 @@ async function invokeProviderOperation(providerType, operation, call, validate)
             try {
                 exactKeys(envelope, Object.hasOwn(envelope, 'value') ? ['ok', 'error', 'value'] : ['ok', 'error'], `${operation} result`);
                 const error = envelope.error;
-                exactKeys(error, ['code', 'message', 'retryable'], `${operation} error`);
-                if (typeof error.code !== 'string' || !error.code || typeof error.message !== 'string' || !error.message || typeof error.retryable !== 'boolean')
+                exactKeys(error, ['code', 'message'], `${operation} error`);
+                if (typeof error.code !== 'string' || !error.code || typeof error.message !== 'string' || !error.message)
                     throw new Error('invalid provider error');
                 return {
                     ok: false,
@@ -648,5 +653,5 @@ function wrapProviderOperations(provider) {
     }
     return wrapped;
 }
-export { invokeProviderOperation, validationError, wrapProviderOperations };
+export { invokeProviderOperation, providerErrorRetryable, validationError, wrapProviderOperations };
 //# sourceMappingURL=provider-validation.js.map

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

@@ -9,6 +9,7 @@ import { extractSection } from '../task/sections.js';
 import { captureTaskWriteMetadata, writeTask } from '../task/write.js';
 import { resolvePlatformProviderContext } from './context.js';
 import { inspectPlatformIssue } from './issues.js';
+import { providerErrorRetryable } from './provider-validation.js';
 import { planPullRequestMetadata } from './pull-request-metadata.js';
 import { planInLabelUpdate, validateInLabelMapping } from './in-label-sync.js';
 import { platformResult } from './types.js';
@@ -582,9 +583,10 @@ async function syncPlatformPullRequestInLabels(prNumber, options = {}) {
                 : unsupportedProviderOperation(provider, 'changeRequests.update');
         if (!synced.ok) {
             const state = resourcesState.find((resource) => resource.kind === item.kind && resourceIdentityEquals(resource.identity, item.identity));
-            state.effect = synced.error.retryable ? 'unknown' : 'no-op';
+            const retryable = synced.error.retryable || providerErrorRetryable(synced.error.code);
+            state.effect = retryable ? 'unknown' : 'no-op';
             state.after = state.effect === 'unknown' ? null : item.snapshot.labels;
-            const partial = successfulWrites > 0 || synced.error.retryable;
+            const partial = successfulWrites > 0 || retryable;
             const error = partial
                 ? { ...synced.error, code: 'IN_LABEL_SYNC_PARTIAL', message: `In-label synchronization is partial or unknown: ${synced.error.message}` }
                 : synced.error;

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

@@ -9,6 +9,7 @@ import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.js';
 import { configuredShortIdLength, resolveShortIdReadOnly } from '../../task/short-id.js';
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
+const SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS = 5 * 60_000;
 export class SandboxControlClientError extends Error {
     detail;
     accepted;
@@ -79,8 +80,10 @@ function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(
     }
 }
 function taskViewEffectForRequest(request) {
-    if (request.family === 'task-lifecycle' || request.family === 'task-finalization')
+    if (request.family === 'task-lifecycle')
         return 'progress';
+    if (request.family === 'task-finalization')
+        return 'recovery';
     return null;
 }
 function parseResponse(raw, id, accepted = false) {
@@ -298,15 +301,24 @@ export function recoverSandboxControl(requestId, params = {}) {
                 else if (now - malformedResponseObservedAt >= SANDBOX_CONTROL_RESPONSE_SETTLE_MS) {
                     clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response remained malformed', false, accepted, requestId);
                 }
-                sleep(25);
+                const remainingMs = deadline - Date.now();
+                if (remainingMs > 0)
+                    sleep(Math.min(25, Math.ceil(remainingMs)));
                 continue;
             }
-            if (response.phase === 'accepted')
+            if (response.phase === 'accepted') {
+                accepted = true;
+            }
+            else if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
                 accepted = true;
-            else
+            }
+            else {
                 return response;
+            }
         }
-        sleep(25);
+        const remainingMs = deadline - Date.now();
+        if (remainingMs > 0)
+            sleep(Math.min(25, Math.ceil(remainingMs)));
     }
     clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request did not produce a final result; inspect domain state before retrying', false, accepted, requestId);
 }
@@ -356,7 +368,43 @@ export function requestSandboxTaskFinalization(params) {
         controllerProcess: null,
         controllerProof: null
     };
-    return exchangeSandboxControl(request, params);
+    let response;
+    try {
+        response = exchangeSandboxControl(request, params);
+    }
+    catch (error) {
+        if (!(error instanceof SandboxControlClientError)
+            || error.detail.code !== 'SANDBOX_CONTROL_RESULT_UNKNOWN'
+            || !error.accepted || !error.requestId)
+            throw error;
+        return recoverAcceptedTaskFinalization(error.requestId, params);
+    }
+    if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
+        return recoverAcceptedTaskFinalization(response.id, params);
+    }
+    return response;
+}
+export function recoverAcceptedTaskFinalization(requestId, params, recover = recoverSandboxControl) {
+    const deadline = Date.now() + (params.recoveryBudgetMs ?? SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS);
+    while (Date.now() < deadline) {
+        const timeoutMs = Math.min(30_000, deadline - Date.now());
+        if (timeoutMs <= 0)
+            break;
+        try {
+            const response = recover(requestId, { channelDir: params.channelDir, timeoutMs });
+            if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
+                continue;
+            return response;
+        }
+        catch (error) {
+            if (error instanceof SandboxControlClientError
+                && error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
+                && error.requestId === requestId)
+                continue;
+            throw error;
+        }
+    }
+    clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'accepted finalization request remained unknown after the automatic recovery budget; inspect the receipt and resume by request id', false, true, requestId);
 }
 function exactKeys(value, keys) {
     return Object.keys(value).sort().join(',') === [...keys].sort().join(',');

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

@@ -6,6 +6,7 @@ import { homedir } from 'node:os';
 import { getProcessStartTime } from '../../server/process-state.js';
 import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
 import { applyTaskFinalization } from '../../task/finalization.js';
+import { serializeTaskFinalizationEnvelope } from '../../task/finalization-envelope.js';
 import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
 import { atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
 import { requestAuditFields, resultAuditFields, appendDiagnosticAudit, createSandboxControlAuditContext, appendCriticalAudit, writeSandboxControlTransition } from './audit.js';
@@ -456,10 +457,14 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         result = request.family === 'task-finalization'
             ? {
                 exitCode: 1,
-                stdout: `${JSON.stringify({
-                    version: 1, status: 'failed', changed: false, accepted: true, result: null,
+                stdout: serializeTaskFinalizationEnvelope({
+                    status: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 'unknown' : 'failed',
+                    changed: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? null : false,
+                    accepted: true,
+                    requestId: request.id,
+                    result: null,
                     error: { code, message: detail, retryable: false }
-                })}\n`,
+                }),
                 stderr: ''
             }
             : request.family === 'task-create'

package/dist/lib/sandbox/removal.js

@@ -19,7 +19,6 @@ import { getProcessStartTime } from '../server/process-state.js';
 import { releaseStaleShortIdRegistry } from '../task/short-id.js';
 import { withRepositoryMutationLock } from '../task/task-execution-lock.js';
 import { fetchSandboxRows } from './commands/list-running.js';
-import { formatIntermediateCleanupReport, cleanupIntermediateUnderRemovalCoordinator, protectIntermediateCleanupReport, mergeIntermediateCleanupReports, scanIntermediateCleanup } from '../task/intermediate-cleanup.js';
 import { createSandboxControlBindingEvidence } from './task-cleanup.js';
 import { createCleanPermit, createDiscardPermit, formatWorktreeSnapshot, inspectRecoveredWorktree, inspectWorktrees, verifyWorktreePermit } from './worktree-safety.js';
 function projectToolDirs(config, tools) {

package/dist/lib/task/artifact-command.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { resolveArtifactContext, hasOpenArtifactRound } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
@@ -74,7 +75,16 @@ export function executeArtifactCommand(command, options = {}) {
     const input = { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskDir, family: schema.family, artifact };
     if (operation === 'init') {
         const context = resolveArtifactContext(taskRef, family, { repoRoot: resolved.repoRoot });
-        if (context.status !== 'ready' || (context.next?.name !== artifact && !hasOpenArtifactRound(fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round))) {
+        const existingCandidate = path.join(taskDir, artifact);
+        let matchingInitializedSkeleton = false;
+        try {
+            const existing = fs.readFileSync(existingCandidate, 'utf8');
+            matchingInitializedSkeleton = existing.includes(`<!-- artifact-context:${resolved.taskId}:${family}:${parsed.round} -->`);
+        }
+        catch { /* an absent candidate is created only for the selected identity */ }
+        if ((context.status !== 'ready' && !matchingInitializedSkeleton) || (context.next?.name !== artifact
+            && !hasOpenArtifactRound(fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round)
+            && !matchingInitializedSkeleton)) {
             return fail('ARTIFACT_INIT_CONTEXT_INVALID', context.error?.message ?? `artifact '${artifact}' is not the next ${family} artifact`);
         }
         return { ...initializeArtifactSkeleton({ ...input, ...(locale ? { locale } : {}) }), ...identity };