@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/host-goal-engine.js

@@ -0,0 +1,793 @@
+import { renderLearningTask } from './learning-input-context.js';
+import { readLearningPolicy } from './learning-policy.js';
+/** Attached MCP execution over the existing GoalRepository and TaskPlan owners. */
+import { createHash } from 'node:crypto';
+import { scheduleHostVerification, hostVerificationActive } from './host-verification-job.js';
+import { defaultGoalBudgets, newGoalId } from './store/repositories/goal-repository.js';
+import { resolveGoalDeps, checkSuccessContract, verificationCommandText } from './goal-engine.js';
+import { createTaskPlan, amendTaskPlan, deriveTaskPlanStatus } from './orchestrator-supervisor.js';
+import { collectUpstreamOutputs, formatStepTaskForBridge, getReadyTaskSteps, utf8Prefix } from './task-plan-context.js';
+import { resolveCurrentWork, formatCurrentWork } from './ace-autonomy.js';
+import { withStoreWriteCoordinator } from './store/write-coordinator.js';
+import { withWorkspaceRoot } from './helpers.js';
+import { syncLinkedTodoStepSafe } from './todo-state.js';
+import { selectLearning, scoreLearning } from './learning-serving.js';
+import { prepareLearned, reopenLearningCorrection } from './learned-artifacts.js';
+import { appendAttempt, harvestStep } from './host-learning.js';
+import { reviseHostRequirements } from './host-plan-revision.js';
+import { observationAdapter, observationSatisfied, pendingObservation, recoverableObservation, retainObservation, settleHostObservations, observationReadyForChecks } from './host-observation.js';
+export function hostRefusal(root, reason, message, goalId) {
+    if (reason === 'follow_up_budget_reached')
+        return { ok: false, isError: true, reason_code: reason, message, waiting_on: ['operator:replan_budget'], now: formatCurrentWork(resolveCurrentWork({ workspaceRoot: root, goal_id: goalId }), 'line') };
+    return { ok: false, isError: true, reason_code: reason, message,
+        now: formatCurrentWork(resolveCurrentWork({ workspaceRoot: root, goal_id: goalId }), 'line'),
+        options: [{ tool: 'next_step', args: goalId ? { goal_id: goalId } : {}, why: 'Receive eligible work or its current wait condition.' },
+            { tool: 'recall_context', args: goalId ? { goal_id: goalId } : {}, why: 'Recover current ownership, results and blockers.' }] };
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+function planValid(plan) {
+    const steps = new Map(plan.steps.map(s => [s.step_id, s]));
+    if (steps.size !== plan.steps.length)
+        return 'Step ids must be unique.';
+    const visited = new Set(), visiting = new Set();
+    const visit = (id) => {
+        if (visited.has(id))
+            return true;
+        const step = steps.get(id);
+        if (!step || visiting.has(id))
+            return false;
+        visiting.add(id);
+        if (!(step.depends_on ?? []).every(visit))
+            return false;
+        visiting.delete(id);
+        visited.add(id);
+        return true;
+    };
+    if (!plan.steps.every(s => s.task.trim() && visit(s.step_id)))
+        return 'Every task needs text and an acyclic dependency on existing step ids.';
+}
+function nowLine(root, goalId) { return formatCurrentWork(resolveCurrentWork({ workspaceRoot: root, goal_id: goalId }), 'line'); }
+function hasFinalChecks(goal) {
+    return goal.success_contract.verification_commands.length > 0 || goal.success_contract.expected_artifacts.some(a => a.required !== false) || goal.success_contract.required_evidence_refs.length > 0;
+}
+function clearImplicitDeadlineBlock(goal) {
+    if (goal.reason_code === 'host_budget_exhausted' && !goal.budgets.host_deadline_explicit) {
+        goal.reason_code = undefined;
+        if (goal.status === 'blocked')
+            goal.status = 'executing';
+    }
+}
+function planWork(root, goal, plan) {
+    return resolveCurrentWork({ workspaceRoot: root, goal_id: goal.goal_id, goal_snapshot: { goal, plan } });
+}
+function assignment(root, goal, plan, step) {
+    // Direct dependency summaries are bounded; the full results remain in this plan.
+    let remaining = 9000;
+    const outputs = collectUpstreamOutputs(plan, step);
+    const upstream = outputs.map((o, index) => {
+        // Share bytes across every direct dependency; early findings cannot consume
+        // the entire budget and erase the most recent prerequisite's summary.
+        const text = utf8Prefix(o.result_summary, Math.min(2000, Math.floor(remaining / (outputs.length - index))));
+        remaining -= Buffer.byteLength(text);
+        return { ...o, result_summary: text.length < o.result_summary.length ? `${text} [full result: ${goal.goal_id}/${o.step_id}]` : text, evidence_refs: o.evidence_refs.slice(0, 8) };
+    });
+    const work = planWork(root, goal, plan);
+    const blockers = [...work.blocked, ...work.waiting].map(item => {
+        const reason = item.reason && utf8Prefix(item.reason, 500);
+        return { ...item, ...(reason && reason !== item.reason ? { reason: `${reason} [full blocker: ${item.goal_id ?? goal.goal_id}/${item.id}]` } : {}) };
+    });
+    const failure = step.verification_failure;
+    const task = formatStepTaskForBridge({ ...step, task: renderLearningTask(root, goal.goal_id, step), upstream_outputs: upstream });
+    return { goal_id: goal.goal_id, step_id: step.step_id, attempt: step.attempt, assignee: step.assignee,
+        task_text: task + (failure ? `\nVerification failure (${failure.ref}; full output: ${goal.goal_id}/${step.step_id}):\n${utf8Prefix(failure.output, 2000)}` : ''), learning: readLearningPolicy(root).enabled ? step.served_learning?.text : undefined, role: step.role,
+        expected_artifacts: (step.expected_artifacts ?? []).map(a => a.path), required_evidence_refs: step.required_evidence_refs ?? [],
+        verify_at_goal_end: goal.success_contract.verification_commands.map(verificationCommandText), open_blockers: blockers,
+        now: formatCurrentWork(work, 'line'), observation: step.observation ?? 'unavailable', started_at: step.started_at };
+}
+/** Called only with a fresh plan while the per-goal lease is already held. */
+function beginStepLocked(root, goal, plan, options, now) {
+    clearImplicitDeadlineBlock(goal);
+    const fail = (reason, message) => hostRefusal(root, reason, message, goal.goal_id);
+    const named = options.step_id ? plan.steps.find(s => s.step_id === options.step_id) : undefined;
+    if (options.step_id && !named)
+        return fail('step_not_found', `Unknown step ${options.step_id}.`);
+    if (named?.status === 'failed') {
+        const result = fail('step_not_ready', `${named.step_id} failed: ${named.result_summary ?? ''}`);
+        result.options = [{ tool: 'resume_goal', args: { goal_id: goal.goal_id }, why: 'After correcting the reported issue, open a new attempt.' }];
+        return result;
+    }
+    if (named?.status === 'blocked' && named.waiting_on)
+        return { ok: true, goal_id: goal.goal_id, status: goal.status, waiting_on: [named.waiting_on], now: nowLine(root, goal.goal_id), message: named.blocked_reason ?? 'Waiting for the named dependency.' };
+    if (named && ['done', 'skipped', 'failed'].includes(named.status))
+        return fail('step_not_ready', `${named.step_id} is ${named.status}: ${named.result_summary ?? ''}`);
+    if (goal.stop_requested || ['stopped', 'failed', 'done', 'verifying'].includes(goal.status))
+        return { ok: true, goal_id: goal.goal_id, status: goal.status, next_ready: [], now: nowLine(root, goal.goal_id), message: goal.result_summary ?? goal.reason_code ?? (goal.status === 'verifying' ? 'Declared checks are pending. If their process was interrupted, resume_goal reruns those checks only.' : undefined), ...(goal.stop_requested || goal.status === 'stopped' ? { waiting_on: ['user:resume'] } : {}), ...(goal.status === 'verifying' ? { options: [{ tool: 'resume_goal', args: { goal_id: goal.goal_id }, why: 'Recover interrupted goal-end verification without rerunning host steps.' }] } : {}) };
+    if (goal.reason_code?.startsWith('follow-up budget reached'))
+        return fail('follow_up_budget_reached', goal.reason_code);
+    const ready = getReadyTaskSteps(plan);
+    const step = options.step_id ? plan.steps.find(s => s.step_id === options.step_id) : plan.steps.find(s => s.status === 'running' && s.assignee === options.agent) ?? ready[0];
+    if (!step && plan.steps.some(s => ['failed', 'blocked'].includes(s.status) && !s.waiting_on))
+        return { ok: true, goal_id: goal.goal_id, status: goal.status, now: nowLine(root, goal.goal_id), message: 'After correcting the reported issue, resume_goal opens a new attempt; it does not rerun accepted or running host work.', options: [{ tool: 'resume_goal', args: { goal_id: goal.goal_id }, why: 'Make corrected failed/blocked work eligible for a new host attempt.' }] };
+    if (!step)
+        return { ok: true, goal_id: goal.goal_id, status: goal.status, waiting_on: plan.steps.filter(s => !['done', 'skipped'].includes(s.status)).map(s => `${s.step_id}: ${s.waiting_on ?? s.blocked_reason ?? s.status}${s.assignee ? ` (${s.assignee})` : ''}`), now: nowLine(root, goal.goal_id), message: 'No ready step. Resume when its listed owner or dependency makes progress.' };
+    if (step.status === 'running' && step.assignee !== options.agent)
+        return fail('step_moved', `${step.step_id} is held by ${step.assignee}. Request a handoff or choose another ready step.`);
+    if (!(step.status === 'running' && step.assignee === options.agent) && !ready.some(s => s.step_id === step.step_id))
+        return fail('step_not_ready', `${step.step_id} is ${step.status}; dependencies: ${(step.depends_on ?? []).join(', ') || 'none'}. ${step.result_summary ?? ''}`);
+    if (step.status !== 'running') {
+        const started = Date.parse(goal.started_at ?? goal.created_at);
+        if (goal.budgets.host_deadline_explicit && now() - started >= goal.budgets.max_wall_clock_ms) {
+            goal.status = 'blocked';
+            goal.reason_code = 'host_budget_exhausted';
+            return { ok: true, goal_id: goal.goal_id, status: 'blocked', reason_code: goal.reason_code,
+                waiting_on: ['operator:budget'], message: 'The host assignment budget has expired. Existing outcomes are retained; new work requires an explicitly authorized budget or a new goal.',
+                now: formatCurrentWork(planWork(root, goal, plan), 'line') };
+        }
+        preserveAttempt(step);
+        step.status = 'running';
+        step.assignee = options.agent;
+        step.attempt = (step.attempt ?? 0) + 1;
+        step.started_at = new Date(now()).toISOString();
+        step.waiting_on = undefined;
+        step.blocked_reason = undefined;
+        step.result_digest = undefined;
+        step.result_response = undefined;
+        step.upstream_outputs = collectUpstreamOutputs(plan, step);
+        step.served_learning = selectLearning(root, plan, step);
+        step.loaded_learning = [];
+        step.observation = 'unavailable';
+        step.observation_window = { workspace_id: root, session_id: options.session_id, started_at: step.started_at };
+        goal.tick_count++;
+        goal.current_step_id = step.step_id;
+        goal.status = 'executing';
+    }
+    step.last_ace_call_at = new Date(now()).toISOString();
+    return { ok: true, assignment: assignment(root, goal, plan, step), now: nowLine(root, goal.goal_id) };
+}
+function preserveAttempt(step) {
+    if (step.attempt && (step.result_digest || step.evidence?.length) && !step.attempt_history?.some(old => old.attempt === step.attempt && old.result_digest === step.result_digest && step.result_digest)) {
+        step.attempt_history ??= [];
+        step.attempt_history.push({ attempt: step.attempt, assignee: step.assignee, status: step.result_response?.status ?? step.status, result_summary: step.result_summary, evidence: step.evidence, artifacts: step.artifacts, result_digest: step.result_digest, result_response: step.result_response });
+    }
+    step.evidence = [];
+    step.evidence_refs = [];
+    step.artifacts = [];
+    step.observation_refs = [];
+    step.observation_check = undefined;
+    step.observation_query = undefined;
+    step.observation_coverage = undefined;
+}
+async function syncViews(root, goal, plan) {
+    const pending = [];
+    for (const step of plan.steps.filter(s => s.todo_id)) {
+        try {
+            await withWorkspaceRoot(root, () => syncLinkedTodoStepSafe(step.todo_id, { goal_id: goal.goal_id, step_id: step.step_id }, step));
+        }
+        catch {
+            pending.push(`todo:${step.todo_id}`);
+        }
+    }
+    for (const step of plan.steps.filter(s => s.handoff_id && s.status === 'done')) {
+        try {
+            const { syncLinkedHandoffStepSafe } = await import('./handoff-registry.js');
+            await withWorkspaceRoot(root, () => syncLinkedHandoffStepSafe(step.handoff_id, step.result_summary ?? 'Step completed'));
+        }
+        catch {
+            pending.push(`handoff:${step.handoff_id}`);
+        }
+    }
+    return pending;
+}
+export async function startHostGoal(objective, options, deps = {}) {
+    const d = resolveGoalDeps(deps);
+    const id = options.goal_id ?? newGoalId();
+    const iso = new Date(d.now()).toISOString();
+    let plan = createTaskPlan({ task: objective, steps: (options.steps ?? []).map(s => ({ role: s.role ?? 'coders', task: s.task, depends_on: s.depends_on, expected_artifacts: s.expected_artifacts?.map(a => typeof a === 'string' ? { path: a, required: true } : { required: true, ...a }), required_evidence_refs: s.required_evidence_refs, required_observation: s.required_observation })) });
+    plan.steps.forEach((s, i) => { s.step_id = options.steps[i].id ?? `S${i + 1}`; s.todo_id = options.todo_ids?.[s.step_id]; });
+    const invalid = !objective.trim() ? 'Objective must not be empty.' : !plan.steps.length ? 'Host goals require at least one step.' : planValid(plan);
+    if (invalid)
+        throw new Error(invalid);
+    const goal = { goal_id: id, objective, executor: 'host', status: options.plan_only ? 'planning' : 'executing',
+        plan_id: plan.plan_id, created_at: iso, updated_at: iso, started_at: iso, tick_count: 0, replan_count: 0, stop_requested: false, escalations: [],
+        budgets: { ...defaultGoalBudgets(), ...(options.max_replans !== undefined ? { max_replans: options.max_replans, replan_budget_explicit: true } : {}), ...(options.budget_hours !== undefined ? { max_wall_clock_ms: options.budget_hours * 3600000, host_deadline_explicit: true, deadline_explicit: true } : {}) },
+        success_contract: { expected_artifacts: plan.steps.flatMap(s => (s.expected_artifacts ?? []).filter(a => !a.transient)), required_evidence_refs: [], verification_commands: options.verify_commands ?? [], gate_ids: [], uncompilable_criteria: [] } };
+    return withStoreWriteCoordinator(d.repo.planPath(id), async () => {
+        if (d.repo.getGoal(id))
+            throw new Error(`Goal already exists: ${id}`);
+        // Linked creation briefly serializes with its existing todo owner. Goals without
+        // linked todos never take the pack lease. Plan records settle duplicate links.
+        const publish = async () => {
+            for (const [stepId, todoId] of Object.entries(options.todo_ids ?? {})) {
+                if (!plan.steps.some(s => s.step_id === stepId))
+                    throw new Error(`Unknown linked step: ${stepId}`);
+                const { readStoreJsonSync } = await import('./store/store-snapshot.js');
+                const todo = readStoreJsonSync(d.workspaceRoot, `state/todo/${todoId}`);
+                if (!todo || todo.step_ref || d.repo.listGoals().some(g => d.repo.getPlan(g.goal_id)?.steps.some(s => s.todo_id === todoId)))
+                    throw new Error(`Todo missing or already linked: ${todoId}`);
+            }
+            d.repo.savePlan(id, plan);
+            d.repo.saveGoal(goal);
+        };
+        if (Object.keys(options.todo_ids ?? {}).length) {
+            const { getWorkspaceStorePath } = await import('./store/store-snapshot.js');
+            await withStoreWriteCoordinator(getWorkspaceStorePath(d.workspaceRoot), publish, { operation_label: 'host_link_creation' });
+        }
+        else
+            await publish();
+        const begun = options.plan_only ? undefined : beginStepLocked(d.workspaceRoot, goal, plan, { agent: options.agent ?? 'host', session_id: options.session_id }, d.now);
+        plan.status = deriveTaskPlanStatus(plan);
+        d.repo.savePlan(id, plan);
+        d.repo.saveGoal(goal);
+        const pending = await syncViews(d.workspaceRoot, goal, plan);
+        return { ...begun, ok: true, goal: d.repo.getGoal(id), assignment: begun?.assignment ? assignment(d.workspaceRoot, goal, plan, plan.steps.find(s => s.step_id === begun.assignment.step_id)) : undefined, now: nowLine(d.workspaceRoot, id), view_repair_pending: pending };
+    }, { operation_label: 'host_goal_start' });
+}
+export async function beginStep(goalId, options, deps = {}) {
+    const d = resolveGoalDeps(deps);
+    return withStoreWriteCoordinator(d.repo.planPath(goalId), async () => {
+        const goal = d.repo.getGoal(goalId), plan = d.repo.getPlan(goalId);
+        if (!goal || !plan || goal.executor !== 'host')
+            return hostRefusal(d.workspaceRoot, 'host_goal_required', 'Choose an existing host-executed goal.', goalId);
+        const previousReason = goal.reason_code;
+        const result = beginStepLocked(d.workspaceRoot, goal, plan, options, d.now);
+        if (result.reason_code === 'host_budget_exhausted' || previousReason !== goal.reason_code)
+            d.repo.saveGoal(goal);
+        if (result.assignment) {
+            plan.steps.find(s => s.step_id === result.assignment.step_id).last_ace_call_at = new Date(d.now()).toISOString();
+            plan.status = deriveTaskPlanStatus(plan);
+            d.repo.savePlan(goalId, plan);
+            d.repo.saveGoal(goal);
+            result.view_repair_pending = await syncViews(d.workspaceRoot, goal, plan);
+            result.assignment = assignment(d.workspaceRoot, goal, plan, plan.steps.find(s => s.step_id === result.assignment.step_id));
+            result.now = result.assignment.now;
+        }
+        return result;
+    }, { operation_label: 'host_next_step' });
+}
+export function applyHostResultToStep(step, outcome) {
+    step.status = outcome.status;
+    step.result_summary = outcome.summary;
+    step.evidence = [...(step.evidence ?? []).filter(e => e.provenance === 'ace'), ...(outcome.evidence ?? []).map(e => ({ ...e, provenance: 'host' }))];
+    step.evidence_refs = [...new Set(step.evidence.map(e => e.ref))];
+    step.artifacts = outcome.artifacts ?? [];
+    step.waiting_on = outcome.status === 'blocked' ? outcome.waiting_on : undefined;
+    step.blocked_reason = outcome.status === 'done' ? undefined : outcome.summary;
+}
+/** Allocate prospective IDs once, then remap duplicates before budget admission. */
+function prepareFollowUps(plan, additions, reserved = []) {
+    // Reserve retained pending IDs in the existing allocator, without admitting
+    // those obligations or persisting placeholder steps in the execution plan.
+    const allocationBase = { ...plan, steps: [...plan.steps, ...reserved.filter(s => !plan.steps.some(p => p.step_id === s.step_id)).map(s => ({ ...s, status: 'planned' }))] };
+    const proposed = amendTaskPlan(allocationBase, { append_steps: additions.map(s => ({ ...s, role: s.role ?? 'coders' })) });
+    const candidates = proposed.steps.slice(allocationBase.steps.length);
+    const aliases = new Map();
+    const retained = [];
+    const skipped = [];
+    for (const candidate of candidates) {
+        const duplicate = [...plan.steps, ...retained].find(s => ['planned', 'running', 'blocked'].includes(s.status) && s.task === candidate.task);
+        if (duplicate) {
+            aliases.set(candidate.step_id, duplicate.step_id);
+            skipped.push(candidate.task);
+        }
+        else
+            retained.push(candidate);
+    }
+    const normalized = retained.map(s => ({ ...s, depends_on: s.depends_on?.map(id => aliases.get(id) ?? id) }));
+    const full = { ...proposed, steps: [...plan.steps, ...normalized] };
+    const invalid = planValid(full);
+    if (invalid)
+        throw new Error(invalid);
+    return { full, candidates: normalized, skipped };
+}
+function addFollowUps(goal, plan, additions) {
+    const { candidates, skipped } = prepareFollowUps(plan, additions, goal.pending_follow_ups);
+    const admitted = admitFollowUpsLocked(goal, plan, candidates);
+    return { plan: admitted, skipped };
+}
+/** Shared admission path for new follow-ups and explicitly funded pending work. */
+function admitFollowUpsLocked(goal, plan, candidates) {
+    const invalid = planValid({ ...plan, steps: [...plan.steps, ...candidates] });
+    if (invalid)
+        throw new Error(invalid);
+    const byId = new Map(candidates.map(s => [s.step_id, s]));
+    const admitted = new Set();
+    const available = goal.budgets.replan_budget_explicit ? Math.max(0, goal.budgets.max_replans - goal.replan_count) : Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const closure = new Set();
+        const visit = (id) => {
+            if (admitted.has(id) || closure.has(id) || !byId.has(id))
+                return;
+            closure.add(id);
+            byId.get(id).depends_on?.forEach(visit);
+        };
+        visit(candidate.step_id);
+        if (admitted.size + closure.size <= available)
+            closure.forEach(id => admitted.add(id));
+    }
+    const pending = candidates.filter(s => !admitted.has(s.step_id));
+    if (pending.length) {
+        goal.pending_follow_ups = [...(goal.pending_follow_ups ?? []), ...pending.map(s => ({ step_id: s.step_id, task: s.task, role: s.role, depends_on: s.depends_on }))];
+        goal.status = 'blocked';
+        goal.reason_code = `follow-up budget reached: ${pending.map(s => s.task).join('; ')}`;
+    }
+    goal.replan_count += admitted.size;
+    return { ...plan, steps: [...plan.steps, ...candidates.filter(s => admitted.has(s.step_id))] };
+}
+/** The caller holds the existing per-goal coordinator; never changes receipts. */
+export function recoverHostBudgetsLocked(goal, plan, options, now) {
+    const hours = options.budget_hours, replans = options.max_replans;
+    const fundingPending = Boolean(goal.pending_follow_ups?.length);
+    if (hours !== undefined) {
+        if (!Number.isFinite(hours * 3600000) || hours <= 0)
+            throw new Error('budget_hours must be a finite positive allowance.');
+        if (!goal.budgets.host_deadline_explicit)
+            throw new Error('Cannot lower an unlimited host budget to a finite deadline through resume.');
+        if (hours * 3600000 < goal.budgets.max_wall_clock_ms)
+            throw new Error('Cannot lower budget_hours; resume accepts only equal or increased allowances.');
+    }
+    if (replans !== undefined && (!Number.isSafeInteger(replans) || replans < goal.budgets.max_replans))
+        throw new Error('Cannot lower max_replans; supply an equal or increased integer allowance.');
+    if (hours !== undefined)
+        goal.budgets.max_wall_clock_ms = hours * 3600000;
+    if (replans !== undefined) {
+        goal.budgets.max_replans = replans;
+        goal.budgets.replan_budget_explicit = true;
+    }
+    if (replans !== undefined && goal.pending_follow_ups?.length) {
+        const pending = goal.pending_follow_ups.map(s => ({ ...s, status: 'planned' }));
+        goal.pending_follow_ups = [];
+        plan = admitFollowUpsLocked(goal, plan, pending);
+    }
+    if (goal.reason_code?.startsWith('follow-up budget reached')) {
+        // A different pending requirement can share this legacy reason prefix.
+        // Funding follow-ups must never certify obligations it did not admit.
+        if (goal.pending_follow_ups?.length || replans === undefined || !fundingPending)
+            return plan;
+        goal.reason_code = undefined;
+    }
+    clearImplicitDeadlineBlock(goal);
+    if (goal.budgets.host_deadline_explicit && now - Date.parse(goal.started_at ?? goal.created_at) >= goal.budgets.max_wall_clock_ms) {
+        if (goal.status !== 'done') {
+            goal.status = 'blocked';
+            goal.reason_code = 'host_budget_exhausted';
+        }
+    }
+    else if (goal.reason_code === 'host_budget_exhausted')
+        goal.reason_code = undefined;
+    return plan;
+}
+export async function completeStep(goalId, stepId, outcome, options, deps = {}) {
+    if (!outcome.learned)
+        return completeStepInternal(goalId, stepId, outcome, options, deps);
+    if (!readLearningPolicy(resolveGoalDeps(deps).workspaceRoot).enabled)
+        return completeStepInternal(goalId, stepId, outcome, options, deps, { ok: false, ids: [], errors: ['Learning is disabled; the work outcome and proposed payload are retained, no artifact was activated.'], reason_code: 'learning_disabled' });
+    const d = resolveGoalDeps(deps);
+    return withStoreWriteCoordinator(`${d.repo.planPath(goalId)}.${createHash('sha256').update(stepId).digest('hex').slice(0, 12)}.${options.attempt}.learning`, async () => {
+        const step = d.repo.getPlan(goalId)?.steps.find(s => s.step_id === stepId);
+        if (!step || step.assignee !== options.agent || step.attempt !== options.attempt || step.result_digest || step.status !== 'running' || !outcome.summary.trim() || outcome.summary.length > 2000)
+            return completeStepInternal(goalId, stepId, outcome, options, deps);
+        const qualified = await prepareLearned(d.workspaceRoot, outcome.learned, { goal_id: goalId, step_id: stepId, attempt: options.attempt }, deps);
+        return completeStepInternal(goalId, stepId, outcome, options, deps, qualified.result, qualified.publish);
+    }, { operation_label: 'learning_qualification' });
+}
+async function completeStepInternal(goalId, stepId, outcome, options, deps = {}, learnedResult, publishLearning) {
+    const d = resolveGoalDeps(deps);
+    if (!outcome.summary.trim() || outcome.summary.length > 2000 || !['done', 'blocked', 'failed'].includes(outcome.status))
+        return hostRefusal(d.workspaceRoot, 'invalid_outcome', 'Supply a status and a summary of 1–2000 characters.', goalId);
+    const digest = createHash('sha256').update(canonical([stepId, options.attempt, outcome])).digest('hex');
+    let verification;
+    // Adapter reads are external and read-only; they never hold the goal's write lease.
+    const before = d.repo.getPlan(goalId)?.steps.find(s => s.step_id === stepId);
+    const window = before?.observation_window && { ...before.observation_window, ended_at: before.observation_window.ended_at ?? new Date(d.now()).toISOString() };
+    const adapter = observationAdapter(d.workspaceRoot, deps);
+    let observed = { status: 'unavailable', records: [] };
+    if (adapter && window && !before?.result_digest) {
+        try {
+            observed = await adapter.readWindow(window);
+        }
+        catch {
+            observed = { status: 'unavailable', records: [], reason_code: 'observation_query_failed' };
+        }
+    }
+    const response = await withStoreWriteCoordinator(d.repo.planPath(goalId), async () => {
+        const goal = d.repo.getGoal(goalId);
+        let plan = d.repo.getPlan(goalId);
+        const fail = (reason, message) => hostRefusal(d.workspaceRoot, reason, message, goalId);
+        if (!goal || !plan || goal.executor !== 'host')
+            return fail('host_goal_required', 'Choose an existing host-executed goal.');
+        let step = plan.steps.find(s => s.step_id === stepId);
+        if (!step)
+            return fail('step_not_found', `Unknown step ${stepId}.`);
+        if (step.assignee !== options.agent || step.attempt !== options.attempt)
+            return fail('step_moved', `${stepId} is held by ${step.assignee} at attempt ${step.attempt}. Forward partial findings through its handoff.`);
+        if (step.result_digest)
+            return step.result_digest === digest ? step.result_response : fail('already_completed', `This attempt already recorded: ${step.result_summary}`);
+        step.last_ace_call_at = new Date(d.now()).toISOString();
+        if (step.status !== 'running')
+            return fail('step_moved', `${stepId} is ${step.status}; wait for its owner or accept its handoff.`);
+        clearImplicitDeadlineBlock(goal);
+        try {
+            prepareFollowUps(plan, outcome.follow_ups ?? [], goal.pending_follow_ups);
+        }
+        catch (error) {
+            return fail('invalid_follow_up', error instanceof Error ? error.message : String(error));
+        }
+        if (outcome.requirement_updates?.length) {
+            try {
+                reviseHostRequirements(plan, outcome.requirement_updates);
+            }
+            catch (error) {
+                return fail('invalid_requirement_update', error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (publishLearning)
+            await publishLearning();
+        applyHostResultToStep(step, outcome);
+        retainObservation(step, observed);
+        step.observation_window = window;
+        if (outcome.status === 'done') {
+            const refs = step.evidence_refs ?? [];
+            const unmet = [...(step.expected_artifacts ?? []).filter(a => a.required !== false && !d.artifactExists(a.path, d.workspaceRoot)).map(a => a.path), ...(step.required_evidence_refs ?? []).filter(ref => !refs.includes(ref))];
+            const missingObservation = step.required_observation && !observationSatisfied(step, observed.records);
+            if (missingObservation && adapter?.supported_requirements && !adapter.supported_requirements.includes(step.required_observation)) {
+                const reason = `Observation requirement ${step.required_observation} is unsupported by this adapter: native file attribution does not prove an ACE attempt or a passed command.`;
+                step.observation_check = { attempt: step.attempt, status: 'unsupported', deadline_at: new Date(d.now()).toISOString(), wait_ms: 0, poll_ms: 250, reason_code: 'observation_requirement_unsupported' };
+                step.status = 'blocked';
+                step.waiting_on = 'operator:observation_capability';
+                step.blocked_reason = reason;
+            }
+            else if (missingObservation && adapter?.late_evidence && !unmet.length) {
+                const wait = Math.max(0, Math.min(120000, adapter.late_evidence.wait_ms));
+                step.observation_check = { attempt: step.attempt, status: 'pending', deadline_at: new Date(d.now() + wait).toISOString(), wait_ms: wait, poll_ms: Math.max(10, adapter.late_evidence.poll_ms ?? 250) };
+                step.status = 'blocked';
+                step.waiting_on = `observation:${step.step_id}`;
+                step.blocked_reason = 'Outcome recorded; waiting for required observation of this original attempt.';
+            }
+            else if (missingObservation)
+                unmet.push(`observed ${step.required_observation}: ${observed.status}`);
+            if (unmet.length) {
+                step.status = 'blocked';
+                step.blocked_reason = `Unmet declared requirements: ${unmet.join(', ')}. Supply the missing evidence, then resume_goal for another attempt.`;
+            }
+        }
+        step.learning_feedback = outcome.feedback;
+        if (outcome.learned) {
+            step.learning_payload = outcome.learned;
+            step.learning_result = learnedResult;
+        }
+        appendAttempt(step, goal, new Date(d.now()).toISOString());
+        const recordedStatus = step.status;
+        let reopened = [], pendingRequirements = [];
+        if (outcome.requirement_updates?.length) {
+            const count = new Set(outcome.requirement_updates.map(update => update.step_id)).size;
+            if (goal.budgets.replan_budget_explicit && goal.replan_count + count > goal.budgets.max_replans) {
+                goal.status = 'blocked';
+                goal.reason_code = `follow-up budget reached: requirement changes ${outcome.requirement_updates.map(u => u.step_id).join(', ')}`;
+                pendingRequirements = outcome.requirement_updates;
+            }
+            else {
+                const revised = reviseHostRequirements(plan, outcome.requirement_updates);
+                plan = revised.plan;
+                reopened = revised.reopened;
+                goal.replan_count += count;
+                goal.success_contract.expected_artifacts = plan.steps.flatMap(s => (s.expected_artifacts ?? []).filter(a => !a.transient));
+            }
+        }
+        const amended = addFollowUps(goal, plan, outcome.follow_ups ?? []);
+        plan = amended.plan;
+        step = plan.steps.find(s => s.step_id === stepId);
+        plan.status = deriveTaskPlanStatus(plan);
+        if (!goal.reason_code?.startsWith('follow-up budget reached')) {
+            const allDone = plan.steps.every(s => ['done', 'skipped'].includes(s.status));
+            if (allDone && goal.reason_code === 'host_budget_exhausted')
+                goal.reason_code = undefined;
+            goal.status = plan.steps.some(pendingObservation) ? 'verifying' : allDone ? (hasFinalChecks(goal) ? 'verifying' : 'done') : goal.reason_code === 'host_budget_exhausted' ? 'blocked' : getReadyTaskSteps(plan).length || plan.steps.some(s => s.status === 'running') ? 'executing' : 'blocked';
+            if (goal.status === 'verifying')
+                goal.verification_attempt = (goal.verification_attempt ?? 0) + 1;
+            if (goal.status === 'done') {
+                goal.verified = false;
+                goal.result_summary = 'done (not machine-verified)';
+            }
+        }
+        if (goal.stop_requested)
+            goal.status = 'stopped';
+        const begun = options.continue && goal.status === 'executing' ? beginStepLocked(d.workspaceRoot, goal, plan, { agent: options.agent }, d.now) : undefined;
+        plan.status = deriveTaskPlanStatus(plan);
+        const pending = plan.steps.flatMap(s => [s.todo_id ? `todo:${s.todo_id}` : '', s.handoff_id && s.status === 'done' ? `handoff:${s.handoff_id}` : ''].filter(Boolean));
+        const result = { ok: true, goal_id: goalId, step_id: stepId, status: recordedStatus, summary: outcome.summary,
+            goal_status: goal.status,
+            now: formatCurrentWork(planWork(d.workspaceRoot, goal, plan), 'line'), next_ready: getReadyTaskSteps(plan).map(s => s.step_id),
+            ...(begun?.assignment ? { assignment: assignment(d.workspaceRoot, goal, plan, plan.steps.find(s => s.step_id === begun.assignment.step_id)) } : {}),
+            ...(pending.length ? { view_repair_pending: [...new Set(pending)] } : {}), ...(amended.skipped.length ? { skipped_follow_ups: amended.skipped } : {}),
+            ...(goal.status === 'verifying' ? { verification: 'pending' } : {}) };
+        if (learnedResult)
+            result.learning = learnedResult;
+        if (reopened.length)
+            result.reopened = reopened;
+        if (pendingRequirements.length)
+            result.requirement_updates_pending = pendingRequirements;
+        if (goal.status === 'blocked')
+            result.message = goal.reason_code ?? step.blocked_reason;
+        if (goal.status === 'verifying') {
+            result.message = 'Step outcome accepted. Goal verification is pending in this immutable receipt; read compact status to confirm completion or receive the corrective next action.';
+            result.options = [{ tool: 'get_goal_status', args: { goal_id: goalId, view: 'compact', agent: options.agent }, why: 'Confirm final acceptance and receive the next action without loading full execution history.' }];
+        }
+        if (goal.stop_requested) {
+            result.waiting_on = ['user:resume'];
+            result.message = 'Stopped at the user request. Resume only when requested.';
+        }
+        else if (goal.reason_code?.startsWith('follow-up budget reached'))
+            result.waiting_on = ['operator:replan_budget'];
+        else if (goal.reason_code === 'host_budget_exhausted')
+            result.waiting_on = ['operator:budget'];
+        else if (['failed', 'blocked'].includes(recordedStatus)) {
+            if (step.waiting_on)
+                result.waiting_on = [step.waiting_on];
+            else if (!result.assignment)
+                result.options = [{ tool: 'resume_goal', args: { goal_id: goalId }, why: 'After correcting the reported issue, open a new attempt without rerunning accepted or running work.' }];
+        }
+        // Commit the outcome, successor and replay response together BEFORE touching views.
+        // A crash during a view write leaves a usable receipt, never an unfinishable attempt.
+        const receipt = reopened.includes(stepId) ? step.attempt_history.at(-1) : step;
+        receipt.result_digest = digest;
+        receipt.result_response = result;
+        // A completion that itself revises its dependencies remains replayable for
+        // this attempt. Older receipts of other reopened steps stay history only.
+        if (receipt !== step) {
+            step.assignee = options.agent;
+            step.result_digest = digest;
+            step.result_response = result;
+        }
+        d.repo.savePlan(goalId, plan);
+        d.repo.saveGoal(goal);
+        const failedViews = await syncViews(d.workspaceRoot, goal, plan);
+        if (failedViews.length)
+            result.view_repair_pending = failedViews;
+        else
+            delete result.view_repair_pending;
+        const accepted = JSON.parse(JSON.stringify(result));
+        receipt.result_response = accepted;
+        if (receipt !== step)
+            step.result_response = accepted;
+        d.repo.savePlan(goalId, plan);
+        if (goal.status === 'verifying')
+            verification = { goal, planDigest: verificationSignature(plan) };
+        return accepted;
+    }, { operation_label: 'host_complete_step' });
+    if (response.ok && readLearningPolicy(d.workspaceRoot).enabled) {
+        const goal = d.repo.getGoal(goalId), step = d.repo.getPlan(goalId)?.steps.find(s => s.step_id === stepId);
+        if (goal && step && !pendingObservation(step)) {
+            await scoreLearning(d.workspaceRoot, goal, step, outcome);
+            await harvestStep(d.workspaceRoot, goal, step);
+            const { advanceLearning } = await import('./learning-controls.js');
+            await advanceLearning(d.workspaceRoot);
+        }
+    }
+    if (response.ok && learnedResult && !learnedResult.ok && goalId === 'G-learning' && readLearningPolicy(d.workspaceRoot).enabled)
+        await reopenLearningCorrection(d.workspaceRoot, learnedResult.errors);
+    if (verification)
+        await scheduleHostVerification(goalId, verification, deps);
+    return response;
+}
+export function verificationSignature(plan) {
+    return canonical(plan.steps.map(s => [s.step_id, s.status, s.attempt, s.task, s.depends_on, s.expected_artifacts, s.required_evidence_refs]));
+}
+export async function finishHostVerification(goalId, snapshot, deps) {
+    const d = resolveGoalDeps(deps);
+    if (d.repo.getPlan(goalId)?.steps.some(pendingObservation)) {
+        if (!await settleHostObservations(goalId, snapshot.goal.verification_attempt, deps))
+            return;
+        const continued = await withStoreWriteCoordinator(d.repo.planPath(goalId), async () => {
+            const current = d.repo.getGoal(goalId), plan = d.repo.getPlan(goalId);
+            if (!current || !plan || current.stop_requested || current.status !== 'verifying' || current.verification_attempt !== snapshot.goal.verification_attempt)
+                return false;
+            if (!observationReadyForChecks(plan)) {
+                current.status = 'executing';
+                current.reason_code = undefined;
+                if (current.verification_run)
+                    current.verification_run.status = 'done';
+                d.repo.saveGoal(current);
+                await syncViews(d.workspaceRoot, current, plan);
+                return false;
+            }
+            snapshot = { goal: current, planDigest: verificationSignature(plan) };
+            return true;
+        }, { operation_label: 'host_observation_continue' });
+        if (!continued)
+            return;
+    }
+    const commands = [];
+    const check = await checkSuccessContract({ ...d, runVerification: async (command, root, options) => {
+            let result;
+            try {
+                result = await d.runVerification(command, root, options);
+            }
+            catch (error) {
+                result = { ok: false, output: error instanceof Error ? error.message : String(error) };
+            }
+            commands.push({ command, ok: result.ok, output: result.output.slice(-12000) });
+            return result;
+        } }, snapshot.goal);
+    if (check.uncheckable && !snapshot.goal.success_contract.verification_commands.length)
+        check.ok = true;
+    await withStoreWriteCoordinator(d.repo.planPath(goalId), async () => {
+        const goal = d.repo.getGoal(goalId);
+        let plan = d.repo.getPlan(goalId);
+        if (!goal || !plan || goal.verification_attempt !== snapshot.goal.verification_attempt)
+            return;
+        if (goal.verification_run)
+            goal.verification_run.status = check.ok ? 'done' : 'failed';
+        if (goal.stop_requested) {
+            goal.status = 'stopped';
+            d.repo.saveGoal(goal);
+            return;
+        }
+        if (goal.status !== 'verifying')
+            return;
+        if (canonical(snapshot.goal.success_contract) !== canonical(goal.success_contract) || snapshot.planDigest !== verificationSignature(plan) || !plan.steps.every(s => ['done', 'skipped'].includes(s.status))) {
+            goal.status = 'executing';
+            d.repo.saveGoal(goal);
+            return;
+        }
+        goal.verification_results = commands;
+        goal.final_contract_check = { ok: check.ok, missing_artifacts: check.missing_artifacts, missing_evidence_refs: check.missing_evidence_refs, failed_commands: check.failed_commands };
+        if (check.ok) {
+            goal.status = 'done';
+            goal.verified = goal.success_contract.verification_commands.length > 0;
+            goal.result_summary = goal.verified ? 'done (machine-verified)' : 'done (not machine-verified)';
+        }
+        else {
+            const signature = canonical({ commands: check.failure_signatures, artifacts: check.missing_artifacts, evidence: check.missing_evidence_refs });
+            const previous = goal.failure_repetition;
+            goal.failure_repetition = { signature, count: previous?.signature === signature ? previous.count + 1 : 1 };
+            if (goal.failure_repetition.count >= 3) {
+                goal.status = 'blocked';
+                goal.reason_code = 'repeated_failure';
+                goal.result_summary = 'The same final acceptance failure repeated three times without progress. Inspect the retained failure before resuming.';
+                d.repo.saveGoal(goal);
+                return;
+            }
+            const additions = [...check.failed_commands.map(cmd => ({ task: `Make \`${cmd}\` pass` })), ...check.missing_artifacts.map(path => ({ task: `Produce missing artifact ${path}` })), ...check.missing_evidence_refs.map(ref => ({ task: `Produce missing evidence ${ref}` }))];
+            const oldIds = new Set(plan.steps.map(s => s.step_id));
+            plan = addFollowUps(goal, plan, additions).plan;
+            for (const follow of plan.steps.filter(s => !oldIds.has(s.step_id))) {
+                const command = commands.find(c => !c.ok && follow.task === `Make \`${c.command}\` pass`);
+                if (command) {
+                    follow.result_summary = command.output;
+                    follow.evidence_refs = [`goal:${goalId}:verification:${command.command}`];
+                    follow.verification_failure = { command: command.command, output: command.output, ref: follow.evidence_refs[0] };
+                    const status = follow.status;
+                    follow.status = 'failed';
+                    follow.attempt = 0;
+                    appendAttempt(follow, goal, new Date(d.now()).toISOString(), [{ command: command.command, cwd: d.workspaceRoot, ok: false }]);
+                    follow.status = status;
+                }
+            }
+            if (!goal.reason_code?.startsWith('follow-up budget reached'))
+                goal.status = 'executing';
+        }
+        plan.status = deriveTaskPlanStatus(plan);
+        d.repo.savePlan(goalId, plan);
+        d.repo.saveGoal(goal);
+    }, { operation_label: 'host_verify_result' });
+}
+/** Explicit restart recovery reruns only the declared checks, never host work. */
+export async function retryHostVerification(goalId, deps = {}) {
+    const d = resolveGoalDeps(deps);
+    if (hostVerificationActive(d.workspaceRoot, goalId))
+        return { goal: d.repo.getGoal(goalId), plan: d.repo.getPlan(goalId) };
+    const snapshot = await withStoreWriteCoordinator(d.repo.planPath(goalId), async () => {
+        const goal = d.repo.getGoal(goalId), plan = d.repo.getPlan(goalId);
+        if (!goal || !plan || goal.executor !== 'host' || goal.status === 'done' || goal.pending_follow_ups?.length || goal.reason_code?.startsWith('follow-up budget reached') || (!plan.steps.every(s => ['done', 'skipped'].includes(s.status)) && !plan.steps.some(recoverableObservation)))
+            return;
+        const adapter = observationAdapter(d.workspaceRoot, deps);
+        for (const step of plan.steps.filter(recoverableObservation)) {
+            if (adapter?.supported_requirements && !adapter.supported_requirements.includes(step.required_observation))
+                return;
+            const check = step.observation_check;
+            check.status = 'pending';
+            check.deadline_at = new Date(d.now() + check.wait_ms).toISOString();
+            step.waiting_on = `observation:${step.step_id}`;
+            step.blocked_reason = 'Retrying evidence collection only; the original edit attempt is retained.';
+        }
+        goal.stop_requested = false;
+        goal.status = 'verifying';
+        goal.verification_attempt = (goal.verification_attempt ?? 0) + 1;
+        d.repo.saveGoal(goal);
+        goal.reason_code = undefined;
+        d.repo.savePlan(goalId, plan);
+        d.repo.saveGoal(goal);
+        return { goal, planDigest: verificationSignature(plan) };
+    }, { operation_label: 'host_retry_verification' });
+    if (snapshot)
+        await scheduleHostVerification(goalId, snapshot, deps);
+    return { goal: d.repo.getGoal(goalId), plan: d.repo.getPlan(goalId) };
+}
+/** Attach only ACE's own result to the exact attempt active when its tool ran. */
+export async function recordHostContact(binding) {
+    if (!binding?.goal_id || !binding.step_id)
+        return;
+    const d = resolveGoalDeps();
+    await withStoreWriteCoordinator(d.repo.planPath(binding.goal_id), async () => {
+        const plan = d.repo.getPlan(binding.goal_id);
+        const step = plan?.steps.find(s => s.step_id === binding.step_id);
+        if (!plan || !step || step.status !== 'running' || step.assignee !== binding.agent || step.attempt !== binding.attempt)
+            return;
+        step.last_ace_call_at = new Date(d.now()).toISOString();
+        d.repo.savePlan(binding.goal_id, plan);
+    }, { operation_label: 'host_assignee_contact' });
+}
+export async function recordHostToolEvidence(tool, result, binding) {
+    if (!binding?.goal_id || !binding.step_id)
+        return;
+    const d = resolveGoalDeps();
+    await withStoreWriteCoordinator(d.repo.planPath(binding.goal_id), async () => {
+        const plan = d.repo.getPlan(binding.goal_id);
+        const step = plan?.steps.find(s => s.step_id === binding.step_id);
+        if (!plan || !step || step.status !== 'running' || step.attempt !== binding.attempt || step.assignee !== binding.agent)
+            return;
+        step.last_ace_call_at = new Date(d.now()).toISOString();
+        const data = result;
+        const detail = JSON.stringify(data.structuredContent ?? data.content ?? result);
+        step.evidence ??= [];
+        step.evidence.push({ ref: `ace:${tool}:${createHash('sha256').update(detail).digest('hex')}`, kind: ['run_tests', 'execute_gates'].includes(tool) ? 'command' : 'diff', provenance: 'ace', detail: detail.slice(-12000), ok: data.structuredContent?.ok ?? (data.isError ? false : undefined) });
+        step.evidence_refs = [...new Set(step.evidence.map(e => e.ref))];
+        d.repo.savePlan(binding.goal_id, plan);
+    }, { operation_label: 'host_ace_tool_result' });
+}
+/** Goal -> packed view is the sole lock order. No store callback acquires a goal lease. */
+export async function withLinkedHandoff(ref, input, writeView) {
+    const d = resolveGoalDeps();
+    return withStoreWriteCoordinator(d.repo.planPath(ref.goal_id), async () => {
+        const goal = d.repo.getGoal(ref.goal_id), plan = d.repo.getPlan(ref.goal_id);
+        const step = plan?.steps.find(s => s.step_id === ref.step_id);
+        if (!goal || goal.executor !== 'host' || !plan || !step)
+            throw new Error('Linked host step missing');
+        if (input.status === 'open' && !(step.handoff_id === input.id && step.waiting_on === `handoff:${input.id}`) && (step.status !== 'running' || step.assignee !== input.actor))
+            throw new Error(`Step is held by ${step.assignee}; cannot hand off another participant's work.`);
+        if (input.status !== 'open' && step.handoff_id !== input.id)
+            throw new Error('Handoff no longer owns this step');
+        if (['done', 'skipped'].includes(step.status))
+            throw new Error('Completed steps cannot be transferred');
+        const result = await writeView();
+        if (result.ok === false)
+            return result;
+        step.handoff_id = input.id;
+        if (input.status === 'accepted') {
+            if (step.assignee !== input.to || step.status !== 'running') {
+                preserveAttempt(step);
+                step.assignee = input.to;
+                step.attempt = (step.attempt ?? 0) + 1;
+                step.status = 'running';
+                step.started_at = new Date(d.now()).toISOString();
+                step.result_digest = undefined;
+                step.result_response = undefined;
+                step.evidence = [];
+                step.evidence_refs = [];
+                step.observation = 'unavailable';
+                step.served_learning = selectLearning(d.workspaceRoot, plan, step);
+                step.loaded_learning = [];
+                step.observation_window = { workspace_id: d.workspaceRoot, started_at: step.started_at };
+            }
+            step.waiting_on = undefined;
+            step.blocked_reason = undefined;
+        }
+        else {
+            step.status = 'blocked';
+            step.waiting_on = `handoff:${input.id}`;
+        }
+        plan.status = deriveTaskPlanStatus(plan);
+        goal.status = input.status === 'accepted' ? 'executing' : 'blocked';
+        d.repo.savePlan(ref.goal_id, plan);
+        d.repo.saveGoal(goal);
+        await syncViews(d.workspaceRoot, goal, plan);
+        return result;
+    }, { operation_label: 'host_handoff_transfer' });
+}
+//# sourceMappingURL=host-goal-engine.js.map