@voybio/ace-swarm 2.4.0 → 2.4.2

package/dist/helpers/constants.js

@@ -53,6 +53,7 @@ export const ALL_LLM_PROVIDERS = [
     "gemini",
     "copilot",
 ];
+export const ALL_EXECUTION_ENGINES = ["direct", "hermes_local"];
 export const ALL_AGENTS = [
     "orchestrator",
     "vos",
@@ -71,6 +72,7 @@ export const ALL_AGENTS = [
     "observability",
     "eval",
     "release",
+    "planner",
 ];
 export const SWARM_AGENTS = ["orchestrator", "vos", "ui", "coders"];
 export const COMPOSABLE_AGENTS = [
@@ -87,6 +89,7 @@ export const COMPOSABLE_AGENTS = [
     "observability",
     "eval",
     "release",
+    "planner",
 ];
 export const SWARM_SUBAGENT_MAP = {
     orchestrator: COMPOSABLE_AGENTS,
@@ -145,6 +148,7 @@ export const AGENT_FILES = {
     ],
     eval: [".agents/ACE/agent-eval/instructions.md", ".agents/ACE/agent-eval/AGENTS.md"],
     release: [".agents/ACE/agent-release/instructions.md", ".agents/ACE/agent-release/AGENTS.md"],
+    planner: [".agents/ACE/agent-planner/instructions.md", ".agents/ACE/agent-planner/AGENTS.md"],
 };
 export const AGENT_MANIFEST_FILES = {
     orchestrator: [
@@ -167,6 +171,7 @@ export const AGENT_MANIFEST_FILES = {
     observability: [".agents/ACE/agent-observability/AGENTS.md"],
     eval: [".agents/ACE/agent-eval/AGENTS.md"],
     release: [".agents/ACE/agent-release/AGENTS.md"],
+    planner: [".agents/ACE/agent-planner/AGENTS.md"],
 };
 export const TASK_FILES = {
     todo: [`${ACE_TASKS_ROOT_REL}/todo.md`],
@@ -208,6 +213,7 @@ export const DEFAULT_AGENT_INSTRUCTION_FILES = {
     observability: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-observability", "instructions.md"),
     eval: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-eval", "instructions.md"),
     release: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-release", "instructions.md"),
+    planner: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-planner", "instructions.md"),
 };
 export const DEFAULT_AGENT_MANIFEST_FILES = {
     orchestrator: resolve(DEFAULTS_ROOT, ".agents", "ACE", "orchestrator", "AGENTS.md"),
@@ -227,6 +233,7 @@ export const DEFAULT_AGENT_MANIFEST_FILES = {
     observability: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-observability", "AGENTS.md"),
     eval: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-eval", "AGENTS.md"),
     release: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-release", "AGENTS.md"),
+    planner: resolve(DEFAULTS_ROOT, ".agents", "ACE", "agent-planner", "AGENTS.md"),
 };
 export const DEFAULT_TASK_FILES = {
     todo: resolve(DEFAULTS_TASKS_ROOT, "todo.md"),
@@ -269,6 +276,7 @@ export const STORE_AGENT_FILES = {
     },
     eval: { agent: "eval", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
     release: { agent: "release", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
+    planner: { agent: "planner", instructions: ["instructions.md", "AGENTS.md"], manifests: ["AGENTS.md"] },
 };
 export const STORE_TASK_FILES = {
     todo: "knowledge/tasks/todo.md",

package/dist/helpers/path-utils.d.ts

@@ -8,7 +8,14 @@ export declare function normalizePathForValidation(path: string): string;
 export declare function isSwarmRole(role: string): role is (typeof SWARM_AGENTS)[number];
 export declare function atomicWrite(filePath: string, content: string): string;
 export declare function fileExists(filePath: string): boolean;
-export declare function resolveWorkspaceWritePath(filePath: string): string;
+export interface WorkspacePathError extends Error {
+    reason_code: "path_escape" | "missing_workspace_path";
+    payload: {
+        reason_code: "path_escape" | "missing_workspace_path";
+        message: string;
+    };
+}
+export declare function resolveWorkspaceWritePath(filePath: string, workspaceRoot?: string): string;
 export declare function resolveWorkspaceReadPath(filePath: string): string;
 export declare function resolveWorkspaceArtifactPath(filePath: string, mode?: "read" | "write"): string;
 export declare function toAbsoluteWorkspaceCandidates(candidates: string[]): string[];

package/dist/helpers/path-utils.js

@@ -54,18 +54,37 @@ export function fileExists(filePath) {
     const abs = isAbsolute(filePath) ? filePath : resolveWorkspaceReadPath(filePath);
     return existsSync(abs);
 }
-export function resolveWorkspaceWritePath(filePath) {
-    const root = currentWorkspaceRoot();
+function workspacePathError(reasonCode, message) {
+    const error = new Error(message);
+    error.reason_code = reasonCode;
+    error.payload = {
+        reason_code: reasonCode,
+        message,
+    };
+    return error;
+}
+function looksLikeWindowsAbsolutePath(filePath) {
+    return /^[a-zA-Z]:[\\/]/.test(filePath) || /^\\\\/.test(filePath);
+}
+export function resolveWorkspaceWritePath(filePath, workspaceRoot = currentWorkspaceRoot()) {
+    const root = resolve(workspaceRoot);
     if (dirname(root) === root) {
         throw new Error("Workspace root resolved to filesystem root. Set ACE_WORKSPACE_ROOT or run ACE from the target workspace.");
     }
-    const abs = isAbsolute(filePath)
-        ? filePath
-        : resolve(root, mapAceWorkspaceRelativePath(filePath));
-    if (!isInside(root, abs)) {
-        throw new Error(`Path escapes workspace root: ${filePath}`);
+    const trimmed = filePath.trim();
+    if (!trimmed) {
+        throw workspacePathError("path_escape", "Workspace write path is empty.");
     }
-    return abs;
+    if (trimmed.startsWith("~") || isAbsolute(trimmed) || looksLikeWindowsAbsolutePath(trimmed)) {
+        throw workspacePathError("path_escape", `Workspace write path must be relative to workspace root: ${filePath}`);
+    }
+    const normalizedPath = mapAceWorkspaceRelativePath(normalizeRelPath(trimmed));
+    const target = resolve(root, normalizedPath);
+    const rel = relative(root, target);
+    if (rel.startsWith("..") || isAbsolute(rel) || !isInside(root, target)) {
+        throw workspacePathError("path_escape", `Path escapes workspace root: ${filePath}`);
+    }
+    return target;
 }
 export function resolveWorkspaceReadPath(filePath) {
     const root = currentWorkspaceRoot();

package/dist/helpers/store-resolution.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import { mkdir, rename, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { dirname, isAbsolute } from "node:path";
 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";
@@ -234,7 +234,9 @@ export function safeWrite(filePath, content) {
             return storeVirtualPath;
         }
     }
-    const abs = resolveWorkspaceWritePath(filePath);
+    const abs = isAbsolute(filePath) && isInside(root, filePath)
+        ? filePath
+        : resolveWorkspaceWritePath(filePath, root);
     mkdirSync(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
     writeFileSync(tmpPath, content, "utf-8");
@@ -271,7 +273,9 @@ export async function safeWriteAsync(filePath, content) {
             return storeVirtualPath;
         }
     }
-    const abs = resolveWorkspaceWritePath(filePath);
+    const abs = isAbsolute(filePath) && isInside(root, filePath)
+        ? filePath
+        : resolveWorkspaceWritePath(filePath, root);
     await mkdir(dirname(abs), { recursive: true });
     const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
     await writeFile(tmpPath, content, "utf-8");

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const HERMES_BRIDGE_PROTOCOL_VERSION = "1.0.0";
+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";
+        session_close: "session_close";
+        delta: "delta";
+        reasoning: "reasoning";
+        assistant_interim: "assistant_interim";
+        tool_progress: "tool_progress";
+        tool_complete: "tool_complete";
+        final: "final";
+    }>;
+    session_id: z.ZodOptional<z.ZodString>;
+    turn_id: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type HermesBridgeEvent = z.infer<typeof bridgeEventSchema>;
+export interface DecodedHermesBridgeFrame {
+    ok: true;
+    event: HermesBridgeEvent;
+}
+export interface RejectedHermesBridgeFrame {
+    ok: false;
+    reason: string;
+    raw: string;
+}
+export type HermesBridgeFrame = DecodedHermesBridgeFrame | RejectedHermesBridgeFrame;
+export declare class HermesBridgeFrameDecoder {
+    private decoder;
+    private buffer;
+    push(chunk: Uint8Array, end?: boolean): HermesBridgeFrame[];
+}
+export declare function decodeHermesBridgeLine(line: string): HermesBridgeFrame;
+export {};
+//# sourceMappingURL=bridge-protocol.d.ts.map

package/dist/hermes/bridge-protocol.js

@@ -0,0 +1,70 @@
+import { TextDecoder } from "node:util";
+import { z } from "zod";
+export const HERMES_BRIDGE_PROTOCOL_VERSION = "1.0.0";
+const bridgeEventBaseSchema = z.object({
+    type: z.enum([
+        "session_open",
+        "turn_run",
+        "interrupt",
+        "session_close",
+        "status",
+        "delta",
+        "reasoning",
+        "assistant_interim",
+        "tool_start",
+        "tool_progress",
+        "tool_complete",
+        "final",
+        "error",
+    ]),
+    session_id: z.string().optional(),
+    turn_id: z.string().optional(),
+    sequence: z.number().int().nonnegative().optional(),
+});
+const bridgeEventSchema = bridgeEventBaseSchema.passthrough();
+function sanitizeBridgeLine(line) {
+    if (line.includes("\u0000"))
+        return undefined;
+    const stripped = line.replace(/[\u0001-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+    const trimmed = stripped.trim();
+    return trimmed ? trimmed : undefined;
+}
+export class HermesBridgeFrameDecoder {
+    decoder = new TextDecoder("utf-8", { fatal: false });
+    buffer = "";
+    push(chunk, end = false) {
+        this.buffer += this.decoder.decode(chunk, { stream: !end });
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = end ? "" : (lines.pop() ?? "");
+        const frames = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            frames.push(decodeHermesBridgeLine(line));
+        }
+        if (end && this.buffer.trim()) {
+            frames.push(decodeHermesBridgeLine(this.buffer));
+            this.buffer = "";
+        }
+        return frames;
+    }
+}
+export function decodeHermesBridgeLine(line) {
+    const sanitized = sanitizeBridgeLine(line);
+    if (!sanitized) {
+        return { ok: false, reason: "bridge_frame_control_bytes", raw: line };
+    }
+    try {
+        const parsed = JSON.parse(sanitized);
+        const event = bridgeEventSchema.parse(parsed);
+        return { ok: true, event };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof Error ? error.message : "bridge_frame_invalid_json",
+            raw: sanitized,
+        };
+    }
+}
+//# sourceMappingURL=bridge-protocol.js.map

package/dist/hermes/launch-profile.d.ts

@@ -0,0 +1,19 @@
+export interface HermesLaunchProfile {
+    enabled: boolean;
+    mode: "ephemeral_subprocess" | "external_command";
+    hermes_root?: string;
+    command: readonly string[];
+    worker_path: string;
+    source: "cli" | "env" | "store" | "default";
+    diagnostics: string[];
+}
+export interface ResolveHermesLaunchProfileInput {
+    workspaceRoot: string;
+    cliHermesRoot?: string;
+    cliHermesPython?: string;
+    cliHermesUvProject?: string;
+    cliHermesCommandJson?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function resolveHermesLaunchProfile(input: ResolveHermesLaunchProfileInput): HermesLaunchProfile;
+//# sourceMappingURL=launch-profile.d.ts.map

package/dist/hermes/launch-profile.js

@@ -0,0 +1,81 @@
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readStoreJsonSync } from "../store/store-snapshot.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DIST_ROOT = resolve(__dirname, "..");
+const PACKAGE_ROOT = resolve(DIST_ROOT, "..");
+function parseCommandJson(raw, source) {
+    if (!raw?.trim())
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${source} must be a JSON array of command tokens.`);
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some((item) => typeof item !== "string" || !item.trim())) {
+        throw new Error(`${source} must be a non-empty JSON array of non-empty strings.`);
+    }
+    return parsed.map((item) => item.trim());
+}
+function defaultHermesRoot() {
+    const candidate = resolve(PACKAGE_ROOT, "..", ".tmp", "hermes-agent");
+    return existsSync(candidate) ? candidate : undefined;
+}
+export function resolveHermesLaunchProfile(input) {
+    const env = input.env ?? process.env;
+    const diagnostics = [];
+    const workerPath = resolve(PACKAGE_ROOT, "scripts", "hermes_bridge_worker.py");
+    const stored = readStoreJsonSync(input.workspaceRoot, "state/runtime/hermes_launch_profile") ??
+        undefined;
+    const hermesRoot = input.cliHermesRoot ?? env.ACE_HERMES_ROOT ?? stored?.hermes_root ?? defaultHermesRoot();
+    const commandJson = input.cliHermesCommandJson ?? env.ACE_HERMES_COMMAND_JSON ?? stored?.hermes_command_json;
+    const uvProject = input.cliHermesUvProject ?? env.ACE_HERMES_UV_PROJECT ?? stored?.hermes_uv_project;
+    const python = input.cliHermesPython ?? env.HERMES_PYTHON ?? stored?.hermes_python;
+    let command;
+    let source = "default";
+    if (commandJson) {
+        command = parseCommandJson(commandJson, input.cliHermesCommandJson ? "--hermes-command-json" : "ACE_HERMES_COMMAND_JSON");
+        source = input.cliHermesCommandJson ? "cli" : "env";
+        if (!input.cliHermesCommandJson && !env.ACE_HERMES_COMMAND_JSON) {
+            source = "store";
+        }
+    }
+    else if (uvProject) {
+        command = ["uv", "run", "--project", uvProject, "python"];
+        source = input.cliHermesUvProject ? "cli" : "env";
+        if (!input.cliHermesUvProject && !env.ACE_HERMES_UV_PROJECT) {
+            source = "store";
+        }
+    }
+    else if (python) {
+        command = [python];
+        source = input.cliHermesPython ? "cli" : "env";
+        if (!input.cliHermesPython && !env.HERMES_PYTHON) {
+            source = "store";
+        }
+    }
+    else {
+        command = ["python3"];
+        diagnostics.push("HERMES_PYTHON not set; using python3 fallback.");
+    }
+    if (!hermesRoot) {
+        diagnostics.push("ACE_HERMES_ROOT not set and no default Hermes checkout was found.");
+    }
+    if (!existsSync(workerPath)) {
+        diagnostics.push(`Hermes bridge worker is missing at ${workerPath}.`);
+    }
+    return {
+        enabled: true,
+        mode: commandJson ? "external_command" : "ephemeral_subprocess",
+        hermes_root: hermesRoot,
+        command,
+        worker_path: workerPath,
+        source,
+        diagnostics,
+    };
+}
+//# sourceMappingURL=launch-profile.js.map

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

@@ -0,0 +1,42 @@
+import type { BridgeResult } from "../model-bridge.js";
+import type { LocalModelRuntimeConfig } from "../local-model-runtime.js";
+import type { LocalModelExecutionPolicy } from "../local-model-policy.js";
+import { type HermesBridgeEvent } from "./bridge-protocol.js";
+import { type HermesLaunchProfile } from "./launch-profile.js";
+export interface HermesLocalTurnOptions {
+    task: string;
+    role: string;
+    runtime: LocalModelRuntimeConfig;
+    policy: LocalModelExecutionPolicy;
+    toolScope?: string[];
+    maxTurns: number;
+}
+export interface HermesLocalTurnResult {
+    result: BridgeResult;
+    metadata: {
+        bridge_protocol_version: string;
+        hermes_session_id: string;
+        shadow_mcp_session_id: string;
+        execution_engine: "hermes_local";
+        provider: string;
+        model: string;
+        events: HermesBridgeEvent[];
+    };
+}
+export interface HermesLocalExecutor {
+    runTurn(options: HermesLocalTurnOptions): Promise<HermesLocalTurnResult>;
+}
+export interface HermesSubprocessExecutorOptions {
+    hermesRoot?: string;
+    workerPath?: string;
+    pythonCommand?: string;
+    command?: readonly string[];
+    launchProfile?: HermesLaunchProfile;
+    keepTemp?: boolean;
+}
+export declare class HermesSubprocessExecutor implements HermesLocalExecutor {
+    private options;
+    constructor(options?: HermesSubprocessExecutorOptions);
+    runTurn(options: HermesLocalTurnOptions): Promise<HermesLocalTurnResult>;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/hermes/session-manager.js

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { HERMES_BRIDGE_PROTOCOL_VERSION, HermesBridgeFrameDecoder, } from "./bridge-protocol.js";
+import { resolveHermesLaunchProfile, } from "./launch-profile.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DIST_ROOT = resolve(__dirname, "..");
+const PACKAGE_ROOT = resolve(DIST_ROOT, "..");
+const MIN_HERMES_LOCAL_CONTEXT_LENGTH = 65536;
+function summarizeToolResult(value) {
+    if (typeof value === "string")
+        return value.slice(0, 500);
+    try {
+        return JSON.stringify(value).slice(0, 500);
+    }
+    catch {
+        return String(value).slice(0, 500);
+    }
+}
+function eventText(event) {
+    const value = event.text ?? event.message;
+    return typeof value === "string" ? value : "";
+}
+function hermesBaseUrl(provider, baseUrl) {
+    const normalized = String(baseUrl ?? "").replace(/\/+$/, "");
+    if (provider === "ollama" && normalized && !normalized.endsWith("/v1")) {
+        return `${normalized}/v1`;
+    }
+    return normalized;
+}
+export class HermesSubprocessExecutor {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runTurn(options) {
+        const sessionId = `hermes-${randomUUID()}`;
+        const shadowId = `shadow-${randomUUID()}`;
+        const hermesHome = mkdtempSync(resolve(tmpdir(), "ace-hermes-home-"));
+        mkdirSync(hermesHome, { recursive: true });
+        const toolScope = options.toolScope ?? [];
+        const cliPath = resolve(DIST_ROOT, "cli.js");
+        const baseUrl = hermesBaseUrl(options.runtime.provider, options.runtime.baseUrl ?? options.runtime.ollamaUrl);
+        writeFileSync(resolve(hermesHome, "config.yaml"), [
+            "model:",
+            `  default: ${JSON.stringify(options.runtime.model)}`,
+            "  provider: custom",
+            `  base_url: ${JSON.stringify(baseUrl)}`,
+            "  api_key: no-key-required",
+            `  context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            "",
+            "auxiliary:",
+            "  compression:",
+            `    model: ${JSON.stringify(options.runtime.model)}`,
+            "    provider: custom",
+            `    base_url: ${JSON.stringify(baseUrl)}`,
+            "    api_key: no-key-required",
+            `    context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            "",
+            "mcp_servers:",
+            "  ace_shadow:",
+            `    command: ${JSON.stringify(process.execPath)}`,
+            "    args:",
+            `      - ${JSON.stringify(cliPath)}`,
+            "      - mcp-shadow",
+            `      - ${JSON.stringify("--tools")}`,
+            `      - ${JSON.stringify(toolScope.join(","))}`,
+            "    timeout: 30",
+            "",
+        ].join("\n"), "utf-8");
+        const launchProfile = this.options.launchProfile ??
+            resolveHermesLaunchProfile({
+                workspaceRoot: options.runtime.workspaceRoot,
+                cliHermesRoot: this.options.hermesRoot,
+                cliHermesPython: this.options.pythonCommand,
+            });
+        const workerPath = this.options.workerPath ?? launchProfile.worker_path;
+        const hermesRoot = this.options.hermesRoot ?? launchProfile.hermes_root;
+        const command = this.options.command ?? launchProfile.command;
+        const [bin, ...args] = command;
+        if (!bin) {
+            throw new Error("Hermes launch command must contain at least one executable argument.");
+        }
+        const child = spawn(bin, [...args, workerPath], {
+            cwd: PACKAGE_ROOT,
+            env: {
+                ...process.env,
+                HERMES_HOME: hermesHome,
+                ACE_WORKSPACE_ROOT: options.runtime.workspaceRoot,
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const decoder = new HermesBridgeFrameDecoder();
+        const events = [];
+        const malformed = [];
+        const stderr = [];
+        let finalText = "";
+        let turns = 0;
+        let sawError = "";
+        child.stdout.on("data", (chunk) => {
+            for (const frame of decoder.push(chunk)) {
+                if (frame.ok) {
+                    events.push(frame.event);
+                    if (frame.event.type === "final") {
+                        finalText = eventText(frame.event);
+                        const rawTurns = frame.event.turns;
+                        turns = typeof rawTurns === "number" ? rawTurns : turns;
+                    }
+                    if (frame.event.type === "error") {
+                        sawError = eventText(frame.event) || "Hermes bridge error";
+                    }
+                }
+                else {
+                    malformed.push(frame.reason);
+                }
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr.push(chunk.toString("utf8"));
+        });
+        const request = {
+            session_id: sessionId,
+            turn_id: randomUUID(),
+            hermes_root: hermesRoot ?? "",
+            task: options.task,
+            role: options.role,
+            provider: options.runtime.provider,
+            model: options.runtime.model,
+            base_url: options.runtime.baseUrl ?? options.runtime.ollamaUrl,
+            max_turns: options.maxTurns,
+            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 exitCode = await new Promise((resolvePromise, reject) => {
+            child.on("error", reject);
+            child.on("close", resolvePromise);
+        });
+        for (const frame of decoder.push(new Uint8Array(), true)) {
+            if (frame.ok)
+                events.push(frame.event);
+            else
+                malformed.push(frame.reason);
+        }
+        if (!this.options.keepTemp) {
+            rmSync(hermesHome, { recursive: true, force: true });
+        }
+        const toolCalls = events
+            .filter((event) => event.type === "tool_complete")
+            .map((event) => ({
+            tool: String(event.tool ?? "unknown"),
+            ok: !event.is_error,
+            summary: summarizeToolResult(event.result ?? eventText(event)),
+            isError: Boolean(event.is_error),
+        }));
+        const status = sawError || malformed.length > 0 || exitCode !== 0 ? "failed" : "completed";
+        const summary = status === "failed"
+            ? sawError ||
+                `Hermes bridge failed${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
+            : finalText || "Hermes-local turn completed.";
+        return {
+            result: {
+                bridge_id: sessionId,
+                role: options.role,
+                status,
+                summary,
+                turns,
+                tool_calls: toolCalls,
+                child_results: [],
+                evidence_refs: toolCalls.map((tool) => `tool:${tool.tool}`),
+            },
+            metadata: {
+                bridge_protocol_version: HERMES_BRIDGE_PROTOCOL_VERSION,
+                hermes_session_id: sessionId,
+                shadow_mcp_session_id: shadowId,
+                execution_engine: "hermes_local",
+                provider: options.runtime.provider,
+                model: options.runtime.model,
+                events,
+            },
+        };
+    }
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/job-scheduler.js

@@ -114,6 +114,30 @@ function defaultJobLockFile() {
         locks: [],
     };
 }
+function coerceJobQueueFile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (candidate.version !== 1)
+        return undefined;
+    return {
+        version: 1,
+        updated_at: typeof candidate.updated_at === "string" ? candidate.updated_at : nowIso(),
+        jobs: Array.isArray(candidate.jobs) ? candidate.jobs : [],
+    };
+}
+function coerceJobLockTableFile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (candidate.version !== 1)
+        return undefined;
+    return {
+        version: 1,
+        updated_at: typeof candidate.updated_at === "string" ? candidate.updated_at : nowIso(),
+        locks: Array.isArray(candidate.locks) ? candidate.locks : [],
+    };
+}
 function defaultLease(owner = "scheduler") {
     const now = new Date();
     const expires = new Date(now.getTime() + 30_000);
@@ -278,8 +302,9 @@ export function readJobQueue() {
     const root = resolveWorkspaceRoot();
     if (storeExistsSync(root)) {
         const stored = readStoreJsonSync(root, "state/scheduler/queue");
-        if (stored)
-            return stored;
+        const normalized = coerceJobQueueFile(stored);
+        if (normalized)
+            return normalized;
     }
     const raw = safeRead(JOB_QUEUE_REL);
     if (isReadError(raw))
@@ -290,8 +315,9 @@ export function readJobLockTable() {
     const root = resolveWorkspaceRoot();
     if (storeExistsSync(root)) {
         const stored = readStoreJsonSync(root, "state/scheduler/locks");
-        if (stored)
-            return stored;
+        const normalized = coerceJobLockTableFile(stored);
+        if (normalized)
+            return normalized;
     }
     const raw = safeRead(JOB_LOCK_TABLE_REL);
     if (isReadError(raw))

package/dist/json-sanitizer.d.ts

@@ -0,0 +1,16 @@
+export interface JsonTextSanitizationResult {
+    text: string;
+    removed_control_bytes: number;
+    had_bom: boolean;
+}
+export declare function sanitizeJsonLikeText(raw: string): JsonTextSanitizationResult;
+export declare function parseJsonLikeText(raw: string): {
+    ok: true;
+    value: unknown;
+    sanitized: JsonTextSanitizationResult;
+} | {
+    ok: false;
+    error: string;
+    sanitized: JsonTextSanitizationResult;
+};
+//# sourceMappingURL=json-sanitizer.d.ts.map