@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/dist/lib/task/artifact-lifecycle.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { resolveTaskRef } from './resolve-ref.js';
 import { locateActivityLog } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
+import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 const artifactFamilyCatalog = [
     { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
@@ -173,24 +174,6 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         return null;
     }
 }
-function extractMarkdownSection(content, names) {
-    const lines = content.split(/\r?\n/);
-    const allowed = new Set(names);
-    const start = lines.findIndex((line) => {
-        const match = /^##\s+(.+?)\s*$/.exec(line.trim());
-        return Boolean(match?.[1] && allowed.has(match[1]));
-    });
-    if (start === -1)
-        return '';
-    let end = lines.length;
-    for (let index = start + 1; index < lines.length; index += 1) {
-        if (/^##\s+/.test(lines[index])) {
-            end = index;
-            break;
-        }
-    }
-    return lines.slice(start + 1, end).join('\n');
-}
 function assertWritableInventory(inventory) {
     if (inventory.status === 'failed')
         return inventory.error;
@@ -333,37 +316,6 @@ function resolveDecisionImplementationInput(inventory, review) {
         return { error: error instanceof Error ? error.message : String(error) };
     }
 }
-function normalizeVerdict(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === '通过' || normalized === 'approved')
-        return 'Approved';
-    if (normalized === '需要修改' || normalized === 'changes requested')
-        return 'Changes Requested';
-    if (normalized === '拒绝' || normalized === 'rejected')
-        return 'Rejected';
-    return null;
-}
-function parseVerdict(file) {
-    let content;
-    try {
-        content = fs.readFileSync(file, 'utf8');
-    }
-    catch (error) {
-        return { ok: false, message: String(error) };
-    }
-    const summary = extractMarkdownSection(content, ['审查摘要', 'Review Summary']);
-    const verdictMatch = /^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im.exec(summary);
-    const verdict = verdictMatch?.[1] ? normalizeVerdict(verdictMatch[1]) : null;
-    if (!verdict)
-        return { ok: false, message: `cannot parse verdict in ${path.basename(file)}` };
-    if (verdict !== 'Approved')
-        return { ok: true, verdict };
-    const findings = /^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im.exec(summary)?.[1];
-    const counts = findings?.match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
-    if (!counts)
-        return { ok: false, message: `cannot parse findings count in ${path.basename(file)}` };
-    return { ok: true, verdict: counts.slice(1).some((value) => Number(value) > 0) ? 'Approved-with-issues' : 'Approved' };
-}
 function validateCompletedArtifact(taskDir, family, name, round) {
     if (path.basename(name) !== name)
         return { ok: false, error: { code: 'ARTIFACT_PATH_INVALID', message: 'artifact must be a top-level basename' } };

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

@@ -9,8 +9,9 @@ import { extractSubSection } from '../sections.js';
 const USAGE = `Usage: ai task decisions [--task <ref> | -t <ref>] [--item <selector> | -i <selector>] [options]
        ai task decisions <ref> [selector] [options]
 
-Lists decision items recorded in a task's review disagreement
-ledger, or prints the full detail block for a single item. Read-only.
+Shows what still needs a maintainer's decision. Without a selector, it lists
+the choices. With a selector, it shows the explanation and how to respond.
+Read-only.
 
   Omit <ref>     Resolve the unique active task for the current branch.
   <ref>          Legacy positional task ref.
@@ -161,28 +162,29 @@ function findDecisionRecord(id, content) {
 function titleOf(row, taskDir) {
     const block = findDetailBlock(row, taskDir);
     if (block) {
-        return block
+        const title = block
             .split('\n')[0]
             .replace(/^###\s+/, '')
             .replace(/\s*\[needs-human-decision\]\s*$/, '')
             .trim();
+        return title.replace(new RegExp(`^${row.id}\\s*[:：]\\s*`, 'i'), '').trim();
     }
-    return row.evidence || '(无详情)';
+    return '(explanation unavailable)';
+}
+function trackingOf(row) {
+    return `stage=${row.stage} · severity=${row.severity} · status=${row.status} · evidence=${row.evidence}`;
 }
 function renderList(rows, format, taskDir) {
     if (rows.length === 0) {
-        process.stdout.write('无待裁决项。\n');
+        process.stdout.write('No pending decisions.\n');
         return;
     }
-    const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+    const headers = ['#', 'CHOICE', 'WHAT NEEDS A DECISION', 'TRACKING'];
     const data = rows.map((r, i) => [
         String(i + 1),
         r.id,
-        r.stage,
-        r.severity,
-        r.status,
-        r.evidence,
-        titleOf(r, taskDir)
+        titleOf(r, taskDir),
+        trackingOf(r)
     ]);
     if (format === 'markdown') {
         const sep = headers.map(() => '---');
@@ -191,10 +193,28 @@ function renderList(rows, format, taskDir) {
             `| ${sep.join(' | ')} |`,
             ...data.map((row) => `| ${row.join(' | ')} |`)
         ];
-        process.stdout.write(`${md.join('\n')}\n`);
+        process.stdout.write(`${md.join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
         return;
     }
-    process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+    process.stdout.write(`${formatTable(headers, data).join('\n')}\n\nView one item: ai task decisions <task-ref> <ordinal|ledger-id>\n`);
+}
+function renderTracking(row, format) {
+    if (format === 'markdown') {
+        return [
+            '**Tracking**',
+            `- stage: \`${row.stage}\``,
+            `- severity: \`${row.severity}\``,
+            `- status: \`${row.status}\``,
+            `- evidence: \`${row.evidence}\``
+        ];
+    }
+    return [
+        'Tracking:',
+        `stage: ${row.stage}`,
+        `severity: ${row.severity}`,
+        `status: ${row.status}`,
+        `evidence: ${row.evidence}`
+    ];
 }
 function renderDetail(rows, selector, format, taskDir, content) {
     const selected = selectDecisionItem(rows, selector);
@@ -204,25 +224,35 @@ function renderDetail(rows, selector, format, taskDir, content) {
     }
     const r = selected.row;
     const block = findDetailBlock(r, taskDir);
+    const title = titleOf(r, taskDir);
     const lines = [];
+    const decided = r.status === 'human-decided';
     if (format === 'markdown') {
-        lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+        lines.push(`## ${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+        if (!decided) {
+            lines.push('**How to record your choice**', `\`ai decide <task-ref> ${r.id} <your choice and rationale>\``, '');
+        }
+        lines.push('**Original context**', '');
     }
     else {
-        lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+        lines.push(`${decided ? 'Decision already recorded' : 'Decision needed'}: ${title}`, '');
+        if (!decided) {
+            lines.push('How to record your choice:', `ai decide <task-ref> ${r.id} <your choice and rationale>`, '');
+        }
+        lines.push('Original context:');
     }
     if (block) {
         lines.push(block);
     }
     else {
-        lines.push(`（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`);
+        lines.push(`This older task does not include a full explanation for ${r.id}.`, 'Use the tracking reference below to find the original context.');
     }
-    if (r.status === 'human-decided') {
+    if (decided) {
         const record = findDecisionRecord(r.id, content);
-        if (record.length) {
-            lines.push('', '人工裁定：', ...record);
-        }
+        lines.push('', format === 'markdown' ? '**Recorded choice**' : 'Recorded choice:');
+        lines.push(...(record.length ? record : ['No separate ruling record was found.']));
     }
+    lines.push('', ...renderTracking(r, format));
     process.stdout.write(`${lines.join('\n')}\n`);
 }
 function decisions(args = []) {

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

@@ -10,11 +10,12 @@ Print a deterministic Issue body extracted from a task's task.md.
   Omit <ref>           Resolve the unique active task for the current branch.
   <ref>               Bare numeric 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).
+                      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.
+Only the task title, '## 任务输入', '## 描述' and '## 需求' sections are ever
+emitted; the rest of task.md is never written to the body.
 `;
+const TASK_INPUT_ALIASES = ['任务输入', 'Task Input'];
 const DESCRIPTION_ALIASES = ['描述', 'Description'];
 const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
 /**
@@ -22,17 +23,21 @@ const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
  * task.md actually uses, with empty sections falling back to `N/A`.
  */
 function buildDefaultBody(content) {
+    const taskInputHeading = findSectionHeading(content, TASK_INPUT_ALIASES);
     const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
     const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+    const taskInput = extractSection(content, TASK_INPUT_ALIASES) || PLACEHOLDER;
     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`;
+    return `## ${taskInputHeading}\n\n${taskInput}\n\n## ${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)
+        requirements: extractSection(content, REQUIREMENTS_ALIASES),
+        taskInput: extractSection(content, TASK_INPUT_ALIASES),
+        taskInputHeading: findSectionHeading(content, TASK_INPUT_ALIASES)
     };
 }
 function issueBody(args = []) {

package/dist/lib/task/delegation-receipts.js

@@ -0,0 +1,107 @@
+import { randomUUID } from 'node:crypto';
+const MANAGED_AGENTS = {
+    'agent-infra-lifecycle-executor': 'executor',
+    'agent-infra-lifecycle-reviewer': 'reviewer'
+};
+function managedDelegationRole(nativeAgent) {
+    return MANAGED_AGENTS[nativeAgent] ?? null;
+}
+function fail(code, message) {
+    return { ok: false, code, message };
+}
+function prepareDelegation(input, options = {}) {
+    return Object.freeze({
+        ...input,
+        id: (options.id ?? randomUUID)(),
+        actualModel: null,
+        modelFallbackReason: null,
+        parentId: null,
+        childId: null,
+        spawnMode: null,
+        agent: null,
+        status: 'prepared',
+        afterFingerprint: null,
+        changedPaths: Object.freeze([]),
+        createdAt: (options.now ?? (() => new Date().toISOString()))(),
+        activatedAt: null,
+        sealedAt: null,
+        consumedAt: null
+    });
+}
+function activateDelegation(receipt, event, options = {}) {
+    const managedRole = managedDelegationRole(event.nativeAgent);
+    if (!managedRole)
+        return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    if (receipt.status !== 'prepared')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    if (managedRole !== receipt.role)
+        return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
+    if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
+        return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
+    }
+    if (event.spawnMode !== 'fresh')
+        return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
+    const actualModel = event.actualModel ?? null;
+    if (actualModel && receipt.requestedModel && actualModel !== receipt.requestedModel && !event.modelFallbackReason) {
+        return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+    }
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'activated',
+            parentId: event.parentId,
+            childId: event.childId,
+            spawnMode: event.spawnMode,
+            actualModel,
+            modelFallbackReason: event.modelFallbackReason ?? null,
+            activatedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+function completeDelegationStage(receipt, event) {
+    if (receipt.status !== 'activated')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
+    if (event.stage !== receipt.stage || event.round !== receipt.round || event.artifact !== receipt.artifact) {
+        return fail('DELEGATION_STAGE_MISMATCH', 'stage completion identity does not match the active delegation');
+    }
+    const acceptedAgents = receipt.client === 'claude-code' ? ['claude', 'claude-code'] : [receipt.client];
+    if (!acceptedAgents.includes(event.agent)) {
+        return fail('DELEGATION_AGENT_MISMATCH', `stage agent '${event.agent}' does not match client '${receipt.client}'`);
+    }
+    return { ok: true, receipt: Object.freeze({ ...receipt, status: 'stage-completed', agent: event.agent }) };
+}
+function sealDelegation(receipt, event, options = {}) {
+    if (receipt.status !== 'stage-completed')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+    if (event.childId !== receipt.childId || event.exitCode !== 0)
+        return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
+    if (receipt.role === 'reviewer') {
+        const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
+        const allowed = new Set([
+            `${taskRoot}${receipt.artifact}`,
+            `${taskRoot}task.md`,
+            `${taskRoot}orchestration.json`
+        ]);
+        const disallowed = event.changedPaths.find((entry) => !allowed.has(entry));
+        if (disallowed)
+            return fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`);
+    }
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'sealed',
+            afterFingerprint: event.afterFingerprint,
+            changedPaths: Object.freeze([...event.changedPaths]),
+            sealedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+function consumeDelegation(receipt, options = {}) {
+    if (receipt.status === 'consumed')
+        return fail('DELEGATION_REPLAY', `delegation ${receipt.id} was already consumed`);
+    if (receipt.status !== 'sealed')
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected sealed`);
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            status: 'consumed',
+            consumedAt: (options.now ?? (() => new Date().toISOString()))()
+        }) };
+}
+export { activateDelegation, completeDelegationStage, consumeDelegation, managedDelegationRole, prepareDelegation, sealDelegation };
+//# sourceMappingURL=delegation-receipts.js.map

package/dist/lib/task/events.js

@@ -3,8 +3,11 @@ import { appendActivityEntry, locateActivityLog, pairEntries } from './activity-
 import { buildArtifactLinkSection, artifactName, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.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 { resolveTaskRef } from './resolve-ref.js';
 import { findSectionHeading } from './sections.js';
+import { completeOrchestrationStage, validateOrchestrationStage } from './orchestration.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 const eventCatalog = [
     'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
@@ -75,12 +78,75 @@ function validateTaskEventRequest(request) {
 const FAMILY = {
     analyze: { artifact: 'analysis', started: ['requirement-analysis', 'requirement-analysis-review', 'code'], completed: ['requirement-analysis', 'requirement-analysis-review', 'code'], target: 'requirement-analysis', label: 'Analyze Task' },
     'review-analysis': { artifact: 'review-analysis', started: ['requirement-analysis', 'requirement-analysis-review'], completed: ['requirement-analysis', 'requirement-analysis-review'], target: 'requirement-analysis-review', label: 'Review Analysis' },
-    plan: { artifact: 'plan', started: ['requirement-analysis-review', 'technical-design-review'], completed: ['requirement-analysis-review', 'technical-design-review'], target: 'technical-design', label: 'Plan Task' },
+    plan: { artifact: 'plan', started: ['requirement-analysis-review', 'technical-design-review', 'commit'], completed: ['requirement-analysis-review', 'technical-design-review', 'commit'], target: 'technical-design', label: 'Plan Task' },
     'review-plan': { artifact: 'review-plan', started: ['technical-design', 'technical-design-review'], completed: ['technical-design', 'technical-design-review'], target: 'technical-design-review', label: 'Review Plan' },
     code: { artifact: 'code', started: ['technical-design-review', 'code-review'], completed: ['technical-design-review', 'code-review'], target: 'code', label: 'Code Task' },
     'review-code': { artifact: 'review-code', started: ['code', 'code-review', 'commit'], completed: ['code', 'code-review', 'commit'], target: 'code-review', label: 'Review Code' },
-    'manual-validation': { artifact: 'manual-validation', started: ['code-review'], completed: ['code-review'], target: null, label: 'Complete Manual Validation' }
+    'manual-validation': { artifact: 'manual-validation', started: ['code-review', 'commit'], completed: ['code-review', 'commit'], target: null, label: 'Complete Manual Validation' }
 };
+const REVIEW_LEDGER_STAGES = {
+    'review-analysis': 'analysis',
+    'review-plan': 'plan',
+    'review-code': 'code'
+};
+function validateReviewFindingCounts(request, content, family, artifactPath) {
+    const stage = REVIEW_LEDGER_STAGES[family];
+    if (!stage || !artifactPath)
+        return null;
+    const rows = parseLedger(content);
+    const invalid = validateLedgerRows(rows);
+    if (invalid)
+        return { code: 'TASK_DOCUMENT_INVALID', message: `${invalid.code}: ${invalid.message}` };
+    const expected = summarizeLedgerStage(rows, stage).unresolvedFindingCounts;
+    const payload = {
+        blocker: request.blockers,
+        major: request.major,
+        minor: request.minor
+    };
+    let reportContent;
+    try {
+        reportContent = fs.readFileSync(artifactPath, 'utf8');
+    }
+    catch (error) {
+        return { code: 'EVENT_FINDING_COUNT_MISMATCH', message: String(error) };
+    }
+    const parsed = parseReviewSummary(reportContent);
+    if (!parsed.ok || !parsed.summary.counts) {
+        return {
+            code: 'EVENT_FINDING_COUNT_MISMATCH',
+            message: parsed.ok ? 'review summary finding counts are not finalized' : parsed.message
+        };
+    }
+    const report = parsed.summary.counts;
+    const reportVerdict = parsed.summary.verdict === 'Approved'
+        ? 'approved'
+        : parsed.summary.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
+    const fields = [
+        ['blocker', 'blockers'],
+        ['major', 'major'],
+        ['minor', 'minor']
+    ];
+    const differences = fields.flatMap(([severity, cliField]) => {
+        const values = [
+            expected[severity] === payload[severity]
+                ? null
+                : `${cliField} ledger ${expected[severity]}, payload ${payload[severity]}`,
+            expected[severity] === report[severity]
+                ? null
+                : `${cliField} ledger ${expected[severity]}, report ${report[severity]}`
+        ];
+        return values.filter((value) => value !== null);
+    });
+    if (request.verdict !== reportVerdict) {
+        differences.push(`verdict report ${reportVerdict}, payload ${request.verdict}`);
+    }
+    if (differences.length === 0)
+        return null;
+    return {
+        code: 'EVENT_FINDING_COUNT_MISMATCH',
+        message: `review summary, payload, and ${stage} ledger do not match: ${differences.join('; ')}`
+    };
+}
 function eventParts(event) {
     const [family, suffix] = event.split('.');
     return { family, phase: suffix === 'started' ? 'started' : suffix === 'awaiting-input' ? 'waiting' : 'completed' };
@@ -257,6 +323,24 @@ function applyTaskEvent(request, options = {}) {
     const allowed = FAMILY[eventIdentity.family][eventIdentity.phase === 'started' ? 'started' : 'completed'];
     if (!allowed.includes(currentStep))
         return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${normalized.event} is not allowed from '${currentStep}'` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+    const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
+    if (findingCountError)
+        return failed(normalized, findingCountError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+    if (eventIdentity.phase === 'completed' && !normalized.dryRun && eventIdentity.family !== 'manual-validation') {
+        const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
+        const provenance = validateOrchestrationStage(normalized.taskRef, {
+            stage: orchestrationStage,
+            round: normalized.round,
+            artifact: normalized.artifact,
+            role: eventIdentity.family.startsWith('review-') ? 'reviewer' : 'executor'
+        }, { repoRoot: options.repoRoot });
+        if (provenance.status === 'failed' || provenance.status === 'paused') {
+            return failed(normalized, {
+                code: 'EVENT_TRANSITION_INVALID',
+                message: provenance.error?.message ?? provenance.run?.pause?.message ?? 'orchestration provenance validation failed'
+            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        }
+    }
     let metadata;
     try {
         metadata = (options.metadataProvider ?? captureTaskWriteMetadata)();
@@ -295,6 +379,21 @@ function applyTaskEvent(request, options = {}) {
     const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
+    if (eventIdentity.phase === 'completed' && !normalized.dryRun && eventIdentity.family !== 'manual-validation') {
+        const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
+        const orchestration = completeOrchestrationStage(normalized.taskRef, {
+            stage: orchestrationStage,
+            round: normalized.round,
+            artifact: normalized.artifact,
+            agent: normalized.agent
+        }, { repoRoot: options.repoRoot });
+        if (orchestration.status === 'failed' || orchestration.status === 'paused') {
+            return failed(normalized, {
+                code: 'EVENT_TRANSITION_INVALID',
+                message: orchestration.error?.message ?? orchestration.run?.pause?.message ?? 'orchestration provenance validation failed'
+            }, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
+        }
+    }
     return {
         status: result.status, changed: result.changed, event: normalized.event,
         requestRef: normalized.taskRef, taskId: result.taskId, taskMdPath: result.taskMdPath,

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

@@ -73,6 +73,8 @@ function renderTemplateBody(formText, fields) {
         const value = mapped.trim() === '' ? PLACEHOLDER : mapped;
         sections.push(`### ${label}\n\n${value}`);
     }
+    const taskInput = fields.taskInput.trim() === '' ? PLACEHOLDER : fields.taskInput;
+    sections.push(`### ${fields.taskInputHeading}\n\n${taskInput}`);
     return `${sections.join('\n\n')}\n`;
 }
 export { requirementFieldLabels, renderTemplateBody, mapFieldValue, PLACEHOLDER };