@taranek/orche 0.0.8

package/dist/review-manager.js

@@ -0,0 +1,225 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, createWriteStream, } from "node:fs";
+import path from "node:path";
+import https from "node:https";
+const REPO = "taranek/orche";
+const TAG_PREFIX = "review-v";
+// Pin review binary version to the CLI version
+const CLI_VERSION = (() => {
+    try {
+        const pkgPath = new URL("../package.json", import.meta.url).pathname;
+        return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+    }
+    catch {
+        return null;
+    }
+})();
+const ORCHE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || "~", ".orche", "review");
+const BIN_DIR = path.join(ORCHE_DIR, "bin");
+const VERSION_FILE = path.join(ORCHE_DIR, "version.json");
+const LOCK_FILE = path.join(ORCHE_DIR, ".downloading");
+function readVersionInfo() {
+    if (!existsSync(VERSION_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(VERSION_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeVersionInfo(info) {
+    mkdirSync(ORCHE_DIR, { recursive: true });
+    writeFileSync(VERSION_FILE, JSON.stringify(info, null, 2));
+}
+function getPlatformKey() {
+    const arch = process.arch === "arm64" ? "arm64" : "x64";
+    if (process.platform === "darwin") {
+        return { platform: "mac", arch, ext: "zip" };
+    }
+    if (process.platform === "linux") {
+        return { platform: "linux", arch, ext: "tar.gz" };
+    }
+    throw new Error(`unsupported platform: ${process.platform}`);
+}
+function getExecutablePath() {
+    if (process.platform === "darwin") {
+        return path.join(BIN_DIR, "orche-review.app", "Contents", "MacOS", "orche-review");
+    }
+    return path.join(BIN_DIR, "orche-review", "orche-review");
+}
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        const get = (requestUrl) => {
+            https.get(requestUrl, { headers: { "User-Agent": "orche-cli", Accept: "application/vnd.github+json" } }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    get(res.headers.location);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode} from ${requestUrl}`));
+                    return;
+                }
+                let data = "";
+                res.on("data", (chunk) => (data += chunk));
+                res.on("end", () => resolve(JSON.parse(data)));
+                res.on("error", reject);
+            }).on("error", reject);
+        };
+        get(url);
+    });
+}
+function download(url, dest) {
+    return new Promise((resolve, reject) => {
+        mkdirSync(path.dirname(dest), { recursive: true });
+        const file = createWriteStream(dest);
+        const get = (requestUrl) => {
+            https.get(requestUrl, { headers: { "User-Agent": "orche-cli" } }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    get(res.headers.location);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    file.close();
+                    reject(new Error(`HTTP ${res.statusCode} downloading ${requestUrl}`));
+                    return;
+                }
+                const totalBytes = parseInt(res.headers["content-length"] || "0", 10);
+                let downloadedBytes = 0;
+                res.on("data", (chunk) => {
+                    downloadedBytes += chunk.length;
+                    if (totalBytes > 0) {
+                        const pct = Math.round((downloadedBytes / totalBytes) * 100);
+                        const mb = (downloadedBytes / 1024 / 1024).toFixed(1);
+                        const totalMb = (totalBytes / 1024 / 1024).toFixed(1);
+                        process.stderr.write(`\r  downloading: ${mb}/${totalMb} MB (${pct}%)`);
+                    }
+                });
+                res.pipe(file);
+                file.on("finish", () => {
+                    if (totalBytes > 0)
+                        process.stderr.write("\n");
+                    file.close();
+                    resolve();
+                });
+                file.on("error", reject);
+            }).on("error", reject);
+        };
+        get(url);
+    });
+}
+async function findRelease() {
+    const releases = await fetchJson(`https://api.github.com/repos/${REPO}/releases`);
+    // Find release matching CLI version, or fall back to latest review release
+    const targetTag = CLI_VERSION ? `${TAG_PREFIX}${CLI_VERSION}` : null;
+    const reviewRelease = targetTag
+        ? releases.find((r) => r.tag_name === targetTag)
+        : releases.find((r) => r.tag_name.startsWith(TAG_PREFIX));
+    if (!reviewRelease)
+        return null;
+    const version = reviewRelease.tag_name.slice(TAG_PREFIX.length);
+    const { platform, arch, ext } = getPlatformKey();
+    // Match asset by platform and arch in filename
+    const asset = reviewRelease.assets.find((a) => {
+        const name = a.name.toLowerCase();
+        if (!name.includes(platform) || !name.endsWith(`.${ext}`) || name.includes("blockmap"))
+            return false;
+        if (arch === "arm64")
+            return name.includes("arm64");
+        return !name.includes("arm64");
+    });
+    if (!asset)
+        return null;
+    return { version, downloadUrl: asset.browser_download_url };
+}
+async function downloadAndExtract(url, version) {
+    const tmpDir = path.join(ORCHE_DIR, ".tmp");
+    mkdirSync(tmpDir, { recursive: true });
+    const { ext } = getPlatformKey();
+    const archivePath = path.join(tmpDir, `orche-review.${ext}`);
+    await download(url, archivePath);
+    // Clean existing bin directory
+    execSync(`rm -rf "${BIN_DIR}"`);
+    mkdirSync(BIN_DIR, { recursive: true });
+    // Extract
+    if (ext === "zip") {
+        execSync(`unzip -q -o "${archivePath}" -d "${BIN_DIR}"`);
+        // Clear macOS quarantine
+        try {
+            execSync(`xattr -cr "${BIN_DIR}"`, { stdio: "ignore" });
+        }
+        catch {
+            // xattr may not exist on all systems
+        }
+    }
+    else {
+        execSync(`tar xzf "${archivePath}" -C "${BIN_DIR}"`);
+    }
+    // Ensure executable permissions on Linux
+    if (process.platform === "linux") {
+        const executablePath = getExecutablePath();
+        if (existsSync(executablePath)) {
+            execSync(`chmod +x "${executablePath}"`);
+        }
+    }
+    // Write version info
+    writeVersionInfo({
+        version,
+        downloadedAt: new Date().toISOString(),
+        lastCheckedAt: new Date().toISOString(),
+    });
+    // Cleanup
+    execSync(`rm -rf "${tmpDir}"`);
+}
+function acquireLock() {
+    if (existsSync(LOCK_FILE)) {
+        try {
+            const lockTime = parseInt(readFileSync(LOCK_FILE, "utf-8"), 10);
+            // Stale if older than 10 minutes
+            if (Date.now() - lockTime < 10 * 60 * 1000)
+                return false;
+        }
+        catch {
+            // corrupt lock, proceed
+        }
+    }
+    mkdirSync(ORCHE_DIR, { recursive: true });
+    writeFileSync(LOCK_FILE, String(Date.now()));
+    return true;
+}
+function releaseLock() {
+    try {
+        unlinkSync(LOCK_FILE);
+    }
+    catch {
+        // ignore
+    }
+}
+export async function getReviewBinaryPath() {
+    const executablePath = getExecutablePath();
+    const info = readVersionInfo();
+    const needsDownload = !info || !existsSync(executablePath)
+        || (CLI_VERSION && info.version !== CLI_VERSION);
+    if (!needsDownload)
+        return executablePath;
+    if (info && CLI_VERSION && info.version !== CLI_VERSION) {
+        console.log(`review app version mismatch (${info.version} → ${CLI_VERSION}), updating...`);
+    }
+    else {
+        console.log("review app not found, downloading...");
+    }
+    if (!acquireLock()) {
+        throw new Error("another download is in progress — try again in a moment");
+    }
+    try {
+        const release = await findRelease();
+        if (!release) {
+            throw new Error("no review app release found — check https://github.com/taranek/orche/releases");
+        }
+        await downloadAndExtract(release.downloadUrl, release.version);
+    }
+    finally {
+        releaseLock();
+    }
+    return executablePath;
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export interface PaneConfig {
+    name: string;
+    command: string;
+    /** Percentage size of this pane (optional, defaults to equal) */
+    size?: number;
+}
+export interface SplitConfig {
+    direction: "horizontal" | "vertical";
+    panes: (PaneConfig | SplitConfig)[];
+    /** Percentage size of this split (optional, defaults to equal) */
+    size?: number;
+}
+export type MultiplexerType = "tmux" | "cmux" | "auto";
+export interface AgentsConfig {
+    multiplexer?: MultiplexerType;
+    layout: PaneConfig | SplitConfig;
+}
+export declare function isSplit(node: PaneConfig | SplitConfig): node is SplitConfig;

package/dist/types.js

@@ -0,0 +1,3 @@
+export function isSplit(node) {
+    return "direction" in node && "panes" in node;
+}

package/dist/worktree.d.ts

@@ -0,0 +1,5 @@
+export interface WorktreeInfo {
+    worktreePath: string;
+    branchName: string;
+}
+export declare function createWorktree(repoPath: string, name: string): WorktreeInfo;

package/dist/worktree.js

@@ -0,0 +1,89 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, symlinkSync, readdirSync, lstatSync, } from "node:fs";
+import path from "node:path";
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 50);
+}
+function ensureGitignore(repoPath, pattern) {
+    const gitignorePath = path.join(repoPath, ".gitignore");
+    let content = "";
+    if (existsSync(gitignorePath)) {
+        content = readFileSync(gitignorePath, "utf-8");
+    }
+    if (!content.includes(pattern)) {
+        appendFileSync(gitignorePath, `\n# Agent worktrees\n${pattern}\n`);
+    }
+}
+function ensureGitRepo(repoPath) {
+    try {
+        execSync("git rev-parse --git-dir", { cwd: repoPath, stdio: "ignore" });
+    }
+    catch {
+        execSync('git init && git add -A && git commit -m "Initial commit" --allow-empty', { cwd: repoPath, stdio: "ignore" });
+    }
+}
+export function createWorktree(repoPath, name) {
+    ensureGitRepo(repoPath);
+    const slug = slugify(name);
+    const timestamp = Date.now();
+    const branchName = `agent/${slug}-${timestamp}`;
+    const worktreesDir = path.join(repoPath, ".orche", "worktrees");
+    const worktreePath = path.join(worktreesDir, `${slug}-${timestamp}`);
+    mkdirSync(worktreesDir, { recursive: true });
+    ensureGitignore(repoPath, ".orche/");
+    execSync(`git worktree add -b "${branchName}" "${worktreePath}"`, {
+        cwd: repoPath,
+        stdio: "ignore",
+    });
+    symlinkNodeModules(repoPath, worktreePath);
+    console.log(`  worktree: ${worktreePath} (${branchName})`);
+    return { worktreePath, branchName };
+}
+function symlinkNodeModules(repoPath, worktreePath) {
+    // Symlink root node_modules
+    const rootNm = path.join(repoPath, "node_modules");
+    const targetNm = path.join(worktreePath, "node_modules");
+    if (existsSync(rootNm) && !existsSync(targetNm)) {
+        symlinkSync(rootNm, targetNm);
+    }
+    // Symlink node_modules in subdirectories (monorepo packages)
+    symlinkNestedNodeModules(repoPath, worktreePath, repoPath);
+}
+function symlinkNestedNodeModules(dir, worktreePath, repoPath) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".orche")
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        // Skip symlinks
+        try {
+            if (lstatSync(fullPath).isSymbolicLink())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const nm = path.join(fullPath, "node_modules");
+        if (existsSync(nm)) {
+            const rel = path.relative(repoPath, fullPath);
+            const targetDir = path.join(worktreePath, rel);
+            const targetNm = path.join(targetDir, "node_modules");
+            if (!existsSync(targetNm) && existsSync(targetDir)) {
+                symlinkSync(nm, targetNm);
+            }
+        }
+        symlinkNestedNodeModules(fullPath, worktreePath, repoPath);
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@taranek/orche",
+  "version": "0.0.8",
+  "type": "module",
+  "bin": {
+    "orche": "./dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/taranek/orche.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.2",
+    "@types/node": "^25.2.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync, watch, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import path from "node:path";
+import { createWorktree } from "./worktree.js";
+import { getMultiplexer } from "./multiplexer.js";
+import { buildLayout } from "./layout.js";
+import { getReviewBinaryPath } from "./review-manager.js";
+import type { AgentsConfig, MultiplexerType } from "./types.js";
+
+const CONFIG_NAME = ".orche.json";
+const CONFIG_LOCAL_NAME = ".orche.local.json";
+
+function die(msg: string): never {
+  console.error(`error: ${msg}`);
+  process.exit(1);
+}
+
+
+function loadConfig(cwd: string): AgentsConfig {
+  const localPath = path.join(cwd, CONFIG_LOCAL_NAME);
+  const configPath = path.join(cwd, CONFIG_NAME);
+
+  if (existsSync(localPath)) {
+    const raw = readFileSync(localPath, "utf-8");
+    return JSON.parse(raw) as AgentsConfig;
+  }
+
+  if (!existsSync(configPath)) {
+    die(`no ${CONFIG_NAME} found in ${cwd}`);
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  return JSON.parse(raw) as AgentsConfig;
+}
+
+function deliverReview(pendingPath: string): void {
+  try {
+    const pending = JSON.parse(readFileSync(pendingPath, "utf-8"));
+    const { reviewPath, multiplexer, paneId, workspaceId } = pending;
+    const markdown = readFileSync(reviewPath, "utf-8");
+
+    if (multiplexer === "tmux" && paneId) {
+      // Use load-buffer/paste-buffer instead of send-keys to safely handle
+      // multi-line markdown with special characters
+      const tmpFile = pendingPath + ".tmp";
+      writeFileSync(tmpFile, markdown);
+      execFileSync("tmux", ["load-buffer", tmpFile]);
+      execFileSync("tmux", ["paste-buffer", "-t", paneId]);
+      execFileSync("tmux", ["send-keys", "-t", paneId, "Enter"]);
+      try { unlinkSync(tmpFile); } catch {}
+    } else if (multiplexer === "cmux" && paneId) {
+      const escaped = markdown.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+      execFileSync("cmux", ["send", "--surface", paneId, ...(workspaceId ? ["--workspace", workspaceId] : []), "--", escaped]);
+      execFileSync("cmux", ["send-key", "--surface", paneId, ...(workspaceId ? ["--workspace", workspaceId] : []), "enter"]);
+    }
+
+    try { unlinkSync(pendingPath); } catch {}
+    console.log("[review] delivered review to agent");
+  } catch (err: any) {
+    console.error("[review] delivery failed:", err?.message ?? err);
+  }
+}
+
+async function runReview(worktreePath: string): Promise<void> {
+  const resolvedPath = path.resolve(worktreePath);
+  const args = ["--worktree=" + resolvedPath];
+
+  console.log(`opening review for ${worktreePath}...`);
+
+  // Watch for .pending files from the Electron app and deliver them
+  // (Electron can't access the cmux socket — only CLI processes can)
+  const repoRoot = getRepoRoot(resolvedPath);
+  const worktreeName = path.basename(resolvedPath);
+  const reviewsDir = path.join(repoRoot, ".orche", "reviews", worktreeName);
+  mkdirSync(reviewsDir, { recursive: true });
+
+  // CLI stays alive to watch for .pending files and deliver them via cmux/tmux
+  // (Electron can't access the cmux socket — only processes started inside cmux can)
+  const watcher = watch(reviewsDir, (event, filename) => {
+    if (event === "rename" && filename?.endsWith(".pending")) {
+      const pendingPath = path.join(reviewsDir, filename);
+      deliverReview(pendingPath);
+      watcher.close();
+      process.exit(0);
+    }
+  });
+
+  // Dev mode: launch electron from local monorepo
+  const cliDir = path.dirname(new URL(import.meta.url).pathname);
+  const localReviewDir = path.resolve(cliDir, "../../review");
+  const devReviewPath = process.env.ORCHE_REVIEW_DEV ||
+    (existsSync(path.join(localReviewDir, "package.json")) ? localReviewDir : undefined);
+  const debug = !!process.env.ORCHE_DEBUG;
+  if (devReviewPath) {
+    const electronBin = path.join(devReviewPath, "node_modules/.bin/electron");
+    if (debug) console.error(`[review] launching: ${electronBin} ${[devReviewPath, ...args].join(" ")}`);
+    spawn(electronBin, [devReviewPath, ...args], {
+      stdio: ["ignore", "inherit", "inherit"],
+      env: { ...process.env, VITE_DEV_SERVER_URL: undefined },
+    });
+    return;
+  }
+
+  const binaryPath = await getReviewBinaryPath();
+  if (debug) console.error(`[review] launching: ${binaryPath} ${args.join(" ")}`);
+  spawn(binaryPath, args, {
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+}
+
+function getRepoRoot(cwd: string): string {
+  // If we're inside an orche worktree, walk up to the real repo
+  const orcheIdx = cwd.indexOf("/.orche/worktrees/");
+  if (orcheIdx !== -1) {
+    return cwd.slice(0, orcheIdx);
+  }
+  return cwd;
+}
+
+function startSession(): void {
+  const cwd = getRepoRoot(process.cwd());
+  const repoName = path.basename(cwd);
+  const taskName = process.argv.slice(3).find((a) => !a.startsWith("--")) || "session";
+
+  const config = loadConfig(cwd);
+  const muxFlag: MultiplexerType | undefined =
+    process.argv.includes("--tmux") ? "tmux" :
+    process.argv.includes("--cmux") ? "cmux" :
+    undefined;
+  const mux = getMultiplexer(muxFlag ?? config.multiplexer);
+
+  // 1. Create worktree
+  console.log(`creating worktree for "${taskName}"...`);
+  const { worktreePath } = createWorktree(cwd, taskName);
+
+  // 2. Create session
+  const sessionName = `${repoName}-${taskName}`.replace(
+    /[^a-zA-Z0-9_-]/g,
+    "-"
+  );
+
+  mux.createSession(sessionName, worktreePath);
+  console.log(`${mux.name} session: ${sessionName}`);
+
+  // 3. Build pane layout
+  buildLayout(mux, sessionName, config.layout, worktreePath);
+
+  // 4. Attach
+  mux.attach(sessionName);
+}
+
+function printUsage(): void {
+  console.log(`
+orche — orchestrate agents across git worktrees
+
+Usage:
+  orche start <task>         Start a new session for <task>
+  orche review [path]        Open the review UI for a worktree
+
+Examples:
+  orche start fix-auth       Create worktree + session for "fix-auth"
+  orche review               Review changes in current directory
+  orche review ./worktree    Review changes in a specific worktree
+
+Requires a ${CONFIG_NAME} file in the current directory.
+Use ${CONFIG_LOCAL_NAME} for local overrides (not committed).
+See .orche.example.json for the config format.
+`);
+}
+
+async function main(): Promise<void> {
+  const subcommand = process.argv[2];
+
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (subcommand === "start") {
+    startSession();
+  } else if (subcommand === "review") {
+    const explicitPath = process.argv[3] && !process.argv[3].startsWith("--")
+      ? process.argv[3]
+      : undefined;
+    const worktreePath = explicitPath || process.cwd();
+    await runReview(worktreePath);
+  } else {
+    console.error(`Unknown command: ${subcommand}\nRun "orche --help" for usage.`);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`error: ${err.message}`);
+  process.exit(1);
+});

package/src/layout.ts

@@ -0,0 +1,99 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { isSplit, type PaneConfig, type SplitConfig } from "./types.js";
+import type { Multiplexer } from "./multiplexer.js";
+
+export interface SessionInfo {
+  multiplexer: string;
+  panes: Record<string, string>; // name → pane/surface ID
+  workspaceId?: string;
+}
+
+/**
+ * Recursively build a pane layout using the given multiplexer.
+ */
+export function buildLayout(
+  mux: Multiplexer,
+  session: string,
+  node: PaneConfig | SplitConfig,
+  worktreePath: string
+): void {
+  const paneMap: Record<string, string> = {};
+
+  if (!isSplit(node)) {
+    const paneId = mux.getActivePaneId(session);
+    paneMap[node.name] = paneId;
+    mux.renamePaneTitle(paneId, node.name);
+    if (node.command) mux.sendCommand(session, node.command);
+    saveSessionInfo(mux.name, paneMap, worktreePath);
+    return;
+  }
+
+  const paneIds = [mux.getActivePaneId(session)];
+
+  for (let i = 1; i < node.panes.length; i++) {
+    const child = node.panes[i];
+    const sizePercent = child.size ?? Math.floor(100 / (node.panes.length - i + 1));
+    mux.splitPane(paneIds[0], node.direction, sizePercent, worktreePath);
+    paneIds.push(mux.getActivePaneId(session));
+  }
+
+  const allPaneIds = mux.listPaneIds(session);
+
+  for (let i = 0; i < node.panes.length; i++) {
+    const child = node.panes[i];
+    const paneId = allPaneIds[i];
+
+    if (isSplit(child)) {
+      mux.focusPane(paneId);
+      collectPaneMap(mux, session, child, paneId, worktreePath, paneMap);
+    } else {
+      paneMap[child.name] = paneId;
+      mux.renamePaneTitle(paneId, child.name);
+      if (child.command) mux.sendCommand(paneId, child.command);
+    }
+  }
+
+  saveSessionInfo(mux.name, paneMap, worktreePath);
+}
+
+function collectPaneMap(
+  mux: Multiplexer,
+  session: string,
+  node: SplitConfig,
+  parentPaneId: string,
+  worktreePath: string,
+  paneMap: Record<string, string>
+): void {
+  const paneIds = [parentPaneId];
+
+  for (let i = 1; i < node.panes.length; i++) {
+    const child = node.panes[i];
+    const sizePercent = child.size ?? Math.floor(100 / (node.panes.length - i + 1));
+    mux.splitPane(paneIds[i - 1], node.direction, sizePercent, worktreePath);
+    paneIds.push(mux.getActivePaneId(session));
+  }
+
+  for (let i = 0; i < node.panes.length; i++) {
+    const child = node.panes[i];
+    if (isSplit(child)) {
+      collectPaneMap(mux, session, child, paneIds[i], worktreePath, paneMap);
+    } else {
+      paneMap[child.name] = paneIds[i];
+      mux.renamePaneTitle(paneIds[i], child.name);
+      if (child.command) mux.sendCommand(paneIds[i], child.command);
+    }
+  }
+}
+
+function saveSessionInfo(
+  multiplexer: string,
+  panes: Record<string, string>,
+  worktreePath: string
+): void {
+  const orcheDir = path.join(worktreePath, ".orche");
+  mkdirSync(orcheDir, { recursive: true });
+  const workspaceId = process.env.CMUX_WORKSPACE_ID || undefined;
+  const info: SessionInfo = { multiplexer, panes, workspaceId };
+  writeFileSync(path.join(orcheDir, "session.json"), JSON.stringify(info, null, 2));
+}