@fitlab-ai/agent-infra 0.9.4 → 0.9.6

package/dist/lib/task/commands/validate.js

@@ -0,0 +1,289 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { loadConfig } from '../../sandbox/config.js';
+import { detectEngine } from '../../sandbox/engine.js';
+import { runEngine } from '../../sandbox/shell.js';
+import { sandboxBranchLabel, sandboxLabel } from '../../sandbox/constants.js';
+import { fetchSandboxRows, selectSandboxContainer } from '../../sandbox/commands/list-running.js';
+import { containerNameCandidates } from '../../sandbox/constants.js';
+import { resolveSandboxTarget } from '../../sandbox/workspace-identity.js';
+import { sandboxControlPaths } from '../../sandbox/workspace-view.js';
+import { appendSandboxControlAudit, readActiveLease, readSandboxControlStatus } from '../../sandbox/control/state.js';
+import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../../sandbox/control/protocol.js';
+import { getProcessStartTime } from '../../server/process-state.js';
+import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
+const USAGE = `Usage: ai task validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] -- <command> [args...]`;
+const MAX_TIMEOUT_MS = 60 * 60 * 1000;
+const RECOVERY_GRACE_MS = 30_000;
+export function parseValidateArgs(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        return { target: '', scope: 'snapshot', timeoutMs: 300_000, format: 'text', command: [], help: true };
+    }
+    const separator = args.indexOf('--');
+    if (separator < 0)
+        throw new Error(`${USAGE}\nA literal -- must separate validation options from the command.`);
+    const optionArgs = args.slice(0, separator);
+    const command = args.slice(separator + 1);
+    let scope = 'snapshot';
+    let timeoutMs = 300_000;
+    let format = 'text';
+    const positionals = [];
+    for (let index = 0; index < optionArgs.length; index += 1) {
+        const arg = optionArgs[index];
+        if (arg === '--scope') {
+            const value = optionArgs[++index];
+            if (value !== 'snapshot' && value !== 'inplace')
+                throw new Error('validate --scope must be snapshot or inplace');
+            scope = value;
+        }
+        else if (arg === '--timeout') {
+            const value = Number(optionArgs[++index]);
+            if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMEOUT_MS)
+                throw new Error(`validate --timeout must be 1..${MAX_TIMEOUT_MS}`);
+            timeoutMs = value;
+        }
+        else if (arg === '--format') {
+            const value = optionArgs[++index];
+            if (value !== 'text' && value !== 'json')
+                throw new Error('validate --format must be text or json');
+            format = value;
+        }
+        else if (arg.startsWith('-')) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    if (positionals.length !== 1 || command.length === 0)
+        throw new Error(USAGE);
+    return { target: positionals[0], scope, timeoutMs, format, command, help: false };
+}
+function runValidationCommand(command, cwd, scope, timeoutMs, json) {
+    const [file, ...args] = command;
+    const result = spawnSync(file, args, {
+        cwd,
+        env: { ...process.env, AGENT_INFRA_VALIDATION_SCOPE: scope },
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file)
+    });
+    if (json) {
+        if (result.stdout)
+            process.stderr.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+    }
+    else {
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+    }
+    return { exitCode: result.status ?? 1, signal: result.signal ?? null };
+}
+function git(root, args) {
+    return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+function waitForState(statusDir, predicate, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const status = readSandboxControlStatus(statusDir);
+            if (predicate(status))
+                return;
+        }
+        catch {
+            // Atomic status publication may be between renames.
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+    throw new Error('SANDBOX_VALIDATION_BROKER_STATE_TIMEOUT');
+}
+function snapshotValidation(repoRoot, commit, options) {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-validation-'));
+    const worktree = path.join(tempRoot, 'worktree');
+    let cleanup = 'not-created';
+    try {
+        git(repoRoot, ['worktree', 'add', '--detach', worktree, commit]);
+        cleanup = 'pending';
+        return { ...runValidationCommand(options.command, worktree, 'snapshot', options.timeoutMs, options.format === 'json'), cleanup: () => cleanup };
+    }
+    finally {
+        let cleanupError = null;
+        if (fs.existsSync(worktree)) {
+            try {
+                git(repoRoot, ['worktree', 'remove', '--force', worktree]);
+                cleanup = 'completed';
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+        }
+        try {
+            git(repoRoot, ['worktree', 'prune']);
+        }
+        catch (error) {
+            cleanupError ??= error;
+        }
+        try {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+        catch (error) {
+            cleanupError ??= error;
+        }
+        if (cleanupError)
+            throw cleanupError;
+    }
+}
+function inplaceValidation(config, target, options) {
+    const engine = detectEngine(config);
+    const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
+    const row = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, target.branch));
+    if (!row)
+        throw new Error('SANDBOX_VALIDATION_CONTAINER_NOT_FOUND');
+    const control = sandboxControlPaths({
+        base: config.controlBase, project: config.project,
+        container: row.name, identity: target.workspace
+    });
+    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
+    const initial = readSandboxControlStatus(control.statusDir);
+    const now = Date.now();
+    if (initial.generation !== manifest.generation
+        || now - initial.updatedAt > SANDBOX_CONTROL_STATUS_STALE_MS
+        || initial.updatedAt > now + SANDBOX_CONTROL_FUTURE_SKEW_MS) {
+        throw new Error('SANDBOX_VALIDATION_BROKER_STATUS_STALE');
+    }
+    if (initial.state !== 'healthy' || initial.activeRequestId !== null) {
+        throw new Error('SANDBOX_VALIDATION_BROKER_NOT_IDLE');
+    }
+    const startTime = getProcessStartTime(process.pid);
+    if (!startTime)
+        throw new Error('SANDBOX_VALIDATION_OWNER_IDENTITY_UNAVAILABLE');
+    const leasePath = path.join(control.root, 'lease.json');
+    const nonce = randomUUID();
+    const issuedAt = Date.now();
+    const lease = {
+        version: 1, generation: manifest.generation, nonce,
+        owner: { pid: process.pid, startTime }, issuedAt,
+        expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
+        taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
+        branch: target.branch, reason: 'manual-validation'
+    };
+    const originalBranch = git(manifest.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const originalHead = git(manifest.worktreeRoot, ['rev-parse', 'HEAD']);
+    fs.writeFileSync(leasePath, `${JSON.stringify(lease)}\n`, { flag: 'wx', mode: 0o600 });
+    let stopped = false;
+    let restored = false;
+    try {
+        appendSandboxControlAudit(manifest, 'lease-acquire', { ownerPid: process.pid });
+        waitForState(control.statusDir, (status) => status.state === 'parked' && status.reasonCode === 'SANDBOX_CONTROL_HANDOFF_ACTIVE');
+        if (row.running) {
+            runEngine(engine, 'docker', ['stop', row.name]);
+            stopped = true;
+        }
+        const refreshedRows = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
+        const refreshed = selectSandboxContainer([...refreshedRows.running, ...refreshedRows.nonRunning], containerNameCandidates(config, target.branch));
+        if (!refreshed || refreshed.running)
+            throw new Error('SANDBOX_VALIDATION_CONTAINER_STILL_RUNNING');
+        const activeLease = readActiveLease(manifest);
+        if (!activeLease || activeLease.nonce !== nonce)
+            throw new Error('SANDBOX_VALIDATION_LEASE_OWNERSHIP_LOST');
+        assertGitWorktreeBinding(config.repoRoot, manifest.worktreeRoot, target.branch);
+        const result = runValidationCommand(options.command, manifest.worktreeRoot, 'inplace', options.timeoutMs, options.format === 'json');
+        return { ...result, cleanup: () => restored ? 'completed' : 'pending' };
+    }
+    finally {
+        const recoveryErrors = [];
+        try {
+            const currentBranch = git(manifest.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+            if (currentBranch !== originalBranch)
+                git(manifest.worktreeRoot, ['switch', originalBranch]);
+        }
+        catch {
+            try {
+                git(manifest.worktreeRoot, ['checkout', '--detach', originalHead]);
+                git(manifest.worktreeRoot, ['switch', originalBranch]);
+            }
+            catch (fallbackError) {
+                recoveryErrors.push(`git binding restore failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
+            }
+        }
+        if (stopped) {
+            try {
+                runEngine(engine, 'docker', ['start', row.name]);
+            }
+            catch (error) {
+                recoveryErrors.push(`container start failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            const currentLease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
+            if (currentLease.nonce !== nonce)
+                throw new Error('SANDBOX_VALIDATION_LEASE_OWNERSHIP_LOST');
+        }
+        catch (error) {
+            recoveryErrors.push(error instanceof Error ? error.message : String(error));
+        }
+        if (recoveryErrors.length === 0) {
+            try {
+                fs.unlinkSync(leasePath);
+                appendSandboxControlAudit(manifest, 'lease-release', { ownerPid: process.pid });
+                waitForState(control.statusDir, (status) => status.state === 'healthy');
+                restored = true;
+            }
+            catch (error) {
+                try {
+                    if (!fs.existsSync(leasePath)) {
+                        fs.writeFileSync(leasePath, `${JSON.stringify(lease)}\n`, { flag: 'wx', mode: 0o600 });
+                    }
+                    appendSandboxControlAudit(manifest, 'lease-release-failed', { ownerPid: process.pid });
+                }
+                catch (leaseError) {
+                    recoveryErrors.push(`lease preservation failed: ${leaseError instanceof Error ? leaseError.message : String(leaseError)}`);
+                }
+                recoveryErrors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (recoveryErrors.length > 0) {
+            throw new Error(`SANDBOX_VALIDATION_RECOVERY_INCOMPLETE: ${recoveryErrors.join('; ')}; run 'ai sandbox start ${target.branch}'`);
+        }
+    }
+}
+export async function validate(args) {
+    const options = parseValidateArgs(args);
+    if (options.help) {
+        process.stdout.write(`${USAGE}\n`);
+        return 0;
+    }
+    const config = loadConfig();
+    const target = resolveSandboxTarget(options.target, config.repoRoot);
+    const commit = git(config.repoRoot, ['rev-parse', target.branch]);
+    const startedAt = new Date().toISOString();
+    const result = options.scope === 'snapshot'
+        ? snapshotValidation(config.repoRoot, commit, options)
+        : inplaceValidation(config, target, options);
+    const evidence = {
+        version: 1,
+        taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
+        branch: target.branch,
+        scope: options.scope,
+        commit,
+        command: path.basename(options.command[0]),
+        startedAt,
+        completedAt: new Date().toISOString(),
+        exitCode: result.exitCode,
+        signal: result.signal,
+        cleanup: result.cleanup()
+    };
+    if (options.format === 'json')
+        process.stdout.write(`${JSON.stringify(evidence)}\n`);
+    else
+        process.stdout.write(`Validation ${result.exitCode === 0 ? 'passed' : 'failed'} (${options.scope}, ${evidence.command}, cleanup=${evidence.cleanup}).\n`);
+    return result.exitCode;
+}
+//# sourceMappingURL=validate.js.map

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

@@ -1,11 +1,11 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { locateActivityLog, appendActivityEntry, pairEntries } from './activity-log.js';
+import { locateActivityLog, appendActivityEntry, pairEntries, parseCommitAttemptStarted } from './activity-log.js';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { parseReviewSummary } from './review-artifacts.js';
-import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.js';
+import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.js';
+import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewedGitTree } from './review-fingerprint.js';
 const SHA_RE = /^[a-f0-9]{40,64}$/;
 function git(repoRoot, args) {
     return execFileSync('git', args, {
@@ -26,6 +26,22 @@ function isAncestor(repoRoot, ancestor, descendant) {
         stdio: 'ignore'
     }).status === 0;
 }
+function hasMatchingApprovedReview(taskDir, beforeRound, baseline, tree) {
+    const entries = fs.readdirSync(taskDir);
+    for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
+        const file = path.join(taskDir, artifactName('review-code', round));
+        if (!fs.existsSync(file))
+            continue;
+        const content = fs.readFileSync(file, 'utf8');
+        const summary = parseReviewSummary(content);
+        if (summary.ok
+            && summary.summary.verdict === 'Approved'
+            && extractReviewBaseline(content) === baseline
+            && extractReviewedSnapshotTree(content) === tree)
+            return true;
+    }
+    return false;
+}
 function outcome(disposition, overrides = {}) {
     return {
         disposition,
@@ -34,10 +50,12 @@ function outcome(disposition, overrides = {}) {
         currentHead: '',
         committedHead: null,
         commitNote: null,
+        activityNote: null,
         needsAnchor: false,
         needsLog: false,
         intent: null,
         intentDigest: null,
+        attempt: null,
         ...overrides
     };
 }
@@ -63,6 +81,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
     const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
     const file = commitIntentPath(taskDir);
     if (!fs.existsSync(file)) {
+        if (openRows.length === 1) {
+            const attempt = parseCommitAttemptStarted(openRows[0].note);
+            if (attempt && attempt.baseline === currentHead) {
+                return outcome('retryable-start', {
+                    message: 'a structured Commit attempt can be safely reused',
+                    currentHead,
+                    attempt
+                });
+            }
+        }
         if (openRows.length > 0) {
             return outcome('orphaned-start', {
                 code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
@@ -119,6 +147,12 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
             message: 'repository HEAD or ancestry conflicts with the commit intent'
         });
     }
+    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
+    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
+    const pushOnlyRetry = intent.phase === 'pushed'
+        && intent.baselineHead === intent.committedHead
+        && matchingDone.length === 1
+        && openRows.length === 1;
     const review = findAuthoritativeReviewCodeArtifact(taskDir);
     let needsAnchor = false;
     if (review.ok && review.path) {
@@ -132,11 +166,13 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
         const summary = parseReviewSummary(reviewContent);
         const reviewBaseline = extractReviewBaseline(reviewContent);
         const reviewTree = extractReviewedSnapshotTree(reviewContent);
-        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !SHA_RE.test(reviewTree)) {
+        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
             return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
         }
         const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-        if (reviewBaseline !== intent.baselineHead || reviewTree !== committedTree) {
+        const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
+        if (!matchingCurrentReview
+            && !hasMatchingApprovedReview(taskDir, review.round, intent.baselineHead, committedTree)) {
             return outcome('conflict', {
                 ...shared,
                 code: 'COMMIT_FINALIZATION_CONFLICT',
@@ -144,18 +180,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
             });
         }
         const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-        if (anchor && anchor !== intent.committedHead) {
+        if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
             return outcome('conflict', {
                 ...shared,
                 code: 'COMMIT_FINALIZATION_CONFLICT',
                 message: 'task review anchor conflicts with the committed intent'
             });
         }
-        needsAnchor = anchor === '';
+        needsAnchor = anchor !== intent.committedHead;
     }
-    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-    const needsLog = matchingDone.length === 0 && openRows.length === 1;
+    const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
     if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
         return outcome('conflict', {
             ...shared,
@@ -168,12 +202,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
         ...shared,
         message: 'commit finalization can be recovered',
         commitNote,
+        activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
         needsAnchor,
         needsLog
     });
 }
 function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
-    if (inspection.disposition !== 'recoverable' || !inspection.committedHead || !inspection.commitNote) {
+    if (inspection.disposition !== 'recoverable'
+        || !inspection.committedHead
+        || !inspection.commitNote
+        || !inspection.activityNote) {
         throw new Error('commit finalization task mutations require a recoverable inspection');
     }
     const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
@@ -196,7 +234,7 @@ function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
                 time: timestamp,
                 step: 'Commit',
                 agent,
-                note: inspection.commitNote
+                note: inspection.activityNote
             })
         });
     }

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

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { syncPlatformComment } from '../platform/issue-comments.js';
+import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
+import { VERSION } from '../version.js';
+import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
+import { createLocalTask } from './create.js';
+import { verifyTaskEvent } from './verification.js';
+const DEFAULT_DEPENDENCIES = {
+    createIssue: createPlatformIssue,
+    syncIssue: syncPlatformIssue,
+    syncComment: syncPlatformComment,
+    addWarning: applyWorkflowWarningIntent
+};
+function verifyCreatedTask(repoRoot, taskId) {
+    const verification = verifyTaskEvent({ taskRef: taskId, event: 'create-task.completed' }, { repoRoot });
+    if (verification.status === 'pass') {
+        return { operation: { name: 'task:verify', status: 'pass', reasonCode: null }, error: null };
+    }
+    const blocked = verification.status === 'blocked';
+    return {
+        operation: {
+            name: 'task:verify', status: verification.status,
+            reasonCode: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED'
+        },
+        error: {
+            code: verification.error?.code ?? 'TASK_CREATE_VERIFICATION_FAILED',
+            message: `Created task did not pass the ${verification.event} gate`,
+            retryable: blocked
+        }
+    };
+}
+function platformOperations(prefix, operations) {
+    return operations.map((operation) => ({
+        name: `${prefix}:${operation.name}`,
+        status: operation.status,
+        reasonCode: operation.reasonCode ?? null
+    }));
+}
+function issueFromTask(repoRoot, taskId) {
+    const content = fs.readFileSync(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), 'utf8');
+    const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
+    return match ? { number: Number(match[1]), url: '' } : null;
+}
+function createTask(value, options) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
+    let candidate;
+    let local;
+    try {
+        candidate = value;
+        local = createLocalTask(candidate, {
+            repoRoot: options.repoRoot,
+            agentInfraVersion: options.agentInfraVersion ?? VERSION
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+        return {
+            status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+            operations: [], warnings: [], error: { code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' }
+        };
+    }
+    const operations = [{
+            name: 'task:local', status: local.status, reasonCode: null
+        }];
+    let issue = issueFromTask(options.repoRoot, local.task.id);
+    const created = dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
+    operations.push(...platformOperations('platform-create', created.operations));
+    if (created.issue)
+        issue = { number: created.issue.number, url: created.issue.url };
+    let platformFailure = created.status === 'failed' || created.status === 'blocked' ? created : null;
+    if (!platformFailure && (created.task.issueNumber || issue)) {
+        const synced = dependencies.syncIssue(local.task.id, {
+            cwd: options.repoRoot,
+            agent: candidate.agent,
+            status: 'waiting-for-triage',
+            assignees: 'current',
+            milestone: 'initial',
+            issueType: true,
+            fields: true
+        });
+        operations.push(...platformOperations('platform-sync', synced.operations));
+        if (synced.issue)
+            issue = { number: synced.issue.number, url: synced.issue.url };
+        if (synced.status === 'failed' || synced.status === 'blocked')
+            platformFailure = synced;
+        if (!platformFailure) {
+            const commented = dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
+            operations.push(...platformOperations('platform-comment', commented.operations));
+            if (commented.status === 'failed' || commented.status === 'blocked')
+                platformFailure = commented;
+        }
+    }
+    if (platformFailure) {
+        const error = platformFailure.error ?? { code: 'ISSUE_CREATE_FAILED', message: 'Platform operation failed', retryable: false };
+        dependencies.addWarning({
+            kind: 'add', taskRef: local.task.id, step: 'create-task', severity: 'ACTION_REQUIRED',
+            code: 'ISSUE_CREATE_FAILED', target: 'issue', message: `${error.code}: ${error.message}`,
+            action: 'Fix platform authentication or connectivity, then retry Issue creation for this task.'
+        }, { repoRoot: options.repoRoot });
+        const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+        operations.push(verified.operation);
+        if (verified.error)
+            return {
+                status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+                task: local.task, issue, operations, warnings: [], error: verified.error
+            };
+        return {
+            status: platformFailure.status === 'blocked' ? 'blocked' : 'degraded',
+            changed: local.changed,
+            task: local.task,
+            issue,
+            operations,
+            warnings: [{ code: 'ISSUE_CREATE_FAILED', severity: 'ACTION_REQUIRED', action: 'Retry Issue creation after fixing the platform failure.' }],
+            error
+        };
+    }
+    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    operations.push(verified.operation);
+    if (verified.error)
+        return {
+            status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
+            task: local.task, issue, operations, warnings: [], error: verified.error
+        };
+    return {
+        status: local.status,
+        changed: local.changed,
+        task: local.task,
+        issue,
+        operations,
+        warnings: [],
+        error: null
+    };
+}
+export { createTask };
+//# sourceMappingURL=create-service.js.map