orcastrator 0.2.6 → 0.2.8

package/dist/agents/claude/session.js

@@ -50,7 +50,7 @@ function extractAssistantText(message) {
         .trim();
     return text.length > 0 ? text : null;
 }
-function parseTaskArray(raw) {
+export function parseTaskArray(raw) {
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
         throw new Error("Claude plan response was not a JSON array");
@@ -63,11 +63,18 @@ function parseTaskArray(raw) {
         dependencies: Array.isArray(task.dependencies)
             ? task.dependencies.map(String)
             : [],
+        // Apply sensible defaults for required fields the LLM may have omitted.
+        name: typeof task.name === "string" && task.name.length > 0 ? task.name : "Unnamed task",
+        description: typeof task.description === "string" ? task.description : "",
+        acceptance_criteria: Array.isArray(task.acceptance_criteria) ? task.acceptance_criteria : [],
+        status: typeof task.status === "string" && task.status.length > 0 ? task.status : "pending",
+        retries: typeof task.retries === "number" ? task.retries : 0,
+        maxRetries: typeof task.maxRetries === "number" ? task.maxRetries : 3,
     }));
 }
-function parseTaskExecution(raw) {
+export function parseTaskExecution(raw) {
     const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error("Claude task response was not a JSON object");
     }
     const candidate = parsed;
@@ -112,9 +119,9 @@ async function collectSessionResult(session) {
 function getModel(config) {
     return config?.claude?.model ?? process.env.ORCA_CLAUDE_MODEL ?? "claude-sonnet-4-5";
 }
-export async function planSpec(spec, systemContext) {
+export async function planSpec(spec, systemContext, config) {
     const session = unstable_v2_createSession({
-        model: getModel()
+        model: getModel(config)
     });
     try {
         const streamPromise = collectSessionResult(session);

package/dist/core/config-loader.js

@@ -49,6 +49,11 @@ function coerceConfig(candidate) {
             }
         }
     }
+    if ("executor" in candidate && candidate.executor !== undefined) {
+        if (candidate.executor !== "claude" && candidate.executor !== "codex") {
+            throw new Error(`Config.executor must be 'claude' or 'codex', got ${String(candidate.executor)}`);
+        }
+    }
     return candidate;
 }
 export async function loadConfig(configPath) {
@@ -62,7 +67,7 @@ export async function loadConfig(configPath) {
     const configCandidate = "default" in importedModule ? importedModule.default : importedModule;
     return coerceConfig(configCandidate);
 }
-const TOP_LEVEL_SCALARS = ["runsDir", "sessionLogs", "maxRetries", "anthropicApiKey", "openaiApiKey"];
+const TOP_LEVEL_SCALARS = ["runsDir", "sessionLogs", "maxRetries", "anthropicApiKey", "openaiApiKey", "executor"];
 export function mergeConfigs(...configs) {
     const presentConfigs = configs.filter((config) => config !== undefined);
     if (presentConfigs.length === 0) {

package/dist/core/planner.js

@@ -24,7 +24,7 @@ export async function runPlanner(specPath, store, runId, config) {
     const systemContext = skills.length === 0
         ? DEFAULT_SYSTEM_CONTEXT
         : `${DEFAULT_SYSTEM_CONTEXT}\n\n${formatSkillsSection(skills)}`;
-    const result = await planSpecImpl(spec, systemContext);
+    const result = await planSpecImpl(spec, systemContext, config);
     validateDAG(result.tasks);
     await store.writeTasks(runId, result.tasks);
     await store.updateRun(runId, {

package/dist/core/task-runner.js

@@ -1,12 +1,14 @@
 import path from "node:path";
 import { promises as fs } from "node:fs";
-import { executeTask } from "../agents/claude/session.js";
+import * as claudeAgent from "../agents/claude/session.js";
+import { createCodexSession } from "../agents/codex/session.js";
 import { loadSkills } from "../utils/skill-loader.js";
 import { getRunnable, validateDAG } from "./dependency-graph.js";
 import { shouldRetry } from "./retry-policy.js";
-let executeTaskImpl = executeTask;
+// Non-null only when set by tests — null means "use real executor logic"
+let testExecuteTaskOverride = null;
 export function setExecuteTaskForTests(fn) {
-    executeTaskImpl = fn ?? executeTask;
+    testExecuteTaskOverride = fn;
 }
 function toErrorMessage(error) {
     if (error instanceof Error) {
@@ -94,15 +96,39 @@ async function writeSessionSummary(store, runId, sessionLogsDir) {
 }
 export async function runTaskRunner(options) {
     const emitHook = options.emitHook ?? defaultEmitHook;
-    const executeTaskFn = options.executeTask ?? executeTaskImpl;
     const { runId, store, config } = options;
     const skills = await loadSkills(config);
     const taskSystemContext = skills.length === 0 ? undefined : formatSkillsSection(skills);
-    let run = await store.getRun(runId);
-    if (!run) {
-        throw new Error(`Run not found: ${runId}`);
+    // Test mocks bypass all executor logic entirely — no real sessions created.
+    const mockFn = options.executeTask ?? testExecuteTaskOverride;
+    // Build real executor (Codex persistent session or Claude stateless fallback).
+    // Only runs in production — skipped completely when a mock is active.
+    let codexSession;
+    let executeTaskFn;
+    if (mockFn) {
+        executeTaskFn = mockFn;
+    }
+    else {
+        const executor = config?.executor ?? "codex";
+        if (executor === "codex") {
+            try {
+                codexSession = await createCodexSession(process.cwd(), config);
+                executeTaskFn = (task, taskRunId, _cfg, systemContext) => codexSession.executeTask(task, taskRunId, systemContext);
+            }
+            catch (sessionError) {
+                console.warn(`[orca] Codex session init failed, falling back to Claude: ${toErrorMessage(sessionError)}`);
+                executeTaskFn = claudeAgent.executeTask;
+            }
+        }
+        else {
+            executeTaskFn = claudeAgent.executeTask;
+        }
     }
     try {
+        let run = await store.getRun(runId);
+        if (!run) {
+            throw new Error(`Run not found: ${runId}`);
+        }
         validateDAG(run.tasks);
         await emitHook({
             runId: run.runId,
@@ -320,4 +346,14 @@ export async function runTaskRunner(options) {
         await writeSessionSummary(store, runId, config?.sessionLogs);
         throw error;
     }
+    finally {
+        if (codexSession) {
+            try {
+                await codexSession.disconnect();
+            }
+            catch {
+                // Best-effort cleanup — don't mask the real error.
+            }
+        }
+    }
 }

package/dist/utils/skill-loader.js

@@ -59,7 +59,12 @@ export async function loadSkill(skillDirPath) {
         skillFileContent = await readFile(skillFilePath, "utf8");
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        const errorCode = error.code;
+        if (errorCode === "ENOENT") {
+            return null;
+        }
+        if (errorCode === "EACCES" || errorCode === "EPERM") {
+            console.warn(`Skipping skill at ${expandedDirPath}: unable to read SKILL.md (${errorCode})`);
             return null;
         }
         throw error;
@@ -87,13 +92,21 @@ export async function loadSkillsFromDir(skillsDirPath) {
         throw error;
     }
     const subdirectories = entries
-        .filter((entry) => entry.isDirectory())
+        .filter((entry) => {
+        if (entry.isSymbolicLink()) {
+            console.warn(`Skipping symlinked skill entry: ${path.join(expandedDirPath, entry.name)}`);
+            return false;
+        }
+        return entry.isDirectory();
+    })
         .map((entry) => entry.name)
         .sort((a, b) => a.localeCompare(b));
     const loaded = await Promise.all(subdirectories.map((subdirName) => loadSkill(path.join(expandedDirPath, subdirName))));
     return loaded.filter((skill) => skill !== null);
 }
 export async function loadSkills(config) {
+    // NOTE: config.skills paths are currently resolved relative to process.cwd().
+    // A future improvement can resolve them relative to the config file location.
     const fromConfig = await Promise.all((config?.skills ?? []).map((skillPath) => loadSkill(skillPath)));
     const projectSkills = await loadSkillsFromDir(path.join(process.cwd(), ".orca", "skills"));
     const globalSkills = await loadSkillsFromDir(path.join(os.homedir(), ".orca", "skills"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orcastrator",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "bin": {
     "orca": "dist/cli/index.js"