smithers-orchestrator 0.8.3 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "AI workflow orchestration with JSX",
   "author": "William Cory",
   "license": "MIT",

package/src/TaskDescriptor.ts

@@ -7,6 +7,7 @@ export type TaskDescriptor = {
   ralphId?: string;
   worktreeId?: string;
   worktreePath?: string;
+  worktreeBranch?: string;
   outputTable: any | null;
   outputTableName: string;
   outputSchema?: import("zod").ZodObject<any>;

package/src/agents/CodexAgent.ts

@@ -106,6 +106,11 @@ export class CodexAgent extends BaseCliAgent {
       args,
       stdin: fullPrompt,
       outputFile,
+      stdoutBannerPatterns: [
+        // Codex CLI prints a startup banner like:
+        // "OpenAI Codex v0.99.0-alpha.13 (research preview)"
+        /^OpenAI Codex v[^\n]*$/gm,
+      ],
       cleanup: async () => {
         if (!this.opts.outputLastMessage) {
           await fs.rm(outputFile, { force: true }).catch(() => undefined);

package/src/components/Worktree.ts

@@ -4,6 +4,7 @@ import { WORKTREE_EMPTY_PATH_ERROR } from "../constants";
 export type WorktreeProps = {
   id?: string;
   path: string;
+  branch?: string;
   skipIf?: boolean;
   children?: React.ReactNode;
 };
@@ -13,6 +14,6 @@ export function Worktree(props: WorktreeProps) {
     throw new Error(WORKTREE_EMPTY_PATH_ERROR);
   }
   if (props.skipIf) return null;
-  const next: { id?: string; path: string } = { id: props.id, path: props.path };
+  const next: { id?: string; path: string; branch?: string } = { id: props.id, path: props.path, branch: props.branch };
   return React.createElement("smithers:worktree", next, props.children);
 }

package/src/dom/extract.ts

@@ -118,7 +118,7 @@ export function extractFromHost(
        * Stack of active <Worktree> contexts (outermost -> innermost).
        * The top of the stack controls the effective root override for tasks.
        */
-      worktreeStack: { id: string; path: string }[];
+      worktreeStack: { id: string; path: string; branch?: string }[];
     },
   ) {
     if (node.kind === "text") return;
@@ -179,7 +179,8 @@ export function extractFromHost(
       const normPath = isAbsolute(pathVal)
         ? resolvePath(pathVal)
         : resolvePath(base, pathVal);
-      nextWorktreeStack = [...worktreeStack, { id, path: normPath }];
+      const branch = node.rawProps?.branch ? String(node.rawProps.branch) : undefined;
+      nextWorktreeStack = [...worktreeStack, { id, path: normPath, branch }];
     }
     if (node.tag === "smithers:task") {
       const raw = node.rawProps || {};
@@ -233,6 +234,7 @@ export function extractFromHost(
         ralphId,
         worktreeId: topWorktree?.id,
         worktreePath: topWorktree?.path,
+        worktreeBranch: topWorktree?.branch,
         outputTable,
         outputTableName,
         outputSchema: outputRaw,

package/src/engine/index.ts

@@ -113,12 +113,15 @@ function findVcsRoot(startDir: string): { type: "git" | "jj"; root: string } | n
 }
 
 /**
- * Ensure a git worktree exists at `worktreePath`, creating it from `rootDir`
- * if necessary. Safe to call multiple times for the same path.
+ * Ensure a worktree exists at `worktreePath`, creating it from `rootDir`
+ * if necessary. When `branch` is provided, a jj bookmark or git branch is
+ * created/updated in the new worktree. Safe to call multiple times for the
+ * same path.
  */
-async function ensureGitWorktree(
+async function ensureWorktree(
   rootDir: string,
   worktreePath: string,
+  branch?: string,
 ): Promise<void> {
   if (createdWorktrees.has(worktreePath)) {
     if (existsSync(worktreePath)) return;
@@ -138,8 +141,9 @@ async function ensureGitWorktree(
     );
   }
 
+  // Best effort: refresh remote refs for git so origin/main can be used as a
+  // base when local main is absent.
   if (vcs.type === "git") {
-    // Try to fetch origin first so origin/main can resolve when available.
     await new Promise<void>((res) => {
       const child = nodeSpawn("git", ["fetch", "origin"], {
         cwd: vcs.root,
@@ -148,29 +152,10 @@ async function ensureGitWorktree(
       child.on("close", () => res());
       child.on("error", () => res());
     });
+  }
 
-    let created = false;
-    const failures: string[] = [];
-    for (const ref of ["origin/main", "HEAD"]) {
-      const result = await runGitCommand(vcs.root, [
-        "worktree",
-        "add",
-        worktreePath,
-        ref,
-      ]);
-      if (result.code === 0) {
-        created = true;
-        break;
-      }
-      failures.push(`${ref}: ${result.stderr || `exit ${result.code}`}`);
-    }
-    if (!created) {
-      throw new Error(
-        `Failed to create git worktree at ${worktreePath}. Tried origin/main and HEAD. ${failures.join(" | ")}`,
-      );
-    }
-  } else {
-    const { workspaceAdd } = await import("../vcs/jj");
+  if (vcs.type === "jj") {
+    const { workspaceAdd, runJj } = await import("../vcs/jj");
     const name = worktreePath.split("/").pop() ?? "worktree";
     const wsResult = await workspaceAdd(name, worktreePath, { cwd: vcs.root });
     if (!wsResult.success) {
@@ -178,6 +163,65 @@ async function ensureGitWorktree(
         `Failed to create jj workspace at ${worktreePath}: ${wsResult.error}`,
       );
     }
+    // Create a bookmark pointing at the new workspace's working copy
+    if (branch) {
+      const setRes = await runJj(["bookmark", "set", branch, "-r", "@"], {
+        cwd: worktreePath,
+      });
+      if (setRes.code !== 0) {
+        throw new Error(
+          `Failed to set jj bookmark ${branch} in ${worktreePath}: ${setRes.stderr || `exit ${setRes.code}`}`,
+        );
+      }
+    }
+  } else {
+    const baseRefs = ["main", "origin/main", "HEAD"] as const;
+    if (branch) {
+      // -B force-creates the branch (handles restarts gracefully)
+      let created = false;
+      const failures: string[] = [];
+      for (const ref of baseRefs) {
+        const result = await runGitCommand(vcs.root, [
+          "worktree",
+          "add",
+          "-B",
+          branch,
+          worktreePath,
+          ref,
+        ]);
+        if (result.code === 0) {
+          created = true;
+          break;
+        }
+        failures.push(`${ref}: ${result.stderr || `exit ${result.code}`}`);
+      }
+      if (!created) {
+        throw new Error(
+          `Failed to create git worktree at ${worktreePath} on branch ${branch}. Tried main, origin/main, and HEAD. ${failures.join(" | ")}`,
+        );
+      }
+    } else {
+      let created = false;
+      const failures: string[] = [];
+      for (const ref of baseRefs) {
+        const result = await runGitCommand(vcs.root, [
+          "worktree",
+          "add",
+          worktreePath,
+          ref,
+        ]);
+        if (result.code === 0) {
+          created = true;
+          break;
+        }
+        failures.push(`${ref}: ${result.stderr || `exit ${result.code}`}`);
+      }
+      if (!created) {
+        throw new Error(
+          `Failed to create git worktree at ${worktreePath}. Tried main, origin/main, and HEAD. ${failures.join(" | ")}`,
+        );
+      }
+    }
   }
 
   createdWorktrees.add(worktreePath);
@@ -738,8 +782,9 @@ async function executeTask(
 
   // Ensure the worktree directory exists on disk before running the task.
   if (desc.worktreePath) {
-    await ensureGitWorktree(toolConfig.rootDir, desc.worktreePath);
+    await ensureWorktree(toolConfig.rootDir, desc.worktreePath, desc.worktreeBranch);
   }
+  const cacheAgent = Array.isArray(desc.agent) ? desc.agent[0] : desc.agent;
 
   try {
     if (signal?.aborted) {
@@ -747,9 +792,9 @@ async function executeTask(
     }
     if (cacheEnabled) {
       const schemaSig = schemaSignature(desc.outputTable as any);
-      const agentSig = desc.agent?.id ?? "agent";
-      const toolsSig = desc.agent?.tools
-        ? Object.keys(desc.agent.tools).sort().join(",")
+      const agentSig = cacheAgent?.id ?? "agent";
+      const toolsSig = cacheAgent?.tools
+        ? Object.keys(cacheAgent.tools).sort().join(",")
         : "";
       // Incorporate JJ state so workspace changes invalidate cache as documented.
       const jjBase = await getJjPointer(taskRoot);
@@ -1237,9 +1282,9 @@ async function executeTask(
         nodeId: desc.nodeId,
         outputTable: desc.outputTableName,
         schemaSig: schemaSignature(desc.outputTable as any),
-        agentSig: desc.agent?.id ?? "agent",
-        toolsSig: desc.agent?.tools
-          ? Object.keys(desc.agent.tools).sort().join(",")
+        agentSig: cacheAgent?.id ?? "agent",
+        toolsSig: cacheAgent?.tools
+          ? Object.keys(cacheAgent.tools).sort().join(",")
           : null,
         jjPointer: cacheJjBase,
         payloadJson: JSON.stringify(payload),