@fitlab-ai/agent-infra 0.9.2 → 0.9.3

package/dist/lib/pr-review/evidence-grading.js

@@ -0,0 +1,229 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+export class HostResolutionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'HostResolutionError';
+        this.code = code;
+    }
+}
+function toPositiveNumber(value) {
+    const n = Number(value);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+/**
+ * Parse the PR body for closing-issue references. Handles the conventional
+ * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
+ * separated, optional keyword list on the same logical line).
+ */
+export function extractClosingIssueNumbers(body) {
+    const result = [];
+    const seen = new Set();
+    const linePattern = /(?:^|\n)[^\n]*\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b[^\n]*/gi;
+    let lineMatch;
+    while ((lineMatch = linePattern.exec(body)) !== null) {
+        const line = lineMatch[0];
+        for (const numMatch of line.matchAll(/#(\d+)/g)) {
+            const n = Number(numMatch[1]);
+            if (Number.isInteger(n) && n > 0 && !seen.has(n)) {
+                seen.add(n);
+                result.push(n);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
+ * PR number or to one of the PR's closing issues. A task is emitted at most once;
+ * a direct `pr_number` hit takes priority over the issue-number reverse lookup.
+ */
+export function collectHostCandidates(input) {
+    const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+    const candidates = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(activeRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const taskDir = path.join(activeRoot, entry.name);
+        const taskMdPath = path.join(taskDir, 'task.md');
+        let content;
+        try {
+            content = fs.readFileSync(taskMdPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const frontmatter = parseTaskFrontmatter(content);
+        const issueNumber = toPositiveNumber(frontmatter.issue_number);
+        const prNumber = toPositiveNumber(frontmatter.pr_number);
+        if (prNumber === input.prNumber) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+        else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+    }
+    return candidates;
+}
+/**
+ * Collapse a candidate list into a typed HostResolution. Zero candidates ->
+ * none; exactly one -> unique; more than one (no stable selection rule) ->
+ * ambiguous (fail closed, AN-6).
+ */
+export function resolveHostFromCandidates(candidates) {
+    if (candidates.length === 0)
+        return { kind: 'none' };
+    if (candidates.length === 1) {
+        const candidate = candidates[0];
+        return {
+            kind: 'unique',
+            taskId: candidate.taskId,
+            taskDir: candidate.taskDir,
+            issueNumber: candidate.issueNumber ?? 0,
+            prNumber: candidate.prNumber ?? 0
+        };
+    }
+    return {
+        kind: 'ambiguous',
+        candidates: candidates.map((candidate) => ({ taskId: candidate.taskId, issueNumber: candidate.issueNumber ?? 0 }))
+    };
+}
+function hasNoLifecycleArtifacts(presence) {
+    return !presence.hasAnalysis && !presence.hasPlan && !presence.hasCode &&
+        !presence.hasReviewAnalysis && !presence.hasReviewPlan && !presence.hasReviewCode &&
+        !presence.hasPriorPrReview;
+}
+function hasFullArtifacts(presence) {
+    return presence.hasAnalysis && presence.hasPlan && presence.hasCode &&
+        presence.hasReviewAnalysis && presence.hasReviewPlan && presence.hasReviewCode;
+}
+function isTrusted(head) {
+    return head.issueNumberBound && head.taskIssueMatches && (!head.prNumberBound || head.taskPrMatches);
+}
+/**
+ * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
+ * resolved data: a unique host is trusted on the issue dimension only when the
+ * task's bound issue_number is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
+ * does not derive the trust factor ad hoc (CD-2).
+ */
+export function deriveTaskIssueMatches(host, closingIssues) {
+    return host.kind === 'unique' && host.issueNumber > 0 && closingIssues.includes(host.issueNumber);
+}
+/**
+ * S1 -> S2 -> S3 classification (analysis §6.1). The ambiguous host is rejected
+ * before classification (AN-6 fail closed). S3(a) is host.kind === 'none';
+ * S3(b) is a unique task with no lifecycle artifacts and no prior pr-review
+ * (PL-5/PL-9 symmetric: any review-only task falls to S2).
+ */
+export function classifyScenario(host, presence, head) {
+    if (host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'multiple candidate hosts; resolve before evidence classification');
+    }
+    if (host.kind === 'none')
+        return 'S3';
+    if (hasNoLifecycleArtifacts(presence))
+        return 'S3';
+    const priorHeadMatches = presence.hasPriorPrReview && head.priorHeadSha !== null && head.priorHeadSha === head.currentHeadSha;
+    if (hasFullArtifacts(presence) && priorHeadMatches && isTrusted(head))
+        return 'S1';
+    return 'S2';
+}
+/**
+ * Freshness is benchmarked against the prior `pr-review*` reviewed head SHA
+ * (analysis §6.2, AN-7). No prior review -> n/a/n/a (first-review special case).
+ */
+export function evaluateHead(head) {
+    if (head.priorHeadSha === null)
+        return { freshness: 'n/a', alignment: 'n/a' };
+    const freshness = head.priorHeadSha === head.currentHeadSha ? 'fresh' : 'stale';
+    const aligned = freshness === 'fresh' && isTrusted(head);
+    return { freshness, alignment: aligned ? 'aligned' : 'misaligned' };
+}
+/**
+ * Pure-evidence risk aggregation (analysis §6.3, AN-5): any priority factor
+ * (sensitivity / sourceCredibility) HIGH -> HIGH; otherwise any HIGH -> MEDIUM;
+ * all LOW -> LOW. Identity factors are structurally absent from the input type.
+ */
+export function gradeRisk(factors) {
+    const priority = [factors.sensitivity, factors.sourceCredibility];
+    if (priority.includes('HIGH'))
+        return 'HIGH';
+    const values = Object.values(factors);
+    if (values.includes('HIGH'))
+        return 'MEDIUM';
+    return 'LOW';
+}
+/**
+ * verify / audit / reconstruct selection matrix (analysis §6.4). S3 ->
+ * reconstruct; S2 -> audit; S1 fresh+aligned -> verify (LOW/MEDIUM risk) or
+ * audit (HIGH risk); any other S1 combination falls back to audit.
+ */
+export function selectMode(scenario, freshness, alignment, risk) {
+    if (scenario === 'S3')
+        return 'reconstruct';
+    if (scenario === 'S2')
+        return 'audit';
+    if (freshness === 'fresh' && alignment === 'aligned') {
+        return risk === 'HIGH' ? 'audit' : 'verify';
+    }
+    return 'audit';
+}
+function buildReason(input) {
+    const pieces = [];
+    if (input.firstReview)
+        pieces.push('first review (no prior pr-review head)');
+    if (input.hasPriorPrReview)
+        pieces.push(`prior head ${input.freshness}`);
+    if (input.freshness === 'fresh')
+        pieces.push(`alignment ${input.alignment}`);
+    pieces.push(`evidence scenario ${input.scenario}`);
+    pieces.push(`risk ${input.risk}`);
+    pieces.push(`mode ${input.mode}`);
+    return pieces.join('; ');
+}
+/**
+ * Full decision pipeline: classify -> freshness/alignment -> risk -> mode,
+ * producing a traceable DecisionRecord (AC3). Ambiguous hosts are rejected
+ * before any classification runs (AN-6).
+ */
+export function decide(input) {
+    if (input.host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'ambiguous host; resolve before evidence classification');
+    }
+    const scenario = classifyScenario(input.host, input.presence, input.head);
+    const { freshness, alignment } = evaluateHead(input.head);
+    const risk = gradeRisk(input.riskFactors);
+    const mode = selectMode(scenario, freshness, alignment, risk);
+    const firstReview = !input.presence.hasPriorPrReview;
+    return {
+        host: input.host,
+        scenario,
+        freshness,
+        alignment,
+        risk,
+        mode,
+        firstReview,
+        reason: buildReason({
+            scenario,
+            freshness,
+            alignment,
+            risk,
+            mode,
+            firstReview,
+            hasPriorPrReview: input.presence.hasPriorPrReview
+        })
+    };
+}
+export { hasFullArtifacts, hasNoLifecycleArtifacts, isTrusted };
+//# sourceMappingURL=evidence-grading.js.map

package/dist/lib/run/tui.js

@@ -1,6 +1,6 @@
 import { renderAgentClientInvocation } from '../agent-clients/invocation.js';
 import { getAgentClientAdapter } from '../agent-clients/registry.js';
-const TUI_NAMES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode']);
 function isTuiName(value) {
     return typeof value === 'string' && TUI_NAMES.has(value);
 }
@@ -25,15 +25,13 @@ export function renderPrompt(params) {
             args: params.args
         });
     }
-    if (params.tui === 'gemini')
-        return `/agent-infra:${suffix}`;
     return `/${suffix}`;
 }
 export function buildTuiCommand(tui, prompt) {
     if (tui === 'claude')
         return ['claude', ['--dangerously-skip-permissions', '--print', prompt]];
-    if (tui === 'gemini')
-        return ['gemini', ['--approval-mode', 'yolo', '--prompt', prompt]];
+    if (tui === 'antigravity')
+        return ['agy', ['--dangerously-skip-permissions', '--print', prompt]];
     if (tui === 'opencode')
         return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
     return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];

package/dist/lib/sandbox/commands/create.js

@@ -729,22 +729,6 @@ export function ensureOpenCodeModelInheritance(toolDir, hostHomeDir) {
         fs.writeFileSync(sandboxConfigPath, JSON.stringify(sandboxJson, null, 2), 'utf8');
     }
 }
-export function ensureGeminiWorkspaceTrust(toolDir) {
-    const trustPath = path.join(toolDir, 'trustedFolders.json');
-    let data = {};
-    if (fs.existsSync(trustPath)) {
-        try {
-            data = JSON.parse(fs.readFileSync(trustPath, 'utf8'));
-        }
-        catch {
-            // malformed JSON, start fresh
-        }
-    }
-    if (data['/workspace'] !== 'TRUST_FOLDER') {
-        data['/workspace'] = 'TRUST_FOLDER';
-        fs.writeFileSync(trustPath, JSON.stringify(data, null, 2), 'utf8');
-    }
-}
 export function sandboxAliasesPath(home) {
     return hostJoin(home, '.agent-infra', 'aliases', 'sandbox.sh');
 }
@@ -1125,10 +1109,6 @@ export async function create(args) {
                             // provider/API settings are enough for Claude Code. If no usable
                             // auth was present, the claude-code entry was removed above.
                         }
-                        const geminiEntry = effectiveResolvedTools.find(({ tool }) => tool.id === 'gemini-cli');
-                        if (geminiEntry) {
-                            ensureGeminiWorkspaceTrust(geminiEntry.dir);
-                        }
                         const opencodeEntry = effectiveResolvedTools.find(({ tool }) => tool.id === 'opencode');
                         if (opencodeEntry) {
                             // The TUI reads <toolDir>/opencode.json via OPENCODE_CONFIG pinned in tools.js.

package/dist/lib/sandbox/commands/show.js

@@ -8,7 +8,7 @@ import { resolveTools, toolConfigDirCandidates } from '../tools.js';
 const USAGE = `Usage: ai sandbox show <branch | TASK-id | N>
 
 Shows one sandbox's worktree path and per-tool state paths (Claude Code,
-Codex, Gemini CLI, OpenCode). The argument follows the same contract as
+Codex, Antigravity CLI, OpenCode). The argument follows the same contract as
 'ai sandbox exec' and 'ai sandbox start': N (bare) is the recommended form
 for task short ids (e.g. 'ai sandbox show 11'); a TASK-id or a plain
 branch name are also accepted. Use 'ai sandbox ls' for the container list.`;

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

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveTaskRef } from './resolve-ref.js';
+import { locateActivityLog, appendActivityEntry } from './activity-log.js';
+import { buildArtifactLinkSection, parseArtifactName } from './artifact-lifecycle.js';
+import { captureTaskWriteMetadata, writeTask } from './write.js';
+function failed(intent, code, message, taskId = null) {
+    return {
+        status: 'failed', changed: false, intent: 'append', taskId,
+        artifact: intent.artifact ?? null, operations: [], error: { code, message }
+    };
+}
+function oneLine(value) {
+    return value.replace(/\s*\r?\n\s*/g, ' ').trim();
+}
+/**
+ * Append an Activity Log entry (and, optionally, a `## 审查反馈` artifact link)
+ * to an active task via the atomic `writeTask` path. `current_step` is never
+ * touched (PL-2): review-pr does not join the standard stage chain.
+ */
+export function applyActivityAppendIntent(intent, options = {}) {
+    if (intent.kind !== 'append')
+        return failed(intent, 'ACTIVITY_INTENT_INVALID', 'intent kind must be append');
+    const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(intent, resolved.code, resolved.message, resolved.taskId);
+    if (resolved.state !== 'active') {
+        return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+    }
+    const step = oneLine(intent.step);
+    const agent = oneLine(intent.agent);
+    const note = oneLine(intent.note);
+    if (!step || !agent || !note || /[\r\n]/.test(intent.step) || /[\r\n]/.test(intent.agent) || /[\r\n]/.test(intent.note)) {
+        return failed(intent, 'ACTIVITY_INTENT_INVALID', 'step, agent and note must be non-empty single-line values', resolved.taskId);
+    }
+    let artifact = null;
+    if (intent.artifact !== undefined) {
+        artifact = parseArtifactName(intent.artifact);
+        if (!artifact || artifact.family !== 'pr-review') {
+            return failed(intent, 'ACTIVITY_ARTIFACT_INVALID', `artifact '${intent.artifact}' is not a canonical pr-review artifact`, resolved.taskId);
+        }
+    }
+    let content;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    }
+    catch (error) {
+        return failed(intent, 'TASK_READ_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const section = locateActivityLog(content);
+    if (!section) {
+        return failed(intent, 'ACTIVITY_SECTION_MISSING', 'task has no unique Activity Log section', resolved.taskId);
+    }
+    let metadata;
+    try {
+        metadata = (options.metadataProvider ?? captureTaskWriteMetadata)();
+    }
+    catch (error) {
+        return failed(intent, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const mutations = [];
+    const activityBody = appendActivityEntry(section, { time: metadata.timestamp, step, agent, note });
+    mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body: activityBody });
+    if (artifact) {
+        const link = buildArtifactLinkSection(content, {
+            ...artifact,
+            path: path.join(resolved.taskDir, artifact.name),
+            size: 0,
+            mtimeMs: 0
+        });
+        mutations.push({ kind: 'section', aliases: link.aliases, heading: link.heading, body: link.body });
+    }
+    const writeResult = writeTask({
+        taskRef: intent.taskRef,
+        expectedState: 'active',
+        mutations,
+        dryRun: intent.dryRun
+    }, {
+        ...options,
+        taskLocation: {
+            repoRoot: resolved.repoRoot,
+            taskId: resolved.taskId,
+            taskMdPath: resolved.taskMdPath,
+            state: resolved.state
+        },
+        metadataProvider: () => metadata
+    });
+    if (writeResult.status === 'failed') {
+        return failed(intent, writeResult.error.code, writeResult.error.message, writeResult.taskId);
+    }
+    return {
+        status: writeResult.status,
+        changed: writeResult.changed,
+        intent: 'append',
+        taskId: writeResult.taskId,
+        artifact: intent.artifact ?? null,
+        operations: writeResult.operations,
+        error: null
+    };
+}
+//# sourceMappingURL=activity-intent.js.map

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

@@ -12,7 +12,8 @@ const artifactFamilyCatalog = [
     { family: 'review-plan', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['技术方案审查', 'Plan Review'] },
     { family: 'code', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['实现报告', 'Implementation Report'] },
     { family: 'review-code', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['代码审查', 'Code Review'] },
-    { family: 'manual-validation', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['人工验证', 'Manual Validation'] }
+    { family: 'manual-validation', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['人工验证', 'Manual Validation'] },
+    { family: 'pr-review', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['PR 审查报告', 'PR Review Report'] }
 ];
 const FAMILY_SET = new Set(artifactFamilyCatalog.map((item) => item.family));
 const BLOCKING_DIAGNOSTICS = new Set([

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

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { classifyAgent } from '../../agent-clients/tokens.js';
 import { formatTable } from '../../table.js';
 import { parseTaskScope } from '../command-options.js';
 import { resolveTaskContext } from '../resolve-ref.js';
@@ -30,11 +31,11 @@ const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // with ` [started]`; the matching done entry carries the identical base action
 // 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.
-// 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']);
+// Known AI tokens, long-name mapping, and loose rendering classification live
+// in lib/agent-clients/tokens.ts (single source of truth shared with the
+// write-side internal commands). Any other executor token (a human name,
+// possibly CJK, or an unknown value) is rendered as human with a visible
+// `(unknown)` marker.
 const REVIEW_STAGE_PREFIXES = [
     { prefix: 'Review Analysis', stage: 'analysis' },
     { prefix: 'Review Plan', stage: 'plan' },
@@ -83,12 +84,11 @@ function humanValidationCount(note) {
 function isHumanCountField(field) {
     return fieldNumber(field, 'manual-validation') !== undefined || fieldNumber(field, 'human-decision') !== undefined;
 }
-// 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);
+// A step is human-executed when its agent token is not a known AI token.
+// Known long names (claude-code -> claude, gemini-cli -> gemini) classify as
+// AI; empty or unknown tokens classify as non-AI (human).
+export function isHumanAgent(agent) {
+    return classifyAgent(agent).status !== 'ai';
 }
 // 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
@@ -148,8 +148,9 @@ function log(args = []) {
         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 { status, display } = classifyAgent(s.agent);
+        const human = status !== 'ai';
+        const agent = status === 'unknown' ? `${display} (unknown)` : display;
         const started = s.started || (human ? '-' : '');
         return [String(idx + 1), s.step, agent, started, s.done || (s.started ? '(in progress)' : ''), note];
     });
@@ -158,5 +159,5 @@ function log(args = []) {
     }
     process.stdout.write(`Total: ${steps.length} steps\n`);
 }
-export { log, isHumanAgent };
+export { log };
 //# sourceMappingURL=log.js.map

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

@@ -14,7 +14,9 @@ function prepareDelegation(input, options = {}) {
         ...input,
         id: (options.id ?? randomUUID)(),
         actualModel: null,
+        actualReasoningEffort: null,
         modelFallbackReason: null,
+        reasoningEffortFallbackReason: null,
         parentId: null,
         childId: null,
         spawnMode: null,
@@ -41,10 +43,27 @@ function activateDelegation(receipt, event, options = {}) {
     }
     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) {
+    const actualModel = event.actualModel;
+    if (!actualModel || actualModel.trim() !== actualModel) {
+        return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+    }
+    if (actualModel !== receipt.requestedModel && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
         return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
     }
+    const actualReasoningEffort = event.actualReasoningEffort;
+    if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
+        return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
+    }
+    if (actualReasoningEffort !== receipt.requestedReasoningEffort
+        && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
+        return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+    }
+    if (actualModel === receipt.requestedModel && event.modelFallbackReason) {
+        return fail('DELEGATION_MODEL_FALLBACK_INVALID', 'model fallback reason is only valid when actual model differs');
+    }
+    if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
+        return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
+    }
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'activated',
@@ -52,7 +71,9 @@ function activateDelegation(receipt, event, options = {}) {
             childId: event.childId,
             spawnMode: event.spawnMode,
             actualModel,
+            actualReasoningEffort,
             modelFallbackReason: event.modelFallbackReason ?? null,
+            reasoningEffortFallbackReason: event.reasoningEffortFallbackReason ?? null,
             activatedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }