@voybio/ace-swarm 2.4.0 → 2.4.1

package/dist/helpers/constants.js

@@ -71,6 +71,7 @@ export const ALL_AGENTS = [
     "observability",
     "eval",
     "release",
+    "planner",
 ];
 export const SWARM_AGENTS = ["orchestrator", "vos", "ui", "coders"];
 export const COMPOSABLE_AGENTS = [
@@ -87,6 +88,7 @@ export const COMPOSABLE_AGENTS = [
     "observability",
     "eval",
     "release",
+    "planner",
 ];
 export const SWARM_SUBAGENT_MAP = {
     orchestrator: COMPOSABLE_AGENTS,
@@ -145,6 +147,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 +170,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 +212,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 +232,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 +275,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/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

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 "";
@@ -50,22 +51,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 = {};
@@ -119,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

@@ -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;