@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/job-scheduler.js

@@ -9,7 +9,7 @@ import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { SchedulerRepository } from "./store/repositories/scheduler-repository.js";
 import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 // ── Buffered transition-event infrastructure ────────────────────────
 // Events are collected during the scheduler lock and flushed after
 // the lock is released.  Emission is failure-tolerant: a broken
@@ -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))
@@ -319,7 +345,7 @@ async function persistSchedulerState(input) {
         return;
     }
     const storePath = getWorkspaceStorePath(root);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const repo = new SchedulerRepository(store);
@@ -331,7 +357,7 @@ async function persistSchedulerState(input) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "persistSchedulerState" });
 }
 function compareJobs(a, b) {
     const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];

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

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,5 +1,7 @@
 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";
 export interface LocalModelRuntimeConfig {
     workspaceRoot: string;
     provider: string;
@@ -19,6 +21,7 @@ export interface RunLocalModelTaskOptions {
     ollamaUrl?: string;
     maxTurns?: number;
     tier?: AceContextTier | "auto";
+    modelClass?: RuntimeModelClass;
     toolScope?: string[];
     clients?: ModelBridgeClients;
 }
@@ -26,8 +29,10 @@ export interface RunLocalModelTaskResult {
     runtime: LocalModelRuntimeConfig;
     role: string;
     routingSummary?: string;
+    policy: LocalModelExecutionPolicy;
     result: BridgeResult;
 }
+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;
@@ -37,4 +42,5 @@ export declare function resolveLocalModelRuntime(input: {
     ollamaUrl?: string;
 }): 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

@@ -6,6 +6,7 @@ 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";
 function extractTextContent(result) {
     if (!result || typeof result !== "object")
         return "";
@@ -18,6 +19,14 @@ function extractTextContent(result) {
         .filter(Boolean)
         .join("\n");
 }
+function extractRoutedRole(result) {
+    const structured = result?.structuredContent;
+    if (!structured || typeof structured !== "object")
+        return undefined;
+    const suggestedRole = structured
+        .suggested_execution_role;
+    return typeof suggestedRole === "string" ? normalizeRoleCandidate(suggestedRole) : undefined;
+}
 function normalizeRoleCandidate(input) {
     if (!input)
         return undefined;
@@ -37,24 +46,18 @@ async function resolveRole(task, sessionId, requestedRole) {
     }
     const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
     const routingSummary = extractTextContent(routing);
-    return { role: fallbackRoleForTask(), routingSummary };
+    return {
+        role: extractRoutedRole(routing) ?? fallbackRoleForTask(),
+        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 = {};
@@ -108,22 +111,31 @@ export async function runLocalModelTask(options) {
     });
     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 result = await bridge.run({
         task: options.task,
         role,
         workspace: runtime.workspaceRoot,
-        tier,
-        maxTurns: options.maxTurns ?? (role === "orchestrator" ? 6 : 4),
+        tier: policy.tier,
+        maxTurns: options.maxTurns ?? defaultTurnsForPolicy(role, policy),
         provider: runtime.provider,
         model: runtime.model,
-        toolScope: options.toolScope,
+        toolScope: options.toolScope ?? defaultToolScopeForPolicy(role, policy),
     });
     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

@@ -11,14 +11,21 @@ export interface BridgeToolResult {
     summary: string;
     isError: boolean;
 }
+export interface BridgeProgressEvent {
+    kind: "model_chunk" | "tool_start" | "tool_finish" | "process_post" | "output" | "thinking";
+    at: number;
+    detail?: Record<string, unknown>;
+}
 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">;
@@ -34,11 +41,16 @@ 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;
     onOutput?: (text: string) => void;
     onThinking?: (text: string) => void;
+    onProgress?: (event: BridgeProgressEvent) => void;
 }
 export declare class ModelBridge {
     private clients;