@fitlab-ai/agent-infra 0.9.12 → 0.9.14

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

@@ -12,8 +12,110 @@ const DEFAULT_DEPENDENCIES = {
     syncComment: syncPlatformComment,
     addWarning: applyWorkflowWarningIntent
 };
-function verifyCreatedTask(repoRoot, taskId) {
-    const verification = verifyTaskEvent({ taskRef: taskId, event: 'create-task.completed' }, { repoRoot });
+function invalidTaskCreateResult() {
+    throw new Error('TASK_CREATE_RESULT_INVALID');
+}
+function exactKeys(value, expected) {
+    return Object.keys(value).sort().join(',') === [...expected].sort().join(',');
+}
+function validTaskReference(value) {
+    return value === null || (typeof value === 'string' && value.length > 0);
+}
+function validTaskCreateError(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const error = value;
+    return exactKeys(error, ['code', 'message', 'retryable'])
+        && typeof error.code === 'string' && /^[A-Z][A-Z0-9_]+$/u.test(error.code)
+        && typeof error.message === 'string'
+        && typeof error.retryable === 'boolean';
+}
+function validTaskCreateControl(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const control = value;
+    return exactKeys(control, ['accepted', 'recovery', 'requestId'])
+        && validTaskReference(control.requestId)
+        && typeof control.accepted === 'boolean'
+        && ['none', 'same-request-id', 'new-request-id', 'inspect-domain-state'].includes(control.recovery);
+}
+export function parseTaskCreateResult(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return invalidTaskCreateResult();
+    const result = value;
+    if (!exactKeys(result, ['changed', 'control', 'error', 'issue', 'operations', 'status', 'task', 'warnings'])
+        && !exactKeys(result, ['changed', 'error', 'issue', 'operations', 'status', 'task', 'warnings'])) {
+        return invalidTaskCreateResult();
+    }
+    if (!['applied', 'no-op', 'degraded', 'failed', 'blocked'].includes(result.status)
+        || typeof result.changed !== 'boolean'
+        || !result.task || typeof result.task !== 'object' || Array.isArray(result.task)
+        || !exactKeys(result.task, ['id', 'shortId'])
+        || !validTaskReference(result.task.id)
+        || !validTaskReference(result.task.shortId)
+        || !Array.isArray(result.operations)
+        || !result.operations.every((operation) => {
+            if (!operation || typeof operation !== 'object' || Array.isArray(operation))
+                return false;
+            const value = operation;
+            return exactKeys(value, ['name', 'reasonCode', 'status'])
+                && typeof value.name === 'string' && typeof value.status === 'string'
+                && (value.reasonCode === null || typeof value.reasonCode === 'string');
+        })
+        || !Array.isArray(result.warnings)
+        || !result.warnings.every((warning) => {
+            if (!warning || typeof warning !== 'object' || Array.isArray(warning))
+                return false;
+            const value = warning;
+            return exactKeys(value, ['action', 'code', 'severity'])
+                && typeof value.action === 'string' && typeof value.code === 'string' && typeof value.severity === 'string';
+        })
+        || (result.issue !== null && (!result.issue || typeof result.issue !== 'object' || Array.isArray(result.issue)
+            || !exactKeys(result.issue, ['number', 'url'])
+            || !Number.isSafeInteger(result.issue.number)
+            || (result.issue.number) <= 0
+            || typeof result.issue.url !== 'string'))
+        || (result.error !== null && !validTaskCreateError(result.error))
+        || ('control' in result && !validTaskCreateControl(result.control))) {
+        return invalidTaskCreateResult();
+    }
+    if (result.status === 'blocked' && !result.error?.retryable)
+        return invalidTaskCreateResult();
+    if (result.status === 'failed' && !result.error)
+        return invalidTaskCreateResult();
+    return result;
+}
+export function projectTaskCreateResult(result, control) {
+    return { ...result, control };
+}
+export function taskCreateExitCode(result) {
+    return result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+}
+export function taskCreateFailure(error, control) {
+    return {
+        status: error.retryable ? 'blocked' : 'failed',
+        changed: false,
+        task: { id: null, shortId: null },
+        issue: null,
+        operations: [],
+        warnings: [],
+        error,
+        ...(control ? { control } : {})
+    };
+}
+export function taskCreateOutputUnavailableResult(requestId) {
+    return taskCreateFailure({
+        code: 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE',
+        message: 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: task-create result output was not retained; inspect domain state before retrying',
+        retryable: false
+    }, {
+        requestId,
+        accepted: true,
+        recovery: 'inspect-domain-state'
+    });
+}
+async function verifyCreatedTask(repoRoot, taskId) {
+    const verification = await verifyTaskEvent({ taskRef: taskId, event: 'create-task.completed' }, { repoRoot });
     if (verification.status === 'pass') {
         return { operation: { name: 'task:verify', status: 'pass', reasonCode: null }, error: null };
     }
@@ -42,7 +144,7 @@ function issueFromTask(repoRoot, taskId) {
     const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
     return match ? { number: Number(match[1]), url: '' } : null;
 }
-function createTask(value, options) {
+async function createTask(value, options) {
     const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
     let candidate;
     let local;
@@ -56,22 +158,19 @@ function createTask(value, options) {
     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' }
-        };
+        return taskCreateFailure({ 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 });
+    const created = await 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, {
+        const synced = await dependencies.syncIssue(local.task.id, {
             cwd: options.repoRoot,
             agent: candidate.agent,
             status: 'waiting-for-triage',
@@ -86,7 +185,7 @@ function createTask(value, options) {
         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 });
+            const commented = await 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;
@@ -99,7 +198,7 @@ function createTask(value, options) {
             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);
+        const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
         operations.push(verified.operation);
         if (verified.error)
             return {
@@ -116,7 +215,7 @@ function createTask(value, options) {
             error
         };
     }
-    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
     operations.push(verified.operation);
     if (verified.error)
         return {

package/dist/lib/task/create.js

@@ -6,6 +6,7 @@ import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.js';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
+import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS } from './qualification-audit.js';
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'];
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'];
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'];
@@ -139,6 +140,23 @@ function markdownBlock(value) {
 function renderList(items) {
     return items.map((item) => `- ${item}`).join('\n');
 }
+function tableCell(value) {
+    return value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ');
+}
+function renderTable(columns, rows) {
+    return [
+        `| ${columns.join(' | ')} |`,
+        `| ${columns.map(() => '---').join(' | ')} |`,
+        ...rows.map((row) => `| ${row.map(tableCell).join(' | ')} |`)
+    ].join('\n');
+}
+function appendCanonicalRows(content, columns, rows) {
+    if (rows.length === 0)
+        return content;
+    const table = renderTable(columns, rows);
+    const separator = `| ${columns.map(() => '---').join(' | ')} |`;
+    return content.replace(separator, `${separator}\n${table.split('\n').slice(2).join('\n')}`);
+}
 function replaceEmptySubsection(content, heading, items) {
     if (items.length === 0)
         return content;
@@ -183,6 +201,13 @@ function renderTask(params) {
     ];
     for (const [heading, key] of sections)
         content = replaceEmptySubsection(content, heading, candidate.taskInput[key]);
+    const constraintIds = candidate.taskInput.constraints.map((_, index) => `C-${index + 1}`);
+    content = appendCanonicalRows(content, CONSTRAINT_COLUMNS, candidate.taskInput.constraints.map((statement, index) => [
+        constraintIds[index], statement, 'assumption', 'create-task', 'taskInput', 'create-task input', '', ''
+    ]));
+    content = appendCanonicalRows(content, CANDIDATE_COLUMNS, candidate.taskInput.alternatives.map((statement, index) => [
+        String.fromCharCode(65 + index), statement, 'pending', constraintIds.join(','), 'requires qualification', 'create-task input'
+    ]));
     content = content.replace('- **关联 Issue**：#XXX', '- **关联 Issue**：N/A');
     content = content.replace('- **关联 PR**：#XXX', '- **关联 PR**：N/A');
     content = content.replace('- **分支**：`feature/xxx`', `- **分支**：\`${branch}\``);

package/dist/lib/task/current-contract.js

@@ -1,6 +1,7 @@
 import { isValidAgentInfraVersion } from '../version.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.js';
+import { parseInvalidationDocument } from './invalidation.js';
 function validateCurrentTaskContract(content) {
     let metadata;
     try {
@@ -29,7 +30,10 @@ function validateCurrentTaskContract(content) {
     const invalid = validateLedgerRows(ledger.rows);
     if (invalid)
         return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalid.code}: ${invalid.message}` };
-    return { ok: true, metadata, ledger };
+    const invalidation = parseInvalidationDocument(content);
+    if (!invalidation.ok)
+        return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalidation.code}: ${invalidation.message}` };
+    return { ok: true, metadata, ledger, invalidation: invalidation.document };
 }
 export { validateCurrentTaskContract };
 //# sourceMappingURL=current-contract.js.map

package/dist/lib/task/decision-details.js

@@ -214,5 +214,5 @@ function normalizeDecisionDetailForDisplay(block) {
         ordered.push(byKey.get('implementation'));
     return [body.slice(heading.start, heading.end).trim(), ...ordered].join('\n\n').trim();
 }
-export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, resolveDecisionDetail };
+export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, resolveDecisionDetail, scanVisibleMarkdown };
 //# sourceMappingURL=decision-details.js.map