@fitlab-ai/agent-infra 0.8.5 → 0.9.0

package/dist/lib/task/frontmatter.js

@@ -1,3 +1,58 @@
+import { parse, stringify } from 'yaml';
+class FrontmatterError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'FrontmatterError';
+        this.code = code;
+    }
+}
+function locateFrontmatter(content) {
+    const opening = /^---(\r?\n)/.exec(content);
+    if (!opening) {
+        throw new FrontmatterError('TASK_DOCUMENT_INVALID', 'task.md frontmatter is missing');
+    }
+    const eol = opening[1];
+    const bodyStart = opening[0].length;
+    const closing = /^---\r?$/gm;
+    closing.lastIndex = bodyStart;
+    const match = closing.exec(content);
+    if (!match) {
+        throw new FrontmatterError('TASK_DOCUMENT_INVALID', 'task.md frontmatter is unclosed');
+    }
+    return { eol, bodyStart, bodyEnd: match.index };
+}
+function parseFrontmatterLines(content, block) {
+    const body = content.slice(block.bodyStart, block.bodyEnd);
+    const lines = body.split(block.eol);
+    return lines.map((raw, index) => {
+        if (!raw.trim() || raw.trimStart().startsWith('#')) {
+            return { raw, index, key: null, value: null };
+        }
+        const match = /^([^\s:#][^:]*):(?:[ \t]*(.*))?$/.exec(raw);
+        if (!match || !match[1]) {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `unsupported frontmatter structure on line ${index + 2}`);
+        }
+        return {
+            raw,
+            index,
+            key: match[1].trim(),
+            value: match[2] ?? ''
+        };
+    });
+}
+function serializeScalar(value) {
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        throw new FrontmatterError('MUTATION_INVALID', 'frontmatter numbers must be finite');
+    }
+    if (value === '')
+        return '';
+    const serialized = stringify(value).trimEnd();
+    if (serialized.includes('\n') || serialized.includes('\r')) {
+        throw new FrontmatterError('MUTATION_INVALID', 'frontmatter values must be scalar');
+    }
+    return serialized;
+}
 function parseTaskFrontmatter(content) {
     const result = {};
     if (!content.startsWith('---'))
@@ -20,6 +75,109 @@ function parseTaskFrontmatter(content) {
     }
     return result;
 }
+function parseTypedTaskFrontmatter(content) {
+    const block = locateFrontmatter(content);
+    const result = {};
+    for (const line of parseFrontmatterLines(content, block)) {
+        if (!line.key || line.value === null)
+            continue;
+        if (Object.hasOwn(result, line.key)) {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `duplicate frontmatter key '${line.key}'`);
+        }
+        if (line.value === '') {
+            result[line.key] = '';
+            continue;
+        }
+        let value;
+        try {
+            value = parse(line.value);
+        }
+        catch {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `frontmatter key '${line.key}' is not a valid scalar`);
+        }
+        if (value !== null &&
+            typeof value !== 'string' &&
+            typeof value !== 'number' &&
+            typeof value !== 'boolean') {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `frontmatter key '${line.key}' is not a scalar`);
+        }
+        if (typeof value === 'number' && !Number.isFinite(value)) {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `frontmatter key '${line.key}' is not a finite scalar`);
+        }
+        result[line.key] = value;
+    }
+    return result;
+}
+function updateTaskFrontmatter(content, set, remove = []) {
+    if (!set || typeof set !== 'object' || Array.isArray(set)) {
+        throw new FrontmatterError('MUTATION_INVALID', 'frontmatter set must be an object');
+    }
+    const entries = Object.entries(set);
+    if (!Array.isArray(remove)) {
+        throw new FrontmatterError('MUTATION_INVALID', 'frontmatter remove must be an array');
+    }
+    const removeSet = new Set(remove);
+    if (removeSet.size !== remove.length) {
+        throw new FrontmatterError('MUTATION_INVALID', 'frontmatter remove keys must be unique');
+    }
+    for (const [key, value] of entries) {
+        if (!key || /[\r\n:]/.test(key)) {
+            throw new FrontmatterError('MUTATION_INVALID', `invalid frontmatter key '${key}'`);
+        }
+        if (value !== null &&
+            typeof value !== 'string' &&
+            typeof value !== 'number' &&
+            typeof value !== 'boolean') {
+            throw new FrontmatterError('MUTATION_INVALID', `invalid scalar for '${key}'`);
+        }
+    }
+    for (const key of remove) {
+        if (!key || /[\r\n:]/.test(key)) {
+            throw new FrontmatterError('MUTATION_INVALID', `invalid frontmatter key '${key}'`);
+        }
+        if (Object.hasOwn(set, key)) {
+            throw new FrontmatterError('MUTATION_INVALID', `frontmatter key '${key}' cannot be set and removed together`);
+        }
+    }
+    const block = locateFrontmatter(content);
+    const lines = parseFrontmatterLines(content, block);
+    const indexes = new Map();
+    for (const line of lines) {
+        if (!line.key)
+            continue;
+        const positions = indexes.get(line.key) ?? [];
+        positions.push(line.index);
+        indexes.set(line.key, positions);
+    }
+    for (const key of [...entries.map(([entryKey]) => entryKey), ...remove]) {
+        if ((indexes.get(key)?.length ?? 0) > 1) {
+            throw new FrontmatterError('TASK_DOCUMENT_INVALID', `duplicate frontmatter key '${key}'`);
+        }
+    }
+    const nextLines = lines.map((line) => line.raw);
+    const additions = [];
+    for (const [key, value] of entries) {
+        const serialized = serializeScalar(value);
+        const replacement = serialized === '' ? `${key}:` : `${key}: ${serialized}`;
+        const index = indexes.get(key)?.[0];
+        if (index === undefined)
+            additions.push(replacement);
+        else
+            nextLines[index] = replacement;
+    }
+    const retainedLines = nextLines.filter((_, index) => {
+        const key = lines[index]?.key;
+        return !key || !removeSet.has(key);
+    });
+    if (additions.length > 0) {
+        if (retainedLines.at(-1) === '')
+            retainedLines.splice(-1, 0, ...additions);
+        else
+            retainedLines.push(...additions);
+    }
+    const body = retainedLines.join(block.eol);
+    return content.slice(0, block.bodyStart) + body + content.slice(block.bodyEnd);
+}
 function extractTitle(content) {
     for (const line of content.split('\n')) {
         const m = /^#\s+(?:任务[:：]?\s*)?(.+)$/.exec(line.trim());
@@ -28,5 +186,5 @@ function extractTitle(content) {
     }
     return '';
 }
-export { parseTaskFrontmatter, extractTitle };
+export { parseTaskFrontmatter, parseTypedTaskFrontmatter, updateTaskFrontmatter, extractTitle };
 //# sourceMappingURL=frontmatter.js.map

package/dist/lib/task/implementation-inputs.js

@@ -0,0 +1,117 @@
+import { parseTable } from './sections.js';
+const SECTION_ALIASES = ['实现输入', 'Implementation Inputs'];
+const COLUMNS = [
+    'id', 'ledger_id', 'decision_evidence', 'stage', 'needs_implementation',
+    'decided_at', 'status', 'consumed_by'
+];
+const TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}$/;
+const ARTIFACT_RE = /^code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/;
+function validateInput(row) {
+    if (!/^II-[1-9]\d*$/.test(row.id))
+        throw new Error(`implementation input id '${row.id}' is invalid`);
+    if (!row.ledgerId || !row.decisionEvidence || /[\r\n]/.test(row.ledgerId) || /[\r\n]/.test(row.decisionEvidence))
+        throw new Error(`implementation input ${row.id} has incomplete decision identity`);
+    if (row.stage !== 'code')
+        throw new Error(`implementation input ${row.id} has invalid stage`);
+    if (!TIMESTAMP_RE.test(row.decidedAt) || !Number.isFinite(Date.parse(row.decidedAt.replace(' ', 'T')))) {
+        throw new Error(`implementation input ${row.id} has invalid decided_at`);
+    }
+    const valid = (row.needsImplementation && row.status === 'pending' && row.consumedBy === '') ||
+        (!row.needsImplementation && row.status === 'not-required' && row.consumedBy === '') ||
+        (row.needsImplementation && row.status === 'consumed' && ARTIFACT_RE.test(row.consumedBy));
+    if (!valid)
+        throw new Error(`implementation input ${row.id} has an invalid state combination`);
+}
+function parseImplementationInputs(content) {
+    const table = parseTable(content, { sectionAliases: SECTION_ALIASES, columns: COLUMNS });
+    if (!table)
+        return { sectionFound: false, rows: [] };
+    const rows = [];
+    const seen = new Set();
+    for (const { values } of table.rows) {
+        const id = values.id;
+        const ledgerId = values.ledger_id;
+        const decisionEvidence = values.decision_evidence;
+        const stage = values.stage;
+        const needs = values.needs_implementation;
+        const decidedAt = values.decided_at;
+        const status = values.status;
+        const consumedBy = values.consumed_by;
+        if (needs !== 'true' && needs !== 'false')
+            throw new Error(`implementation input ${id} has invalid needs_implementation`);
+        const row = {
+            id: id, ledgerId: ledgerId, decisionEvidence: decisionEvidence, stage: stage,
+            needsImplementation: needs === 'true', decidedAt: decidedAt,
+            status: status, consumedBy: consumedBy
+        };
+        validateInput(row);
+        if (seen.has(row.id))
+            throw new Error(`duplicate implementation input id '${row.id}'`);
+        seen.add(row.id);
+        rows.push(row);
+    }
+    return { sectionFound: true, rows };
+}
+function nextId(rows) {
+    let max = 0;
+    for (const row of rows)
+        max = Math.max(max, Number.parseInt(row.id.slice(3), 10));
+    return `II-${max + 1}`;
+}
+function createImplementationInput(rows, draft) {
+    const row = {
+        id: nextId(rows), ledgerId: draft.ledgerId, decisionEvidence: draft.decisionEvidence,
+        stage: 'code', needsImplementation: draft.needsImplementation, decidedAt: draft.decidedAt,
+        status: draft.needsImplementation ? 'pending' : 'not-required', consumedBy: ''
+    };
+    validateInput(row);
+    return row;
+}
+function selectPendingImplementationInput(rows, reviewCompletedAt) {
+    const reviewEpoch = Date.parse(reviewCompletedAt.replace(' ', 'T'));
+    if (!Number.isFinite(reviewEpoch))
+        throw new Error('latest review completion time is invalid');
+    const pending = rows.filter((row) => row.needsImplementation && row.status === 'pending');
+    const stale = pending.find((row) => Date.parse(row.decidedAt.replace(' ', 'T')) <= reviewEpoch);
+    if (stale)
+        throw new Error(`implementation input ${stale.id} is not later than the latest approved review`);
+    return [...pending].sort((left, right) => {
+        const time = Date.parse(left.decidedAt.replace(' ', 'T')) - Date.parse(right.decidedAt.replace(' ', 'T'));
+        return time || Number.parseInt(left.id.slice(3), 10) - Number.parseInt(right.id.slice(3), 10);
+    })[0] ?? null;
+}
+function consumeImplementationInput(rows, id, artifact) {
+    if (!ARTIFACT_RE.test(artifact))
+        throw new Error(`implementation input artifact '${artifact}' is invalid`);
+    let found = false;
+    const next = rows.map((row) => {
+        if (row.id !== id)
+            return row;
+        found = true;
+        if (row.status !== 'pending' || !row.needsImplementation) {
+            throw new Error(`implementation input ${id} is not pending`);
+        }
+        return { ...row, status: 'consumed', consumedBy: artifact };
+    });
+    if (!found)
+        throw new Error(`implementation input ${id} was not found`);
+    next.forEach(validateInput);
+    return next;
+}
+function renderImplementationInputs(rows) {
+    rows.forEach(validateInput);
+    const ids = new Set(rows.map((row) => row.id));
+    if (ids.size !== rows.length)
+        throw new Error('implementation input ids must be unique');
+    return [
+        `| ${COLUMNS.join(' | ')} |`,
+        '|----|-----------|-------------------|-------|----------------------|------------|--------|-------------|',
+        ...rows.map((row) => {
+            const cells = [row.id, row.ledgerId, row.decisionEvidence, 'code', String(row.needsImplementation), row.decidedAt, row.status, row.consumedBy]
+                .map((value) => value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|'));
+            return `| ${cells.join(' | ')} |`;
+        })
+    ].join('\n');
+}
+export { SECTION_ALIASES as IMPLEMENTATION_INPUT_ALIASES, createImplementationInput, consumeImplementationInput, parseImplementationInputs, renderImplementationInputs, selectPendingImplementationInput };
+//# sourceMappingURL=implementation-inputs.js.map

package/dist/lib/task/index.js

@@ -1,23 +1,26 @@
 const USAGE = `Usage: ai task <command> [options]
 
 Commands:
-  cat <ref> <artifact | N>               Print a task artifact (by name or number)
-  decisions, d <ref> [selector]          List human-decision (HD-) items, or show one's detail
-  files <ref>                            List artifacts in a task dir (numbered)
-  grep <pattern> [ref] [artifact | N]    Literal search across task artifacts (omit ref to scan all)
-  issue-body <ref> [--template <path>]   Print a deterministic Issue body from task.md (描述 + 需求, or an Issue Form)
-  log <ref>                              Render a task's activity log as a timeline
+  cat [--task <ref>] <artifact | N>      Print a task artifact (by name or number)
+  decisions, d [--task <ref>] [-i item]  List review decisions, or show one item's detail
+  files [--task <ref>]                   List artifacts in a task dir (numbered)
+  grep <pattern> [--current|--task <ref>] Literal search across task artifacts (global by default)
+  issue-body [--task <ref>] [--template] Print a deterministic Issue body from task.md
+  log [--task <ref>]                     Render a task's activity log as a timeline
   ls [--all | --blocked | --completed]   List tasks (default: active)
-  show <N | #N | TASK-id>                Print a task.md
-  status <ref>                           Aggregated status view (metadata / artifacts / git / platform)
+  show [--task <ref>]                    Print a task.md
+  status [--task <ref>]                  Aggregated status view (metadata / artifacts / git / platform)
 
 Examples:
   ai task cat 11 analysis
+  ai task cat analysis
   ai task cat 11 3
   ai task decisions 11
-  ai task d 11 HD-3 --format markdown
+  ai task decisions --item 1
+  ai task d 11 PL-3 --format markdown
   ai task files 11
   ai task grep resolveArtifact
+  ai task grep resolveArtifact --current
   ai task grep resolveArtifact 11
   ai task issue-body 11
   ai task issue-body 11 --template .github/ISSUE_TEMPLATE/05_other.yml

package/dist/lib/task/issue-form.js

@@ -28,6 +28,23 @@ function mapFieldValue(id, fields) {
         return fields.requirements;
     return '';
 }
+function parseFormFields(formText) {
+    const doc = parse(formText);
+    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
+        throw new Error('Issue Form has no body[] list');
+    }
+    return doc.body;
+}
+function requirementFieldLabels(formText) {
+    return parseFormFields(formText).flatMap((raw) => {
+        if (!raw || typeof raw !== 'object')
+            return [];
+        const type = typeof raw.type === 'string' ? raw.type : '';
+        const id = typeof raw.id === 'string' ? raw.id : '';
+        const label = typeof raw.attributes?.label === 'string' ? raw.attributes.label.trim() : '';
+        return TEXT_FIELD_TYPES.has(type) && REQUIREMENTS_IDS.has(id) && label ? [label] : [];
+    });
+}
 /**
  * Render the final Issue body for a GitHub Issue Form (scenario A).
  *
@@ -41,12 +58,8 @@ function mapFieldValue(id, fields) {
  * caller can fall back to the default body.
  */
 function renderTemplateBody(formText, fields) {
-    const doc = parse(formText);
-    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
-        throw new Error('Issue Form has no body[] list');
-    }
     const sections = [];
-    for (const raw of doc.body) {
+    for (const raw of parseFormFields(formText)) {
         if (!raw || typeof raw !== 'object')
             continue;
         const type = typeof raw.type === 'string' ? raw.type : '';
@@ -62,5 +75,5 @@ function renderTemplateBody(formText, fields) {
     }
     return `${sections.join('\n\n')}\n`;
 }
-export { renderTemplateBody, mapFieldValue, PLACEHOLDER };
+export { requirementFieldLabels, renderTemplateBody, mapFieldValue, PLACEHOLDER };
 //# sourceMappingURL=issue-form.js.map

package/dist/lib/task/ledger-intents.js

@@ -0,0 +1,185 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { writeTask } from './write.js';
+const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
+const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
+const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
+const REVIEW_ARTIFACT = {
+    analysis: /^review-analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    plan: /^review-plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    code: /^review-code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
+};
+const ARTIFACT = {
+    analysis: /^analysis(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    plan: /^plan(?:-r(?:[2-9]|[1-9]\d+))?\.md$/,
+    code: /^code(?:-r(?:[2-9]|[1-9]\d+))?\.md$/
+};
+function failed(intent, code, message, taskId = null, entityId = null) {
+    return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, operations: [], error: { code, message } };
+}
+function normalizedEvidence(value) {
+    return value.trim();
+}
+function ledgerReadErrorCode(error) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
+}
+function maxHandshakeRounds(repoRoot) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
+        const value = parsed.review?.maxHandshakeRounds;
+        return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 3;
+    }
+    catch {
+        return 3;
+    }
+}
+function nextFindingId(rows, stage) {
+    const prefix = PREFIX[stage];
+    let max = 0;
+    for (const row of rows) {
+        const match = new RegExp(`^${prefix}-(\\d+)$`).exec(row.id);
+        if (match)
+            max = Math.max(max, Number(match[1]));
+    }
+    return `${prefix}-${max + 1}`;
+}
+function reviewArtifactRound(reviewArtifact) {
+    const match = /-r([1-9]\d*)\.md$/.exec(reviewArtifact);
+    return match ? Number(match[1]) : 1;
+}
+function rowMutation(row) {
+    return {
+        kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS,
+        columns: LEDGER_COLUMNS, keyColumn: 'id', key: row.id,
+        values: { stage: row.stage, round: row.round, severity: row.severity, status: row.status, evidence: row.evidence }
+    };
+}
+function ledgerSectionMutation(content) {
+    if (/^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/m.test(content))
+        return [];
+    const english = /^##\s+Activity Log\s*$/m.test(content);
+    return [{
+            kind: 'section', aliases: LEDGER_HEADINGS, heading: english ? 'Review Disagreement Ledger' : '审查分歧账本',
+            body: `| ${LEDGER_COLUMNS.join(' | ')} |\n|----|-------|-------|----------|--------|----------|`
+        }];
+}
+function mapWrite(intent, entityId, before, after, result) {
+    if (result.status === 'failed')
+        return failed(intent, result.error.code, result.error.message, result.taskId, entityId);
+    return { status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId, before, after, operations: result.operations, error: null };
+}
+function applyLedgerIntent(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 = parseLedger(content);
+    }
+    catch (error) {
+        return failed(intent, ledgerReadErrorCode(error), error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const invalidRows = validateLedgerRows(rows);
+    if (invalidRows)
+        return failed(intent, invalidRows.code, invalidRows.message, resolved.taskId);
+    if (intent.kind === 'decision-next-id') {
+        return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: nextHdId(rows), before: null, after: null, operations: [], error: null };
+    }
+    let before = null;
+    let after;
+    if (intent.kind === 'finding-upsert') {
+        if (!REVIEW_ARTIFACT[intent.stage]?.test(intent.reviewArtifact) || !Number.isInteger(intent.ordinal) || intent.ordinal < 1 || !['blocker', 'major', 'minor'].includes(intent.severity)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'finding identity, stage, ordinal, or severity is invalid', resolved.taskId);
+        }
+        const evidence = normalizedEvidence(intent.evidence);
+        if (!evidence.startsWith(`${intent.reviewArtifact}#`) || /[\r\n]/.test(evidence)) {
+            return failed(intent, 'LEDGER_EVIDENCE_INVALID', 'finding evidence must be a single-line anchor in the review artifact', resolved.taskId);
+        }
+        const artifactRows = rows.filter((row) => row.stage === intent.stage && row.id.startsWith(`${PREFIX[intent.stage]}-`) && row.evidence.startsWith(`${intent.reviewArtifact}#`));
+        if (artifactRows.length < intent.ordinal - 1)
+            return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'finding ordinals must be submitted in order', resolved.taskId);
+        before = artifactRows[intent.ordinal - 1] ?? null;
+        if (before) {
+            if (before.severity !== intent.severity || before.evidence !== evidence || before.status !== 'open') {
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'finding identity conflicts with the existing open row', resolved.taskId, before.id);
+            }
+            after = { ...before };
+        }
+        else {
+            const id = nextFindingId(rows, intent.stage);
+            after = {
+                id, stage: intent.stage, round: String(reviewArtifactRound(intent.reviewArtifact)),
+                severity: intent.severity, status: 'open', evidence, sourceLine: -1
+            };
+        }
+    }
+    else if (intent.kind === 'decision-upsert') {
+        if (!/^HD-[1-9]\d*$/.test(intent.id) || !ARTIFACT[intent.stage]?.test(intent.artifact)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'decision id, stage, or artifact is invalid', resolved.taskId, intent.id);
+        }
+        const evidence = `${intent.artifact}#${intent.id}`;
+        before = rows.find((row) => row.id === intent.id) ?? null;
+        if (before) {
+            if (before.stage !== intent.stage || before.round !== '-' || before.severity !== 'decision' || before.status !== 'needs-human-decision' || before.evidence !== evidence) {
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', `decision id '${intent.id}' conflicts with an existing row`, resolved.taskId, intent.id);
+            }
+            after = { ...before };
+        }
+        else {
+            if (intent.id !== nextHdId(rows))
+                return failed(intent, 'LEDGER_ID_CONFLICT', `next decision id is ${nextHdId(rows)}`, resolved.taskId, intent.id);
+            after = { id: intent.id, stage: intent.stage, round: '-', severity: 'decision', status: 'needs-human-decision', evidence, sourceLine: -1 };
+        }
+    }
+    else {
+        before = rows.find((row) => row.id === intent.id) ?? null;
+        if (!before || !/^(AN|PL|CD)-[1-9]\d*$/.test(before.id))
+            return failed(intent, 'LEDGER_NOT_FOUND', `finding '${intent.id}' was not found`, resolved.taskId, intent.id);
+        const evidence = normalizedEvidence(intent.evidence);
+        if (!evidence || /[\r\n]/.test(evidence))
+            return failed(intent, 'LEDGER_EVIDENCE_INVALID', 'evidence must be a non-empty single line', resolved.taskId, intent.id);
+        if (intent.kind === 'finding-respond') {
+            if (!RESPONSE.has(intent.status) || !Number.isInteger(intent.round) || intent.round < 1)
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'response status or round is invalid', resolved.taskId, intent.id);
+            if (before.status === intent.status && before.round === String(intent.round) && before.evidence === evidence)
+                after = { ...before };
+            else if (before.status !== 'open' || Number(before.round) + 1 !== intent.round)
+                return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot accept this response`, resolved.taskId, intent.id);
+            else
+                after = { ...before, round: String(intent.round), status: intent.status, evidence };
+        }
+        else {
+            if (!DISPOSITION.has(intent.status))
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'review disposition is invalid', resolved.taskId, intent.id);
+            if (before.status === intent.status && before.evidence === evidence)
+                after = { ...before };
+            else {
+                const allowed = before.status === 'accepted'
+                    ? new Set(['closed', 'open', 'needs-human-decision'])
+                    : before.status === 'adjusted' || before.status === 'refuted'
+                        ? new Set(['confirmed', 'open', 'needs-human-decision'])
+                        : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
+                const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
+                if ((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot))) {
+                    return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
+                }
+                after = { ...before, status: intent.status, evidence };
+            }
+        }
+    }
+    const result = writeTask({
+        taskRef: intent.taskRef, expectedState: 'active',
+        mutations: [...ledgerSectionMutation(content), rowMutation(after)],
+        dryRun: 'dryRun' in intent ? intent.dryRun : false
+    }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
+    return mapWrite(intent, after.id, before, after, result);
+}
+export { applyLedgerIntent };
+//# sourceMappingURL=ledger-intents.js.map