@fitlab-ai/agent-infra 0.9.13 → 0.9.15

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

@@ -12,6 +12,108 @@ const DEFAULT_DEPENDENCIES = {
     syncComment: syncPlatformComment,
     addWarning: applyWorkflowWarningIntent
 };
+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') {
@@ -56,10 +158,7 @@ async 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

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, parseTaskQualification } 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,75 @@ 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 escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function candidateIdFor(index) {
+    let value = index + 1;
+    let id = '';
+    while (value > 0) {
+        const remainder = (value - 1) % 26;
+        id = `${String.fromCharCode(65 + remainder)}${id}`;
+        value = Math.floor((value - 1) / 26);
+    }
+    return id;
+}
+function appendCanonicalRows(content, heading, columns, rows) {
+    if (rows.length === 0)
+        return content;
+    const table = renderTable(columns, rows);
+    const [header, separator, ...rowLines] = table.split('\n');
+    const eol = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.split(/\r?\n/);
+    const headingPattern = new RegExp(`^###\\s+${escapeRegExp(heading)}\\s*$`);
+    const sectionStart = lines.findIndex((line) => headingPattern.test(line));
+    if (sectionStart < 0)
+        throw new Error(`TASK_CREATE_QUALIFICATION_INVALID: section '${heading}' is missing`);
+    let sectionEnd = lines.length;
+    for (let index = sectionStart + 1; index < lines.length; index += 1) {
+        if (/^#{2,3}\s+/.test(lines[index])) {
+            sectionEnd = index;
+            break;
+        }
+    }
+    const matches = [];
+    for (let index = sectionStart + 1; index + 1 < sectionEnd; index += 1) {
+        if (lines[index].trim() === header && lines[index + 1].trim() === separator)
+            matches.push(index);
+    }
+    if (matches.length !== 1) {
+        throw new Error(`TASK_CREATE_QUALIFICATION_INVALID: section '${heading}' must contain exactly one canonical qualification table`);
+    }
+    lines.splice(matches[0] + 2, 0, ...rowLines);
+    return lines.join(eol);
+}
+function validateRenderedQualification(content, candidate) {
+    const parsed = parseTaskQualification(content);
+    if (!parsed.ok) {
+        throw new Error(`TASK_CREATE_QUALIFICATION_INVALID: ${parsed.code}: ${parsed.message}`);
+    }
+    if (!parsed.qualification.present) {
+        throw new Error('TASK_CREATE_QUALIFICATION_INVALID: rendered task qualification contract is missing');
+    }
+    const expectedConstraintIds = candidate.taskInput.constraints.map((_, index) => `C-${index + 1}`);
+    const expectedCandidateIds = candidate.taskInput.alternatives.map((_, index) => candidateIdFor(index));
+    const actualConstraintIds = parsed.qualification.constraints.map((row) => row.constraintId);
+    const actualCandidateIds = parsed.qualification.candidates.map((row) => row.candidateId);
+    if (JSON.stringify(actualConstraintIds) !== JSON.stringify(expectedConstraintIds)
+        || JSON.stringify(actualCandidateIds) !== JSON.stringify(expectedCandidateIds)) {
+        throw new Error('TASK_CREATE_QUALIFICATION_INVALID: rendered task qualification rows do not match task input');
+    }
+}
 function replaceEmptySubsection(content, heading, items) {
     if (items.length === 0)
         return content;
@@ -183,6 +253,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) => [
+        candidateIdFor(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}\``);
@@ -303,8 +380,6 @@ function createLocalTask(value, options) {
     return withCreateLock(repoRoot, workspaceRoot, () => {
         if (fs.existsSync(receipts))
             assertRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
-        else
-            fs.mkdirSync(receipts, { mode: 0o700 });
         const receiptPath = path.join(receipts, `${keyDigest}.json`);
         if (fs.existsSync(receiptPath)) {
             const stat = fs.lstatSync(receiptPath);
@@ -320,6 +395,7 @@ function createLocalTask(value, options) {
         }
         const recovered = recoverPublishedTask(activeRoot, repoRoot, keyDigest, candidateDigest);
         if (recovered) {
+            ensureRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
             writeReceipt(receiptPath, {
                 version: 1, candidateDigest, taskId: recovered.taskId, shortId: recovered.shortId, status: 'recovered'
             });
@@ -341,6 +417,8 @@ function createLocalTask(value, options) {
             template: fs.readFileSync(templatePath, 'utf8'), candidate, taskId, project: projectConfig.project, delivery: projectConfig.delivery, timestamp,
             agentInfraVersion, keyDigest, candidateDigest
         });
+        validateRenderedQualification(rendered, candidate);
+        ensureRealDirectory(receipts, 'TASK_CREATE_RECEIPT_INVALID');
         const temporary = path.join(workspaceRoot, `.task-create.tmp.${process.pid}.${randomUUID()}`);
         fs.mkdirSync(temporary, { mode: 0o700 });
         fs.writeFileSync(path.join(temporary, 'task.md'), rendered, { flag: 'wx', mode: 0o600 });

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

@@ -1,51 +1,7 @@
+import { scanVisibleMarkdown } from './markdown.js';
 const DECISION_ID = /^(AN|PL|CD|HD)-[1-9]\d*(?=$|[\s:：])/i;
-const HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)\s*$/;
-const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-const FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})\s*$/;
-const ANCHOR = /^\s*<a\s+id=(['"])([^'"]+)\1\s*><\/a>\s*$/;
 const FIELD = /^\s*[-*]\s+\*\*([^*]+)\*\*\s*[:：]\s*/;
 const OPTION_HEADING = /^(?:方案|Option)\s+[A-Z](?:\b|\s*[:：])/i;
-function sourceLines(content) {
-    const lines = [];
-    let start = 0;
-    while (start < content.length) {
-        const newline = content.indexOf('\n', start);
-        const end = newline === -1 ? content.length : newline;
-        lines.push({ start, end, text: content.slice(start, end).replace(/\r$/, '') });
-        start = newline === -1 ? content.length : newline + 1;
-    }
-    return lines;
-}
-function scanVisibleMarkdown(content) {
-    const lines = sourceLines(content);
-    const visible = [];
-    const headings = [];
-    const anchors = [];
-    let fence = null;
-    for (const line of lines) {
-        if (fence) {
-            const close = line.text.match(FENCE_CLOSE);
-            if (close && close[1][0] === fence.character && close[1].length >= fence.length)
-                fence = null;
-            continue;
-        }
-        const open = line.text.match(FENCE_OPEN);
-        const marker = open?.[1];
-        const info = open?.[2] ?? '';
-        if (marker && !(marker[0] === '`' && info.includes('`'))) {
-            fence = { character: marker[0], length: marker.length };
-            continue;
-        }
-        visible.push(line);
-        const heading = line.text.match(HEADING);
-        if (heading)
-            headings.push({ ...line, level: heading[1].length, text: heading[2].trim() });
-        const anchor = line.text.match(ANCHOR);
-        if (anchor)
-            anchors.push({ ...line, id: anchor[2] });
-    }
-    return { lines: visible, headings, anchors };
-}
 function parseDecisionDetailBlocks(content) {
     const scanned = scanVisibleMarkdown(content);
     const details = scanned.headings.filter((heading) => heading.level === 3 && DECISION_ID.test(heading.text));
@@ -214,5 +170,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, scanVisibleMarkdown };
+export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, resolveDecisionDetail };
 //# sourceMappingURL=decision-details.js.map