@fitlab-ai/agent-infra 0.9.3 → 0.9.5

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

@@ -0,0 +1,278 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+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, parseReviewedGitTree } from './review-fingerprint.js';
+const SHA_RE = /^[a-f0-9]{40,64}$/;
+function git(repoRoot, args) {
+    return execFileSync('git', args, {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function commitExists(repoRoot, value) {
+    return SHA_RE.test(value) && spawnSync('git', ['cat-file', '-e', `${value}^{commit}`], {
+        cwd: repoRoot,
+        stdio: 'ignore'
+    }).status === 0;
+}
+function isAncestor(repoRoot, ancestor, descendant) {
+    return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
+        cwd: repoRoot,
+        stdio: 'ignore'
+    }).status === 0;
+}
+function outcome(disposition, overrides = {}) {
+    return {
+        disposition,
+        code: null,
+        message: disposition,
+        currentHead: '',
+        committedHead: null,
+        commitNote: null,
+        needsAnchor: false,
+        needsLog: false,
+        intent: null,
+        intentDigest: null,
+        attempt: null,
+        ...overrides
+    };
+}
+function invalid(message, currentHead = '', code = 'COMMIT_FINALIZATION_EVIDENCE_INVALID', overrides = {}) {
+    return outcome('invalid', { code, message, currentHead, ...overrides });
+}
+function inspectCommitFinalization(taskDir, repoRoot, taskId) {
+    let currentHead;
+    let taskContent;
+    let metadata;
+    try {
+        currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
+        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        metadata = parseTypedTaskFrontmatter(taskContent);
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : String(error));
+    }
+    const activity = locateActivityLog(taskContent);
+    if (!activity)
+        return invalid('task activity log is missing or ambiguous', currentHead);
+    const commitRows = pairEntries(activity.entries).filter((row) => row.step === 'Commit');
+    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',
+                message: 'an open Commit activity entry exists without a commit intent',
+                currentHead
+            });
+        }
+        return outcome('idle', { message: 'no active commit finalization exists', currentHead });
+    }
+    let raw;
+    let intent;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+        intent = readCommitIntent(taskDir, taskId);
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : String(error), currentHead);
+    }
+    const intentDigest = digest(raw);
+    const shared = { currentHead, intent, intentDigest, committedHead: intent.committedHead };
+    if (!commitExists(repoRoot, intent.baselineHead)) {
+        return invalid('commit intent baseline is not a valid Git commit', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
+    }
+    if (intent.phase === 'prepared') {
+        if (intent.committedHead !== null || intent.pushEvidence !== null) {
+            return invalid('prepared commit intent contains commit or push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
+        }
+        if (currentHead !== intent.baselineHead || openRows.length !== 1) {
+            return outcome('conflict', {
+                ...shared,
+                code: 'COMMIT_FINALIZATION_CONFLICT',
+                message: 'prepared commit intent does not match HEAD and exactly one open Commit entry'
+            });
+        }
+        return outcome('prepared', { ...shared, message: 'prepared commit intent can be safely retried' });
+    }
+    if (!intent.committedHead || !commitExists(repoRoot, intent.committedHead)) {
+        return invalid('committed intent head is missing or invalid', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
+    }
+    if (intent.phase === 'committed' && intent.pushEvidence !== null) {
+        return invalid('committed intent contains premature push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
+    }
+    if (intent.phase === 'pushed'
+        && (intent.pushEvidence === null
+            || intent.pushEvidence.head !== intent.committedHead
+            || !intent.pushEvidence.remote
+            || !intent.pushEvidence.ref)) {
+        return invalid('pushed intent evidence is missing or inconsistent', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
+    }
+    if (currentHead !== intent.committedHead || !isAncestor(repoRoot, intent.baselineHead, intent.committedHead)) {
+        return outcome('conflict', {
+            ...shared,
+            code: 'COMMIT_FINALIZATION_CONFLICT',
+            message: 'repository HEAD or ancestry conflicts with the commit intent'
+        });
+    }
+    const review = findAuthoritativeReviewCodeArtifact(taskDir);
+    let needsAnchor = false;
+    if (review.ok && review.path) {
+        let reviewContent;
+        try {
+            reviewContent = fs.readFileSync(review.path, 'utf8');
+        }
+        catch (error) {
+            return invalid(error instanceof Error ? error.message : String(error), currentHead, 'COMMIT_FINALIZATION_EVIDENCE_MISSING', shared);
+        }
+        const summary = parseReviewSummary(reviewContent);
+        const reviewBaseline = extractReviewBaseline(reviewContent);
+        const reviewTree = extractReviewedSnapshotTree(reviewContent);
+        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) {
+            return outcome('conflict', {
+                ...shared,
+                code: 'COMMIT_FINALIZATION_CONFLICT',
+                message: 'review baseline or snapshot tree conflicts with the committed intent'
+            });
+        }
+        const anchor = String(metadata.last_reviewed_commit ?? '').trim();
+        if (anchor && anchor !== intent.committedHead) {
+            return outcome('conflict', {
+                ...shared,
+                code: 'COMMIT_FINALIZATION_CONFLICT',
+                message: 'task review anchor conflicts with the committed intent'
+            });
+        }
+        needsAnchor = anchor === '';
+    }
+    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;
+    if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
+        return outcome('conflict', {
+            ...shared,
+            code: 'COMMIT_FINALIZATION_CONFLICT',
+            message: 'Commit activity identity is missing, duplicated, or ambiguous',
+            commitNote
+        });
+    }
+    return outcome('recoverable', {
+        ...shared,
+        message: 'commit finalization can be recovered',
+        commitNote,
+        needsAnchor,
+        needsLog
+    });
+}
+function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
+    if (inspection.disposition !== 'recoverable' || !inspection.committedHead || !inspection.commitNote) {
+        throw new Error('commit finalization task mutations require a recoverable inspection');
+    }
+    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const frontmatter = { assigned_to: agent };
+    if (inspection.needsAnchor)
+        frontmatter.last_reviewed_commit = inspection.committedHead;
+    const mutations = [{
+            kind: 'frontmatter',
+            set: frontmatter
+        }];
+    if (inspection.needsLog) {
+        const activity = locateActivityLog(taskContent);
+        if (!activity)
+            throw new Error('task activity log is missing or ambiguous');
+        mutations.push({
+            kind: 'section',
+            aliases: ['活动日志', 'Activity Log'],
+            heading: activity.heading,
+            body: appendActivityEntry(activity, {
+                time: timestamp,
+                step: 'Commit',
+                agent,
+                note: inspection.commitNote
+            })
+        });
+    }
+    return { mutations, commitNote: inspection.commitNote };
+}
+function inspectCreatePrCommitGate(taskDir, repoRoot, taskId) {
+    const lifecycle = inspectCommitFinalization(taskDir, repoRoot, taskId);
+    if (lifecycle.disposition !== 'idle') {
+        const pending = lifecycle.disposition === 'prepared' || lifecycle.disposition === 'recoverable';
+        return {
+            allowed: false,
+            code: pending ? 'COMMIT_FINALIZATION_PENDING' : lifecycle.code ?? 'COMMIT_FINALIZATION_CONFLICT',
+            message: pending ? 'commit finalization must complete before creating a pull request' : lifecycle.message,
+            disposition: lifecycle.disposition,
+            action: 'rerun-commit'
+        };
+    }
+    const review = findAuthoritativeReviewCodeArtifact(taskDir);
+    if (!review.ok || !review.path) {
+        return { allowed: true, code: null, message: 'no review-code history requires an anchor', disposition: 'idle', action: 'continue' };
+    }
+    try {
+        const content = fs.readFileSync(review.path, 'utf8');
+        const summary = parseReviewSummary(content);
+        if (!summary.ok || summary.summary.verdict !== 'Approved') {
+            return {
+                allowed: false,
+                code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
+                message: 'latest authoritative review-code is not approved',
+                disposition: 'idle',
+                action: 'rerun-review-code'
+            };
+        }
+        const task = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
+        const currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
+        const anchor = String(task.last_reviewed_commit ?? '').trim();
+        if (!anchor || !commitExists(repoRoot, anchor)) {
+            return {
+                allowed: false,
+                code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
+                message: 'approved review snapshot is not anchored to a Git commit',
+                disposition: 'idle',
+                action: 'rerun-commit'
+            };
+        }
+        if (anchor !== currentHead || extractReviewedSnapshotTree(content) !== git(repoRoot, ['rev-parse', 'HEAD^{tree}'])) {
+            return {
+                allowed: false,
+                code: 'COMMIT_FINALIZATION_CONFLICT',
+                message: 'approved review anchor or tree does not match repository HEAD',
+                disposition: 'idle',
+                action: 'rerun-review-code'
+            };
+        }
+        return { allowed: true, code: null, message: 'commit finalization evidence is complete', disposition: 'idle', action: 'continue' };
+    }
+    catch (error) {
+        return {
+            allowed: false,
+            code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
+            message: error instanceof Error ? error.message : String(error),
+            disposition: 'idle',
+            action: 'rerun-review-code'
+        };
+    }
+}
+export { inspectCommitFinalization, inspectCreatePrCommitGate, planCommitTaskFinalization };
+//# sourceMappingURL=commit-finalization.js.map

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

@@ -0,0 +1,165 @@
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+class CommitIntentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'CommitIntentError';
+        this.code = code;
+    }
+}
+function commitIntentPath(taskDir) {
+    return path.join(taskDir, 'commit-intent.json');
+}
+function digest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function serialize(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function atomicWrite(file, value) {
+    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temp, serialize(value), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        const handle = fs.openSync(temp, 'r+');
+        try {
+            fs.fsyncSync(handle);
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+        fs.renameSync(temp, file);
+        fs.chmodSync(file, 0o600);
+        try {
+            const directory = fs.openSync(path.dirname(file), 'r');
+            try {
+                fs.fsyncSync(directory);
+            }
+            finally {
+                fs.closeSync(directory);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (!['EACCES', 'EISDIR', 'EINVAL', 'EPERM'].includes(code ?? ''))
+                throw error;
+        }
+    }
+    finally {
+        if (fs.existsSync(temp))
+            fs.unlinkSync(temp);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function keysEqual(value, expected) {
+    return Object.keys(value).sort().join('\0') === [...expected].sort().join('\0');
+}
+function validPushEvidence(value) {
+    return value === null || (isRecord(value)
+        && keysEqual(value, ['remote', 'ref', 'head'])
+        && ['remote', 'ref', 'head'].every((key) => typeof value[key] === 'string' && value[key] !== ''));
+}
+function validOrchestration(value) {
+    if (value === null)
+        return true;
+    if (!isRecord(value) || !keysEqual(value, [
+        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest',
+        'completionUpdatedAt', 'plannedReceipt'
+    ]))
+        return false;
+    return [
+        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest', 'completionUpdatedAt'
+    ].every((key) => typeof value[key] === 'string' && value[key] !== '') && isRecord(value.plannedReceipt);
+}
+function parseIntent(raw, taskId) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent is not valid JSON');
+    }
+    if (!isRecord(value) || !keysEqual(value, [
+        'schemaVersion', 'taskId', 'mode', 'phase', 'tokenDigest', 'baselineHead', 'committedHead',
+        'pushEvidence', 'orchestration', 'createdAt', 'updatedAt'
+    ])) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has an invalid schema');
+    }
+    if (value.schemaVersion !== 1
+        || value.taskId !== taskId
+        || !['standalone', 'orchestrated'].includes(String(value.mode))
+        || !['prepared', 'committed', 'pushed'].includes(String(value.phase))
+        || typeof value.tokenDigest !== 'string'
+        || !/^[a-f0-9]{64}$/.test(value.tokenDigest)
+        || typeof value.baselineHead !== 'string'
+        || (value.committedHead !== null && typeof value.committedHead !== 'string')
+        || !validPushEvidence(value.pushEvidence)
+        || !validOrchestration(value.orchestration)
+        || typeof value.createdAt !== 'string'
+        || typeof value.updatedAt !== 'string'
+        || (value.mode === 'standalone') !== (value.orchestration === null)) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has invalid field values');
+    }
+    return value;
+}
+function tokenMatches(actualDigest, token) {
+    const actual = Buffer.from(actualDigest, 'hex');
+    const supplied = Buffer.from(digest(token), 'hex');
+    return actual.length === supplied.length && timingSafeEqual(actual, supplied);
+}
+function readCommitIntent(taskDir, taskId, token) {
+    const file = commitIntentPath(taskDir);
+    const intent = parseIntent(fs.readFileSync(file, 'utf8'), taskId);
+    if (token !== undefined && !tokenMatches(intent.tokenDigest, token)) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_TOKEN_MISMATCH', 'commit intent token does not match');
+    }
+    return intent;
+}
+function createCommitIntent(taskDir, input, options = {}) {
+    const file = commitIntentPath(taskDir);
+    if (fs.existsSync(file)) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists');
+    }
+    const token = (options.token ?? (() => randomBytes(32).toString('base64url')))();
+    const intent = Object.freeze({ schemaVersion: 1, ...input, tokenDigest: digest(token) });
+    atomicWrite(file, intent);
+    return { intent, token };
+}
+function updateCommitIntent(taskDir, taskId, token, updates) {
+    const current = readCommitIntent(taskDir, taskId, token);
+    const nextPhase = updates.phase ?? current.phase;
+    const transitions = {
+        prepared: ['prepared', 'committed', 'pushed'],
+        committed: ['committed', 'pushed'],
+        pushed: ['pushed']
+    };
+    if (!transitions[current.phase].includes(nextPhase)) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_STATE_INVALID', `cannot move commit intent from ${current.phase} to ${nextPhase}`);
+    }
+    const updated = Object.freeze({ ...current, ...updates, phase: nextPhase });
+    atomicWrite(commitIntentPath(taskDir), updated);
+    return updated;
+}
+function removeCommitIntent(taskDir, taskId, token) {
+    readCommitIntent(taskDir, taskId, token);
+    fs.unlinkSync(commitIntentPath(taskDir));
+}
+function removeCommitIntentByDigest(taskDir, taskId, expectedDigest) {
+    const file = commitIntentPath(taskDir);
+    const raw = fs.readFileSync(file);
+    parseIntent(raw.toString('utf8'), taskId);
+    const actual = digest(raw);
+    const expected = Buffer.from(expectedDigest, 'hex');
+    const observed = Buffer.from(actual, 'hex');
+    if (!/^[a-f0-9]{64}$/.test(expectedDigest)
+        || expected.length !== observed.length
+        || !timingSafeEqual(expected, observed)) {
+        throw new CommitIntentError('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit intent changed after recovery inspection');
+    }
+    fs.unlinkSync(file);
+}
+export { CommitIntentError, commitIntentPath, createCommitIntent, digest, readCommitIntent, removeCommitIntent, removeCommitIntentByDigest, serialize, updateCommitIntent };
+//# sourceMappingURL=commit-intent.js.map

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