sisyphi 1.0.13 → 1.0.14

package/dist/daemon.js

@@ -5,7 +5,7 @@ import {
   execEnv,
   execSafe,
   loadConfig
-} from "./chunk-LWWRGQWM.js";
+} from "./chunk-MMA43N67.js";
 import {
   shellQuote
 } from "./chunk-6G226ZK7.js";
@@ -32,7 +32,7 @@ import {
   statePath,
   worktreeBaseDir,
   worktreeConfigPath
-} from "./chunk-JXKUI4P6.js";
+} from "./chunk-YGBGKMTF.js";
 
 // src/daemon/index.ts
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
@@ -42,11 +42,12 @@ import { setTimeout as sleep } from "timers/promises";
 // src/daemon/server.ts
 import { createServer } from "net";
 import { unlinkSync, existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync6, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
 import { existsSync as existsSync7, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
+import { join as join6 } from "path";
 
 // src/daemon/state.ts
 import { randomUUID } from "crypto";
@@ -108,7 +109,11 @@ function createSession(id, task, cwd, context, name) {
 }
 function getSession(cwd, sessionId) {
   const content = readFileSync(statePath(cwd, sessionId), "utf-8");
-  return JSON.parse(content);
+  const session = JSON.parse(content);
+  for (const agent of session.agents) {
+    if (!agent.repo) agent.repo = ".";
+  }
+  return session;
 }
 function saveSession(session) {
   atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
@@ -202,6 +207,13 @@ async function updateReportSummary(cwd, sessionId, agentId, filePath, summary) {
     }
   });
 }
+async function updateSessionName(cwd, sessionId, name) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.name = name;
+    saveSession(session);
+  });
+}
 async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -521,6 +533,9 @@ function sessionExists(sessionName) {
 function killSession(sessionName) {
   execSafe(`tmux kill-session -t "${sessionName}"`);
 }
+function renameSession(oldName, newName) {
+  exec(`tmux rename-session -t "${oldName}" "${newName}"`);
+}
 function setSessionOption(sessionName, option, value) {
   execSafe(`tmux set-option -t "${sessionName}" ${option} ${shellQuote(value)}`);
 }
@@ -602,6 +617,43 @@ function lookupPane(paneId) {
 }
 
 // src/daemon/orchestrator.ts
+function detectRepos(cwd) {
+  const config = loadConfig(cwd);
+  const repos = [];
+  if (existsSync4(join3(cwd, ".git"))) {
+    try {
+      repos.push(getRepoInfo(cwd, "."));
+    } catch {
+    }
+  }
+  try {
+    const entries = readdirSync3(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const childPath = join3(cwd, entry.name);
+      if (existsSync4(join3(childPath, ".git"))) {
+        try {
+          repos.push(getRepoInfo(childPath, entry.name));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (config.repos && config.repos.length > 0) {
+    const allowed = new Set(config.repos);
+    return repos.filter((r) => r.name === "." || allowed.has(r.name));
+  }
+  return repos;
+}
+function getRepoInfo(repoPath, name) {
+  const branchRaw = execSafe(`git -C ${shellQuote(repoPath)} rev-parse --abbrev-ref HEAD`)?.trim();
+  if (!branchRaw) throw new Error(`Failed to detect git branch for repo: ${repoPath}`);
+  const status = execSafe(`git -C ${shellQuote(repoPath)} status --porcelain`);
+  const isDirty = !!(status && status.trim().length > 0);
+  return { name, path: repoPath, branch: branchRaw, isDirty };
+}
 var sessionWindowMap = /* @__PURE__ */ new Map();
 var sessionOrchestratorPane = /* @__PURE__ */ new Map();
 function getWindowId(sessionId) {
@@ -700,30 +752,30 @@ ${agentLines}
 `;
   }
   const roadmapRef = existsSync4(roadmapFile) ? `@${roadmapFile}` : "(empty)";
-  const worktreeAgents = session.agents.filter((a) => a.worktreePath);
-  let worktreeSection = "";
-  if (worktreeAgents.length > 0 || existsSync4(worktreeConfigPath(session.cwd))) {
-    let wtLines = "";
-    if (worktreeAgents.length > 0) {
-      wtLines = "\n" + worktreeAgents.map((a) => {
-        if (a.mergeStatus === "conflict") {
-          return `- ${a.id}: CONFLICT \u2014 ${a.mergeDetails ?? "unknown"}
-  Branch: ${a.branchName}
-  Worktree: ${a.worktreePath}`;
-        }
-        if (a.mergeStatus === "no-changes") {
-          return `- ${a.id}: NO CHANGES \u2014 agent did not commit any work to branch ${a.branchName}`;
+  const repos = detectRepos(session.cwd);
+  let repositoriesSection = "\n\n## Repositories\n";
+  if (repos.length === 0) {
+    repositoriesSection += "\nNo git repositories detected.\n";
+  } else {
+    for (const repo of repos) {
+      const dirtyTag = repo.isDirty ? " (dirty)" : "";
+      repositoriesSection += `
+### ${repo.name === "." ? "Session Root (.)" : repo.name}
+`;
+      repositoriesSection += `Branch: \`${repo.branch}\`${dirtyTag}
+`;
+      const repoAgents = session.agents.filter((a) => a.repo === repo.name);
+      if (repoAgents.length > 0) {
+        repositoriesSection += "\nAgents:\n";
+        for (const a of repoAgents) {
+          repositoriesSection += `- ${a.id} (${a.name}) [${a.status}]
+`;
         }
-        const status = a.mergeStatus ?? "pending";
-        return `- ${a.id}: ${status} (branch ${a.branchName})`;
-      }).join("\n");
+      }
+    }
+    if (repos.length > 1) {
+      repositoriesSection += '\nTarget agents at specific repos:\n```bash\nsisyphus spawn --name "impl" --repo <repo-name> "task"\n```\n';
     }
-    const worktreeHint = existsSync4(worktreeConfigPath(session.cwd)) ? "Worktree config active (`.sisyphus/worktree.json`). Use `--worktree` flag with `sisyphus spawn` to isolate agents in their own worktrees. Recommended for feature work, especially with potential file overlap." : "No worktree configuration found. If this session involves parallel work where agents may edit overlapping files, use the `git-management` skill to set up `.sisyphus/worktree.json` and enable worktree isolation.";
-    worktreeSection = `
-
-## Git Worktrees
-
-${worktreeHint}${wtLines}`;
   }
   const goalFile = goalPath(session.cwd, session.id);
   const goalContent = existsSync4(goalFile) ? readFileSync3(goalFile, "utf-8").trim() : session.task;
@@ -738,7 +790,7 @@ ${previousCyclesSection}${mostRecentCycleSection}
 ## Roadmap
 
 ${roadmapRef}
-${worktreeSection}`;
+`;
 }
 async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   try {
@@ -767,10 +819,12 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   writeFileSync3(promptFilePath, systemPrompt, "utf-8");
   sessionWindowMap.set(sessionId, windowId);
   const npmBinDir = resolveNpmBinDir();
+  const sesDir = sessionDir(cwd, sessionId);
   const envExports = buildEnvExports([
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
     `export SISYPHUS_AGENT_ID='orchestrator'`,
     `export SISYPHUS_CWD='${cwd}'`,
+    `export SISYPHUS_SESSION_DIR='${sesDir}'`,
     `export PATH="${npmBinDir}:$PATH"`
   ]);
   let userPrompt = formattedState;
@@ -798,11 +852,11 @@ ${continuationText}`;
   const settingsPath = resolve2(import.meta.dirname, "../templates/orchestrator-settings.json");
   const config = loadConfig(cwd);
   const effort = config.orchestratorEffort ?? "high";
-  const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --settings "${settingsPath}" --plugin-dir "${pluginPath}" --name "sisyphus:orch-${sessionId.slice(0, 8)}-cycle-${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
+  const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --settings "${settingsPath}" --plugin-dir "${pluginPath}" --name "sisyphus:orch-${session.name ?? sessionId.slice(0, 8)}-cycle-${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
   const paneId = createPane(windowId, cwd, "left");
   sessionOrchestratorPane.set(sessionId, paneId);
   registerPane(paneId, sessionId, "orchestrator");
-  setPaneTitle(paneId, `Sisyphus`);
+  setPaneTitle(paneId, session.name ? `${session.name} (orch)` : "Sisyphus");
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
   const bannerCmd = resolveBannerCmd();
   const notifyCmd = buildNotifyCmd(paneId);
@@ -866,37 +920,53 @@ import { dirname as dirname2, join as join4 } from "path";
 function loadWorktreeConfig(cwd) {
   try {
     const content = readFileSync4(worktreeConfigPath(cwd), "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+    const parsed = JSON.parse(content);
+    const flatKeys = ["copy", "clone", "symlink", "init"];
+    if (Object.keys(parsed).some((k) => flatKeys.includes(k))) {
+      throw new Error(
+        'Flat worktree.json format is no longer supported. Migrate to keyed format: wrap your config under a "." key.\nExample: { ".": { "symlink": ["node_modules"], "init": "npm install" } }'
+      );
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(
+          `Invalid worktree.json: value for "${key}" must be an object with optional keys: copy, clone, symlink, init`
+        );
+      }
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) return null;
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") return null;
+    throw err;
   }
 }
-function createWorktreeShell(cwd, sessionId, agentId) {
+function createWorktreeShell(repoRoot, sessionId, agentId) {
   const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
-  const worktreePath = join4(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
+  const worktreePath = join4(worktreeBaseDir(repoRoot), sessionId.slice(0, 8), agentId);
   mkdirSync2(dirname2(worktreePath), { recursive: true });
-  execSafe(`git -C ${shellQuote(cwd)} worktree prune`);
+  execSafe(`git -C ${shellQuote(repoRoot)} worktree prune`);
   if (existsSync5(worktreePath)) {
-    execSafe(`git -C ${shellQuote(cwd)} worktree remove --force ${shellQuote(worktreePath)}`);
+    execSafe(`git -C ${shellQuote(repoRoot)} worktree remove --force ${shellQuote(worktreePath)}`);
   }
-  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
-  exec(`git -C ${shellQuote(cwd)} branch ${shellQuote(branchName)} HEAD`);
-  exec(`git -C ${shellQuote(cwd)} worktree add ${shellQuote(worktreePath)} ${shellQuote(branchName)}`);
+  execSafe(`git -C ${shellQuote(repoRoot)} branch -D ${shellQuote(branchName)}`);
+  exec(`git -C ${shellQuote(repoRoot)} branch ${shellQuote(branchName)} HEAD`);
+  exec(`git -C ${shellQuote(repoRoot)} worktree add ${shellQuote(worktreePath)} ${shellQuote(branchName)}`);
   return { worktreePath, branchName };
 }
-function bootstrapWorktree(cwd, worktreePath, config) {
+function bootstrapWorktree(repoRoot, worktreePath, config) {
   if (config.copy) {
     for (const entry of config.copy) {
       const dest = join4(worktreePath, entry);
       mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe(`cp -r ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
+      execSafe(`cp -r ${shellQuote(join4(repoRoot, entry))} ${shellQuote(dest)}`);
     }
   }
   if (config.clone) {
     for (const entry of config.clone) {
       const dest = join4(worktreePath, entry);
       mkdirSync2(dirname2(dest), { recursive: true });
-      const src = shellQuote(join4(cwd, entry));
+      const src = shellQuote(join4(repoRoot, entry));
       const dstQ = shellQuote(dest);
       if (execSafe(`cp -Rc ${src} ${dstQ}`) === null) {
         execSafe(`cp -r ${src} ${dstQ}`);
@@ -907,7 +977,7 @@ function bootstrapWorktree(cwd, worktreePath, config) {
     for (const entry of config.symlink) {
       const dest = join4(worktreePath, entry);
       mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe(`ln -s ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
+      execSafe(`ln -s ${shellQuote(join4(repoRoot, entry))} ${shellQuote(dest)}`);
     }
   }
   if (config.init) {
@@ -918,8 +988,8 @@ function bootstrapWorktree(cwd, worktreePath, config) {
     }
   }
 }
-function resolveWorktreeBranch(cwd, worktreePath) {
-  const output = execSafe(`git -C ${shellQuote(cwd)} worktree list --porcelain`);
+function resolveWorktreeBranch(repoRoot, worktreePath) {
+  const output = execSafe(`git -C ${shellQuote(repoRoot)} worktree list --porcelain`);
   if (!output) return null;
   const lines = output.split("\n");
   for (let i = 0; i < lines.length; i++) {
@@ -941,42 +1011,59 @@ function mergeWorktrees(cwd, agents) {
     (a) => a.worktreePath && a.mergeStatus === "pending"
   );
   const results = [];
-  execSafe(`git -C ${shellQuote(cwd)} add .sisyphus`);
-  execSafe(`git -C ${shellQuote(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
+  const byRepo = /* @__PURE__ */ new Map();
   for (const agent of pending) {
-    const branch = resolveWorktreeBranch(cwd, agent.worktreePath);
-    if (!branch) {
-      results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
-      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)} --force`);
-      continue;
-    }
-    const aheadLog = execSafe(`git -C ${shellQuote(cwd)} log HEAD..${shellQuote(branch)} --oneline`);
-    if (!aheadLog) {
-      results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
-      cleanupWorktree(cwd, agent.worktreePath, branch);
-      continue;
-    }
-    const mergeMsg = `sisyphus: merge ${agent.id} (${agent.name})`;
-    const mergeCmd = `git -C ${shellQuote(cwd)} merge --no-ff ${shellQuote(branch)} -m ${shellQuote(mergeMsg)}`;
-    try {
-      exec(mergeCmd);
-      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)}`);
-      execSafe(`git -C ${shellQuote(cwd)} branch -d ${shellQuote(branch)}`);
-      results.push({ agentId: agent.id, name: agent.name, status: "merged" });
-    } catch (err) {
-      execSafe(`git -C ${shellQuote(cwd)} merge --abort`);
-      const errObj = err;
-      const stdout = errObj.stdout ? (typeof errObj.stdout === "string" ? errObj.stdout : errObj.stdout.toString("utf-8")).trim() : "";
-      const stderr = errObj.stderr ? (typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr.toString("utf-8")).trim() : "";
-      const conflictDetails = stdout || stderr || (err instanceof Error ? err.message : String(err));
-      results.push({ agentId: agent.id, name: agent.name, status: "conflict", conflictDetails });
+    const repo = agent.repo;
+    if (!byRepo.has(repo)) byRepo.set(repo, []);
+    byRepo.get(repo).push(agent);
+  }
+  if (existsSync5(join4(cwd, ".git"))) {
+    execSafe(`git -C ${shellQuote(cwd)} add .sisyphus`);
+    execSafe(`git -C ${shellQuote(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
+  } else {
+    console.log("[sisyphus] Skipping .sisyphus snapshot \u2014 session root is not a git repo");
+  }
+  for (const [repo, repoAgents] of byRepo) {
+    const repoRoot = repo === "." ? cwd : join4(cwd, repo);
+    if (repo !== ".") {
+      execSafe(`git -C ${shellQuote(repoRoot)} add -A`);
+      execSafe(`git -C ${shellQuote(repoRoot)} commit -m 'sisyphus: snapshot before merge'`);
+    }
+    for (const agent of repoAgents) {
+      const branch = resolveWorktreeBranch(repoRoot, agent.worktreePath);
+      if (!branch) {
+        results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
+        execSafe(`git -C ${shellQuote(repoRoot)} worktree remove ${shellQuote(agent.worktreePath)} --force`);
+        continue;
+      }
+      const aheadLog = execSafe(`git -C ${shellQuote(repoRoot)} log HEAD..${shellQuote(branch)} --oneline`);
+      if (!aheadLog) {
+        results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
+        cleanupWorktree(repoRoot, agent.worktreePath, branch);
+        continue;
+      }
+      const mergeMsg = `sisyphus: merge ${agent.id} (${agent.name})`;
+      const mergeCmd = `git -C ${shellQuote(repoRoot)} merge --no-ff ${shellQuote(branch)} -m ${shellQuote(mergeMsg)}`;
+      try {
+        exec(mergeCmd);
+        execSafe(`git -C ${shellQuote(repoRoot)} worktree remove ${shellQuote(agent.worktreePath)}`);
+        execSafe(`git -C ${shellQuote(repoRoot)} branch -d ${shellQuote(branch)}`);
+        results.push({ agentId: agent.id, name: agent.name, status: "merged" });
+      } catch (err) {
+        execSafe(`git -C ${shellQuote(repoRoot)} merge --abort`);
+        const errObj = err;
+        const stdout = errObj.stdout ? (typeof errObj.stdout === "string" ? errObj.stdout : errObj.stdout.toString("utf-8")).trim() : "";
+        const stderr = errObj.stderr ? (typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr.toString("utf-8")).trim() : "";
+        const conflictDetails = stdout || stderr || (err instanceof Error ? err.message : String(err));
+        results.push({ agentId: agent.id, name: agent.name, status: "conflict", conflictDetails });
+      }
     }
   }
   return results;
 }
-function cleanupWorktree(cwd, worktreePath, branchName) {
-  execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(worktreePath)} --force`);
-  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
+function cleanupWorktree(repoRoot, worktreePath, branchName) {
+  execSafe(`git -C ${shellQuote(repoRoot)} worktree remove ${shellQuote(worktreePath)} --force`);
+  execSafe(`git -C ${shellQuote(repoRoot)} branch -D ${shellQuote(branchName)}`);
   const baseDir = dirname2(worktreePath);
   try {
     const entries = readdirSync4(baseDir);
@@ -993,6 +1080,38 @@ function countWorktreeAgents(agents) {
 // src/daemon/summarize.ts
 import { query } from "@r-cli/sdk";
 var disabled = false;
+async function generateSessionName(task) {
+  if (disabled) return null;
+  try {
+    const session = await query({
+      prompt: `Generate a 2-4 word kebab-case name for this task. Output ONLY the name.
+
+${task.slice(0, 500)}`,
+      options: {
+        model: "haiku",
+        maxTurns: 1
+      }
+    });
+    let text = "";
+    for await (const msg of session) {
+      if (msg.type === "assistant" && msg.message?.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "text") text += block.text;
+        }
+      }
+    }
+    const name = text.trim().toLowerCase();
+    if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) return null;
+    return name.slice(0, 30);
+  } catch (err) {
+    console.error(`[sisyphus] Haiku name generation failed: ${err instanceof Error ? err.message : err}`);
+    const status = err.status;
+    if (status === 401 || status === 403) {
+      disabled = true;
+    }
+    return null;
+  }
+}
 async function summarizeReport(reportText) {
   if (disabled) return null;
   try {
@@ -1048,14 +1167,7 @@ function renderAgentSuffix(sessionId, instruction, worktreeContext) {
 Session: {{SESSION_ID}}
 Task: {{INSTRUCTION}}`;
   }
-  let worktreeBlock = "";
-  if (worktreeContext) {
-    worktreeBlock = [
-      "## Worktree Context",
-      `You are working in an isolated git worktree on branch \`${worktreeContext.branchName}\`.`,
-      `If you start any services that require ports, add ${worktreeContext.offset} to the default port.`
-    ].join("\n");
-  }
+  const worktreeBlock = "";
   return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{WORKTREE_CONTEXT\}\}/g, worktreeBlock);
 }
 function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
@@ -1125,10 +1237,12 @@ function setupAgentPane(opts) {
   writeFileSync4(suffixFilePath, suffix, "utf-8");
   const bannerCmd = resolveBannerCmd();
   const npmBinDir = resolveNpmBinDir();
+  const sesDir = sessionDir(cwd, sessionId);
   const envExports = buildEnvExports([
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
     `export SISYPHUS_AGENT_ID='${agentId}'`,
     `export SISYPHUS_CWD='${cwd}'`,
+    `export SISYPHUS_SESSION_DIR='${sesDir}'`,
     ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : [],
     `export PATH="${npmBinDir}:$PATH"`
   ]);
@@ -1177,12 +1291,14 @@ async function spawnAgent(opts) {
   } catch {
     throw new Error(`${cliToCheck} CLI not found on PATH. Run \`sisyphus doctor\` to diagnose.`);
   }
-  let paneCwd = cwd;
+  const repo = opts.repo !== void 0 ? opts.repo : ".";
+  const repoRoot = repo === "." ? cwd : join5(cwd, repo);
+  let paneCwd = repoRoot;
   let worktreePath;
   let branchName;
   let worktreeContext;
   if (opts.worktree) {
-    const wt = createWorktreeShell(cwd, sessionId, agentId);
+    const wt = createWorktreeShell(repoRoot, sessionId, agentId);
     worktreePath = wt.worktreePath;
     branchName = wt.branchName;
     paneCwd = worktreePath;
@@ -1216,16 +1332,18 @@ async function spawnAgent(opts) {
     completedAt: null,
     reports: [],
     paneId,
+    repo,
     ...worktreePath ? { worktreePath, branchName, mergeStatus: "pending" } : {}
   };
   await addAgent(cwd, sessionId, agent);
   if (opts.worktree && worktreePath) {
     const config = loadWorktreeConfig(cwd);
-    if (config) {
+    const repoConfig = config ? config[repo] : void 0;
+    if (repoConfig) {
       const wtPath = worktreePath;
       setImmediate(() => {
         try {
-          bootstrapWorktree(cwd, wtPath, config);
+          bootstrapWorktree(repoRoot, wtPath, repoConfig);
         } catch (err) {
           console.error(`[sisyphus] worktree bootstrap failed for ${agentId}: ${err instanceof Error ? err.message : err}`);
         }
@@ -1268,6 +1386,8 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
       total: portOffset,
       branchName: agent.branchName
     };
+  } else if (agent.repo !== ".") {
+    paneCwd = join5(cwd, agent.repo);
   }
   if (agent.paneId) {
     try {
@@ -1521,6 +1641,30 @@ async function startSession(task, cwd, context, name) {
   updateTrackedWindow(sessionId, windowId);
   killPane(initialPaneId);
   pruneOldSessions(cwd);
+  if (!name) {
+    generateSessionName(task).then(async (generatedName) => {
+      if (!generatedName) return;
+      let finalName = generatedName;
+      let candidate = `sisyphus-${finalName}`;
+      let attempt = 0;
+      while (sessionExists(candidate) && attempt < 5) {
+        attempt++;
+        finalName = `${generatedName}-${attempt}`;
+        candidate = `sisyphus-${finalName}`;
+      }
+      if (sessionExists(candidate)) return;
+      try {
+        renameSession(tmuxName, candidate);
+      } catch {
+        return;
+      }
+      await updateSessionName(cwd, sessionId, finalName);
+      await updateSessionTmux(cwd, sessionId, candidate, getSession(cwd, sessionId).tmuxWindowId);
+      trackSession(sessionId, cwd, candidate);
+      registerSessionTmux(sessionId, candidate, getSession(cwd, sessionId).tmuxWindowId);
+    }).catch(() => {
+    });
+  }
   return { ...getSession(cwd, sessionId), tmuxSessionName: tmuxName };
 }
 var PRUNE_KEEP_COUNT = 10;
@@ -1711,7 +1855,7 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
     }
   });
 }
-async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree) {
+async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree, repo) {
   const windowId = getWindowId(sessionId);
   if (!windowId) throw new Error(`No tmux window found for session ${sessionId}`);
   const session = getSession(cwd, sessionId);
@@ -1726,7 +1870,8 @@ async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktre
     name,
     instruction,
     windowId,
-    worktree
+    worktree,
+    repo
   });
   await appendAgentToLastCycle(cwd, sessionId, agent.id);
   return { agentId: agent.id };
@@ -1783,7 +1928,8 @@ async function handleKill(sessionId, cwd) {
   }
   for (const agent of session.agents) {
     if (agent.worktreePath && agent.branchName) {
-      cleanupWorktree(cwd, agent.worktreePath, agent.branchName);
+      const repoRoot = agent.repo !== "." ? join6(cwd, agent.repo) : cwd;
+      cleanupWorktree(repoRoot, agent.worktreePath, agent.branchName);
     }
   }
   const orchPaneId = getOrchestratorPaneId(sessionId);
@@ -1821,7 +1967,8 @@ async function handleKillAgent(sessionId, cwd, agentId) {
     killPane(agent.paneId);
   }
   if (agent.worktreePath && agent.branchName) {
-    cleanupWorktree(cwd, agent.worktreePath, agent.branchName);
+    const repoRoot = agent.repo !== "." ? join6(cwd, agent.repo) : cwd;
+    cleanupWorktree(repoRoot, agent.worktreePath, agent.branchName);
   }
   await updateAgent(cwd, sessionId, agentId, {
     status: "killed",
@@ -1854,7 +2001,8 @@ async function handleRollback(sessionId, cwd, toCycle) {
   }
   for (const agent of session.agents) {
     if (agent.worktreePath && agent.branchName) {
-      cleanupWorktree(cwd, agent.worktreePath, agent.branchName);
+      const repoRoot = agent.repo !== "." ? join6(cwd, agent.repo) : cwd;
+      cleanupWorktree(repoRoot, agent.worktreePath, agent.branchName);
     }
   }
   const orchPaneId = getOrchestratorPaneId(sessionId);
@@ -1906,7 +2054,7 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
 var server = null;
 var sessionTrackingMap = /* @__PURE__ */ new Map();
 function registryPath() {
-  return join6(globalDir(), "session-registry.json");
+  return join7(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
@@ -1964,7 +2112,7 @@ async function handleRequest(req) {
       case "spawn": {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
-        const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.worktree);
+        const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.worktree, req.repo);
         return { ok: true, data: { agentId: result.agentId } };
       }
       case "submit": {
@@ -2117,7 +2265,7 @@ async function handleRequest(req) {
           sessionTrackingMap.delete(req.sessionId);
           persistSessionRegistry();
         }
-        const { sessionDir: sessionDir2 } = await import("./paths-NUUALUVP.js");
+        const { sessionDir: sessionDir2 } = await import("./paths-FYYSBD27.js");
         rmSync4(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
         return { ok: true };
       }
@@ -2150,7 +2298,7 @@ async function handleRequest(req) {
         if (req.content.length > 200) {
           const dir = messagesDir(tracking.cwd, req.sessionId);
           mkdirSync4(dir, { recursive: true });
-          filePath = join6(dir, `${id}.md`);
+          filePath = join7(dir, `${id}.md`);
           writeFileSync5(filePath, req.content, "utf-8");
         }
         await appendMessage(tracking.cwd, req.sessionId, {