@fitlab-ai/agent-infra 0.8.4 → 0.9.0

package/dist/lib/task/verification-review.js

@@ -0,0 +1,3 @@
+export { extractReviewBaseline, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewVerdict, resolvePostReviewGlobs } from './review-fingerprint.js';
+export { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+//# sourceMappingURL=verification-review.js.map

package/dist/lib/task/verification-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=verification-types.js.map

package/dist/lib/task/verification.js

@@ -0,0 +1,113 @@
+import path from 'node:path';
+// Verification runs in-process; configuration, review parsing and platform
+// checks are provided by typed domain modules without a stdout protocol.
+import { verifyInProcess } from './verification-engine.js';
+import { parseArtifactName } from './artifact-lifecycle.js';
+import { resolveTaskRef } from './resolve-ref.js';
+const gate = (skill, expectedState, artifactFamily) => ({
+    skill, expectedState, mode: 'gate', ...(artifactFamily ? { artifactFamily } : {})
+});
+const VERIFICATION_CATALOG = {
+    'analyze.awaiting-input': { skill: 'analyze-task', expectedState: 'active', mode: 'checks', checks: ['task-meta'] },
+    'analyze.completed': gate('analyze-task', 'active', 'analysis'),
+    'review-analysis.completed': gate('review-analysis', 'active', 'review-analysis'),
+    'plan.completed': gate('plan-task', 'active', 'plan'),
+    'review-plan.completed': gate('review-plan', 'active', 'review-plan'),
+    'code.completed': gate('code-task', 'active', 'code'),
+    'review-code.completed': gate('review-code', 'active', 'review-code'),
+    'manual-validation.completed': gate('complete-manual-validation', 'active', 'manual-validation'),
+    'block-task.completed': gate('block-task', 'blocked'),
+    'cancel-task.completed': gate('cancel-task', 'completed'),
+    'commit.completed': gate('commit', 'active'),
+    'complete-task.preflight': { skill: 'complete-task', expectedState: 'active', mode: 'checks', checks: ['review-ledger', 'post-review-commit', 'required-checks', 'platform-sync-preflight'] },
+    'complete-task.completed': gate('complete-task', 'completed'),
+    'create-pr.completed': gate('create-pr', 'active'),
+    'create-task.completed': gate('create-task', 'active'),
+    'import-codescan.completed': gate('import-codescan', 'active'),
+    'import-dependabot.completed': gate('import-dependabot', 'active'),
+    'import-issue.completed': gate('import-issue', 'active'),
+    'watch-pr.completed': gate('watch-pr', 'active')
+};
+function failure(request, code, message, extra = {}) {
+    return {
+        status: 'failed', changed: false, event: request.event, requestRef: request.taskRef,
+        taskId: null, taskDir: null, taskState: null, skill: null, mode: null,
+        artifact: request.artifact ?? null, invocations: [], error: { code, message }, ...extra
+    };
+}
+function verifyTaskEvent(request, options = {}) {
+    const spec = VERIFICATION_CATALOG[request.event];
+    if (!spec)
+        return failure(request, 'VERIFY_EVENT_UNKNOWN', `unknown verification event '${request.event}'`);
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failure(request, resolved.code, resolved.message, { taskId: resolved.taskId, skill: spec.skill, mode: spec.mode });
+    const identity = { taskId: resolved.taskId, taskDir: resolved.taskDir, taskState: resolved.state, skill: spec.skill, mode: spec.mode };
+    if (resolved.state !== spec.expectedState) {
+        return failure(request, 'VERIFY_TASK_STATE_MISMATCH', `event '${request.event}' requires workspace '${spec.expectedState}', received '${resolved.state}'`, identity);
+    }
+    if (spec.artifactFamily) {
+        if (!request.artifact)
+            return failure(request, 'VERIFY_ARTIFACT_REQUIRED', `event '${request.event}' requires an artifact`, identity);
+        const parsed = parseArtifactName(request.artifact);
+        if (path.basename(request.artifact) !== request.artifact || !parsed || parsed.family !== spec.artifactFamily) {
+            return failure(request, 'VERIFY_ARTIFACT_INVALID', `artifact '${request.artifact}' is not a canonical ${spec.artifactFamily} artifact`, identity);
+        }
+    }
+    else if (request.artifact) {
+        return failure(request, 'VERIFY_ARTIFACT_UNEXPECTED', `event '${request.event}' does not accept an artifact`, identity);
+    }
+    const invocations = [];
+    const engine = options.engine ?? verifyInProcess;
+    if (spec.mode === 'gate') {
+        const payload = engine({ mode: 'gate', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [], repositoryRoot: resolved.repoRoot });
+        const status = payload.gate;
+        invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
+    }
+    else {
+        for (const check of spec.checks ?? []) {
+            const payload = engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
+            const status = payload.status;
+            invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
+            if (status !== 'pass')
+                break;
+        }
+    }
+    const status = invocations.some((item) => item.status === 'blocked') ? 'blocked'
+        : invocations.some((item) => item.status === 'fail') ? 'fail' : 'pass';
+    return {
+        status, changed: false, event: request.event, requestRef: request.taskRef,
+        ...identity, artifact: request.artifact ?? null, invocations, error: null
+    };
+}
+function statusLabel(status) {
+    return status === 'fail' ? 'FAIL' : status === 'blocked' ? 'BLOCKED' : 'pass';
+}
+function renderPayload(payload) {
+    const lines = [];
+    if (Array.isArray(payload.checks)) {
+        lines.push(`Verification: ${payload.gate} | Skill: ${payload.skill}`, '');
+        for (const check of payload.checks) {
+            lines.push(`  [${statusLabel(check.status)}] ${check.type} - ${check.message}`);
+        }
+        lines.push('', `Result: ${payload.summary} - ${payload.action}`);
+    }
+    else {
+        lines.push(`Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
+        lines.push(`  [${statusLabel(payload.status)}] ${payload.type} - ${payload.message}`);
+        const summary = payload.status === 'pass' ? '1 passed, 0 failed'
+            : payload.status === 'blocked' ? '0 passed, 0 failed, 1 blocked' : '0 passed, 1 failed';
+        const action = payload.status === 'pass' ? 'Requested check passed'
+            : payload.status === 'blocked' ? `Resolve blocked ${payload.type} check and re-run check`
+                : `Fix ${payload.type} issues and re-run check`;
+        lines.push('', `Result: ${summary} - ${action}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderTaskVerification(result) {
+    if (result.status === 'failed')
+        return `Verification failed: ${result.error?.code ?? 'VERIFY_FAILED'} - ${result.error?.message ?? 'unknown error'}\n`;
+    return result.invocations.map((invocation) => renderPayload(invocation.payload)).join('');
+}
+export { VERIFICATION_CATALOG, renderTaskVerification, verifyTaskEvent };
+//# sourceMappingURL=verification.js.map

package/dist/lib/task/workflow-warning-intents.js

@@ -0,0 +1,131 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from './resolve-ref.js';
+import { WORKFLOW_WARNING_COLUMNS, WORKFLOW_WARNING_HEADINGS, WORKFLOW_WARNING_SEVERITIES, WORKFLOW_WARNING_STATUSES, parseWorkflowWarnings } from './workflow-warnings.js';
+import { captureTaskWriteMetadata, writeTask } from './write.js';
+function failed(intent, code, message, taskId = null, entityId = null) {
+    return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, warnings: [], operations: [], error: { code, message } };
+}
+function oneLine(value) {
+    return value.replace(/\s*\r?\n\s*/g, ' ').trim();
+}
+function nextWarningId(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const match = /^WW-(\d+)$/.exec(row.id);
+        if (match)
+            max = Math.max(max, Number(match[1]));
+    }
+    return `WW-${max + 1}`;
+}
+function validateRows(rows) {
+    const ids = new Set();
+    for (const row of rows) {
+        if (!/^WW-[1-9]\d*$/.test(row.id))
+            return { code: 'WARNING_ID_INVALID', message: `warning id '${row.id}' is invalid` };
+        if (ids.has(row.id))
+            return { code: 'WARNING_DUPLICATE_ID', message: `duplicate warning id '${row.id}'` };
+        ids.add(row.id);
+        if (!WORKFLOW_WARNING_SEVERITIES.has(row.severity) || !WORKFLOW_WARNING_STATUSES.has(row.status))
+            return { code: 'WARNING_DOCUMENT_INVALID', message: `warning '${row.id}' has invalid severity or status` };
+    }
+    return null;
+}
+function sectionMutation(content) {
+    if (/^##\s+(工作流告警|Workflow Warnings)\s*$/m.test(content))
+        return [];
+    const english = /^##\s+Activity Log\s*$/m.test(content);
+    return [{
+            kind: 'section', aliases: WORKFLOW_WARNING_HEADINGS, heading: english ? 'Workflow Warnings' : '工作流告警',
+            body: `| ${WORKFLOW_WARNING_COLUMNS.join(' | ')} |\n|----|------|------|----------|------|--------|--------|---------|--------|-------------|------------|`
+        }];
+}
+function rowMutation(row) {
+    return {
+        kind: 'table-row', action: 'upsert', sectionAliases: WORKFLOW_WARNING_HEADINGS,
+        columns: WORKFLOW_WARNING_COLUMNS, keyColumn: 'id', key: row.id,
+        values: {
+            time: row.time, step: row.step, severity: row.severity, code: row.code, status: row.status,
+            target: row.target, message: row.message, action: row.action,
+            resolved_at: row.resolvedAt, resolution: row.resolution
+        }
+    };
+}
+function applyWorkflowWarningIntent(intent, options = {}) {
+    const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(intent, resolved.code, resolved.message, resolved.taskId);
+    if (resolved.state !== 'active')
+        return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+    let content;
+    let rows;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        rows = parseWorkflowWarnings(content);
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : 'WARNING_DOCUMENT_INVALID';
+        return failed(intent, code, error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const invalid = validateRows(rows);
+    if (invalid)
+        return failed(intent, invalid.code, invalid.message, resolved.taskId);
+    if (intent.kind === 'list') {
+        if (intent.status && !WORKFLOW_WARNING_STATUSES.has(intent.status))
+            return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning status is invalid', resolved.taskId);
+        const warnings = rows.filter((row) => !intent.status || row.status === intent.status);
+        return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: null, before: null, after: null, warnings, operations: [], error: null };
+    }
+    let metadata;
+    try {
+        metadata = (options.metadataProvider ?? captureTaskWriteMetadata)();
+    }
+    catch (error) {
+        return failed(intent, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    let before;
+    let after;
+    if (intent.kind === 'add') {
+        const step = oneLine(intent.step);
+        const code = oneLine(intent.code);
+        const target = oneLine(intent.target);
+        const message = oneLine(intent.message);
+        const action = oneLine(intent.action);
+        if (!step || !code || !target || !message || !action || !WORKFLOW_WARNING_SEVERITIES.has(intent.severity)) {
+            return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning add payload is invalid', resolved.taskId);
+        }
+        before = rows.find((row) => row.status === 'open' && row.step === step && row.code === code && row.target === target) ?? null;
+        after = before
+            ? { ...before, severity: intent.severity, message, action }
+            : { id: nextWarningId(rows), time: metadata.timestamp, step, severity: intent.severity, code, status: 'open', target, message, action, resolvedAt: '', resolution: '' };
+    }
+    else {
+        if (!/^WW-[1-9]\d*$/.test(intent.id) || !['resolved', 'ignored'].includes(intent.status) || !oneLine(intent.resolution)) {
+            return failed(intent, 'WARNING_PAYLOAD_INVALID', 'warning status payload is invalid', resolved.taskId, intent.id);
+        }
+        before = rows.find((row) => row.id === intent.id) ?? null;
+        if (!before)
+            return failed(intent, 'WARNING_NOT_FOUND', `warning '${intent.id}' was not found`, resolved.taskId, intent.id);
+        const resolution = oneLine(intent.resolution);
+        if (before.status === intent.status && before.resolution === resolution)
+            after = { ...before };
+        else if (before.status !== 'open')
+            return failed(intent, 'WARNING_TRANSITION_INVALID', `warning '${intent.id}' cannot transition from ${before.status}`, resolved.taskId, intent.id);
+        else
+            after = { ...before, status: intent.status, resolvedAt: metadata.timestamp, resolution };
+    }
+    const writeResult = writeTask({
+        taskRef: intent.taskRef, expectedState: 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
+    }, {
+        ...options,
+        taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
+        metadataProvider: () => metadata
+    });
+    if (writeResult.status === 'failed')
+        return failed(intent, writeResult.error.code, writeResult.error.message, writeResult.taskId, after.id);
+    return {
+        status: writeResult.status, changed: writeResult.changed, intent: intent.kind, taskId: writeResult.taskId,
+        entityId: after.id, before, after, warnings: [], operations: writeResult.operations, error: null
+    };
+}
+export { applyWorkflowWarningIntent };
+//# sourceMappingURL=workflow-warning-intents.js.map

package/dist/lib/task/workflow-warnings.js

@@ -1,84 +1,16 @@
-import { extractSection } from './sections.js';
+import { parseTable } from './sections.js';
 const WORKFLOW_WARNING_HEADINGS = ['工作流告警', 'Workflow Warnings'];
 const WORKFLOW_WARNING_STATUSES = new Set(['open', 'resolved', 'ignored']);
 const WORKFLOW_WARNING_SEVERITIES = new Set(['IMPORTANT', 'ACTION_REQUIRED']);
-function splitTableRow(line) {
-    let value = line.trim();
-    if (!value.startsWith('|'))
-        return [];
-    value = value.replace(/^\|/, '').replace(/\|$/, '');
-    const cells = [];
-    let cell = '';
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (char === '|' && !isEscapedAt(value, index)) {
-            cells.push(unescapeTableCell(cell.trim()));
-            cell = '';
-            continue;
-        }
-        cell += char;
-    }
-    cells.push(unescapeTableCell(cell.trim()));
-    return cells;
-}
-function unescapeTableCell(value) {
-    let output = '';
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        const next = value[index + 1];
-        if (char === '\\' && (next === '\\' || next === '|')) {
-            output += next;
-            index += 1;
-            continue;
-        }
-        output += char;
-    }
-    return output;
-}
-function isEscapedAt(value, index) {
-    let backslashes = 0;
-    for (let cursor = index - 1; cursor >= 0 && value[cursor] === '\\'; cursor -= 1) {
-        backslashes += 1;
-    }
-    return backslashes % 2 === 1;
-}
-function isSeparatorRow(cells) {
-    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
-}
-/**
- * Parses well-formed workflow warning rows. Malformed rows are intentionally
- * ignored here; validate-artifact is responsible for reporting structure errors.
- */
+const WORKFLOW_WARNING_COLUMNS = ['id', 'time', 'step', 'severity', 'code', 'status', 'target', 'message', 'action', 'resolved_at', 'resolution'];
+/** Parses workflow warning rows and fails closed on malformed table structure. */
 function parseWorkflowWarnings(content) {
-    const section = extractSection(content, WORKFLOW_WARNING_HEADINGS);
-    if (!section)
-        return [];
-    const rows = [];
-    for (const rawLine of section.split(/\r?\n/)) {
-        const cells = splitTableRow(rawLine);
-        if (cells.length === 0)
-            continue;
-        if ((cells[0] ?? '').toLowerCase() === 'id')
-            continue;
-        if (isSeparatorRow(cells))
-            continue;
-        if (cells.length < 11)
-            continue;
-        rows.push({
-            id: cells[0] ?? '',
-            time: cells[1] ?? '',
-            step: cells[2] ?? '',
-            severity: cells[3] ?? '',
-            code: cells[4] ?? '',
-            status: cells[5] ?? '',
-            target: cells[6] ?? '',
-            message: cells[7] ?? '',
-            action: cells[8] ?? '',
-            resolvedAt: cells[9] ?? '',
-            resolution: cells[10] ?? ''
-        });
-    }
-    return rows;
+    const table = parseTable(content, { sectionAliases: WORKFLOW_WARNING_HEADINGS, columns: WORKFLOW_WARNING_COLUMNS });
+    return table?.rows.map(({ values }) => ({
+        id: values.id, time: values.time, step: values.step, severity: values.severity,
+        code: values.code, status: values.status, target: values.target, message: values.message,
+        action: values.action, resolvedAt: values.resolved_at, resolution: values.resolution
+    })) ?? [];
 }
 function getOpenWorkflowWarnings(content) {
     return parseWorkflowWarnings(content).filter((warning) => warning.status === 'open');
@@ -90,5 +22,5 @@ function formatWorkflowWarningSummary(warnings) {
         return `${warning.id} [${warning.severity}] ${warning.code}${target}${action}`;
     });
 }
-export { WORKFLOW_WARNING_HEADINGS, WORKFLOW_WARNING_STATUSES, WORKFLOW_WARNING_SEVERITIES, parseWorkflowWarnings, getOpenWorkflowWarnings, formatWorkflowWarningSummary };
+export { WORKFLOW_WARNING_HEADINGS, WORKFLOW_WARNING_STATUSES, WORKFLOW_WARNING_SEVERITIES, WORKFLOW_WARNING_COLUMNS, parseWorkflowWarnings, getOpenWorkflowWarnings, formatWorkflowWarningSummary };
 //# sourceMappingURL=workflow-warnings.js.map

package/dist/lib/task/write.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { VERSION } from '../version.js';
+import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { mutateTableRow, upsertSection } from './sections.js';
+const DEFAULT_FILE_SYSTEM = {
+    readFileSync: (file) => fs.readFileSync(file, 'utf8'),
+    statModeSync: (file) => fs.statSync(file).mode,
+    writeFileSync: (file, content, mode) => {
+        fs.writeFileSync(file, content, { encoding: 'utf8', flag: 'wx', mode });
+    },
+    renameSync: (from, to) => fs.renameSync(from, to),
+    unlinkSync: (file) => fs.unlinkSync(file)
+};
+function canonicalTimestamp() {
+    const now = new Date();
+    const pad = (value) => String(value).padStart(2, '0');
+    const offsetMinutes = -now.getTimezoneOffset();
+    const offsetSign = offsetMinutes >= 0 ? '+' : '-';
+    const offset = Math.abs(offsetMinutes);
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}${offsetSign}${pad(Math.floor(offset / 60))}:${pad(offset % 60)}`;
+}
+function captureTaskWriteMetadata() {
+    return { timestamp: canonicalTimestamp(), agentInfraVersion: VERSION };
+}
+function failure(request, identity, code, message, operations = [], metadata = null) {
+    return {
+        status: 'failed',
+        requestRef: request.taskRef,
+        expectedState: request.expectedState,
+        taskId: identity.taskId,
+        taskMdPath: identity.taskMdPath,
+        actualState: identity.actualState,
+        changed: false,
+        operations,
+        timestamp: metadata?.timestamp ?? null,
+        agentInfraVersion: metadata?.agentInfraVersion ?? null,
+        error: { code, message }
+    };
+}
+function errorDetails(error, fallback) {
+    if (error && typeof error === 'object' && 'code' in error && typeof error.code === 'string') {
+        return {
+            code: error.code,
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+    return {
+        code: fallback,
+        message: error instanceof Error ? error.message : String(error)
+    };
+}
+function writeTask(request, options = {}) {
+    const resolved = options.taskLocation
+        ? {
+            ok: true,
+            repoRoot: options.taskLocation.repoRoot,
+            taskId: options.taskLocation.taskId,
+            taskDir: path.dirname(options.taskLocation.taskMdPath),
+            taskMdPath: options.taskLocation.taskMdPath,
+            state: options.taskLocation.state
+        }
+        : resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok) {
+        return failure(request, { taskId: resolved.taskId, taskMdPath: null, actualState: null }, resolved.code, resolved.message);
+    }
+    const identity = {
+        taskId: resolved.taskId,
+        taskMdPath: resolved.taskMdPath,
+        actualState: resolved.state
+    };
+    if (resolved.state !== request.expectedState) {
+        return failure(request, identity, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected ${request.expectedState}`);
+    }
+    const io = { ...DEFAULT_FILE_SYSTEM, ...options.fileSystem };
+    let original;
+    let mode;
+    try {
+        original = io.readFileSync(resolved.taskMdPath);
+        mode = io.statModeSync(resolved.taskMdPath);
+    }
+    catch (error) {
+        return failure(request, identity, 'TASK_READ_FAILED', error instanceof Error ? error.message : String(error));
+    }
+    let candidate = original;
+    const operations = [];
+    try {
+        parseTypedTaskFrontmatter(original);
+        if (!Array.isArray(request.mutations)) {
+            throw Object.assign(new Error('mutations must be an array'), { code: 'MUTATION_INVALID' });
+        }
+        for (const [index, mutation] of request.mutations.entries()) {
+            if (!mutation || typeof mutation !== 'object' || !('kind' in mutation)) {
+                throw Object.assign(new Error(`mutation ${index} is invalid`), { code: 'MUTATION_INVALID' });
+            }
+            const before = candidate;
+            if (mutation.kind === 'frontmatter') {
+                candidate = updateTaskFrontmatter(candidate, mutation.set, mutation.remove);
+                operations.push({
+                    index,
+                    kind: 'frontmatter',
+                    fields: [...Object.keys(mutation.set), ...(mutation.remove ?? [])],
+                    wouldChange: candidate !== before
+                });
+            }
+            else if (mutation.kind === 'section') {
+                const result = upsertSection(candidate, mutation);
+                candidate = result.content;
+                operations.push({
+                    index,
+                    kind: 'section',
+                    heading: result.heading,
+                    operation: result.operation,
+                    wouldChange: candidate !== before
+                });
+            }
+            else if (mutation.kind === 'table-row') {
+                const result = mutateTableRow(candidate, mutation);
+                candidate = result.content;
+                operations.push({
+                    index,
+                    kind: 'table-row',
+                    section: result.section,
+                    keyColumn: mutation.keyColumn,
+                    key: mutation.key.trim(),
+                    operation: result.operation,
+                    wouldChange: candidate !== before
+                });
+            }
+            else {
+                throw Object.assign(new Error(`mutation ${index} has an unknown kind`), {
+                    code: 'MUTATION_INVALID'
+                });
+            }
+        }
+    }
+    catch (error) {
+        const details = errorDetails(error, 'MUTATION_INVALID');
+        return failure(request, identity, details.code, details.message);
+    }
+    let metadata;
+    try {
+        metadata = (options.metadataProvider ?? captureTaskWriteMetadata)();
+        if (!metadata ||
+            typeof metadata.timestamp !== 'string' ||
+            !metadata.timestamp ||
+            typeof metadata.agentInfraVersion !== 'string' ||
+            !metadata.agentInfraVersion) {
+            throw new Error('metadata provider returned invalid metadata');
+        }
+    }
+    catch (error) {
+        return failure(request, identity, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), operations);
+    }
+    if (candidate === original) {
+        return {
+            status: 'no-op',
+            requestRef: request.taskRef,
+            expectedState: request.expectedState,
+            taskId: resolved.taskId,
+            taskMdPath: resolved.taskMdPath,
+            actualState: resolved.state,
+            changed: false,
+            operations,
+            timestamp: metadata.timestamp,
+            agentInfraVersion: metadata.agentInfraVersion,
+            error: null
+        };
+    }
+    try {
+        const beforeMetadata = candidate;
+        candidate = updateTaskFrontmatter(candidate, {
+            updated_at: metadata.timestamp,
+            agent_infra_version: metadata.agentInfraVersion
+        });
+        operations.push({
+            index: -1,
+            kind: 'metadata',
+            fields: ['updated_at', 'agent_infra_version'],
+            wouldChange: candidate !== beforeMetadata
+        });
+    }
+    catch (error) {
+        const details = errorDetails(error, 'TASK_DOCUMENT_INVALID');
+        return failure(request, identity, details.code, details.message, operations, metadata);
+    }
+    const successBase = {
+        requestRef: request.taskRef,
+        expectedState: request.expectedState,
+        taskId: resolved.taskId,
+        taskMdPath: resolved.taskMdPath,
+        actualState: resolved.state,
+        operations,
+        timestamp: metadata.timestamp,
+        agentInfraVersion: metadata.agentInfraVersion,
+        error: null
+    };
+    if (request.dryRun) {
+        return { ...successBase, status: 'planned', changed: true };
+    }
+    const suffix = (options.randomSuffix ?? (() => Math.random().toString(36).slice(2)))();
+    const tempPath = path.join(path.dirname(resolved.taskMdPath), `.task.md.${process.pid}.${suffix}.tmp`);
+    let primary = null;
+    let shouldCleanupTemp = false;
+    try {
+        io.writeFileSync(tempPath, candidate, mode);
+        shouldCleanupTemp = true;
+    }
+    catch (error) {
+        shouldCleanupTemp = error.code !== 'EEXIST';
+        primary = errorDetails(error, 'TEMP_WRITE_FAILED');
+        primary.code = 'TEMP_WRITE_FAILED';
+    }
+    if (!primary) {
+        try {
+            io.renameSync(tempPath, resolved.taskMdPath);
+        }
+        catch (error) {
+            primary = errorDetails(error, 'RENAME_FAILED');
+            primary.code = 'RENAME_FAILED';
+        }
+    }
+    if (primary && shouldCleanupTemp) {
+        try {
+            io.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            const nodeError = cleanupError;
+            if (nodeError.code !== 'ENOENT') {
+                return failure(request, identity, 'TEMP_CLEANUP_FAILED', `${primary.code}: ${primary.message}; failed to clean ${tempPath}: ${nodeError.message}`, operations, metadata);
+            }
+        }
+    }
+    if (primary) {
+        return failure(request, identity, primary.code, primary.message, operations, metadata);
+    }
+    return { ...successBase, status: 'applied', changed: true };
+}
+export { writeTask, captureTaskWriteMetadata, canonicalTimestamp };
+//# sourceMappingURL=write.js.map

package/dist/lib/update.js

@@ -145,6 +145,8 @@ async function cmdUpdate() {
     // update skill
     copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
     ok('Updated .agents/skills/update-agent-infra/');
+    renderFile(path.join(templateDir, '.agents', 'scripts', 'lib', 'agent-infra-package.js'), path.join('.agents', 'scripts', 'lib', 'agent-infra-package.js'), replacements);
+    ok('Updated .agents/scripts/lib/agent-infra-package.js');
     try {
         fs.unlinkSync(path.join('.agents', 'skills', 'update-agent-infra', 'scripts', 'sync-templates.cjs'));
     }