@voybio/ace-swarm 2.4.0 → 2.4.2

package/dist/json-sanitizer.js

@@ -0,0 +1,26 @@
+export function sanitizeJsonLikeText(raw) {
+    const hadBom = raw.startsWith("\uFEFF");
+    let removed = 0;
+    const text = raw
+        .replace(/^\uFEFF/, "")
+        .replace(/\r\n?/g, "\n")
+        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, () => {
+        removed += 1;
+        return "";
+    });
+    return { text, removed_control_bytes: removed, had_bom: hadBom };
+}
+export function parseJsonLikeText(raw) {
+    const sanitized = sanitizeJsonLikeText(raw);
+    try {
+        return { ok: true, value: JSON.parse(sanitized.text), sanitized };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            sanitized,
+        };
+    }
+}
+//# sourceMappingURL=json-sanitizer.js.map

package/dist/local-model-policy.d.ts

@@ -0,0 +1,27 @@
+import type { AceContextTier } from "./ace-context.js";
+import { type RuntimeModelClass } from "./runtime-profile.js";
+export interface LocalModelPolicyInput {
+    provider: string;
+    model: string;
+    role: string;
+    task?: string;
+    requested_tier?: "auto" | AceContextTier;
+    requested_model_class?: RuntimeModelClass;
+}
+export interface LocalModelExecutionPolicy {
+    model_class: RuntimeModelClass;
+    tier: AceContextTier;
+    mutation_lane: "structural_edit" | "raw_write_allowed";
+    structural_tools_required: boolean;
+    read_file_lines_max_lines: number | null;
+}
+export declare function resolveLocalModelClass(input: {
+    provider: string;
+    model: string;
+    requested_model_class?: RuntimeModelClass;
+}): RuntimeModelClass;
+export declare function tierForModelClass(role: string, modelClass: RuntimeModelClass, requestedTier?: "auto" | AceContextTier): AceContextTier;
+export declare function defaultTurnsForPolicy(role: string, policy: LocalModelExecutionPolicy): number;
+export declare function defaultToolScopeForPolicy(role: string, policy: LocalModelExecutionPolicy): string[] | undefined;
+export declare function resolveLocalModelExecutionPolicy(input: LocalModelPolicyInput): LocalModelExecutionPolicy;
+//# sourceMappingURL=local-model-policy.d.ts.map

package/dist/local-model-policy.js

@@ -0,0 +1,84 @@
+import { DEFAULT_SURGICAL_READ_BUDGETS, } from "./runtime-profile.js";
+const FRONTIER_MODEL_PATTERN = /\b(70b|72b|90b|405b|claude|gpt-|codex|gemini|o[1345])\b/i;
+const SMALL_LOCAL_MODEL_PATTERN = /\b(1\.5b|2b|3b|4b|5b|6b|7b|8b|mini|small|phi|tiny|qwen2\.5-coder|llama-3\.2-3b)\b/i;
+const LOCAL_PROVIDER_PATTERN = /\b(ollama|llama\.cpp|llamacpp|openai-compatible|local)\b/i;
+const HOSTED_PROVIDER_PATTERN = /\b(codex|claude|gemini|copilot)\b/i;
+function normalize(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+function isMutationTask(task, role) {
+    if (role === "coders" || role === "builder")
+        return true;
+    return /\b(write|create|mutate|edit|patch|modify|persist|save|generate|implement)\b/i.test(task ?? "");
+}
+export function resolveLocalModelClass(input) {
+    if (input.requested_model_class)
+        return input.requested_model_class;
+    const provider = normalize(input.provider);
+    const model = normalize(input.model);
+    const joined = `${provider} ${model}`;
+    if (FRONTIER_MODEL_PATTERN.test(joined) || HOSTED_PROVIDER_PATTERN.test(provider) || provider === "openai") {
+        return "frontier";
+    }
+    if (SMALL_LOCAL_MODEL_PATTERN.test(model)) {
+        return "small_local";
+    }
+    if (LOCAL_PROVIDER_PATTERN.test(provider)) {
+        return "mid";
+    }
+    return "mid";
+}
+export function tierForModelClass(role, modelClass, requestedTier) {
+    if (requestedTier && requestedTier !== "auto")
+        return requestedTier;
+    if (role === "orchestrator")
+        return "compressed";
+    if (modelClass === "frontier")
+        return "full";
+    if (modelClass === "small_local")
+        return "brief";
+    return "compressed";
+}
+export function defaultTurnsForPolicy(role, policy) {
+    if (role === "orchestrator")
+        return 6;
+    return policy.model_class === "small_local" ? 4 : 4;
+}
+export function defaultToolScopeForPolicy(role, policy) {
+    if (!policy.structural_tools_required || !(role === "coders" || role === "builder")) {
+        return undefined;
+    }
+    return [
+        "outline_file",
+        "astgrep_query",
+        "astgrep_locate",
+        "read_file_lines",
+        "compile_structural_edit",
+        "preview_structural_edit",
+        "astgrep_rewrite",
+        "safe_edit_file",
+        "write_workspace_file",
+        "run_tests",
+        "git_diff",
+        "git_status",
+        "execute_gates",
+    ];
+}
+export function resolveLocalModelExecutionPolicy(input) {
+    const role = normalize(input.role);
+    const modelClass = resolveLocalModelClass({
+        provider: input.provider,
+        model: input.model,
+        requested_model_class: input.requested_model_class,
+    });
+    const mutationIntent = isMutationTask(input.task, role);
+    const structuralToolsRequired = modelClass === "small_local" && mutationIntent;
+    return {
+        model_class: modelClass,
+        tier: tierForModelClass(role, modelClass, input.requested_tier),
+        mutation_lane: structuralToolsRequired ? "structural_edit" : "raw_write_allowed",
+        structural_tools_required: structuralToolsRequired,
+        read_file_lines_max_lines: DEFAULT_SURGICAL_READ_BUDGETS[modelClass],
+    };
+}
+//# sourceMappingURL=local-model-policy.js.map

package/dist/local-model-runtime.d.ts

@@ -1,7 +1,13 @@
+import { type ExecutionEngine } from "./helpers/constants.js";
 import { type BridgeResult, type ModelBridgeClients } from "./model-bridge.js";
 import type { AceContextTier } from "./ace-context.js";
+import { type LocalModelExecutionPolicy } from "./local-model-policy.js";
+import type { RuntimeModelClass } from "./runtime-profile.js";
+import { type HermesLocalExecutor, type HermesLocalTurnResult } from "./hermes/session-manager.js";
+import { type HermesLaunchProfile } from "./hermes/launch-profile.js";
 export interface LocalModelRuntimeConfig {
     workspaceRoot: string;
+    executionEngine: ExecutionEngine;
     provider: string;
     model: string;
     baseUrl?: string;
@@ -14,27 +20,38 @@ export interface RunLocalModelTaskOptions {
     role?: string;
     workspaceRoot?: string;
     provider?: string;
+    engine?: string;
     model?: string;
     baseUrl?: string;
     ollamaUrl?: string;
     maxTurns?: number;
     tier?: AceContextTier | "auto";
+    modelClass?: RuntimeModelClass;
     toolScope?: string[];
     clients?: ModelBridgeClients;
+    hermesExecutor?: HermesLocalExecutor;
+    hermesLaunchProfile?: HermesLaunchProfile;
 }
 export interface RunLocalModelTaskResult {
     runtime: LocalModelRuntimeConfig;
     role: string;
     routingSummary?: string;
+    policy: LocalModelExecutionPolicy;
     result: BridgeResult;
+    hermes?: HermesLocalTurnResult["metadata"];
 }
+export declare function parseExecutionEngine(input?: string): ExecutionEngine | undefined;
+export declare function resolveTier(requested: RunLocalModelTaskOptions["tier"], provider: string, model: string, role: string): AceContextTier;
 export declare function createDefaultModelBridgeClients(runtime: Pick<LocalModelRuntimeConfig, "providerBaseUrls">): ModelBridgeClients;
 export declare function resolveLocalModelRuntime(input: {
     workspaceRoot?: string;
     provider?: string;
+    engine?: string;
     model?: string;
     baseUrl?: string;
     ollamaUrl?: string;
+    hermesReady?: boolean;
 }): LocalModelRuntimeConfig;
 export declare function runLocalModelTask(options: RunLocalModelTaskOptions): Promise<RunLocalModelTaskResult>;
+export { resolveLocalModelExecutionPolicy, resolveLocalModelClass } from "./local-model-policy.js";
 //# sourceMappingURL=local-model-runtime.d.ts.map

package/dist/local-model-runtime.js

@@ -1,11 +1,36 @@
 import { resolve } from "node:path";
 import { ROLE_ENUM } from "./shared.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
+import { ALL_EXECUTION_ENGINES } from "./helpers/constants.js";
 import { executeAceInternalTool } from "./ace-internal-tools.js";
 import { ModelBridge } from "./model-bridge.js";
 import { OllamaClient } from "./tui/ollama.js";
 import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./tui/openai-compatible.js";
 import { discoverProviderContext } from "./tui/provider-discovery.js";
+import { defaultToolScopeForPolicy, defaultTurnsForPolicy, resolveLocalModelExecutionPolicy, } from "./local-model-policy.js";
+import { HermesSubprocessExecutor, } from "./hermes/session-manager.js";
+import { resolveHermesLaunchProfile, } from "./hermes/launch-profile.js";
+export function parseExecutionEngine(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase().replace(/-/g, "_");
+    return ALL_EXECUTION_ENGINES.includes(normalized)
+        ? normalized
+        : undefined;
+}
+function isLocalProvider(provider) {
+    return provider === "ollama" || provider === "llama.cpp";
+}
+function resolveExecutionEngine(input) {
+    const parsed = parseExecutionEngine(input.requested);
+    if (parsed) {
+        if (parsed === "hermes_local" && !isLocalProvider(input.provider)) {
+            throw new Error("engine=hermes_local is only valid for local providers.");
+        }
+        return parsed;
+    }
+    return isLocalProvider(input.provider) && input.hermesReady ? "hermes_local" : "direct";
+}
 function extractTextContent(result) {
     if (!result || typeof result !== "object")
         return "";
@@ -50,22 +75,13 @@ async function resolveRole(task, sessionId, requestedRole) {
         routingSummary,
     };
 }
-function resolveTier(requested, provider, model, role) {
-    if (requested && requested !== "auto")
-        return requested;
-    const normalizedProvider = provider.trim().toLowerCase();
-    const normalizedModel = model.trim().toLowerCase();
-    if (role === "orchestrator")
-        return "compressed";
-    if (normalizedProvider !== "ollama")
-        return "full";
-    if (/(70b|72b|90b|405b|claude|gpt-|codex|gemini|o[1345])/.test(normalizedModel)) {
-        return "full";
-    }
-    if (/(7b|8b|mini|small|phi|tiny)/.test(normalizedModel)) {
-        return "brief";
-    }
-    return "compressed";
+export function resolveTier(requested, provider, model, role) {
+    return resolveLocalModelExecutionPolicy({
+        provider,
+        model,
+        role,
+        requested_tier: requested,
+    }).tier;
 }
 export function createDefaultModelBridgeClients(runtime) {
     const providerConfigs = {};
@@ -88,6 +104,11 @@ export function resolveLocalModelRuntime(input) {
         cliBaseUrl: input.baseUrl,
         cliOllamaUrl: input.ollamaUrl,
     });
+    const executionEngine = resolveExecutionEngine({
+        requested: input.engine,
+        provider: discovered.provider,
+        hermesReady: input.hermesReady,
+    });
     if (discovered.provider === "ollama" && !discovered.ollamaUrl) {
         throw new Error("Ollama base URL is not configured. Provide `--base-url`/`ollama_url`, set OLLAMA_HOST, or run `ace doctor --llm ollama --scan`.");
     }
@@ -101,6 +122,7 @@ export function resolveLocalModelRuntime(input) {
     }
     return {
         workspaceRoot,
+        executionEngine,
         provider: discovered.provider,
         model: discovered.model,
         baseUrl: discovered.baseUrl,
@@ -113,28 +135,63 @@ export async function runLocalModelTask(options) {
     const runtime = resolveLocalModelRuntime({
         workspaceRoot: options.workspaceRoot,
         provider: options.provider,
+        engine: options.engine,
         model: options.model,
         baseUrl: options.baseUrl,
         ollamaUrl: options.ollamaUrl,
     });
     const bridge = new ModelBridge(options.clients ?? createDefaultModelBridgeClients(runtime));
     const { role, routingSummary } = await resolveRole(options.task, undefined, options.role);
-    const tier = resolveTier(options.tier, runtime.provider, runtime.model, role);
+    const policy = resolveLocalModelExecutionPolicy({
+        provider: runtime.provider,
+        model: runtime.model,
+        role,
+        task: options.task,
+        requested_tier: options.tier,
+        requested_model_class: options.modelClass,
+    });
+    const maxTurns = options.maxTurns ?? defaultTurnsForPolicy(role, policy);
+    const toolScope = options.toolScope ?? defaultToolScopeForPolicy(role, policy);
+    if (runtime.executionEngine === "hermes_local") {
+        const launchProfile = options.hermesLaunchProfile ?? resolveHermesLaunchProfile({ workspaceRoot: runtime.workspaceRoot });
+        const hermesExecutor = options.hermesExecutor ??
+            new HermesSubprocessExecutor({
+                launchProfile,
+            });
+        const hermes = await hermesExecutor.runTurn({
+            task: options.task,
+            role,
+            runtime,
+            policy,
+            toolScope,
+            maxTurns,
+        });
+        return {
+            runtime,
+            role,
+            routingSummary,
+            policy,
+            result: hermes.result,
+            hermes: hermes.metadata,
+        };
+    }
     const result = await bridge.run({
         task: options.task,
         role,
         workspace: runtime.workspaceRoot,
-        tier,
-        maxTurns: options.maxTurns ?? (role === "orchestrator" ? 6 : 4),
+        tier: policy.tier,
+        maxTurns,
         provider: runtime.provider,
         model: runtime.model,
-        toolScope: options.toolScope,
+        toolScope,
     });
     return {
         runtime,
         role,
         routingSummary,
+        policy,
         result,
     };
 }
+export { resolveLocalModelExecutionPolicy, resolveLocalModelClass } from "./local-model-policy.js";
 //# sourceMappingURL=local-model-runtime.js.map

package/dist/model-bridge.d.ts

@@ -19,12 +19,13 @@ export interface BridgeProgressEvent {
 export interface BridgeResult {
     bridge_id: string;
     role: string;
-    status: "completed" | "needs_input" | "failed" | "max_turns";
+    status: "completed" | "blocked" | "needs_input" | "failed" | "max_turns";
     summary: string;
     turns: number;
     tool_calls: BridgeToolResult[];
     child_results: BridgeResult[];
     evidence_refs?: string[];
+    reason_code?: string;
 }
 export interface ModelBridgeClients {
     ollama: Pick<OllamaClient, "chat" | "abort">;
@@ -40,6 +41,10 @@ export interface ModelBridgeRunOptions {
     provider: string;
     model: string;
     toolScope?: string[];
+    expectedArtifacts?: {
+        path: string;
+        required?: boolean;
+    }[];
     parentBridge?: string;
     onToolCall?: (tool: string, args: Record<string, unknown>) => void;
     onToolResult?: (tool: string, result: BridgeToolResult) => void;