@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/task/control-authority.js

@@ -1,24 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { isAgentClientId } from '../agent-clients/types.js';
 import { sandboxControlPaths } from '../sandbox/workspace-view.js';
-import { getAgentClientAdapter } from '../agent-clients/registry.js';
-import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle } from './lifecycle.js';
-import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { verifyTaskEvent } from './verification.js';
 import { releaseStaleShortIdRegistry } from './short-id.js';
-export function taskControlOperationKey(operation) {
-    if (operation.family === 'task-finalization')
-        return 'complete';
-    if (operation.family === 'task-lifecycle')
-        return operation.request.intent;
-    return operation.intent === 'route'
-        ? operation.input && operation.input.completed === true ? 'route.clean-completion' : 'route.read'
-        : operation.intent;
-}
 function invalidContext(message) {
     throw new Error(`TASK_CONTROL_CONTEXT_INVALID: ${message}`);
 }
@@ -85,20 +73,6 @@ export function assertTaskControlExecutionContext(context) {
 function boundTaskRef(context, taskRef) {
     return context.source === 'sandbox-executor' ? context.taskId : taskRef;
 }
-function autoTaskOptions(context, options) {
-    if (context.source === 'sandbox-executor')
-        return { ...options, taskId: context.taskId };
-    const resolved = resolveTaskContext(undefined, { repoRoot: context.repoRoot });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return { ...options, taskId: resolved.taskId };
-}
-function domainOptions(context, options) {
-    return {
-        ...options,
-        repoRoot: context.repoRoot
-    };
-}
 function lifecycleTaskId(request, repoRoot) {
     if (request.intent === 'restore')
         return TASK_ID_RE.test(request.taskRef) ? request.taskRef : null;
@@ -114,19 +88,6 @@ async function applyLifecycleWithAuthority(context, request) {
     const taskId = lifecycleTaskId(request, context.repoRoot);
     const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
     const execute = async () => {
-        if (request.intent === 'recover-started') {
-            const adapter = isAgentClientId(request.agent)
-                ? getAgentClientAdapter(request.agent).orchestrationAdapter
-                : undefined;
-            if (!adapter?.recoverStarted) {
-                return {
-                    status: 'no-op', changed: false, targetState: 'active',
-                    requestRef: request.taskRef, intent: 'recover-started', taskId: null,
-                    receiptId: null, childId: null, error: null
-                };
-            }
-            return adapter.recoverStarted(request, { repoRoot: context.repoRoot });
-        }
         return applyTaskLifecycle(request, {
             repoRoot: context.repoRoot,
             ...(controlRoot ? { controlRoot } : {}),
@@ -147,62 +108,6 @@ function controlRootForTask(context, taskId) {
         identity: { mode: 'task-bound', taskId }
     }).root;
 }
-function orchestration(context, operation) {
-    const taskRef = boundTaskRef(context, operation.taskRef);
-    const input = operation.input;
-    const options = domainOptions(context, operation.options);
-    switch (operation.intent) {
-        case 'begin-or-resume':
-            return beginOrResumeOrchestration(taskRef, {
-                ...options,
-                client: input.client,
-                maxSteps: input.maxSteps,
-                modelPolicy: input.modelPolicy
-            });
-        case 'route': return routeOrchestration(taskRef, options);
-        case 'status': return statusOrchestration(taskRef, options);
-        case 'prepare': return prepareTaskOrchestration(context, { ...operation, taskRef }, options);
-        case 'dispatch': return dispatchOrchestrationDelegation(taskRef, options);
-        case 'await-activation':
-            return awaitOrchestrationDelegationActivation(taskRef, input.event, options);
-        case 'recover-prepared': return recoverPreparedOrchestrationDelegation(taskRef, options);
-        case 'hook-start':
-            return input.auto === true
-                ? activateMatchingOrchestrationDelegation(input.client, input.event, autoTaskOptions(context, options))
-                : activateOrchestrationDelegation(taskRef, input.event, options);
-        case 'hook-stop':
-            return input.auto === true
-                ? sealMatchingOrchestrationDelegation(input.client, input.event, autoTaskOptions(context, options))
-                : sealOrchestrationDelegation(taskRef, input.event, undefined, options);
-        case 'advance': return advanceOrchestration(taskRef, options);
-        case 'pause':
-            return pauseOrchestration(taskRef, input.code, input.message, input.recoverable, options);
-    }
-}
-function prepareTaskOrchestration(context, operation, options) {
-    const input = operation.input;
-    const prepareInput = {
-        client: input.client,
-        requestedModel: input.requestedModel,
-        requestedReasoningEffort: input.requestedReasoningEffort,
-    };
-    const prepareDelegation = getAgentClientAdapter(prepareInput.client).orchestrationAdapter?.prepareDelegation;
-    return prepareDelegation
-        ? prepareDelegation(operation.taskRef, prepareInput, {
-            repoRoot: context.repoRoot,
-            orchestrationOptions: options,
-        })
-        : prepareOrchestrationDelegation(operation.taskRef, prepareInput, options);
-}
-function orchestrationFailure(error) {
-    if (error instanceof OrchestrationStateError) {
-        return {
-            status: 'failed', changed: false, taskId: error.taskId, run: null, next: null,
-            error: { code: error.code, message: error.message }
-        };
-    }
-    throw error;
-}
 export function dispatchTaskControlOperation(context, operation) {
     assertTaskControlExecutionContext(context);
     assertTaskControlOperation(operation);
@@ -253,13 +158,7 @@ export function dispatchTaskControlOperation(context, operation) {
             }
         });
     }
-    try {
-        const result = orchestration(context, operation);
-        return result instanceof Promise ? result.catch(orchestrationFailure) : result;
-    }
-    catch (error) {
-        return orchestrationFailure(error);
-    }
+    throw new Error('TASK_CONTROL_OPERATION_INVALID: unsupported operation family');
 }
 export function assertTaskControlOperation(operation) {
     if (operation.family === 'task-lifecycle') {
@@ -274,31 +173,20 @@ export function assertTaskControlOperation(operation) {
         }
         return;
     }
-    if (!operation.taskRef || !operation.intent || !operation.input || typeof operation.input !== 'object' || Array.isArray(operation.input)) {
-        throw new Error('TASK_CONTROL_OPERATION_INVALID: orchestration operation is invalid');
-    }
 }
 function operationInvalid(message) {
     throw new Error(`TASK_CONTROL_OPERATION_INVALID: ${message}`);
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--auto', '--dry-run'
+    '--dry-run'
 ]);
 const FINALIZATION_FLAGS = new Set(['--agent']);
-const ORCHESTRATION_FLAGS = new Set([
-    '--agent', '--max-steps', '--executor-model', '--executor-reasoning-effort', '--reviewer-model',
-    '--reviewer-reasoning-effort', '--client', '--requested-model', '--requested-reasoning-effort',
-    '--parent-id', '--before-fingerprint', '--stage', '--round', '--artifact', '--role',
-    '--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'
-]);
 function parseValues(args, start, flags) {
     const values = {};
     for (let index = start; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--dry-run' || flag === '--auto') {
+        if (flag === '--dry-run') {
             if (!flags.has(flag))
                 operationInvalid(`unknown option '${flag}'`);
             if (values[flag] !== undefined)
@@ -321,11 +209,6 @@ function value(values, flag) {
     const current = values[flag];
     return typeof current === 'string' ? current : undefined;
 }
-function required(values, flags) {
-    const missing = flags.find((flag) => value(values, flag) === undefined);
-    if (missing)
-        operationInvalid(`option '${missing}' is required`);
-}
 export function parseTaskControlOperation(family, args) {
     if (family === 'task-finalization') {
         if (args.length !== 4 || args[1] !== 'complete' || args[2] !== '--agent' || !args[0] || !args[3]) {
@@ -341,140 +224,24 @@ export function parseTaskControlOperation(family, args) {
         operationInvalid('task ref and intent are required');
     const taskRef = args[0];
     const intent = args[1];
-    if (family === 'task-lifecycle') {
-        if (intent === 'complete')
-            operationInvalid('complete must use task-finalization');
-        const values = parseValues(args, 2, LIFECYCLE_FLAGS);
-        const agent = normalizeAgentToken(value(values, '--agent') ?? '');
-        if (!agent)
-            operationInvalid('lifecycle agent is invalid');
-        const input = {
-            taskRef,
-            intent,
-            agent,
-            ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
-            ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
-            ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
-            ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
-            ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
-            ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
-            ...(values['--auto'] === true ? { auto: true } : {}),
-            ...(values['--dry-run'] === true ? { dryRun: true } : {})
-        };
-        if (intent === 'recover-started') {
-            const recoveryFlags = new Set(['--agent', '--auto']);
-            for (const flag of Object.keys(values)) {
-                if (!recoveryFlags.has(flag))
-                    operationInvalid(`option '${flag}' is not supported for recover-started`);
-            }
-            if (values['--auto'] !== true)
-                operationInvalid('--auto is required for recover-started');
-            return { family, request: input };
-        }
-        else if (values['--auto'] !== undefined) {
-            operationInvalid('--auto is only supported for recover-started');
-        }
-        return { family, request: input };
-    }
-    const values = parseValues(args, 2, ORCHESTRATION_FLAGS);
-    const orchestrationIntents = new Set([
-        'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
-    ]);
-    if (!orchestrationIntents.has(intent)) {
-        operationInvalid(`unknown orchestration intent '${intent}'`);
-    }
-    const client = value(values, '--client');
-    if (client !== undefined && !isAgentClientId(client))
-        operationInvalid(`unknown client '${client}'`);
-    const parsedIntent = intent;
-    const input = {};
-    if (parsedIntent === 'begin-or-resume' || parsedIntent === 'prepare') {
-        required(values, ['--client']);
-        if (!client || !isAgentClientId(client))
-            operationInvalid(`unknown client '${client ?? ''}'`);
-        input.client = client;
-    }
-    if (parsedIntent === 'begin-or-resume') {
-        const maxSteps = value(values, '--max-steps');
-        if (maxSteps !== undefined) {
-            const parsed = Number(maxSteps);
-            if (!Number.isInteger(parsed) || parsed < 1)
-                operationInvalid('--max-steps must be a positive integer');
-            input.maxSteps = parsed;
-        }
-        const policyFlags = ['--executor-model', '--executor-reasoning-effort', '--reviewer-model', '--reviewer-reasoning-effort'];
-        const hasPolicy = policyFlags.some((flag) => value(values, flag) !== undefined);
-        if (hasPolicy && policyFlags.some((flag) => value(values, flag) === undefined)) {
-            operationInvalid('explicit model policy requires executor/reviewer model and reasoning effort');
-        }
-        if (hasPolicy) {
-            input.modelPolicy = {
-                executor: { model: value(values, '--executor-model'), reasoningEffort: value(values, '--executor-reasoning-effort') },
-                reviewer: { model: value(values, '--reviewer-model'), reasoningEffort: value(values, '--reviewer-reasoning-effort') }
-            };
-        }
-    }
-    if (parsedIntent === 'prepare') {
-        input.requestedModel = value(values, '--requested-model');
-        input.requestedReasoningEffort = value(values, '--requested-reasoning-effort');
-    }
-    if (parsedIntent === 'await-activation') {
-        required(values, ['--stage', '--round', '--artifact', '--role']);
-        const round = Number(value(values, '--round'));
-        if (!Number.isSafeInteger(round) || round < 1)
-            operationInvalid('--round must be a positive integer');
-        const role = value(values, '--role');
-        if (role !== 'executor' && role !== 'reviewer')
-            operationInvalid('--role must be executor or reviewer');
-        input.event = { stage: value(values, '--stage'), round, artifact: value(values, '--artifact'), role };
-    }
-    if (parsedIntent === 'hook-start') {
-        required(values, ['--native-agent', '--child-id', '--parent-id']);
-        if (taskRef === 'auto')
-            required(values, ['--client']);
-        input.auto = taskRef === 'auto';
-        input.client = value(values, '--client');
-        input.event = {
-            nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), parentId: value(values, '--parent-id'),
-            spawnMode: value(values, '--spawn-mode'), actualModel: value(values, '--actual-model'),
-            actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-            reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-        };
-    }
-    if (parsedIntent === 'hook-stop') {
-        input.auto = taskRef === 'auto';
-        if (input.auto) {
-            required(values, ['--client', '--native-agent', '--child-id']);
-            input.client = value(values, '--client');
-            input.event = {
-                nativeAgent: value(values, '--native-agent'), childId: value(values, '--child-id'), actualModel: value(values, '--actual-model'),
-                actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-                reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-            };
-        }
-        else {
-            required(values, ['--child-id', '--exit-code', '--after-fingerprint']);
-            const exitCode = Number(value(values, '--exit-code'));
-            if (!Number.isInteger(exitCode))
-                operationInvalid('--exit-code must be an integer');
-            input.event = {
-                childId: value(values, '--child-id'), exitCode, afterFingerprint: value(values, '--after-fingerprint'),
-                changedPaths: value(values, '--changed-paths')?.split(',').filter(Boolean) ?? [], actualModel: value(values, '--actual-model'),
-                actualReasoningEffort: value(values, '--actual-reasoning-effort'), modelFallbackReason: value(values, '--model-fallback-reason'),
-                reasoningEffortFallbackReason: value(values, '--reasoning-effort-fallback-reason')
-            };
-        }
-    }
-    if (parsedIntent === 'pause') {
-        required(values, ['--code', '--message', '--recoverable']);
-        const recoverable = value(values, '--recoverable');
-        if (recoverable !== 'true' && recoverable !== 'false')
-            operationInvalid('--recoverable must be true or false');
-        input.code = value(values, '--code');
-        input.message = value(values, '--message');
-        input.recoverable = recoverable === 'true';
-    }
-    return { family, taskRef, intent: parsedIntent, input };
+    if (intent === 'complete')
+        operationInvalid('complete must use task-finalization');
+    const values = parseValues(args, 2, LIFECYCLE_FLAGS);
+    const agent = normalizeAgentToken(value(values, '--agent') ?? '');
+    if (!agent)
+        operationInvalid('lifecycle agent is invalid');
+    const request = {
+        taskRef,
+        intent,
+        agent,
+        ...(value(values, '--reason') ? { reason: value(values, '--reason') } : {}),
+        ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
+        ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
+        ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
+        ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
+        ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
+        ...(values['--dry-run'] === true ? { dryRun: true } : {})
+    };
+    return { family, request: request };
 }
 //# sourceMappingURL=control-authority.js.map

package/dist/lib/task/control-recovery.js

@@ -16,7 +16,7 @@ export function parseControlOutput(output) {
 export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
-const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
+const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore'];
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS = Object.freeze([
     ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle', intent, class: 'lifecycle-mutation' })),
     { family: 'task-create', intent: 'create', class: 'task-create' }
@@ -33,13 +33,11 @@ function bindingMatchesResult(binding, result) {
         && (result.taskId === undefined || result.taskId === binding.taskId)
         && (result.intentDigest === undefined || result.intentDigest === binding.intentDigest);
 }
-function domainEvidenceMatches(operation, result, domain) {
+function domainEvidenceMatches(domain) {
     if (!domain)
         return false;
     if (domain.consistent !== true)
         return false;
-    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started')
-        return false;
     return true;
 }
 export function classifySandboxControlRecovery(input) {
@@ -71,7 +69,7 @@ export function classifySandboxControlRecovery(input) {
     if (result.changed === null) {
         return { outcome: 'unknown', responseReconstructable: false, reasonCode: 'RECOVERY_RESULT_CHANGE_FLAG_MISSING' };
     }
-    if (!domainEvidenceMatches(input.operation, result, input.domain)) {
+    if (!domainEvidenceMatches(input.domain)) {
         if (input.journal?.exists && (input.journal.completedSteps?.length ?? 0) > 0) {
             return { outcome: 'in-progress', responseReconstructable: false, reasonCode: 'RECOVERY_DOMAIN_EVIDENCE_INCOMPLETE' };
         }

package/dist/lib/task/create.js

@@ -8,6 +8,7 @@ import { readDeliveryDefaults, validateBaseRef, validateRemote } from './deliver
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.js';
 import { enumerateAllTaskDirs } from './resolve-ref.js';
+import { serializeLifecycleExecution } from './lifecycle-execution.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { AGENT_TOKEN_VALUES } from '../agent-clients/tokens.js';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
@@ -23,7 +24,6 @@ function payloadError(message) {
 }
 function exactKeys(value, expected, label, optional = []) {
     const actual = Object.keys(value).sort();
-    const wanted = [...expected].sort();
     const allowed = new Set([...expected, ...optional]);
     if (actual.some((key) => !allowed.has(key))) {
         payloadError(`${label} has unknown or missing fields`);
@@ -134,9 +134,6 @@ function taskIdFor(date) {
     const pad = (value) => String(value).padStart(2, '0');
     return `TASK-${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
 }
-function yamlString(value) {
-    return JSON.stringify(value);
-}
 function markdownBlock(value) {
     return value.split(/\r?\n/).map((line) => /^(?:#{1,6}\s|```)/.test(line) ? `\\${line}` : line).join('\n');
 }
@@ -237,6 +234,7 @@ function renderTask(params) {
         'target_date:',
         'current_step: requirement-analysis',
         `assigned_to: ${candidate.agent}`,
+        `lifecycle_execution: ${JSON.stringify(serializeLifecycleExecution([]))}`,
         `pr_delivery_fact: ${JSON.stringify(encodePrDeliveryFact(buildUnboundFact()))}`,
         `delivery_remote: ${candidate.deliveryRemote ?? params.delivery.remote}`,
         `delivery_base_ref: ${candidate.deliveryBaseRef ?? params.delivery.baseRef}`,

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

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { isDecisionItem, listDecisionItems, selectDecisionItem } from './decision-items.js';
 import { createImplementationInput, finalizeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs, selectDeclaredImplementationInput } from './implementation-inputs.js';
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument } from './ledger.js';
@@ -77,7 +77,7 @@ function applyHumanDecision(request, options = {}) {
             const replay = existingDecision(content, direct[0], request.decision.trim(), request.needsImplementation);
             if ('conflict' in replay)
                 return failed('DECISION_CONFLICT', replay.conflict, resolved.taskId, direct[0].id);
-            return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0].id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null };
+            return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0].id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null, warnings: activityWarnings(content) };
         }
         catch (error) {
             return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, direct[0].id);
@@ -126,8 +126,6 @@ function applyHumanDecision(request, options = {}) {
     const decision = request.decision.trim();
     const record = `### ${recordId}\n\n- **原账本 ID**：${row.id}\n- **裁决时间**：${metadata.timestamp}\n- **裁决结果**：${decision}`;
     const activity = locateActivityLog(content);
-    if (!activity)
-        return failed('DECISION_ACTIVITY_MISSING', 'activity log section is missing or ambiguous', resolved.taskId, row.id);
     const mutations = [
         {
             kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS,
@@ -155,10 +153,11 @@ function applyHumanDecision(request, options = {}) {
             body: renderImplementationInputs(nextInputs)
         });
     }
-    mutations.push({
-        kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
-        body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
-    });
+    if (activity)
+        mutations.push({
+            kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
+            body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
+        });
     try {
         const parsedRework = parseReworkIntentDocument(content);
         if (!parsedRework.ok)
@@ -177,7 +176,7 @@ function applyHumanDecision(request, options = {}) {
     });
     if (writeResult.status === 'failed')
         return failed(writeResult.error.code, writeResult.error.message, writeResult.taskId, row.id);
-    return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null };
+    return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null, warnings: activityWarnings(content) };
 }
 export { applyHumanDecision };
 //# sourceMappingURL=decision-intents.js.map

package/dist/lib/task/delivery-target.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
 const REMOTE_RE = /^(?!-)(?!.*\.\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._/-]+$/;
 const REF_RE = /^(?!-)(?!.*\.\.)(?!.*(?:^|\/)\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
 function validateRemote(value) {
@@ -55,43 +54,5 @@ function resolveDeliveryTarget(repoRoot, existing = {}, explicit = {}) {
         return defaults;
     return bindDeliveryTarget({ defaults: defaults.value, existing, explicit });
 }
-function gitText(repoRoot, args) {
-    return execFileSync('git', [...args], {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe']
-    }).trim();
-}
-function resolveTargetHead(repoRoot, target) {
-    try {
-        const output = gitText(repoRoot, ['ls-remote', '--refs', target.remote, `refs/heads/${target.baseRef}`]);
-        const head = output.split(/\s+/)[0] ?? '';
-        if (!/^[a-f0-9]{40}$/i.test(head)) {
-            return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: `Delivery target ${target.remote}/${target.baseRef} is unavailable` };
-        }
-        try {
-            gitText(repoRoot, ['cat-file', '-e', `${head}^{commit}`]);
-        }
-        catch {
-            return { ok: false, code: 'DELIVERY_TARGET_OBJECT_MISSING', message: `Delivery target commit ${head} is not available locally` };
-        }
-        return { ok: true, value: target, head };
-    }
-    catch (error) {
-        return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
-    }
-}
-function resolveDiffBase(repoRoot, reviewedHead, targetHead) {
-    try {
-        const diffBase = gitText(repoRoot, ['merge-base', reviewedHead, targetHead]);
-        if (!/^[a-f0-9]{40}$/i.test(diffBase)) {
-            return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: 'Git returned an invalid diff base' };
-        }
-        return { ok: true, diffBase };
-    }
-    catch (error) {
-        return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
-    }
-}
-export { bindDeliveryTarget, readDeliveryDefaults, resolveDeliveryTarget, resolveTargetHead, resolveDiffBase, validateBaseRef, validateRemote };
+export { bindDeliveryTarget, readDeliveryDefaults, resolveDeliveryTarget, validateBaseRef, validateRemote };
 //# sourceMappingURL=delivery-target.js.map