@fitlab-ai/agent-infra 0.9.10 → 0.9.11

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

@@ -0,0 +1,263 @@
+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));
+    return details.map((heading) => {
+        const next = scanned.headings.find((candidate) => (candidate.start > heading.start && candidate.level <= 3));
+        const end = next?.start ?? content.length;
+        return {
+            id: heading.text.match(DECISION_ID)[0],
+            heading: heading.text,
+            canonical: /\[needs-human-decision\]/i.test(heading.text),
+            start: heading.start,
+            end,
+            content: content.slice(heading.start, end).trim()
+        };
+    });
+}
+function parseDecisionEvidence(evidence) {
+    const separator = evidence.indexOf('#');
+    if (separator <= 0 || evidence.indexOf('#', separator + 1) !== -1)
+        return { ok: false };
+    const artifact = evidence.slice(0, separator);
+    const anchor = evidence.slice(separator + 1);
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*\.md$/.test(artifact))
+        return { ok: false };
+    if (!anchor || /[\s\u0000-\u001f#]/.test(anchor))
+        return { ok: false };
+    return { ok: true, artifact, anchor };
+}
+function sameId(left, right) {
+    return left.toUpperCase() === right.toUpperCase();
+}
+function resolveDecisionDetail(content, rowId, anchor) {
+    const scanned = scanVisibleMarkdown(content);
+    const blocks = parseDecisionDetailBlocks(content);
+    const explicit = scanned.anchors.filter((candidate) => candidate.id === anchor);
+    if (explicit.length > 1) {
+        return { status: 'ambiguous', reason: `evidence anchor '${anchor}' occurs more than once`, candidates: [] };
+    }
+    if (explicit.length === 1) {
+        const marker = explicit[0];
+        const followingLine = scanned.lines.find((line) => line.start > marker.end && line.text.trim());
+        const followingHeading = followingLine
+            ? scanned.headings.find((heading) => heading.start === followingLine.start)
+            : undefined;
+        const candidate = followingHeading?.level === 3
+            ? blocks.find((block) => block.start === followingHeading.start)
+            : undefined;
+        if (!candidate || !sameId(candidate.id, rowId) || !candidate.canonical) {
+            return { status: 'missing', reason: `evidence anchor '${anchor}' does not identify a canonical ${rowId} detail` };
+        }
+        return { status: 'found', block: candidate };
+    }
+    if (!sameId(anchor, rowId)) {
+        return { status: 'missing', reason: `evidence anchor '${anchor}' is not the ledger id '${rowId}'` };
+    }
+    const matches = blocks.filter((block) => sameId(block.id, rowId) && block.canonical);
+    if (matches.length === 0)
+        return { status: 'missing', reason: `no canonical ${rowId} detail was found` };
+    if (matches.length > 1) {
+        return { status: 'ambiguous', reason: `more than one canonical ${rowId} detail was found`, candidates: matches };
+    }
+    return { status: 'found', block: matches[0] };
+}
+const INFORMAL_SHORT_HEADING = /^(?:AN|PL|CD|HD)-[1-9]\d*[：:]\s*(?:上一轮)?简短复核$/i;
+const INFORMAL_SHORT_FRAGMENT = /^简短(?:结论|说明)$/;
+function isInformalShortBlock(block) {
+    if (block.canonical || block.content.length > 600)
+        return false;
+    if (!INFORMAL_SHORT_HEADING.test(block.heading))
+        return false;
+    const scanned = scanVisibleMarkdown(block.content);
+    const bodyLines = scanned.lines
+        .filter((line) => !scanned.headings.some((heading) => heading.start === line.start) && line.text.trim())
+        .map((line) => line.text);
+    if (bodyLines.length === 0 || bodyLines.length > 2)
+        return false;
+    const fragments = bodyLines.map((line) => line.match(/^\s*[-*]\s+([^\s].*?)\s*$/)?.[1] ?? null);
+    if (fragments.some((fragment) => fragment === null))
+        return false;
+    return fragments.every((fragment) => INFORMAL_SHORT_FRAGMENT.test(fragment));
+}
+function hasDirectPrecedingAnchor(block, scanned) {
+    return scanned.anchors.some((anchor) => (anchor.end < block.start
+        && !scanned.lines.some((line) => line.start > anchor.end && line.start < block.start && line.text.trim())));
+}
+function inspectDecisionDetailDuplicates(content) {
+    const blocks = parseDecisionDetailBlocks(content);
+    const scanned = scanVisibleMarkdown(content);
+    const grouped = new Map();
+    for (const block of blocks) {
+        const key = block.id.toUpperCase();
+        const group = grouped.get(key) ?? [];
+        group.push(block);
+        grouped.set(key, group);
+    }
+    const duplicates = [];
+    for (const group of grouped.values()) {
+        if (group.length < 2)
+            continue;
+        const canonical = group.filter((block) => block.canonical);
+        const repairable = canonical.length === 1 && group.every((block) => (block.canonical || (!hasDirectPrecedingAnchor(block, scanned) && isInformalShortBlock(block))));
+        duplicates.push({ id: canonical[0]?.id ?? group[0].id, blocks: group, repairable });
+    }
+    if (duplicates.length === 0)
+        return { ok: true, blocks };
+    const summary = duplicates.map((duplicate) => {
+        const types = duplicate.blocks.map((block) => block.canonical ? 'canonical' : 'informal').join(', ');
+        return `${duplicate.id} (${duplicate.blocks.length} blocks: ${types}${duplicate.repairable ? '; safe repair available' : ''})`;
+    }).join(', ');
+    return {
+        ok: false,
+        code: 'DECISION_DETAIL_DUPLICATE',
+        message: `Duplicate decision detail ids: ${summary}`,
+        blocks,
+        duplicates
+    };
+}
+function repairDecisionDetailDuplicates(content) {
+    const inspection = inspectDecisionDetailDuplicates(content);
+    if (inspection.ok)
+        return { ok: true, changed: false, content };
+    const unsafe = inspection.duplicates.filter((duplicate) => !duplicate.repairable);
+    if (unsafe.length > 0) {
+        return {
+            ok: false,
+            code: 'DECISION_DETAIL_AMBIGUOUS',
+            message: `Cannot safely repair duplicate decision detail ids: ${unsafe.map((duplicate) => duplicate.id).join(', ')}`,
+            content
+        };
+    }
+    const removals = inspection.duplicates.flatMap((duplicate) => duplicate.blocks.filter((block) => !block.canonical));
+    let repaired = content;
+    for (const block of removals.sort((left, right) => right.start - left.start)) {
+        repaired = repaired.slice(0, block.start) + repaired.slice(block.end);
+    }
+    return { ok: true, changed: repaired !== content, content: repaired };
+}
+const FIELD_KEYS = {
+    '为什么现在要决定': 'why', 'why decide now': 'why', 'why a decision is needed now': 'why',
+    '要决定什么': 'decision', 'what to decide': 'decision', 'what needs a decision': 'decision',
+    '会影响什么': 'impact', 'what it affects': 'impact', 'what this affects': 'impact',
+    '如果选错或暂不处理': 'risk', 'if wrong or postponed': 'risk',
+    'what could go wrong': 'risk',
+    '打个比方': 'analogy', '例子': 'analogy', 'example': 'analogy',
+    '建议选哪个': 'recommend', 'recommended option': 'recommend', 'recommended choice': 'recommend',
+    '为什么这样建议': 'reason', 'why this recommendation': 'reason', 'why this choice': 'reason',
+    '是否需要实现': 'implementation', 'implementation required': 'implementation'
+};
+const TERMINAL_FIELD_KEYS = new Set(['recommend', 'reason', 'implementation']);
+function normalizeDecisionDetailForDisplay(block) {
+    const body = block.content;
+    const scanned = scanVisibleMarkdown(body);
+    const heading = scanned.headings.find((candidate) => candidate.level === 3);
+    if (!heading)
+        return body.trim();
+    const options = scanned.headings.filter((candidate) => candidate.level === 4 && OPTION_HEADING.test(candidate.text));
+    const optionRanges = options.map((option, index) => ({
+        start: option.start,
+        end: options[index + 1]?.start
+            ?? scanned.headings.find((candidate) => candidate.start > option.start && candidate.level <= 3)?.start
+            ?? scanned.lines.find((line) => (line.start > option.start
+                && FIELD.test(line.text)
+                && TERMINAL_FIELD_KEYS.has(FIELD_KEYS[line.text.match(FIELD)[1].trim().toLowerCase()])))?.start
+            ?? body.length
+    }));
+    const topLines = scanned.lines.filter((line) => (line.start > heading.end && !optionRanges.some((range) => line.start >= range.start && line.start < range.end)));
+    const fields = [];
+    for (const line of topLines) {
+        const match = line.text.match(FIELD);
+        if (!match)
+            continue;
+        const key = FIELD_KEYS[match[1].trim().toLowerCase()];
+        fields.push({ key: key ?? null, line });
+    }
+    if (fields.some((field) => field.key === null))
+        return body.trim();
+    const byKey = new Map();
+    const selectedRanges = [];
+    for (let index = 0; index < fields.length; index += 1) {
+        const field = fields[index];
+        if (!field.key)
+            continue;
+        const nextOption = optionRanges.find((range) => range.start > field.line.start)?.start ?? body.length;
+        const end = Math.min(fields[index + 1]?.line.start ?? body.length, nextOption);
+        const value = body.slice(field.line.start, end).trim();
+        byKey.set(field.key, value);
+        selectedRanges.push({ start: field.line.start, end });
+    }
+    selectedRanges.push(...optionRanges);
+    const required = ['decision', 'why', 'impact', 'recommend', 'reason'];
+    if (required.some((key) => !byKey.has(key)) || options.length < 2)
+        return body.trim();
+    const sortedRanges = selectedRanges.sort((left, right) => left.start - right.start);
+    let cursor = heading.end;
+    for (const range of sortedRanges) {
+        if (/\S/.test(body.slice(cursor, range.start)))
+            return body.trim();
+        cursor = Math.max(cursor, range.end);
+    }
+    if (/\S/.test(body.slice(cursor)))
+        return body.trim();
+    const ordered = [
+        byKey.get('decision'), byKey.get('why'), byKey.get('impact')
+    ];
+    for (const optional of ['risk', 'analogy'])
+        if (byKey.has(optional))
+            ordered.push(byKey.get(optional));
+    ordered.push(...optionRanges.map((range) => body.slice(range.start, range.end).trim()));
+    ordered.push(byKey.get('recommend'), byKey.get('reason'));
+    if (byKey.has('implementation'))
+        ordered.push(byKey.get('implementation'));
+    return [body.slice(heading.start, heading.end).trim(), ...ordered].join('\n\n').trim();
+}
+export { inspectDecisionDetailDuplicates, normalizeDecisionDetailForDisplay, parseDecisionDetailBlocks, parseDecisionEvidence, repairDecisionDetailDuplicates, resolveDecisionDetail };
+//# sourceMappingURL=decision-details.js.map

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

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { isDecisionItem, listDecisionItems, selectDecisionItem } from './decision-items.js';
 import { createImplementationInput, finalizeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs, selectDeclaredImplementationInput } from './implementation-inputs.js';
-import { LEDGER_COLUMNS, LEDGER_HEADINGS, parseLedger } from './ledger.js';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument } from './ledger.js';
 import { resolveTaskContext } from './resolve-ref.js';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
@@ -64,7 +64,10 @@ function applyHumanDecision(request, options = {}) {
     let rows;
     try {
         content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-        rows = parseLedger(content);
+        const ledger = parseLedgerDocument(content);
+        if (!ledger.present)
+            return failed(LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, resolved.taskId);
+        rows = ledger.rows;
     }
     catch (error) {
         return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);

package/dist/lib/task/events.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
-import { appendActivityEntry, locateActivityLog, pairEntries } from './activity-log.js';
+import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { buildArtifactLinkSection, artifactName, inspectArtifactDirectory, parseReviewedInputReference, parseCodePlanInputReference, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
 import { ArtifactReceiptError, sha256File, upsertArtifactReceipt } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { consumeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
-import { parseReviewSummary } from './review-artifacts.js';
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { findSectionHeading } from './sections.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
@@ -101,7 +101,10 @@ function validateReviewFindingCounts(request, content, family, artifactPath) {
     const stage = REVIEW_LEDGER_STAGES[family];
     if (!stage || !artifactPath)
         return null;
-    const rows = parseLedger(content);
+    const ledger = parseLedgerDocument(content);
+    if (!ledger.present)
+        return { code: 'EVENT_FINDING_COUNT_MISMATCH', message: `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}` };
+    const rows = ledger.rows;
     const invalid = validateLedgerRows(rows);
     if (invalid)
         return { code: 'TASK_DOCUMENT_INVALID', message: `${invalid.code}: ${invalid.message}` };
@@ -125,6 +128,9 @@ function validateReviewFindingCounts(request, content, family, artifactPath) {
             message: parsed.ok ? 'review summary finding counts are not finalized' : parsed.message
         };
     }
+    const canonical = resolveCanonicalVerdict(parsed.summary);
+    if (!canonical.ok)
+        return { code: 'EVENT_VERDICT_INVALID', message: `${canonical.code}: ${canonical.message}` };
     const report = parsed.summary.counts;
     const reportVerdict = parsed.summary.verdict === 'Approved'
         ? 'approved'
@@ -352,7 +358,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     const section = locateActivityLog(content);
     if (!section)
         return failed(request, { code: 'EVENT_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-    const rows = pairEntries(section.entries);
+    const rows = startedBackedRows(pairEntries(section.entries));
     let normalized = request;
     let artifactContext = null;
     const initialParts = eventParts(request.event);

package/dist/lib/task/index.js

@@ -1,34 +1,33 @@
 const USAGE = `Usage: ai task <command> [options]
 
 Commands:
-  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
+  cat [--task <ref> | -t <ref>] <artifact | N> Print a task artifact (by name or number)
+  decisions, d [--task <ref> | -t <ref>] [--item <selector> | -i <selector>] List review decisions, or show one item's detail
+  files [--task <ref> | -t <ref>]        List artifacts in a task dir (numbered)
+  grep [--current | --task <ref> | -t <ref>] <pattern> Literal search in the current or selected task
+  issue-body [--task <ref> | -t <ref>] [--template <path>] Print a deterministic Issue body from task.md
+  log [--task <ref> | -t <ref>]          Render a task's activity log as a timeline
   ls [--all | --blocked | --completed]   List tasks (default: active)
-  show [--task <ref>]                    Print a task.md
-  status [--task <ref>]                  Aggregated status view (metadata / artifacts / git / platform)
+  show [--task <ref> | -t <ref>]         Print a task.md
+  status [--task <ref> | -t <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 cat --task 11 analysis
+  ai task decisions --task 11
   ai task decisions --item 1
-  ai task d 11 PL-3 --format markdown
-  ai task files 11
+  ai task d --task 11 --item PL-3 --format markdown
+  ai task files --task 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
-  ai task log 11
+  ai task grep resolveArtifact --task 11
+  ai task issue-body --task 11
+  ai task issue-body --task 11 --template .github/ISSUE_TEMPLATE/05_other.yml
+  ai task log --task 11
   ai task ls
-  ai task show 11
-  ai task show TASK-20260612-162737
-  ai task status 11
+  ai task show --task 11
+  ai task show --task TASK-20260612-162737
+  ai task status --task 11
 
 Run 'ai task <command> --help' for details.`;
 export async function runTask(args) {

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { declareImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
-import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.js';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, nextHdId, parseLedgerDocument, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
 import { allowsManualOverride } from './guard-override.js';
@@ -26,6 +26,8 @@ function normalizedEvidence(value) {
 }
 function ledgerReadErrorCode(error) {
     const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    if (code === LEDGER_SECTION_MISSING_CODE)
+        return code;
     return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
 }
 function maxHandshakeRounds(repoRoot) {
@@ -60,13 +62,7 @@ function rowMutation(row) {
     };
 }
 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|----|-------|-------|----------|--------|----------|`
-        }];
+    return [];
 }
 function implementationInputMutation(content, rows) {
     const english = /^##\s+Activity Log\s*$/m.test(content);
@@ -92,7 +88,10 @@ function applyLedgerIntent(intent, options = {}) {
     let rows;
     try {
         content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-        rows = parseLedger(content);
+        const ledger = parseLedgerDocument(content);
+        if (!ledger.present)
+            return failed(intent, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, resolved.taskId);
+        rows = ledger.rows;
     }
     catch (error) {
         return failed(intent, ledgerReadErrorCode(error), error instanceof Error ? error.message : String(error), resolved.taskId);

package/dist/lib/task/ledger.js

@@ -12,18 +12,25 @@ const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
 // Statuses that represent a decision row awaiting or carrying a human ruling.
 const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
 const FINDING_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'confirmed', 'needs-human-decision', 'closed', 'human-decided']);
+const LEDGER_SECTION_MISSING_CODE = 'LEDGER_SECTION_MISSING';
+const LEDGER_SECTION_MISSING_MESSAGE = 'review disagreement ledger section is missing';
 function isReviewStage(stage) {
     return stage === 'analysis' || stage === 'plan' || stage === 'code';
 }
 // Parse all rows of the disagreement ledger table. Skips the heading, the
 // header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
 // Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
-function parseLedger(content) {
+function parseLedgerDocument(content) {
     const table = parseTable(content, { sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS });
-    return table?.rows.map(({ values, sourceLine }) => ({
-        id: values.id, stage: values.stage, round: values.round, severity: values.severity,
-        status: values.status, evidence: values.evidence, sourceLine
-    })) ?? [];
+    if (!table)
+        return { present: false, rows: [] };
+    return {
+        present: true,
+        rows: table.rows.map(({ values, sourceLine }) => ({
+            id: values.id, stage: values.stage, round: values.round, severity: values.severity,
+            status: values.status, evidence: values.evidence, sourceLine
+        }))
+    };
 }
 function validateLedgerRows(rows) {
     const seen = new Set();
@@ -104,5 +111,5 @@ function nextHdId(rows) {
     }
     return `HD-${max + 1}`;
 }
-export { LEDGER_HEADINGS, LEDGER_COLUMNS, parseLedger, nextHdId, isReviewStage, validateLedgerRows, summarizeLedgerStage, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+export { LEDGER_HEADINGS, LEDGER_COLUMNS, parseLedgerDocument, nextHdId, isReviewStage, validateLedgerRows, summarizeLedgerStage, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE };
 //# sourceMappingURL=ledger.js.map

package/dist/lib/task/lifecycle.js

@@ -7,6 +7,8 @@ import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { locateHotTaskDirs, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { configuredShortIdLength, executeShortIdCommand, loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { validateCurrentTaskContract } from './current-contract.js';
+import { isValidAgentInfraVersion } from '../version.js';
 const lifecycleIntentCatalog = [
     'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ];
@@ -57,6 +59,9 @@ function failed(request, error, extra = {}) {
         error, ...extra
     };
 }
+export function taskLifecycleFailure(request, error, taskId = null) {
+    return failed(request, error, { taskId });
+}
 function normalizedRequest(request) {
     if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent)) {
         return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -366,6 +371,11 @@ function applyTaskLifecycle(requestInput, options = {}) {
         return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     if (!locateActivityLog(content) && !allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'))
         return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+    if (spec.target === 'active') {
+        const contract = validateCurrentTaskContract(content);
+        if (!contract.ok)
+            return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: contract.message }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+    }
     const registryRequest = executeShortIdCommand({
         operation: 'list', activeDir: path.join(repoRoot, '.agents', 'workspace', 'active'),
         shortIdLength: configuredShortIdLength(repoRoot)
@@ -394,6 +404,9 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         if (journal.taskId !== taskId || journal.intent !== request.intent)
             return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+        if (spec.target === 'active' && !isValidAgentInfraVersion(journal.metadata.agentInfraVersion)) {
+            return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: `journal metadata agentInfraVersion must be a valid v-prefixed semver (received ${journal.metadata.agentInfraVersion})` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+        }
         if (request.dryRun) {
             if (!journal.failure)
                 return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
@@ -411,6 +424,9 @@ function applyTaskLifecycle(requestInput, options = {}) {
         catch (error) {
             return failed(request, { code: 'LIFECYCLE_METADATA_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
         }
+        if (spec.target === 'active' && !isValidAgentInfraVersion(metadata.agentInfraVersion)) {
+            return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: `metadata agentInfraVersion must be a valid v-prefixed semver (received ${metadata.agentInfraVersion})` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+        }
         journal = { version: 1, taskId, intent: request.intent, intentDigest: digest, sourceState, targetState: spec.target, metadata, completedSteps: [] };
         if (request.dryRun) {
             const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));

package/dist/lib/task/orchestration.js

@@ -2,9 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { parseReviewSummary } from './review-artifacts.js';
+import { validateCurrentTaskContract } from './current-contract.js';
+import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
 import { inspectArtifactDirectory } from './artifact-lifecycle.js';
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
@@ -350,9 +351,21 @@ function hasReviewAfterArtifact(taskDir, family, reviewFamily) {
 function latestReviewApproved(taskDir, family) {
     const round = highestRound(taskDir, family);
     if (round === 0)
-        return false;
-    const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, artifactName(family, round)), 'utf8'));
-    return parsed.ok && parsed.summary.verdict === 'Approved' && parsed.summary.counts !== null;
+        return { approved: false, error: null };
+    let content;
+    try {
+        content = fs.readFileSync(path.join(taskDir, artifactName(family, round)), 'utf8');
+    }
+    catch (error) {
+        return { approved: false, error: String(error) };
+    }
+    const parsed = parseReviewSummary(content);
+    if (!parsed.ok)
+        return { approved: false, error: `${parsed.code}: ${parsed.message}` };
+    const verdict = resolveCanonicalVerdict(parsed.summary);
+    if (!verdict.ok)
+        return { approved: false, error: `${verdict.code}: ${verdict.message}` };
+    return { approved: verdict.verdict === 'Approved', error: null };
 }
 function routeFromFacts(taskDir) {
     const analysisRound = highestRound(taskDir, 'analysis');
@@ -369,7 +382,10 @@ function routeFromFacts(taskDir) {
         const round = analysisReviewRound + 1;
         return { action: 'review-analysis', role: 'reviewer', stage: 'review-analysis', round, artifact: artifactName('review-analysis', round) };
     }
-    if (!latestReviewApproved(taskDir, 'review-analysis')) {
+    const analysisVerdict = latestReviewApproved(taskDir, 'review-analysis');
+    if (analysisVerdict.error)
+        return { error: analysisVerdict.error };
+    if (!analysisVerdict.approved) {
         const round = analysisRound + 1;
         return { action: 'analyze-task', role: 'executor', stage: 'analysis', round, artifact: artifactName('analysis', round) };
     }
@@ -381,7 +397,10 @@ function routeFromFacts(taskDir) {
         const round = planReviewRound + 1;
         return { action: 'review-plan', role: 'reviewer', stage: 'review-plan', round, artifact: artifactName('review-plan', round) };
     }
-    if (!latestReviewApproved(taskDir, 'review-plan')) {
+    const planVerdict = latestReviewApproved(taskDir, 'review-plan');
+    if (planVerdict.error)
+        return { error: planVerdict.error };
+    if (!planVerdict.approved) {
         const round = planRound + 1;
         return { action: 'plan-task', role: 'executor', stage: 'plan', round, artifact: artifactName('plan', round) };
     }
@@ -393,7 +412,10 @@ function routeFromFacts(taskDir) {
         const round = codeReviewRound + 1;
         return { action: 'review-code', role: 'reviewer', stage: 'review-code', round, artifact: artifactName('review-code', round) };
     }
-    if (!latestReviewApproved(taskDir, 'review-code')) {
+    const codeVerdict = latestReviewApproved(taskDir, 'review-code');
+    if (codeVerdict.error)
+        return { error: codeVerdict.error };
+    if (!codeVerdict.approved) {
         const round = codeRound + 1;
         return { action: 'code-task', role: 'executor', stage: 'code', round, artifact: artifactName('code', round) };
     }
@@ -418,13 +440,25 @@ function routeOrchestration(taskRef, options = {}) {
         return failed('ORCHESTRATION_TASK_READ_FAILED', String(error), resolved.taskId);
     }
     let metadata;
-    try {
-        metadata = parseTypedTaskFrontmatter(content);
+    let currentLedger = null;
+    if (resolved.state === 'active') {
+        const contract = validateCurrentTaskContract(content);
+        if (!contract.ok)
+            return failed('ORCHESTRATION_CURRENT_CONTRACT_INVALID', contract.message, resolved.taskId);
+        metadata = contract.metadata;
+        currentLedger = contract.ledger;
     }
-    catch (error) {
-        return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    else {
+        try {
+            metadata = parseTypedTaskFrontmatter(content);
+        }
+        catch (error) {
+            return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+        }
     }
     const routed = routeFromFacts(resolved.taskDir);
+    if (routed && 'error' in routed)
+        return failed('ORCHESTRATION_REVIEW_INVALID', routed.error, resolved.taskId);
     if (!routed)
         return failed('ORCHESTRATION_ROUTE_UNKNOWN', 'cannot determine a unique lifecycle action', resolved.taskId);
     const run = readRun(resolved.taskDir);
@@ -440,7 +474,10 @@ function routeOrchestration(taskRef, options = {}) {
         if (!review.ok || review.summary.manualValidation === null) {
             return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
         }
-        const rows = parseLedger(content);
+        const ledger = currentLedger ?? parseLedgerDocument(content);
+        if (!ledger.present)
+            return failed('ORCHESTRATION_CURRENT_CONTRACT_INVALID', `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`, resolved.taskId);
+        const rows = ledger.rows;
         const ledgerError = validateLedgerRows(rows);
         if (ledgerError)
             return failed('ORCHESTRATION_LEDGER_INVALID', ledgerError.message, resolved.taskId);