@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/helpers/bootstrap.js

@@ -1,3 +1,4 @@
+import { assertTestWriteAllowed } from "../store/test-write-boundary.js";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
@@ -9,6 +10,7 @@ import { resolveWorkspaceRoot } from "./workspace-root.js";
 function ensureDir(dirPath, result) {
     if (existsSync(dirPath))
         return;
+    assertTestWriteAllowed(dirPath);
     mkdirSync(dirPath, { recursive: true });
     result.created.push(dirPath);
 }
@@ -25,12 +27,14 @@ function copyTree(srcRoot, destRoot, result, force = false) {
             continue;
         }
         if (!existsSync(dest)) {
+            assertTestWriteAllowed(dest);
             mkdirSync(dirname(dest), { recursive: true });
             copyFileSync(src, dest);
             result.created.push(dest);
             continue;
         }
         if (force) {
+            assertTestWriteAllowed(dest);
             copyFileSync(src, dest);
             result.updated.push(dest);
         }
@@ -41,12 +45,14 @@ function copyTree(srcRoot, destRoot, result, force = false) {
 }
 function writeIfMissingOrForced(path, content, result, force = false) {
     if (!existsSync(path)) {
+        assertTestWriteAllowed(path);
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, content, "utf-8");
         result.created.push(path);
         return;
     }
     if (force) {
+        assertTestWriteAllowed(path);
         writeFileSync(path, content, "utf-8");
         result.updated.push(path);
     }
@@ -410,17 +416,6 @@ function buildWorkspaceStateSeedFiles(projectName, generatedAt) {
                 primary_cta: "",
             }, null, 2),
         },
-        {
-            path: wsPath("engineering-state", "BUILD_STATUS.md"),
-            content: [
-                "# BUILD_STATUS",
-                "",
-                "- Status: not started",
-                "- Active owner: ACE-Coders",
-                "- Blockers: none recorded",
-                `- Last update: ${generatedAt}`,
-            ].join("\n"),
-        },
         {
             path: wsPath("engineering-state", "SPEC_CONTRACT.json"),
             content: JSON.stringify({
@@ -447,20 +442,12 @@ function buildWorkspaceStateSeedFiles(projectName, generatedAt) {
                 "- TBD",
             ].join("\n"),
         },
-        {
-            path: wsPath("engineering-state", "TEST_LOG.md"),
-            content: [
-                "# TEST_LOG",
-                "",
-                `- ${generatedAt} bootstrap: no tests executed yet.`,
-            ].join("\n"),
-        },
         {
             path: wsPath("engineering-state", "src", "README.md"),
             content: [
                 "# Engineering Source",
                 "",
-                `Place the main implementation here. Keep test evidence in \`${ACE_ROOT_REL}/engineering-state/TEST_LOG.md\`.`,
+                "Place the main implementation here. Use the project’s existing tests and return their actual results with the work outcome.",
             ].join("\n"),
         },
     ];
@@ -595,6 +582,12 @@ export function bootstrapAceWorkspace(options = {}) {
     }
     copyTree(DEFAULTS_GITHUB_ROOT, acePath(".github"), result, force);
     copyTree(DEFAULTS_SCRIPTS_ROOT, acePath("scripts", "ace"), result, force);
+    const dispatcher = acePath("scripts", "ace", "ace-hook-dispatch.mjs");
+    if (result.created.includes(dispatcher) || result.updated.includes(dispatcher)) {
+        const moduleUrl = new URL("../ace-autonomy.js", import.meta.url).href;
+        assertTestWriteAllowed(dispatcher);
+        writeFileSync(dispatcher, readFileSync(dispatcher, "utf8").replace("__ACE_AUTONOMY_MODULE_URL__", moduleUrl));
+    }
     const masterPlanPath = wsPath("global-state", "MASTER_PLAN.md");
     writeIfMissingOrForced(masterPlanPath, [
         `# ${projectName} — Master Plan`,

package/dist/helpers/path-utils.js

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { isInside, normalizeRelPath } from "../shared.js";
 import { ACE_MANAGED_PREFIXES, ACE_PROJECTED_WORKSPACE_FILES, ACE_ROOT_REL, SWARM_AGENTS, } from "./constants.js";
 import { resolveWorkspaceRoot } from "./workspace-root.js";
+import { assertTestWriteAllowed } from "../store/test-write-boundary.js";
 export function currentWorkspaceRoot() {
     return resolveWorkspaceRoot();
 }
@@ -44,6 +45,7 @@ export function isSwarmRole(role) {
 }
 export function atomicWrite(filePath, content) {
     const abs = isAbsolute(filePath) ? filePath : resolveWorkspaceWritePath(filePath);
+    assertTestWriteAllowed(abs);
     mkdirSync(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.tmp`;
     writeFileSync(tmpPath, content, "utf-8");

package/dist/helpers/store-resolution.js

@@ -5,6 +5,7 @@ import { isInside, normalizeRelPath } from "../shared.js";
 import { getWorkspaceStorePath, listStoreKeysSync, parseVirtualStorePath, readStoreBlobSync, readVirtualStorePathSync, toVirtualStorePath, } from "../store/store-snapshot.js";
 import { isOperationalArtifactPath, operationalArtifactKey, writeOperationalArtifactQueued, writeStoreBlobQueued, writeStoreBlobSync, } from "../store/store-artifacts.js";
 import { withStoreWriteCoordinatorSync } from "../store/write-coordinator.js";
+import { assertTestWriteAllowed, captureTestWriteBoundary, withTestWriteBoundary } from "../store/test-write-boundary.js";
 import { ACE_ROOT_REL, ACE_SCRIPTS_ROOT_REL, ACE_SKILLS_ROOT_REL, ACE_TASKS_ROOT_REL, AGENT_FILES, AGENT_MANIFEST_FILES, DEFAULTS_ROOT, KERNEL_FILES, STORE_AGENT_FILES, STORE_KERNEL_FILES, STORE_TASK_FILES, TASK_FILES, } from "./constants.js";
 import { currentWorkspaceRoot, isProjectedAceWorkspacePath, mapAceWorkspaceRelativePath, resolveWorkspaceReadPath, resolveWorkspaceWritePath, } from "./path-utils.js";
 export function formatStorePath(key) {
@@ -24,9 +25,16 @@ export function listStoreSkillReferences() {
     const root = currentWorkspaceRoot();
     const names = new Set();
     for (const key of listStoreKeysSync(root, "knowledge/skills/")) {
-        const parts = key.split("/");
-        if (parts[2])
-            names.add(parts[2]);
+        if (!key.endsWith('/SKILL.md'))
+            continue;
+        const name = key.slice('knowledge/skills/'.length, -'/SKILL.md'.length);
+        if (name.startsWith('learned/')) {
+            const text = readStoreBlobSync(root, key) ?? '';
+            if (!/^status: active$/m.test(text))
+                continue;
+        }
+        if (name)
+            names.add(name);
     }
     return [...names]
         .sort((a, b) => a.localeCompare(b))
@@ -249,6 +257,7 @@ export function safeWrite(filePath, content) {
     const abs = isAbsolute(filePath) && isInside(root, filePath)
         ? filePath
         : resolveWorkspaceWritePath(filePath, root);
+    assertTestWriteAllowed(abs);
     mkdirSync(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
     writeFileSync(tmpPath, content, "utf-8");
@@ -277,15 +286,21 @@ export async function safeWriteAsync(filePath, content) {
     const abs = isAbsolute(filePath) && isInside(root, filePath)
         ? filePath
         : resolveWorkspaceWritePath(filePath, root);
+    const assertBoundary = captureTestWriteBoundary(abs);
     await mkdir(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
+    assertBoundary();
     await writeFile(tmpPath, content, "utf-8");
+    assertBoundary();
     await rename(tmpPath, abs);
     return abs;
 }
 const _fileLocks = new Map();
 export async function withFileLock(path, fn) {
     const key = resolveWorkspaceWritePath(path);
+    return withTestWriteBoundary(key, () => withFileLockInternal(key, fn));
+}
+async function withFileLockInternal(key, fn) {
     const prev = _fileLocks.get(key) ?? Promise.resolve();
     let releaseLock;
     const next = new Promise((r) => { releaseLock = r; });

package/dist/helpers/workspace-root.d.ts

@@ -1,3 +1,5 @@
+/** Bind an operation and its asynchronous descendants without changing process-wide environment. */
+export declare function withWorkspaceRoot<T>(root: string, fn: () => T): T;
 export declare function resolveWorkspaceRoot(): string;
 export declare const WORKSPACE_ROOT: string;
 //# sourceMappingURL=workspace-root.d.ts.map

package/dist/helpers/workspace-root.js

@@ -1,5 +1,11 @@
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+const workspaceScope = new AsyncLocalStorage();
+/** Bind an operation and its asynchronous descendants without changing process-wide environment. */
+export function withWorkspaceRoot(root, fn) {
+    return workspaceScope.run(normalizeWorkspaceRootLikePath(root), fn);
+}
 function normalizeWorkspaceRootCandidate(candidate) {
     const trimmed = candidate?.trim();
     if (!trimmed)
@@ -51,6 +57,9 @@ function pinWorkspaceRoot(root) {
     return normalized;
 }
 export function resolveWorkspaceRoot() {
+    const scoped = workspaceScope.getStore();
+    if (scoped)
+        return scoped;
     const explicit = normalizeWorkspaceRootCandidate(process.env.ACE_WORKSPACE_ROOT);
     if (explicit)
         return pinWorkspaceRoot(findNearestInitiatedWorkspaceRoot(explicit) ?? explicit);

package/dist/helpers.d.ts

@@ -2,6 +2,7 @@ import { resolveWorkspaceRoot } from "./helpers/workspace-root.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
 export * from "./helpers/constants.js";
 export { resolveWorkspaceRoot };
+export { withWorkspaceRoot } from "./helpers/workspace-root.js";
 export declare const WORKSPACE_ROOT: string;
 export * from "./helpers/path-utils.js";
 export * from "./helpers/store-resolution.js";

package/dist/helpers.js

@@ -2,6 +2,7 @@ import { resolveWorkspaceRoot } from "./helpers/workspace-root.js";
 export { isInside, isReadError, normalizeRelPath, looksLikeSwarmHandoffPath } from "./shared.js";
 export * from "./helpers/constants.js";
 export { resolveWorkspaceRoot };
+export { withWorkspaceRoot } from "./helpers/workspace-root.js";
 export const WORKSPACE_ROOT = resolveWorkspaceRoot();
 export * from "./helpers/path-utils.js";
 export * from "./helpers/store-resolution.js";

package/dist/hermes/bridge-protocol.d.ts

@@ -4,7 +4,6 @@ declare const bridgeEventSchema: z.ZodObject<{
     type: z.ZodEnum<{
         error: "error";
         status: "status";
-        tool_start: "tool_start";
         session_open: "session_open";
         turn_run: "turn_run";
         interrupt: "interrupt";
@@ -12,6 +11,7 @@ declare const bridgeEventSchema: z.ZodObject<{
         delta: "delta";
         reasoning: "reasoning";
         assistant_interim: "assistant_interim";
+        tool_start: "tool_start";
         tool_progress: "tool_progress";
         tool_complete: "tool_complete";
         final: "final";

package/dist/hermes/session-manager.d.ts

@@ -12,7 +12,14 @@ export interface HermesLocalTurnOptions {
     maxTurns: number;
     /** Probed context window for the model; falls back to a conservative default. */
     contextLength?: number;
+    /** Explicit total deadline only; omitted or 0 means unlimited. */
     timeoutMs?: number;
+    stallTimeoutMs?: number;
+    stallWarningMs?: number;
+    onStall?: (event: {
+        silence_ms: number;
+        last_progress_at: number;
+    }) => void;
 }
 export interface HermesLocalTurnResult {
     result: BridgeResult;
@@ -38,14 +45,24 @@ export interface HermesSubprocessExecutorOptions {
     command?: readonly string[];
     launchProfile?: HermesLaunchProfile;
     keepTemp?: boolean;
+    /** Explicit total deadline only; omitted or 0 means unlimited. */
     timeoutMs?: number;
+    stallTimeoutMs?: number;
+    stallWarningMs?: number;
+    onStall?: (event: {
+        silence_ms: number;
+        last_progress_at: number;
+    }) => void;
     maxOutputBytes?: number;
 }
 export declare class HermesSubprocessExecutor implements HermesLocalExecutor {
     private options;
     private readonly activeChildren;
+    private readonly interruptedChildren;
+    private readonly killTimers;
     constructor(options?: HermesSubprocessExecutorOptions);
     interrupt(): void;
+    private signalChildGroup;
     private interruptChild;
     runTurn(options: HermesLocalTurnOptions): Promise<HermesLocalTurnResult>;
 }

package/dist/hermes/session-manager.js

@@ -66,6 +66,8 @@ function hermesBaseUrl(provider, baseUrl) {
 export class HermesSubprocessExecutor {
     options;
     activeChildren = new Set();
+    interruptedChildren = new WeakSet();
+    killTimers = new WeakMap();
     constructor(options = {}) {
         this.options = options;
     }
@@ -73,18 +75,39 @@ export class HermesSubprocessExecutor {
         for (const child of this.activeChildren)
             this.interruptChild(child);
     }
+    signalChildGroup(child, signal) {
+        if (!child.pid)
+            return;
+        try {
+            if (process.platform === "win32")
+                child.kill(signal);
+            else
+                process.kill(-child.pid, signal);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw error;
+        }
+    }
     interruptChild(child) {
-        if (child.killed)
+        if (this.interruptedChildren.has(child))
             return;
-        child.kill("SIGTERM");
-        const killTimer = setTimeout(() => {
-            if (this.activeChildren.has(child) && child.exitCode === null && child.signalCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 1_000);
+        this.interruptedChildren.add(child);
+        this.signalChildGroup(child, "SIGTERM");
+        const killTimer = setTimeout(() => this.signalChildGroup(child, "SIGKILL"), 1_000);
         killTimer.unref();
+        this.killTimers.set(child, killTimer);
     }
     async runTurn(options) {
+        const timeoutMs = options.timeoutMs ?? this.options.timeoutMs;
+        const stallTimeoutMs = options.stallTimeoutMs ?? this.options.stallTimeoutMs ?? 60 * 60_000;
+        const stallWarningMs = options.stallWarningMs ?? this.options.stallWarningMs ?? Math.min(10 * 60_000, stallTimeoutMs);
+        for (const [name, value] of Object.entries({ timeoutMs, stallTimeoutMs, stallWarningMs })) {
+            if (value !== undefined && (!Number.isFinite(value) || value < 0))
+                throw new Error(`${name} must be finite and nonnegative; 0 disables the limit.`);
+        }
+        if (stallTimeoutMs > 0 && stallWarningMs > stallTimeoutMs)
+            throw new Error("The stall warning must not follow the final silence limit.");
         const sessionId = `hermes-${randomUUID()}`;
         const shadowId = `shadow-${randomUUID()}`;
         const hermesHome = mkdtempSync(resolve(tmpdir(), "ace-hermes-home-"));
@@ -147,6 +170,7 @@ export class HermesSubprocessExecutor {
                 ACE_WORKSPACE_ROOT: options.runtime.workspaceRoot,
             },
             stdio: ["pipe", "pipe", "pipe"],
+            detached: process.platform !== "win32",
         });
         this.activeChildren.add(child);
         const decoder = new HermesBridgeFrameDecoder();
@@ -159,6 +183,8 @@ export class HermesSubprocessExecutor {
         let finalCompleted;
         let finalCount = 0;
         let outputBytes = 0;
+        let lastProgressAt = Date.now();
+        let warned = false;
         let outputOverflow = false;
         const maxOutputBytes = this.options.maxOutputBytes ?? 4 * 1024 * 1024;
         // Single per-frame consumer so the live stream and the post-close tail-flush
@@ -183,6 +209,8 @@ export class HermesSubprocessExecutor {
             }
         };
         child.stdout.on("data", (chunk) => {
+            lastProgressAt = Date.now();
+            warned = false;
             outputBytes += chunk.byteLength;
             if (outputBytes > maxOutputBytes) {
                 outputOverflow = true;
@@ -194,6 +222,8 @@ export class HermesSubprocessExecutor {
             }
         });
         child.stderr.on("data", (chunk) => {
+            lastProgressAt = Date.now();
+            warned = false;
             outputBytes += chunk.byteLength;
             if (outputBytes > maxOutputBytes) {
                 outputOverflow = true;
@@ -215,18 +245,41 @@ export class HermesSubprocessExecutor {
             system_prompt: "You are running inside ACE Hermes-local mode. Use only the imported ACE MCP toolset for tool calls. Do not use plain text as executable authority.",
         };
         child.stdin.end(`${JSON.stringify(request)}\n`);
-        const timeoutMs = options.timeoutMs ?? this.options.timeoutMs ?? 120_000;
+        let stalled = false;
+        const silenceTimer = stallTimeoutMs > 0 ? setInterval(() => {
+            const silence = Date.now() - lastProgressAt;
+            if (!warned && stallWarningMs > 0 && silence >= stallWarningMs) {
+                warned = true;
+                try {
+                    (options.onStall ?? this.options.onStall)?.({ silence_ms: silence, last_progress_at: lastProgressAt });
+                }
+                catch { /* Warning callback cannot terminate useful work. */ }
+            }
+            if (silence >= stallTimeoutMs) {
+                stalled = true;
+                this.interruptChild(child);
+            }
+        }, Math.max(10, Math.min(1000, stallWarningMs || stallTimeoutMs, stallTimeoutMs))) : undefined;
+        silenceTimer?.unref();
         let timedOut = false;
-        const timeout = setTimeout(() => {
+        const timeout = timeoutMs && timeoutMs > 0 ? setTimeout(() => {
             timedOut = true;
             this.interruptChild(child);
-        }, timeoutMs);
-        timeout.unref();
+        }, timeoutMs) : undefined;
+        timeout?.unref();
         const exitCode = await new Promise((resolvePromise, reject) => {
             child.on("error", reject);
             child.on("close", resolvePromise);
         }).finally(() => {
-            clearTimeout(timeout);
+            if (timeout)
+                clearTimeout(timeout);
+            if (silenceTimer)
+                clearInterval(silenceTimer);
+            if (this.interruptedChildren.has(child))
+                this.signalChildGroup(child, "SIGKILL");
+            const killTimer = this.killTimers.get(child);
+            if (killTimer)
+                clearTimeout(killTimer);
             this.activeChildren.delete(child);
         });
         for (const frame of decoder.push(new Uint8Array(), true)) {
@@ -252,14 +305,14 @@ export class HermesSubprocessExecutor {
             (event.turn_id !== undefined && event.turn_id !== request.turn_id));
         const eventAfterFinal = finalIndex >= 0 && events.slice(finalIndex + 1).some((event) => event.type !== "session_close");
         const protocolInvalid = protocolIdentityInvalid || eventAfterFinal;
-        const status = sawError || malformed.length > 0 || exitCode !== 0 || timedOut || outputOverflow || finalCount !== 1 || protocolInvalid
+        const status = sawError || malformed.length > 0 || exitCode !== 0 || timedOut || stalled || outputOverflow || finalCount !== 1 || protocolInvalid
             ? "failed"
             : finalCompleted === false
                 ? "blocked"
                 : "completed";
         const summary = status === "failed"
             ? sawError ||
-                `Hermes bridge failed${timedOut ? "; reason_code=hermes_timeout" : ""}${outputOverflow ? "; reason_code=hermes_output_limit" : ""}${finalCount !== 1 ? `; terminal_frames=${finalCount}` : ""}${protocolIdentityInvalid ? "; reason_code=hermes_frame_identity" : ""}${eventAfterFinal ? "; reason_code=hermes_frame_after_final" : ""}${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
+                `Hermes bridge failed${timedOut ? "; reason_code=hermes_timeout" : ""}${stalled ? "; reason_code=hermes_stalled" : ""}${outputOverflow ? "; reason_code=hermes_output_limit" : ""}${finalCount !== 1 ? `; terminal_frames=${finalCount}` : ""}${protocolIdentityInvalid ? "; reason_code=hermes_frame_identity" : ""}${eventAfterFinal ? "; reason_code=hermes_frame_after_final" : ""}${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
             : status === "blocked"
                 ? finalText || "Hermes reported completed=false."
                 : finalText || "Hermes-local turn completed.";

package/dist/host-goal-engine.d.ts

@@ -0,0 +1,138 @@
+import { type GoalRecord } from './store/repositories/goal-repository.js';
+import { type GoalEngineDeps, type StartGoalOptions, type ResumeGoalOptions } from './goal-engine.js';
+import { type TaskPlan, type TaskStep } from './orchestrator-supervisor.js';
+import { type CurrentWorkItem } from './ace-autonomy.js';
+import type { HostWorkBinding } from './host-work-context.js';
+import { type LearnedPayload, type LearningAcceptance } from './learned-artifacts.js';
+import { type HostRequirementUpdate } from './host-plan-revision.js';
+export interface StepOutcome {
+    status: 'done' | 'blocked' | 'failed';
+    summary: string;
+    evidence?: Array<{
+        ref: string;
+        kind: 'command' | 'artifact' | 'diff' | 'note';
+        detail?: string;
+    }>;
+    artifacts?: string[];
+    follow_ups?: Array<{
+        task: string;
+        role?: string;
+        depends_on?: string[];
+    }>;
+    waiting_on?: string;
+    requirement_updates?: HostRequirementUpdate[];
+    learned?: LearnedPayload;
+    feedback?: Array<{
+        id: string;
+        helpful: boolean;
+    }>;
+}
+export interface Assignment {
+    goal_id: string;
+    step_id: string;
+    attempt: number;
+    assignee: string;
+    task_text: string;
+    role: string;
+    expected_artifacts: string[];
+    required_evidence_refs: string[];
+    verify_at_goal_end: string[];
+    open_blockers: CurrentWorkItem[];
+    now: string;
+    observation: string;
+    started_at?: string;
+    learning?: string;
+}
+export interface HostStepResult {
+    ok: boolean;
+    isError?: boolean;
+    reason_code?: string;
+    message?: string;
+    now: string;
+    options?: Array<{
+        tool: string;
+        args: Record<string, unknown>;
+        why: string;
+    }>;
+    waiting_on?: string[];
+    candidates?: unknown[];
+    assignment?: Assignment;
+    next_ready?: string[];
+    goal_id?: string;
+    step_id?: string;
+    status?: string;
+    summary?: string;
+    goal_status?: GoalRecord['status'];
+    verification?: 'pending';
+    view_repair_pending?: string[];
+    skipped_follow_ups?: string[];
+    learning?: LearningAcceptance;
+    reopened?: string[];
+    requirement_updates_pending?: HostRequirementUpdate[];
+}
+export declare function hostRefusal(root: string, reason: string, message: string, goalId?: string): HostStepResult;
+export declare function startHostGoal(objective: string, options: StartGoalOptions, deps?: GoalEngineDeps): Promise<{
+    ok: boolean;
+    goal: GoalRecord;
+    assignment: Assignment | undefined;
+    now: string;
+    view_repair_pending: string[];
+    isError?: boolean;
+    reason_code?: string;
+    message?: string;
+    options?: Array<{
+        tool: string;
+        args: Record<string, unknown>;
+        why: string;
+    }>;
+    waiting_on?: string[];
+    candidates?: unknown[];
+    next_ready?: string[];
+    goal_id?: string;
+    step_id?: string;
+    status?: string;
+    summary?: string;
+    goal_status?: GoalRecord["status"];
+    verification?: "pending";
+    skipped_follow_ups?: string[];
+    learning?: LearningAcceptance;
+    reopened?: string[];
+    requirement_updates_pending?: HostRequirementUpdate[];
+}>;
+export declare function beginStep(goalId: string, options: {
+    step_id?: string;
+    agent: string;
+    session_id?: string;
+}, deps?: GoalEngineDeps): Promise<HostStepResult>;
+export declare function applyHostResultToStep(step: TaskStep, outcome: StepOutcome): void;
+/** The caller holds the existing per-goal coordinator; never changes receipts. */
+export declare function recoverHostBudgetsLocked(goal: GoalRecord, plan: TaskPlan, options: ResumeGoalOptions, now: number): TaskPlan;
+export declare function completeStep(goalId: string, stepId: string, outcome: StepOutcome, options: {
+    agent: string;
+    attempt: number;
+    continue?: boolean;
+}, deps?: GoalEngineDeps): Promise<HostStepResult>;
+export declare function verificationSignature(plan: TaskPlan): string;
+export declare function finishHostVerification(goalId: string, snapshot: {
+    goal: GoalRecord;
+    planDigest: string;
+}, deps: GoalEngineDeps): Promise<void>;
+/** Explicit restart recovery reruns only the declared checks, never host work. */
+export declare function retryHostVerification(goalId: string, deps?: GoalEngineDeps): Promise<{
+    goal: GoalRecord;
+    plan: TaskPlan | undefined;
+}>;
+/** Attach only ACE's own result to the exact attempt active when its tool ran. */
+export declare function recordHostContact(binding?: HostWorkBinding): Promise<void>;
+export declare function recordHostToolEvidence(tool: string, result: unknown, binding?: HostWorkBinding): Promise<void>;
+/** Goal -> packed view is the sole lock order. No store callback acquires a goal lease. */
+export declare function withLinkedHandoff<T>(ref: {
+    goal_id: string;
+    step_id: string;
+}, input: {
+    id: string;
+    status: string;
+    actor: string;
+    to: string;
+}, writeView: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=host-goal-engine.d.ts.map