@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/dist/lib/internal/release-workflow.js

@@ -139,9 +139,58 @@ function runOptionalDemo(cwd, run = command) {
     writeDigestAtomically(cwd, digest);
     return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
-function git(cwd, args) {
-    const result = command(cwd, 'git', args);
-    return result.status === 0 ? String(result.stdout).trim() : null;
+function git(cwd, args, run = command, trim = true) {
+    const result = run(cwd, 'git', args);
+    const stdout = String(result.stdout);
+    return result.status === 0 ? (trim ? stdout.trim() : stdout) : null;
+}
+function inspectLocalReleaseFacts(cwd, version, run = command) {
+    const tag = `v${version}`;
+    const head = git(cwd, ['rev-parse', 'HEAD'], run);
+    const tagCommit = git(cwd, ['rev-parse', '--verify', `${tag}^{commit}`], run);
+    const localTag = Boolean(tagCommit && tagCommit === head);
+    const localTagAncestor = Boolean(tagCommit && head && !localTag
+        && run(cwd, 'git', ['merge-base', '--is-ancestor', tagCommit, head]).status === 0);
+    const localTagConflict = Boolean(tagCommit && !localTag && !localTagAncestor);
+    const postSubject = `chore: prepare next dev iteration after v${version}`;
+    const postLog = localTag || localTagAncestor
+        ? git(cwd, ['log', '--format=%s', `${tag}..HEAD`], run) ?? ''
+        : '';
+    const postCommit = postLog.split('\n').some((subject) => subject === postSubject);
+    return { localTag, localTagAncestor, localTagConflict, postCommit };
+}
+function releaseSmokeStatus(workflows, version, tagCommit) {
+    const manualTitle = `Post-Release Smoke v${version}`;
+    const targets = workflows.filter((run) => {
+        if (String(run.workflowName || run.name) !== 'Post-Release Smoke')
+            return false;
+        if (String(run.event) === 'workflow_run')
+            return Boolean(tagCommit && String(run.headSha) === tagCommit);
+        return String(run.event) === 'workflow_dispatch' && String(run.displayTitle) === manualTitle;
+    }).sort((left, right) => {
+        const leftOrder = [Date.parse(String(left.createdAt || '')) || 0, Number(left.databaseId) || 0, Number(left.attempt) || 0];
+        const rightOrder = [Date.parse(String(right.createdAt || '')) || 0, Number(right.databaseId) || 0, Number(right.attempt) || 0];
+        for (let index = 0; index < leftOrder.length; index += 1) {
+            if (leftOrder[index] !== rightOrder[index])
+                return rightOrder[index] - leftOrder[index];
+        }
+        return 0;
+    });
+    const latest = targets[0];
+    if (!latest)
+        return null;
+    if (String(latest.status) !== 'completed')
+        return 'pending';
+    return String(latest.conclusion) === 'success' ? 'success' : 'failed';
+}
+function inspectPostWorktree(cwd) {
+    const inspected = inspectGitWorkflow(cwd);
+    if (!inspected.snapshot)
+        return inspected.error ?? { code: 'GIT_INSPECT_FAILED', message: 'Unable to inspect Git repository' };
+    if (inspected.snapshot.worktree.length || inspected.snapshot.staged.length) {
+        return { code: 'WORKTREE_DIRTY', message: 'Release post requires a clean worktree' };
+    }
+    return null;
 }
 async function inspectFacts(cwd, version) {
     const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
@@ -150,6 +199,7 @@ async function inspectFacts(cwd, version) {
     const branch = git(cwd, ['branch', '--show-current']) || '';
     const head = git(cwd, ['rev-parse', 'HEAD']);
     const localTagTarget = git(cwd, ['rev-parse', '--verify', `${tag}^{commit}`]);
+    const local = inspectLocalReleaseFacts(cwd, version);
     const remoteBranch = branch ? git(cwd, ['ls-remote', '--heads', 'origin', branch]) : null;
     const remoteTag = git(cwd, ['ls-remote', '--tags', 'origin', `refs/tags/${tag}`]);
     const platform = inspectPlatformRelease(tag, { cwd });
@@ -157,23 +207,25 @@ async function inspectFacts(cwd, version) {
     const formulaUrl = `https://raw.githubusercontent.com/${config.org}/homebrew-tap/main/Formula/${config.project}.rb`;
     const homebrew = await inspectHomebrewChannel(formulaUrl, version);
     const workflows = platform.workflows;
-    const smokeRun = workflows.find((run) => String(run.name).toLowerCase().includes('post-release-smoke') && String(run.headBranch) === tag);
-    const smoke = smokeRun ? String(smokeRun.conclusion) === 'success' ? 'success' : String(smokeRun.status) === 'completed' ? 'failed' : 'pending' : null;
-    const postMessage = git(cwd, ['log', '-1', '--pretty=%s']) || '';
+    const smoke = releaseSmokeStatus(workflows, version, localTagTarget);
     return {
-        localTag: Boolean(localTagTarget && localTagTarget === head),
-        localTagConflict: Boolean(localTagTarget && localTagTarget !== head),
+        ...local,
         remoteBranch: Boolean(remoteBranch && remoteBranch.split(/\s+/)[0] === head), remoteTag: Boolean(remoteTag),
         githubRelease: platform.platform.type !== 'github'
             ? true
             : platform.status === 'blocked' ? null : Boolean(platform.release?.published),
-        npm: npm.published, homebrew: homebrew.published, smoke,
-        postCommit: postMessage.includes(`after v${version}`)
+        npm: npm.published, homebrew: homebrew.published, smoke
     };
 }
-function changedPaths(cwd) {
-    const output = git(cwd, ['status', '--porcelain=v1']) || '';
-    return output.split('\n').filter(Boolean).map((line) => line.slice(3)).filter((value, index, all) => all.indexOf(value) === index);
+function parsePorcelainPath(record) {
+    const match = /^.. (.+)$/.exec(record);
+    if (!match)
+        throw new Error('Invalid git status --porcelain=v1 record');
+    return match[1];
+}
+function changedPaths(cwd, run = command) {
+    const output = git(cwd, ['status', '--porcelain=v1'], run, false) || '';
+    return output.split(/\r?\n/).filter(Boolean).map(parsePorcelainPath).filter((value, index, all) => all.indexOf(value) === index);
 }
 function updateReleaseMetadata(cwd, version) {
     const [major = '0', minor = '0'] = version.split('.');
@@ -208,12 +260,12 @@ async function releaseWorkflow(args = []) {
         process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
         return;
     }
+    if (before.facts.localTagConflict) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag v${version} is not reachable from HEAD` } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
     if (action === 'prepare') {
-        if (before.facts.localTagConflict) {
-            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag v${version} does not point to HEAD` } })}\n`);
-            process.exitCode = 1;
-            return;
-        }
         if (before.phase !== 'unprepared') {
             const milestones = reconcileReleaseMilestones(version, { cwd });
             process.stdout.write(`${JSON.stringify({ ...milestones, snapshot: before })}\n`);
@@ -267,7 +319,7 @@ async function releaseWorkflow(args = []) {
         return;
     }
     if (action === 'publish') {
-        if (!['prepared', 'partially-published'].includes(before.phase)) {
+        if (!before.facts.localTag || !['prepared', 'partially-published'].includes(before.phase)) {
             process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_PHASE_INVALID', message: `Cannot publish from ${before.phase}` } })}\n`);
             process.exitCode = 1;
             return;
@@ -279,12 +331,22 @@ async function releaseWorkflow(args = []) {
         process.exitCode = result.status === 'failed' ? 1 : result.status === 'degraded' ? 2 : 0;
         return;
     }
+    if (before.phase === 'complete') {
+        process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
+        return;
+    }
     const channelsComplete = before.facts.githubRelease === true && before.facts.npm === true && before.facts.homebrew === true;
     if (!['published', 'post-pending'].includes(before.phase) || !channelsComplete || before.facts.smoke !== 'success') {
         process.stdout.write(`${JSON.stringify({ status: before.facts.smoke === 'failed' ? 'failed' : 'blocked', changed: false, snapshot: before, error: { code: 'RELEASE_CHANNELS_PENDING', message: 'Release channels or smoke workflow are not complete' } })}\n`);
         process.exitCode = before.facts.smoke === 'failed' ? 1 : 2;
         return;
     }
+    const worktreeError = inspectPostWorktree(cwd);
+    if (worktreeError) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: worktreeError })}\n`);
+        process.exitCode = 1;
+        return;
+    }
     const built = command(cwd, 'npm', ['run', 'build']);
     if (built.status !== 0) {
         process.stdout.write(`${JSON.stringify({ status: 'failed', changed: true, snapshot: before, error: { code: 'RELEASE_POST_COMMAND_FAILED', message: String(built.stderr || built.stdout) } })}\n`);
@@ -316,5 +378,5 @@ async function releaseWorkflow(args = []) {
     process.stdout.write(`${JSON.stringify({ ...pushed, demo, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`);
     process.exitCode = pushed.status === 'failed' ? 1 : pushed.status === 'degraded' ? 2 : 0;
 }
-export { computeDemoInputDigest, inspectFacts, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

package/dist/lib/internal/task-activity.js

@@ -0,0 +1,73 @@
+import { applyActivityAppendIntent } from '../task/activity-intent.js';
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> append --step <step> --agent <agent> --note <note> [--artifact <canonical.md>] [--dry-run]
+`;
+const FLAGS = {
+    '--step': 'step',
+    '--agent': 'agent',
+    '--note': 'note',
+    '--artifact': 'artifact'
+};
+function usageFailure(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function taskActivity(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const [taskRef, kind] = args;
+    if (!taskRef || taskRef.startsWith('--') || !kind || kind !== 'append') {
+        usageFailure('task ref and the append intent are required');
+        return;
+    }
+    const values = { kind, taskRef };
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--dry-run') {
+            if (seen.has(flag)) {
+                usageFailure(`duplicate option '${flag}'`);
+                return;
+            }
+            seen.add(flag);
+            values.dryRun = true;
+            continue;
+        }
+        const key = FLAGS[flag];
+        if (!key) {
+            usageFailure(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            usageFailure(`duplicate option '${flag}'`);
+            return;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--')) {
+            usageFailure(`option '${flag}' requires a value`);
+            return;
+        }
+        seen.add(flag);
+        values[key] = value;
+    }
+    const allowed = new Set(['kind', 'taskRef', 'dryRun', 'step', 'agent', 'note', 'artifact']);
+    const unexpected = Object.keys(values).find((key) => !allowed.has(key));
+    if (unexpected) {
+        usageFailure(`append does not accept '${unexpected}'`);
+        return;
+    }
+    for (const key of ['step', 'agent', 'note']) {
+        if (values[key] === undefined) {
+            usageFailure(`append requires '${key}'`);
+            return;
+        }
+    }
+    const result = applyActivityAppendIntent(values);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskActivity };
+//# sourceMappingURL=task-activity.js.map

package/dist/lib/internal/task-event.js

@@ -1,5 +1,6 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskEvent, eventCatalog } from '../task/events.js';
-const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--dry-run]
+const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
 Events: ${eventCatalog.join(', ')}
@@ -30,6 +31,15 @@ function taskEvent(args = []) {
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
+        if (flag === '--orchestrated') {
+            if (seen.has(flag)) {
+                usageFailure(`duplicate option '${flag}'`);
+                return;
+            }
+            seen.add(flag);
+            request.orchestrated = true;
+            continue;
+        }
         if (flag === '--dry-run') {
             if (seen.has(flag)) {
                 usageFailure(`duplicate option '${flag}'`);
@@ -61,6 +71,12 @@ function taskEvent(args = []) {
         else
             request[key] = value;
     }
+    const agent = normalizeAgentToken(String(request.agent ?? ''));
+    if (!agent) {
+        usageFailure(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    request.agent = agent;
     const result = applyTaskEvent(request);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

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

@@ -1,3 +1,4 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.js';
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\n`;
 const FLAGS = {
@@ -49,6 +50,12 @@ function taskLifecycle(args = []) {
         seen.add(flag);
         values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
     }
+    const agent = normalizeAgentToken(String(values.agent ?? ''));
+    if (!agent) {
+        usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    values.agent = agent;
     const result = applyTaskLifecycle(values);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

package/dist/lib/internal/task-orchestration.js

@@ -0,0 +1,196 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginOrResumeOrchestration, completeCommitOrchestrationStage, pauseOrchestration, prepareOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
+import { isAgentClientId } from '../agent-clients/types.js';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|stage-completed|hook-stop|advance|pause|status> [options]\n';
+function usageFailure(message) {
+    process.stdout.write(`${JSON.stringify({
+        status: 'failed', changed: false,
+        error: { code: 'ORCHESTRATION_PAYLOAD_INVALID', message }
+    })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 2;
+}
+function taskOrchestration(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (args.length < 2) {
+        usageFailure('task ref and intent are required');
+        return;
+    }
+    const [taskRef, intent] = args;
+    if (!['begin-or-resume', 'route', 'prepare', 'hook-start', 'stage-completed', 'hook-stop', 'advance', 'pause', 'status'].includes(intent)) {
+        usageFailure(`unknown intent '${intent}'`);
+        return;
+    }
+    const values = {};
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (![
+            '--max-steps', '--executor-model', '--executor-reasoning-effort',
+            '--reviewer-model', '--reviewer-reasoning-effort',
+            '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
+            '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
+            '--model-fallback-reason', '--reasoning-effort-fallback-reason',
+            '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent'
+        ].includes(flag)) {
+            usageFailure(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            usageFailure(`duplicate option '${flag}'`);
+            return;
+        }
+        seen.add(flag);
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            usageFailure(`option '${flag}' requires a value`);
+            return;
+        }
+        values[flag] = value;
+    }
+    const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
+    if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
+        usageFailure(`unknown client '${values['--client']}'`);
+        return;
+    }
+    let result;
+    if (intent === 'begin-or-resume') {
+        const missing = requireValues(['--client']);
+        if (missing) {
+            usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
+            return;
+        }
+        const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
+        if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
+            usageFailure('--max-steps must be a positive integer');
+            return;
+        }
+        const policyFlags = [
+            '--executor-model', '--executor-reasoning-effort',
+            '--reviewer-model', '--reviewer-reasoning-effort'
+        ];
+        const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
+        if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
+            usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
+            return;
+        }
+        result = beginOrResumeOrchestration(taskRef, {
+            maxSteps,
+            client: values['--client'],
+            modelPolicy: hasAnyPolicy ? {
+                executor: {
+                    model: values['--executor-model'],
+                    reasoningEffort: values['--executor-reasoning-effort']
+                },
+                reviewer: {
+                    model: values['--reviewer-model'],
+                    reasoningEffort: values['--reviewer-reasoning-effort']
+                }
+            } : undefined
+        });
+    }
+    else if (intent === 'route') {
+        result = routeOrchestration(taskRef);
+    }
+    else if (intent === 'status') {
+        result = statusOrchestration(taskRef);
+    }
+    else if (intent === 'prepare') {
+        const missing = requireValues(['--client']);
+        if (missing) {
+            usageFailure(`intent 'prepare' requires '${missing}'`);
+            return;
+        }
+        result = prepareOrchestrationDelegation(taskRef, {
+            client: values['--client'],
+            requestedModel: values['--requested-model'],
+            requestedReasoningEffort: values['--requested-reasoning-effort']
+        });
+    }
+    else if (intent === 'hook-start') {
+        const missing = requireValues([
+            ...(taskRef === 'auto' ? ['--client'] : []),
+            '--native-agent', '--child-id', '--parent-id', '--spawn-mode'
+        ]);
+        if (missing) {
+            usageFailure(`intent 'hook-start' requires '${missing}'`);
+            return;
+        }
+        const event = {
+            nativeAgent: values['--native-agent'], childId: values['--child-id'],
+            parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
+            actualModel: values['--actual-model'],
+            actualReasoningEffort: values['--actual-reasoning-effort'],
+            modelFallbackReason: values['--model-fallback-reason'],
+            reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+        };
+        result = taskRef === 'auto'
+            ? activateMatchingOrchestrationDelegation(values['--client'], event)
+            : activateOrchestrationDelegation(taskRef, event);
+    }
+    else if (intent === 'hook-stop') {
+        if (taskRef === 'auto') {
+            const missing = requireValues(['--client', '--native-agent', '--child-id']);
+            if (missing) {
+                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                return;
+            }
+            result = sealMatchingOrchestrationDelegation(values['--client'], {
+                nativeAgent: values['--native-agent'], childId: values['--child-id']
+            });
+        }
+        else {
+            const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+            if (missing) {
+                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                return;
+            }
+            const exitCode = Number(values['--exit-code']);
+            if (!Number.isInteger(exitCode)) {
+                usageFailure('--exit-code must be an integer');
+                return;
+            }
+            result = sealOrchestrationDelegation(taskRef, {
+                childId: values['--child-id'], exitCode,
+                afterFingerprint: values['--after-fingerprint'],
+                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
+            });
+        }
+    }
+    else if (intent === 'stage-completed') {
+        const missing = requireValues(['--agent']);
+        if (missing) {
+            usageFailure(`intent 'stage-completed' requires '${missing}'`);
+            return;
+        }
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = completeCommitOrchestrationStage(taskRef, agent);
+    }
+    else if (intent === 'advance') {
+        result = advanceOrchestration(taskRef);
+    }
+    else {
+        const missing = requireValues(['--code', '--message', '--recoverable']);
+        if (missing) {
+            usageFailure(`intent 'pause' requires '${missing}'`);
+            return;
+        }
+        if (!['true', 'false'].includes(values['--recoverable'])) {
+            usageFailure('--recoverable must be true or false');
+            return;
+        }
+        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true');
+    }
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskOrchestration };
+//# sourceMappingURL=task-orchestration.js.map

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

@@ -0,0 +1,70 @@
+import { finalizeReviewSummary } from '../task/review-finalization.js';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+function failUsage(message) {
+    process.stdout.write(`${JSON.stringify({
+        status: 'failed',
+        changed: false,
+        intent: 'finalize-summary',
+        error: { code: 'REVIEW_PAYLOAD_INVALID', message }
+    })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 2;
+}
+function taskReview(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (args.length < 2) {
+        failUsage('task ref and intent are required');
+        return;
+    }
+    if (args[1] !== 'finalize-summary') {
+        failUsage(`unknown intent '${args[1]}'`);
+        return;
+    }
+    let stage = '';
+    let artifact = '';
+    let dryRun = false;
+    let orchestrated = false;
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!['--stage', '--artifact', '--orchestrated', '--dry-run'].includes(flag)) {
+            failUsage(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            failUsage(`duplicate option '${flag}'`);
+            return;
+        }
+        seen.add(flag);
+        if (flag === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (flag === '--orchestrated') {
+            orchestrated = true;
+            continue;
+        }
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            failUsage(`option '${flag}' requires a value`);
+            return;
+        }
+        if (flag === '--stage')
+            stage = value;
+        else
+            artifact = value;
+    }
+    if (!stage || !artifact) {
+        failUsage("options '--stage' and '--artifact' are required");
+        return;
+    }
+    const result = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskReview };
+//# sourceMappingURL=task-review.js.map

package/dist/lib/merge.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { info, ok } from './log.js';
+import { removeDirRecursive } from './remove-dir.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 const TITLE_RE = /^# (.+)$/m;
@@ -527,7 +528,7 @@ function mergeMutableSections({ sourceWorkspace, localWorkspace, backupRoot, rep
             if (comparison > 0) {
                 backupTaskDir(backupRoot, localMatch.section, localMatch.taskDir, localMatch.taskId);
                 report.backupCount += 1;
-                fs.rmSync(localMatch.taskDir, { recursive: true, force: true });
+                removeDirRecursive(localMatch.taskDir);
                 const destinationDir = copyTaskToSection(sourceTask, localWorkspace);
                 localIndex.set(sourceTask.taskId, {
                     taskId: sourceTask.taskId,

package/dist/lib/platform/adapters.js

@@ -7,8 +7,52 @@ function registerPlatformAdapter(adapter) {
 function getPlatformAdapter(type) {
     return type ? adapters.get(type) ?? null : null;
 }
+function registerPlatformCapabilities(type, capabilities) {
+    const adapter = adapters.get(type);
+    if (!adapter)
+        throw new Error(`Platform adapter '${type}' must be registered before its capabilities`);
+    adapters.set(type, { ...adapter, ...capabilities });
+}
+function hasPlatformCapability(type, capability) {
+    const adapter = getPlatformAdapter(type);
+    if (capability === 'change-request')
+        return typeof adapter?.inspectChangeRequest === 'function';
+    if (capability === 'issue-closing-change-requests')
+        return typeof adapter?.inspectIssueClosingChangeRequests === 'function';
+    if (capability === 'required-checks')
+        return typeof adapter?.inspectRequiredChecks === 'function';
+    return typeof adapter?.resolveChangeRequestGitEvidence === 'function';
+}
+function inspectPlatformIssueClosingChangeRequests(type, context) {
+    const adapter = getPlatformAdapter(type);
+    return adapter?.inspectIssueClosingChangeRequests?.(context) ??
+        unsupported(type, 'issue closing change-request inspection');
+}
+function unsupported(type, capability) {
+    return {
+        ok: false,
+        error: {
+            code: 'PLATFORM_CAPABILITY_UNSUPPORTED',
+            message: `Platform '${type || 'none'}' does not provide ${capability}`,
+            retryable: false
+        }
+    };
+}
+function inspectPlatformChangeRequest(type, context) {
+    const adapter = getPlatformAdapter(type);
+    return adapter?.inspectChangeRequest?.(context) ?? unsupported(type, 'change-request inspection');
+}
+function inspectPlatformRequiredChecks(type, context) {
+    const adapter = getPlatformAdapter(type);
+    return adapter?.inspectRequiredChecks?.(context) ?? unsupported(type, 'required-checks inspection');
+}
+function resolvePlatformChangeRequestGitEvidence(type, context) {
+    const adapter = getPlatformAdapter(type);
+    return adapter?.resolveChangeRequestGitEvidence?.(context) ??
+        unsupported(type, 'change-request Git evidence');
+}
 function listPlatformAdapters() {
     return [...adapters.keys()].sort();
 }
-export { getPlatformAdapter, listPlatformAdapters, registerPlatformAdapter };
+export { getPlatformAdapter, hasPlatformCapability, inspectPlatformChangeRequest, inspectPlatformIssueClosingChangeRequests, inspectPlatformRequiredChecks, listPlatformAdapters, registerPlatformAdapter, registerPlatformCapabilities, resolvePlatformChangeRequestGitEvidence };
 //# sourceMappingURL=adapters.js.map