@fitlab-ai/agent-infra 0.7.6 → 0.8.0

package/dist/lib/task/commands/decisions.js

@@ -0,0 +1,258 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatTable } from "../../table.js";
+import { resolveTaskRef } from "../resolve-ref.js";
+import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
+import { extractSubSection } from "../sections.js";
+const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
+
+Lists the human-decision (HD-) items recorded in a task's review disagreement
+ledger, or prints the full detail block for a single item. Read-only.
+
+  <ref>          Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  [selector]     Ordinal (1-based) or HD id (e.g. 'HD-3') to show one item's detail.
+
+Options:
+  --all              Include already-decided (human-decided) items, not just pending.
+  --stage <s>        Filter to one stage: analysis | plan | code.
+  --format <fmt>     Output format: text (default) | markdown.
+  -h, --help         Show this help.
+
+Aliased as 'ai task d'.
+`;
+const STAGES = new Set(['analysis', 'plan', 'code']);
+const FORMATS = new Set(['text', 'markdown']);
+const HD_ID_RE = /^HD-\d+$/;
+function fail(message) {
+    process.stderr.write(`ai task decisions: ${message}\n`);
+    process.exitCode = 1;
+}
+// Returns null and sets the exit code when an option is malformed.
+function parseArgs(args) {
+    const out = { positionals: [], all: false, format: 'text' };
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === '--all') {
+            out.all = true;
+        }
+        else if (a === '--stage') {
+            const v = args[i + 1];
+            if (v === undefined) {
+                fail('--stage requires a value (analysis|plan|code)');
+                return null;
+            }
+            out.stage = v;
+            i += 1;
+        }
+        else if (a.startsWith('--stage=')) {
+            out.stage = a.slice('--stage='.length);
+        }
+        else if (a === '--format') {
+            const v = args[i + 1];
+            if (v === undefined) {
+                fail('--format requires a value (text|markdown)');
+                return null;
+            }
+            out.format = v;
+            i += 1;
+        }
+        else if (a.startsWith('--format=')) {
+            out.format = a.slice('--format='.length);
+        }
+        else if (a.startsWith('-')) {
+            fail(`unknown option '${a}'`);
+            return null;
+        }
+        else {
+            out.positionals.push(a);
+        }
+    }
+    return out;
+}
+// Parse `<file>.md#anchor` evidence into its filename, when present.
+function evidenceFile(evidence) {
+    const m = /([\w.-]+\.md)#/.exec(evidence);
+    return m ? m[1] : null;
+}
+function roundOf(file) {
+    const m = /-r(\d+)\.md$/.exec(file);
+    return m ? Number.parseInt(m[1], 10) : 1;
+}
+// Locate the `### HD-N` detail block for a row. Prefer the artifact named by the
+// row's evidence anchor; otherwise scan analysis/plan/code artifacts and return
+// the block from the highest-round file that contains it. Returns '' when none
+// is found (caller degrades gracefully — plan B3).
+function findDetailBlock(row, taskDir) {
+    const hinted = evidenceFile(row.evidence);
+    if (hinted) {
+        const p = path.join(taskDir, hinted);
+        if (fs.existsSync(p)) {
+            const block = extractSubSection(fs.readFileSync(p, 'utf8'), row.id);
+            if (block)
+                return block;
+        }
+    }
+    let best = '';
+    let bestRound = -1;
+    let entries;
+    try {
+        entries = fs.readdirSync(taskDir);
+    }
+    catch {
+        return '';
+    }
+    for (const file of entries) {
+        if (!/^(analysis|plan|code)(-r\d+)?\.md$/.test(file))
+            continue;
+        const block = extractSubSection(fs.readFileSync(path.join(taskDir, file), 'utf8'), row.id);
+        if (block && roundOf(file) > bestRound) {
+            best = block;
+            bestRound = roundOf(file);
+        }
+    }
+    return best;
+}
+// Pull the `## 人工裁决` record lines that mention this HD id, so a decided item
+// shows the human's recorded ruling alongside its detail block.
+function findDecisionRecord(id, content) {
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length && !/^##\s+(人工裁决|Human Decisions?)\s*$/.test(lines[i]))
+        i += 1;
+    if (i >= lines.length)
+        return [];
+    const idRe = new RegExp(`(^|[^\\w-])${id}(?![\\w-])`);
+    const out = [];
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (/^##\s/.test(lines[j]))
+            break;
+        if (lines[j].trim().startsWith('-') && idRe.test(lines[j]))
+            out.push(lines[j]);
+    }
+    return out;
+}
+function titleOf(row, taskDir) {
+    const block = findDetailBlock(row, taskDir);
+    if (block) {
+        return block
+            .split('\n')[0]
+            .replace(/^###\s+/, '')
+            .replace(/\s*\[needs-human-decision\]\s*$/, '')
+            .trim();
+    }
+    return row.evidence || '(无详情)';
+}
+function renderList(rows, format, taskDir) {
+    if (rows.length === 0) {
+        process.stdout.write('无待裁决项。\n');
+        return;
+    }
+    const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+    const data = rows.map((r, i) => [
+        String(i + 1),
+        r.id,
+        r.stage,
+        r.severity,
+        r.status,
+        r.evidence,
+        titleOf(r, taskDir)
+    ]);
+    if (format === 'markdown') {
+        const sep = headers.map(() => '---');
+        const md = [
+            `| ${headers.join(' | ')} |`,
+            `| ${sep.join(' | ')} |`,
+            ...data.map((row) => `| ${row.join(' | ')} |`)
+        ];
+        process.stdout.write(`${md.join('\n')}\n`);
+        return;
+    }
+    process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+}
+function renderDetail(rows, selector, format, taskDir, content) {
+    let row;
+    if (/^\d+$/.test(selector)) {
+        const idx = Number.parseInt(selector, 10) - 1;
+        if (idx < 0 || idx >= rows.length) {
+            fail(`ordinal '${selector}' out of range (1..${rows.length})`);
+            return;
+        }
+        row = rows[idx];
+    }
+    else {
+        const want = selector.toUpperCase();
+        const matches = rows.filter((r) => r.id.toUpperCase() === want);
+        if (matches.length === 0) {
+            fail(`no decision item matches '${selector}'`);
+            return;
+        }
+        if (matches.length > 1) {
+            fail(`duplicate id '${selector}' in ledger; select by ordinal instead`);
+            return;
+        }
+        row = matches[0];
+    }
+    const r = row;
+    const block = findDetailBlock(r, taskDir);
+    const lines = [];
+    if (format === 'markdown') {
+        lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+    }
+    else {
+        lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+    }
+    if (block) {
+        lines.push(block);
+    }
+    else {
+        lines.push(`（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`);
+    }
+    if (r.status === 'human-decided') {
+        const record = findDecisionRecord(r.id, content);
+        if (record.length) {
+            lines.push('', '人工裁定：', ...record);
+        }
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+}
+function decisions(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const parsed = parseArgs(args);
+    if (!parsed)
+        return;
+    if (parsed.positionals.length === 0) {
+        process.stdout.write(USAGE);
+        process.exitCode = 1;
+        return;
+    }
+    if (parsed.stage !== undefined && !STAGES.has(parsed.stage)) {
+        fail(`invalid --stage '${parsed.stage}' (expected analysis|plan|code)`);
+        return;
+    }
+    if (!FORMATS.has(parsed.format)) {
+        fail(`invalid --format '${parsed.format}' (expected text|markdown)`);
+        return;
+    }
+    const resolved = resolveTaskRef(parsed.positionals[0]);
+    if (!resolved.ok) {
+        fail(resolved.message);
+        return;
+    }
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    let rows = parseLedger(content).filter((r) => HD_ID_RE.test(r.id));
+    rows = rows.filter((r) => parsed.all ? HUMAN_DECISION_STATUSES.has(r.status) : r.status === 'needs-human-decision');
+    if (parsed.stage !== undefined)
+        rows = rows.filter((r) => r.stage === parsed.stage);
+    const selector = parsed.positionals[1];
+    if (selector === undefined) {
+        renderList(rows, parsed.format, resolved.taskDir);
+    }
+    else {
+        renderDetail(rows, selector, parsed.format, resolved.taskDir, content);
+    }
+}
+export { decisions };
+//# sourceMappingURL=decisions.js.map

package/dist/lib/task/commands/issue-body.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from "../resolve-ref.js";
+import { extractTitle } from "../frontmatter.js";
+import { extractSection, findSectionHeading } from "../sections.js";
+import { renderTemplateBody, PLACEHOLDER } from "../issue-form.js";
+const USAGE = `Usage: ai task issue-body <N | #N | TASK-id> [--template <path>]
+
+Print a deterministic Issue body extracted from a task's task.md.
+  <ref>               Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  --template <path>   Render the final body for the given GitHub Issue Form (scenario A);
+                      without it, print the default '描述 + 需求' body (scenario B).
+
+Only the task title, '## 描述' and '## 需求' sections are ever emitted; the rest of
+task.md (scaffolding sections, placeholders) is never written to the body.
+`;
+const DESCRIPTION_ALIASES = ['描述', 'Description'];
+const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
+/**
+ * Build the scenario B default body, mirroring whichever heading language the
+ * task.md actually uses, with empty sections falling back to `N/A`.
+ */
+function buildDefaultBody(content) {
+    const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
+    const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+    const description = extractSection(content, DESCRIPTION_ALIASES) || PLACEHOLDER;
+    const requirements = extractSection(content, REQUIREMENTS_ALIASES) || PLACEHOLDER;
+    return `## ${descHeading}\n\n${description}\n\n## ${reqHeading}\n\n${requirements}\n`;
+}
+function readTaskFields(content) {
+    return {
+        title: extractTitle(content),
+        description: extractSection(content, DESCRIPTION_ALIASES),
+        requirements: extractSection(content, REQUIREMENTS_ALIASES)
+    };
+}
+function issueBody(args = []) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        if (args.length === 0)
+            process.exitCode = 1;
+        return;
+    }
+    let ref;
+    let templatePath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--template') {
+            templatePath = args[i + 1];
+            i += 1;
+        }
+        else if (ref === undefined) {
+            ref = arg;
+        }
+    }
+    if (!ref) {
+        process.stderr.write('ai task issue-body: missing task ref\n');
+        process.exitCode = 1;
+        return;
+    }
+    if (templatePath === undefined && args.includes('--template')) {
+        process.stderr.write('ai task issue-body: --template requires a path\n');
+        process.exitCode = 1;
+        return;
+    }
+    const resolved = resolveTaskRef(ref);
+    if (!resolved.ok) {
+        process.stderr.write(`ai task issue-body: ${resolved.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    if (templatePath !== undefined) {
+        let formText;
+        try {
+            formText = fs.readFileSync(templatePath, 'utf8');
+        }
+        catch (e) {
+            process.stderr.write(`ai task issue-body: cannot read template '${templatePath}': ${e.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            process.stdout.write(renderTemplateBody(formText, readTaskFields(content)));
+        }
+        catch (e) {
+            process.stderr.write(`ai task issue-body: cannot render template '${templatePath}': ${e.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    process.stdout.write(buildDefaultBody(content));
+}
+export { issueBody, buildDefaultBody };
+//# sourceMappingURL=issue-body.js.map

package/dist/lib/task/commands/log.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from "../../table.js";
 import { resolveTaskRef } from "../resolve-ref.js";
+import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
 Renders a task's activity log as a per-step status table. A step's start and
@@ -9,6 +10,10 @@ completion time (or '(in progress)' while still running).
   <ref>   Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
 
 Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
+  A human-executed step shows AGENT as 'human' and, when it has no start marker,
+  a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
+  the verdict list, right after blockers/major/minor: manual-verify (env-blocked)
+  and human-decision (current ledger stage total).
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // The activity-log H2 heading is language-dependent (zh template / en template).
@@ -23,6 +28,20 @@ const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*
 // without the suffix. Pairing therefore keys on the base action (including any
 // `(Round N)`), so every round and every repeated execution pairs on its own.
 const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+// Short agent tokens that actually appear in activity logs for AI executors
+// (workflow recommended_agents claude/codex/gemini/cursor + enabled TUI opencode;
+// note these differ from the `.airc.json` long names claude-code/gemini-cli).
+// Any other executor token (a human name, possibly CJK) is treated as human.
+const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode', 'cursor']);
+const ENV_BLOCKED_RE = /\(\+\s*(\d+)\s+env-blocked\)/i;
+// Same match plus any leading whitespace, so folding the count into the verdict
+// text drops the redundant `(+ n env-blocked)` fragment without leaving a gap.
+const ENV_BLOCKED_STRIP_RE = /\s*\(\+\s*\d+\s+env-blocked\)/i;
+const REVIEW_STAGE_PREFIXES = [
+    { prefix: 'Review Analysis', stage: 'analysis' },
+    { prefix: 'Review Plan', stage: 'plan' },
+    { prefix: 'Review Code', stage: 'code' }
+];
 function parseActivityLog(content) {
     const lines = content.split('\n');
     let i = 0;
@@ -82,6 +101,42 @@ function pairEntries(entries) {
     }
     return rows;
 }
+function countHumanDecisionsByStage(rows) {
+    const counts = new Map();
+    for (const row of rows) {
+        if (!isReviewStage(row.stage) || !HUMAN_DECISION_STATUSES.has(row.status))
+            continue;
+        counts.set(row.stage, (counts.get(row.stage) ?? 0) + 1);
+    }
+    return counts;
+}
+function isReviewStage(stage) {
+    return stage === 'analysis' || stage === 'plan' || stage === 'code';
+}
+function reviewStageForStep(step) {
+    return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
+}
+function humanValidationCount(note) {
+    const match = ENV_BLOCKED_RE.exec(note);
+    return match ? Number(match[1]) : 0;
+}
+// A step is human-executed when its agent token is not a known AI token. Take
+// the first whitespace-delimited token and drop any trailing parenthetical
+// annotation (e.g. `张三 (executed on host)` -> `张三`) before the lookup.
+function isHumanAgent(agent) {
+    const token = agent.trim().split(/\s+/)[0]?.replace(/\(.*$/, '') ?? '';
+    return token !== '' && !KNOWN_AI_AGENTS.has(token);
+}
+// Fold the two human counts into a review row's verdict NOTE: comma-joined, right
+// after the blockers/major/minor list and before the ` → artifact` link, mirroring
+// the review count line. The raw `(+ n env-blocked)` fragment is dropped so the
+// env-blocked number is not shown twice (it becomes the manual-verify count).
+function foldHumanCounts(note, decisions, envBlocked) {
+    const base = note.replace(ENV_BLOCKED_STRIP_RE, '');
+    const group = `Manual-verify: ${envBlocked}, Human-decision: ${decisions}`;
+    const arrow = base.indexOf(' → ');
+    return arrow === -1 ? `${base}, ${group}` : `${base.slice(0, arrow)}, ${group}${base.slice(arrow)}`;
+}
 function log(args = []) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
@@ -108,18 +163,21 @@ function log(args = []) {
         return;
     }
     const steps = pairEntries(entries);
-    const rows = steps.map((s, idx) => [
-        String(idx + 1),
-        s.step,
-        s.agent,
-        s.started,
-        s.done || (s.started ? '(in progress)' : ''),
-        s.note
-    ]);
+    const humanDecisionCounts = countHumanDecisionsByStage(parseLedger(content));
+    const rows = steps.map((s, idx) => {
+        const stage = reviewStageForStep(s.step);
+        const note = stage
+            ? foldHumanCounts(s.note, humanDecisionCounts.get(stage) ?? 0, humanValidationCount(s.note))
+            : s.note;
+        const human = isHumanAgent(s.agent);
+        const agent = human ? 'human' : s.agent;
+        const started = s.started || (human ? '-' : '');
+        return [String(idx + 1), s.step, agent, started, s.done || (s.started ? '(in progress)' : ''), note];
+    });
     for (const line of formatTable(TABLE_HEADERS, rows, { zebra: Boolean(process.stdout.isTTY) })) {
         process.stdout.write(`${line}\n`);
     }
     process.stdout.write(`Total: ${steps.length} steps\n`);
 }
-export { log, parseActivityLog, pairEntries };
+export { log, parseActivityLog, pairEntries, isHumanAgent };
 //# sourceMappingURL=log.js.map

package/dist/lib/task/index.js

@@ -2,8 +2,10 @@ 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
   ls [--all | --blocked | --completed]   List tasks (default: active)
   show <N | #N | TASK-id>                Print a task.md
@@ -12,9 +14,13 @@ Commands:
 Examples:
   ai task cat 11 analysis
   ai task cat 11 3
+  ai task decisions 11
+  ai task d 11 HD-3 --format markdown
   ai task files 11
   ai task grep resolveArtifact
   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 ls
   ai task show 11
@@ -39,6 +45,12 @@ export async function runTask(args) {
             cat(rest);
             break;
         }
+        case 'decisions':
+        case 'd': {
+            const { decisions } = await import("./commands/decisions.js");
+            decisions(rest);
+            break;
+        }
         case 'files': {
             const { files } = await import("./commands/files.js");
             files(rest);
@@ -49,6 +61,11 @@ export async function runTask(args) {
             grep(rest);
             break;
         }
+        case 'issue-body': {
+            const { issueBody } = await import("./commands/issue-body.js");
+            issueBody(rest);
+            break;
+        }
         case 'log': {
             const { log } = await import("./commands/log.js");
             log(rest);

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

@@ -0,0 +1,66 @@
+import { parse } from 'yaml';
+// Field id -> task value mapping (single source of truth, per HD-1).
+// Only ids that map cleanly to title / description / requirements get a value;
+// every other text field gets `N/A`. This deliberately tightens the older
+// "suggested" mapping table (impact / context / alternatives / steps / expected
+// no longer flow into requirements) so the requirements checklist is never
+// pushed into an unrelated field.
+const TITLE_IDS = new Set(['summary', 'title']);
+const DESCRIPTION_IDS = new Set([
+    'description',
+    'problem',
+    'what-happened',
+    'question',
+    'current-content',
+    'issue-description',
+    'detailed-description'
+]);
+const REQUIREMENTS_IDS = new Set(['requirements', 'solution', 'suggested-content']);
+// Only free-text field types carry task content; structural / static fields are skipped.
+const TEXT_FIELD_TYPES = new Set(['input', 'textarea']);
+const PLACEHOLDER = 'N/A';
+function mapFieldValue(id, fields) {
+    if (TITLE_IDS.has(id))
+        return fields.title;
+    if (DESCRIPTION_IDS.has(id))
+        return fields.description;
+    if (REQUIREMENTS_IDS.has(id))
+        return fields.requirements;
+    return '';
+}
+/**
+ * Render the final Issue body for a GitHub Issue Form (scenario A).
+ *
+ * Walks the form's `body[]` in order, skips `markdown` / `dropdown` /
+ * `checkboxes`, and renders each `input` / `textarea` as `### {label}` followed
+ * by the deterministically-mapped task value (or `N/A` when the field has no
+ * reliable source). The template structure is preserved; the whole task.md and
+ * its scaffolding sections are never emitted.
+ *
+ * Throws on unreadable / non-object YAML or a missing `body[]` list so the
+ * 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) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const type = typeof raw.type === 'string' ? raw.type : '';
+        if (!TEXT_FIELD_TYPES.has(type))
+            continue;
+        const label = typeof raw.attributes?.label === 'string' ? raw.attributes.label.trim() : '';
+        if (!label)
+            continue;
+        const id = typeof raw.id === 'string' ? raw.id : '';
+        const mapped = mapFieldValue(id, fields);
+        const value = mapped.trim() === '' ? PLACEHOLDER : mapped;
+        sections.push(`### ${label}\n\n${value}`);
+    }
+    return `${sections.join('\n\n')}\n`;
+}
+export { renderTemplateBody, mapFieldValue, PLACEHOLDER };
+//# sourceMappingURL=issue-form.js.map

package/dist/lib/task/ledger.js

@@ -0,0 +1,66 @@
+// Shared parser for the task.md `## 审查分歧账本` (Review Disagreement Ledger).
+// Single source of truth for ledger row parsing across `ai task` commands
+// (log, decisions) — see the plan's D1 constraint "no third parser". The gate
+// parser in `.agents/scripts/validate-artifact.js` is a separate concern and
+// must be kept semantically in sync by hand (noted in review-handshake.md).
+// The ledger H2 heading is language-dependent (zh template / en template).
+const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
+const NEXT_H2_RE = /^##\s/;
+// Terminal statuses the completion gates treat as resolved.
+const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
+// Statuses that represent an executor-raised human-decision row (pending or done).
+const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
+// 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) {
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]))
+        i += 1;
+    if (i >= lines.length)
+        return [];
+    const rows = [];
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (NEXT_H2_RE.test(lines[j]))
+            break;
+        const line = lines[j].trim();
+        if (!line.startsWith('|'))
+            continue;
+        const cells = line
+            .split('|')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+        if (cells.length < 6)
+            continue;
+        if (cells[0] === 'id' || /^-+$/.test(cells[0] ?? ''))
+            continue;
+        rows.push({
+            id: cells[0],
+            stage: cells[1],
+            round: cells[2],
+            severity: cells[3],
+            status: cells[4],
+            evidence: cells[5]
+        });
+    }
+    return rows;
+}
+// Allocate the next globally-unique human-decision id. Scans every `HD-<n>`
+// already present in the ledger (across all stages) and returns `HD-{max+1}`,
+// or `HD-1` when none exist. Global monotonic allocation prevents id collisions
+// across the analysis / plan / code stages (plan PL-2).
+function nextHdId(rows) {
+    let max = 0;
+    for (const row of rows) {
+        const m = /^HD-(\d+)$/.exec(row.id);
+        if (!m)
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        if (n > max)
+            max = n;
+    }
+    return `HD-${max + 1}`;
+}
+export { parseLedger, nextHdId, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+//# sourceMappingURL=ledger.js.map