@taskless-app/swarm 0.4.4 → 0.4.7

package/README.md

@@ -20,7 +20,7 @@ CLI, который поднимает у вас на машине **рой др
 
 ```bash
 npx @taskless-app/swarm login --workspace <slug>        # войти в свой Taskless-воркспейс
-npx @taskless-app/swarm start --repo <путь к репо>      # поднять демон роя
+npx @taskless-app/swarm start                          # поднять демон роя
 ```
 
 Или один раз глобально:
@@ -28,10 +28,16 @@ npx @taskless-app/swarm start --repo <путь к репо>      # поднят
 ```bash
 npm i -g @taskless-app/swarm
 swarm login --workspace <slug>
-swarm start --repo <путь к репо>   # поднять рой: уходит в фон, терминал остаётся вам
+swarm start                        # поднять рой: уходит в фон, терминал остаётся вам
 swarm --help                       # список остальных команд (spawn/ls/questions/answer/…)
 ```
 
+**Пути к репозиториям указывать не нужно.** Демон сам находит клоны на машине: у
+каждого в `.git/config` записан origin, и по нему клон сопоставляется с репозиторием
+проекта в Taskless. Смотрит в привычных местах (`~/projects`, `~/code`, `~/src`,
+`~/work`, …) на три уровня вглубь — на типовой машине это десятки миллисекунд. Клоны
+лежат где-то ещё — скажите один раз, `swarm start --repo <путь>`, дальше запомнится.
+
 **Демон открепляется от терминала.** `swarm start` не занимает окно: процесс уходит
 в фон, а весь вывод пишется в `~/.taskless-swarm/overmind.log` — тот самый файл, из
 которого агент читает хвост лога удалённо. Посмотреть: `swarm logs -f`. Нужен вывод

package/dist/cli.js

@@ -557,6 +557,7 @@ var DRONE_CHANNEL_GRACE_MS = envNum("SWARM_DRONE_CHANNEL_GRACE_MS", 12e4);
 var HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join(SWARM_HOME, "overmind.heartbeat");
 var HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
 var SWARM_REPO = process.env.SWARM_REPO || "";
+var SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
 var SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
 var TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
 var SWARM_SHOT_TIMEOUT_MS = envNum("SWARM_SHOT_TIMEOUT_MS", 2e4);
@@ -3480,7 +3481,7 @@ function pidsWithCwdUnder(dir, opts = {}) {
   if ((opts.platform ?? process.platform) === "win32") return winProcsUnder(dir, opts.procs ?? listProcs);
   let out;
   try {
-    out = execQuiet("lsof", ["-w", "-a", "-d", "cwd", "-F", "pn"], { maxBuffer: PROC_SNAPSHOT_MAX_BUFFER });
+    out = execQuiet("lsof", ["-a", "-d", "cwd", "-F", "pn"], { maxBuffer: PROC_SNAPSHOT_MAX_BUFFER });
   } catch (e) {
     logTransientSpawnError("lsof", e);
     return [];
@@ -3940,7 +3941,7 @@ async function collectRunDiff(worktree, opts = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.4.4",
+  version: "0.4.7",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -7277,7 +7278,9 @@ function usage() {
   swarm login [--workspace <slug|id>] [--no-open]
                            \u0432\u043E\u0439\u0442\u0438 \u0432 Taskless \u0438 \u0432\u044B\u0431\u0440\u0430\u0442\u044C \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441
   swarm start [--repo <path>] [--foreground]
-                           \u043F\u043E\u0434\u043D\u044F\u0442\u044C \u0440\u043E\u0439 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: \u0440\u0430\u0437\u0431\u0438\u0440\u0430\u0435\u0442 \u043E\u0447\u0435\u0440\u0435\u0434\u044C, \u0441\u043F\u0430\u0432\u043D\u0438\u0442 \u0438 \u0431\u0443\u0434\u0438\u0442 \u0434\u0440\u043E\u043D\u043E\u0432
+                           \u043F\u043E\u0434\u043D\u044F\u0442\u044C \u0440\u043E\u0439 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: \u0440\u0430\u0437\u0431\u0438\u0440\u0430\u0435\u0442 \u043E\u0447\u0435\u0440\u0435\u0434\u044C, \u0441\u043F\u0430\u0432\u043D\u0438\u0442 \u0438 \u0431\u0443\u0434\u0438\u0442 \u0434\u0440\u043E\u043D\u043E\u0432.
+                           \u0420\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u043D\u0430\u0445\u043E\u0434\u0438\u0442 \u0441\u0430\u043C \u2014 \u043A\u043B\u043E\u043D\u044B \u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432 Taskless \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435;
+                           --repo \u043D\u0443\u0436\u0435\u043D, \u0442\u043E\u043B\u044C\u043A\u043E \u0435\u0441\u043B\u0438 \u043E\u043D\u0438 \u043B\u0435\u0436\u0430\u0442 \u0432 \u043D\u0435\u043E\u0431\u044B\u0447\u043D\u043E\u043C \u043C\u0435\u0441\u0442\u0435
   swarm status             \u0436\u0438\u0432 \u043B\u0438 \u0434\u0435\u043C\u043E\u043D, \u043D\u0430 \u043F\u0430\u0443\u0437\u0435 \u043B\u0438 \u0440\u043E\u0439, \u0441\u043A\u043E\u043B\u044C\u043A\u043E \u0434\u0440\u043E\u043D\u043E\u0432 \u0432 \u0440\u0430\u0431\u043E\u0442\u0435
 
 \u0414\u0410\u0422\u042C \u0420\u041E\u042E \u0420\u0410\u0411\u041E\u0422\u0423
@@ -7422,14 +7425,11 @@ if (cmd === "start") {
   }
   const { repo: repoFlag } = takeRepo(startArgs);
   const repo = repoFlag ?? SWARM_REPO;
-  if (!repo) {
-    console.warn("SWARM_REPO \u043D\u0435 \u0437\u0430\u0434\u0430\u043D \u2014 \u043F\u0440\u043E\u0433\u043E\u043D\u044B \u0431\u0435\u0437 \u044F\u0432\u043D\u043E\u0433\u043E repo \u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u0442\u044F\u0442\u0441\u044F (\u043D\u0443\u0436\u0435\u043D spawn --repo).");
-  }
   if (!foreground) {
     process.exit(await runStartDetached(startArgs));
   }
   try {
-    await runDaemon({ repo });
+    await runDaemon({ repo, repoFlag });
   } catch (e) {
     console.error(`\u0434\u0435\u043C\u043E\u043D \u043D\u0435 \u043F\u043E\u0434\u043D\u044F\u043B\u0441\u044F: ${e instanceof Error ? e.message : e}`);
     process.exit(1);

package/dist/overmind.js

@@ -407,13 +407,13 @@ var init_slug = __esm({
 function extractText(d) {
   if (typeof d === "string") return d;
   const out = [];
-  const walk = (n) => {
+  const walk2 = (n) => {
     if (!n || typeof n !== "object") return;
     const node = n;
     if (node.text) out.push(node.text);
-    (node.content ?? []).forEach(walk);
+    (node.content ?? []).forEach(walk2);
   };
-  walk(d);
+  walk2(d);
   return out.join(" ");
 }
 function sanitizeEventText(text) {
@@ -793,6 +793,7 @@ __export(config_exports, {
   SWARM_REPO: () => SWARM_REPO,
   SWARM_REPO_PATHS: () => SWARM_REPO_PATHS,
   SWARM_REVIEW_CAP: () => SWARM_REVIEW_CAP,
+  SWARM_SCAN_DEPTH: () => SWARM_SCAN_DEPTH,
   SWARM_SHOT_TIMEOUT_MS: () => SWARM_SHOT_TIMEOUT_MS,
   SWARM_STORM_URL: () => SWARM_STORM_URL,
   SWARM_SWEEP_INTERVAL_MS: () => SWARM_SWEEP_INTERVAL_MS,
@@ -892,7 +893,7 @@ function reviewCutoffAt() {
   }
   return at;
 }
-var SWARM_HOME, DB_PATH, DRONE_HOME, DRONE_HOME_ISOLATION, DRONE_ISOLATION, WORKTREES_NOINDEX_DIR, WORKTREES_LEGACY_DIR, WORKTREES_DIR, RUN_LOGS_DIR, DAEMON_LOG_PATH, DIST_BUILD, SWARM_BACKEND, SWARM_OUTBOX, SWARM_MAX_IN_FLIGHT, SWARM_CLAIM_INTERVAL_MS, SWARM_MAX_LOAD_FACTOR, SWARM_MIN_FREE_GB, SWARM_MAX_FD_LOAD_FACTOR, SWARM_MAX_CPU_BUSY, SWARM_RELIEF_LOAD_FACTOR, SWARM_RELIEF_MIN_FREE_GB, SWARM_RELIEF_MAX_FD_LOAD_FACTOR, SWARM_RELIEF_CPU_BUSY, SWARM_RELIEF_COST_WINDOW_MS, SWARM_RELIEF_ALERT_PAUSES, SWARM_RELIEF_ALERT_LOST_MS, SWARM_RELIEF_ALERT_MIN_STEPS, SWARM_RELIEF_ALERT_SUSTAIN_MS, SWARM_LOW_DISK_GB, SWARM_REHYDRATE_MS, SWARM_DRONE_BRIDGE_MS, SWARM_PROD_HEARTBEAT_MS, SWARM_VERSION_CHECK_MS, SWARM_SWEEP_INTERVAL_MS, DRONE_CHANNEL_ENABLED, DRONE_CHANNEL_PORT, DRONE_CHANNEL_URL, DRONE_CHANNEL_SECRET_PATH, DRONE_CHANNEL_GRACE_MS, HEARTBEAT_PATH, HEARTBEAT_STALE_MS, SWARM_REPO, SWARM_REPO_PATHS, TASKLESS_API, SWARM_SHOT_TIMEOUT_MS, TASKLESS_MCP_PATH, TASKLESS_TOKEN, TASKLESS_WORKSPACE, TASKLESS_WORKSPACE_SLUG, TASKLESS_TASK_URL_BASE, SWARM_VERIFY, SWARM_AUTO_REVIEW, REVIEW_CUTOFF_PATH, SWARM_REVIEW_CAP, SWARM_STORM_URL, WEB_PORT, WEB_REDIRECT_URI, SWARM_ANOMALY_RENOTIFY_MS, SWARM_ANOMALY_MAX_REPEATS, SWARM_ANOMALY_RUN_DOWN_WINDOW_MS, SWARM_ANOMALY_FAILED_SPIKE_COUNT, SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS, SWARM_ANOMALY_QUEUE_STALLED_MS, SWARM_ANOMALY_PR_STUCK_MERGE_MS, SWARM_ANOMALY_PR_NO_REVIEWER_MS, SWARM_ANOMALY_QUESTION_UNANSWERED_MS, SWARM_ANOMALY_OUTBOX_STUCK_MS, SWARM_ANOMALY_RESOURCE_GATE_STALL_MS, SWARM_WATCHDOG_STALL_MS;
+var SWARM_HOME, DB_PATH, DRONE_HOME, DRONE_HOME_ISOLATION, DRONE_ISOLATION, WORKTREES_NOINDEX_DIR, WORKTREES_LEGACY_DIR, WORKTREES_DIR, RUN_LOGS_DIR, DAEMON_LOG_PATH, DIST_BUILD, SWARM_BACKEND, SWARM_OUTBOX, SWARM_MAX_IN_FLIGHT, SWARM_CLAIM_INTERVAL_MS, SWARM_MAX_LOAD_FACTOR, SWARM_MIN_FREE_GB, SWARM_MAX_FD_LOAD_FACTOR, SWARM_MAX_CPU_BUSY, SWARM_RELIEF_LOAD_FACTOR, SWARM_RELIEF_MIN_FREE_GB, SWARM_RELIEF_MAX_FD_LOAD_FACTOR, SWARM_RELIEF_CPU_BUSY, SWARM_RELIEF_COST_WINDOW_MS, SWARM_RELIEF_ALERT_PAUSES, SWARM_RELIEF_ALERT_LOST_MS, SWARM_RELIEF_ALERT_MIN_STEPS, SWARM_RELIEF_ALERT_SUSTAIN_MS, SWARM_LOW_DISK_GB, SWARM_REHYDRATE_MS, SWARM_DRONE_BRIDGE_MS, SWARM_PROD_HEARTBEAT_MS, SWARM_VERSION_CHECK_MS, SWARM_SWEEP_INTERVAL_MS, DRONE_CHANNEL_ENABLED, DRONE_CHANNEL_PORT, DRONE_CHANNEL_URL, DRONE_CHANNEL_SECRET_PATH, DRONE_CHANNEL_GRACE_MS, HEARTBEAT_PATH, HEARTBEAT_STALE_MS, SWARM_REPO, SWARM_SCAN_DEPTH, SWARM_REPO_PATHS, TASKLESS_API, SWARM_SHOT_TIMEOUT_MS, TASKLESS_MCP_PATH, TASKLESS_TOKEN, TASKLESS_WORKSPACE, TASKLESS_WORKSPACE_SLUG, TASKLESS_TASK_URL_BASE, SWARM_VERIFY, SWARM_AUTO_REVIEW, REVIEW_CUTOFF_PATH, SWARM_REVIEW_CAP, SWARM_STORM_URL, WEB_PORT, WEB_REDIRECT_URI, SWARM_ANOMALY_RENOTIFY_MS, SWARM_ANOMALY_MAX_REPEATS, SWARM_ANOMALY_RUN_DOWN_WINDOW_MS, SWARM_ANOMALY_FAILED_SPIKE_COUNT, SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS, SWARM_ANOMALY_QUEUE_STALLED_MS, SWARM_ANOMALY_PR_STUCK_MERGE_MS, SWARM_ANOMALY_PR_NO_REVIEWER_MS, SWARM_ANOMALY_QUESTION_UNANSWERED_MS, SWARM_ANOMALY_OUTBOX_STUCK_MS, SWARM_ANOMALY_RESOURCE_GATE_STALL_MS, SWARM_WATCHDOG_STALL_MS;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -940,6 +941,7 @@ var init_config = __esm({
     HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join(SWARM_HOME, "overmind.heartbeat");
     HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
     SWARM_REPO = process.env.SWARM_REPO || "";
+    SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
     SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
     TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
     SWARM_SHOT_TIMEOUT_MS = envNum("SWARM_SHOT_TIMEOUT_MS", 2e4);
@@ -2278,7 +2280,7 @@ function pidsWithCwdUnder(dir, opts = {}) {
   if ((opts.platform ?? process.platform) === "win32") return winProcsUnder(dir, opts.procs ?? listProcs);
   let out;
   try {
-    out = execQuiet("lsof", ["-w", "-a", "-d", "cwd", "-F", "pn"], { maxBuffer: PROC_SNAPSHOT_MAX_BUFFER });
+    out = execQuiet("lsof", ["-a", "-d", "cwd", "-F", "pn"], { maxBuffer: PROC_SNAPSHOT_MAX_BUFFER });
   } catch (e) {
     logTransientSpawnError("lsof", e);
     return [];
@@ -2468,16 +2470,16 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync8, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
 import { appendFile, mkdir, readFile, rm } from "fs/promises";
-import { isAbsolute, join as join9 } from "path";
+import { isAbsolute, join as join11 } from "path";
 import { $ as $2 } from "execa";
 async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync4(join9(dir, ".git")).isFile();
+    return statSync5(join11(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -2583,9 +2585,9 @@ async function ensureGitExcluded(worktree, pattern) {
     const out = await $2({ reject: false })`git -C ${worktree} rev-parse --git-common-dir`;
     const raw = out.stdout.trim();
     if (out.exitCode !== 0 || !raw) return false;
-    const commonDir = isAbsolute(raw) ? raw : join9(worktree, raw);
-    const infoDir = join9(commonDir, "info");
-    const excludeFile = join9(infoDir, "exclude");
+    const commonDir = isAbsolute(raw) ? raw : join11(worktree, raw);
+    const infoDir = join11(commonDir, "info");
+    const excludeFile = join11(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -2618,7 +2620,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync7(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join9(dir, d.name));
+      return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join11(dir, d.name));
     } catch {
       return [];
     }
@@ -2730,18 +2732,18 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname3 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync10(path, "utf8").trim();
+    const s = readFileSync12(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
   mkdirSync5(dirname3(path), { recursive: true });
-  writeFileSync7(path, secret, { mode: 384 });
+  writeFileSync8(path, secret, { mode: 384 });
   try {
     chmodSync(path, 384);
   } catch {
@@ -3071,10 +3073,10 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
-  const walk = (node) => {
+  const walk2 = (node) => {
     if (!node || typeof node !== "object") return;
     const n = node;
     const attrs = n.attrs ?? {};
@@ -3093,9 +3095,9 @@ function attachmentsFromDoc(doc, origin) {
         });
       }
     }
-    if (Array.isArray(n.content)) for (const c of n.content) walk(c);
+    if (Array.isArray(n.content)) for (const c of n.content) walk2(c);
   };
-  walk(doc);
+  walk2(doc);
   return out;
 }
 function collectTaskAttachments(task) {
@@ -3162,7 +3164,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join11(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join13(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -3208,7 +3210,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join11(dir, name), file.bytes);
+      await io.writeFile(join13(dir, name), file.bytes);
     } catch (e) {
       result.skipped.push(`${label} \u2014 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043B\u043E\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A (${errText(e)})`);
       continue;
@@ -3361,7 +3363,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute2, join as join12 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute2, join as join14 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -3387,7 +3389,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute2(path) ? path : join12(opts.worktree, path));
+      bytes = await read(isAbsolute2(path) ? path : join14(opts.worktree, path));
     } catch (e) {
       skipped.push({ path, reason: `\u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D: ${e instanceof Error ? e.message : String(e)}` });
       continue;
@@ -3465,8 +3467,8 @@ var init_shotUpload = __esm({
 
 // src/oauth.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, unlinkSync as unlinkSync2 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -3550,13 +3552,13 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync11(STORE_PATH, "utf8"));
+    return JSON.parse(readFileSync13(STORE_PATH, "utf8"));
   } catch {
     return null;
   }
 }
 function saveStore(s) {
-  writeFileSync8(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync9(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -3566,7 +3568,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync11(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync13(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -3575,7 +3577,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync8(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync9(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -3601,18 +3603,18 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH = join13(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join13(SWARM_HOME, "oauth-client.json");
+    STORE_PATH = join15(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join15(SWARM_HOME, "oauth-client.json");
     base = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
+import { join as join16 } from "path";
 function loadAgentToken() {
   try {
-    const s = JSON.parse(readFileSync12(STORE_PATH2, "utf8"));
+    const s = JSON.parse(readFileSync14(STORE_PATH2, "utf8"));
     return s.token ? s : null;
   } catch {
     return null;
@@ -3649,17 +3651,17 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH2 = join14(SWARM_HOME, "agent.json");
+    STORE_PATH2 = join16(SWARM_HOME, "agent.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync4 } from "fs";
+import { join as join17 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync13(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync15(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -3673,7 +3675,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join15(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join17(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -4137,8 +4139,9 @@ var init_droneStore = __esm({
 
 // src/overmind.ts
 init_db();
-import { existsSync as existsSync12, readFileSync as readFileSync15, readdirSync as readdirSync9, renameSync as renameSync7 } from "fs";
-import { basename as basename4, dirname as dirname5, join as join19 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync12, readFileSync as readFileSync17, readdirSync as readdirSync10, renameSync as renameSync7 } from "fs";
+import { basename as basename4, dirname as dirname5, join as join21 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { spawn as spawn3 } from "child_process";
 
@@ -6035,6 +6038,18 @@ init_heartbeat();
 // src/repoRegistry.ts
 init_config();
 import { $ } from "execa";
+function effectiveRepoPaths(flagRepo, envPaths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of [flagRepo ?? "", ...envPaths]) {
+    if (!raw.trim()) continue;
+    const key = normalizeRepo(raw);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
 function parseRepoFullName(remoteUrl) {
   const m = remoteUrl.trim().match(/^(?:https?:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:)([^/]+)\/([^/]+?)(\.git)?\/?$/i);
   if (!m) return null;
@@ -6057,19 +6072,137 @@ async function buildRepoRegistry(paths) {
   return resolved.filter((e) => e !== null);
 }
 
+// src/repoMemory.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join4 } from "path";
+var FILE = "repos.json";
+function loadRememberedRepos(home) {
+  let raw;
+  try {
+    raw = readFileSync6(join4(home, FILE), "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.paths)) return [];
+    return parsed.paths.filter((p) => typeof p === "string" && p.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+function rememberRepos(home, paths, now = () => /* @__PURE__ */ new Date()) {
+  const clean = paths.filter((p) => p.trim().length > 0);
+  if (clean.length === 0) return;
+  writeFileSync5(join4(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
+`);
+}
+function pickRepoPaths(args) {
+  if (args.flag.length > 0) return { paths: [...args.flag], source: "flag" };
+  if (args.env.length > 0) return { paths: [...args.env], source: "env" };
+  if (args.remembered.length > 0) return { paths: [...args.remembered], source: "memory" };
+  return { paths: [], source: "none" };
+}
+
+// src/repoScan.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+var SKIP = /* @__PURE__ */ new Set([
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  "target",
+  "Library",
+  "Applications",
+  ".Trash",
+  "venv",
+  ".venv",
+  "__pycache__"
+]);
+function parseOriginFromGitConfig(text) {
+  let inOrigin = false;
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("[")) {
+      inOrigin = /^\[remote\s+"origin"\]$/.test(t);
+      continue;
+    }
+    if (!inOrigin) continue;
+    const m = /^url\s*=\s*(.+)$/.exec(t);
+    if (m?.[1]) return m[1].trim();
+  }
+  return null;
+}
+function originOf(dir) {
+  try {
+    return parseOriginFromGitConfig(readFileSync7(join5(dir, ".git", "config"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function scanRoots(roots, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 3;
+  const found = /* @__PURE__ */ new Map();
+  for (const root of roots) walk(root, 0, maxDepth, found);
+  return found;
+}
+function walk(dir, depth, maxDepth, found) {
+  if (depth > maxDepth) return;
+  const origin = originOf(dir);
+  if (origin) {
+    const full = parseRepoFullName(origin);
+    if (full && !found.has(full)) found.set(full, dir);
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name.startsWith(".") || SKIP.has(name)) continue;
+    const child = join5(dir, name);
+    try {
+      if (!statSync2(child).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    walk(child, depth + 1, maxDepth, found);
+  }
+}
+function defaultScanRoots(home, knownPaths = []) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (p) => {
+    if (!p || seen.has(p)) return;
+    seen.add(p);
+    out.push(p);
+  };
+  for (const p of knownPaths) {
+    const parent = p.replace(/\/+$/, "").replace(/\/[^/]+$/, "");
+    if (parent && parent !== p) add(parent);
+  }
+  for (const name of ["projects", "code", "src", "dev", "work", "repos", "git", "Projects", "Code", "Developer", "Documents/GitHub", "go/src"]) {
+    add(join5(home, name));
+  }
+  return out;
+}
+
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync5, readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join6 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join4(home, "host.json");
+  return join6(home, "host.json");
 }
 function loadHostIdentity(deps) {
   const exists = deps.exists ?? existsSync5;
-  const readFile2 = deps.readFile ?? ((p) => readFileSync6(p, "utf8"));
+  const readFile2 = deps.readFile ?? ((p) => readFileSync8(p, "utf8"));
   const writeFile2 = deps.writeFile ?? ((p, data) => {
-    writeFileSync5(`${p}.tmp`, data);
+    writeFileSync6(`${p}.tmp`, data);
     renameSync4(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
@@ -6252,14 +6385,14 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync as readdirSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync as readdirSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join8 } from "path";
 import { fileURLToPath } from "url";
 
 // src/claudeBin.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
 import { win32 as winPath } from "path";
 var CLAUDE_FALLBACK = "claude";
 function compareVersionDirs(a, b) {
@@ -6274,7 +6407,7 @@ function compareVersionDirs(a, b) {
 }
 function realListDir(dir) {
   try {
-    return readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return readdirSync3(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
     return [];
   }
@@ -6331,8 +6464,8 @@ function resolveClaudeBin(opts = {}) {
 }
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync3, rmSync, statSync as statSync2, symlinkSync } from "fs";
-import { join as join5, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync4, rmSync, statSync as statSync3, symlinkSync } from "fs";
+import { join as join7, relative, sep } from "path";
 var DRONE_HOME_DENY_DEFAULT = [".taskless-swarm", ".bash_history", ".zsh_history"];
 function droneHomeDeny(env = process.env) {
   const extra = (env.SWARM_DRONE_HOME_DENY || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -6351,28 +6484,28 @@ function buildDroneHome(opts) {
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
   mkdirSync3(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync3(realHome), deny, platform));
+  const wanted = new Set(mirroredEntries(readdirSync4(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync3(droneHome)) {
+  for (const existing of readdirSync4(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join5(droneHome, existing);
+    const p = join7(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join5(droneHome, name);
+    const link = join7(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join5(realHome, name);
+    const target = join7(realHome, name);
     let isDir;
     try {
-      isDir = statSync2(target).isDirectory();
+      isDir = statSync3(target).isDirectory();
     } catch {
       continue;
     }
@@ -6390,7 +6523,7 @@ var REAL_PATH_ENV_PINS = [
   { env: "YARN_GLOBAL_FOLDER", segments: [".yarn", "berry"] }
 ];
 function realPathEnvPins(realHome) {
-  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join5(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join7(realHome, ...segments)]));
 }
 function droneDenyRules(realHome, swarmHome) {
   const paths = [
@@ -6482,7 +6615,7 @@ function droneEnv(worktree, base3 = process.env, isolation, droneCap = null) {
   const env = { ...base3 };
   const isolate = base3.SWARM_TURBO_ISOLATE !== "0";
   if (isolate && !base3.TURBO_CACHE_DIR) {
-    env.TURBO_CACHE_DIR = join6(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join8(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -6510,29 +6643,29 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join6(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
+  return join8(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join6(worktree, ".claude", "roles", kind);
+  return join8(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
   return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync7(dir));
 }
 function transcriptDir(worktree, projectsDir) {
-  return join6(projectsDir, worktree.replace(/[/.]/g, "-"));
+  return join8(projectsDir, worktree.replace(/[/.]/g, "-"));
 }
-function sessionTranscriptExists(worktree, projectsDir = join6(homedir2(), ".claude", "projects")) {
+function sessionTranscriptExists(worktree, projectsDir = join8(homedir2(), ".claude", "projects")) {
   try {
-    return readdirSync4(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
+    return readdirSync5(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
   } catch {
     return false;
   }
 }
-function transcriptMtimeMs(worktree, projectsDir = join6(homedir2(), ".claude", "projects")) {
+function transcriptMtimeMs(worktree, projectsDir = join8(homedir2(), ".claude", "projects")) {
   const dir = transcriptDir(worktree, projectsDir);
   let files;
   try {
-    files = readdirSync4(dir);
+    files = readdirSync5(dir);
   } catch {
     return null;
   }
@@ -6540,7 +6673,7 @@ function transcriptMtimeMs(worktree, projectsDir = join6(homedir2(), ".claude",
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue;
     try {
-      const mtime2 = statSync3(join6(dir, f)).mtimeMs;
+      const mtime2 = statSync4(join8(dir, f)).mtimeMs;
       if (latest === null || mtime2 > latest) latest = mtime2;
     } catch {
     }
@@ -6548,11 +6681,11 @@ function transcriptMtimeMs(worktree, projectsDir = join6(homedir2(), ".claude",
   return latest;
 }
 function nextRunLogPath(runLogsDir, runId) {
-  const dir = join6(runLogsDir, String(runId));
+  const dir = join8(runLogsDir, String(runId));
   mkdirSync4(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync4(dir);
+    files = readdirSync5(dir);
   } catch {
   }
   let next = 0;
@@ -6560,7 +6693,7 @@ function nextRunLogPath(runLogsDir, runId) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join6(dir, `${next}.json`);
+  return join8(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runId) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -6634,16 +6767,16 @@ function makeLauncher(cfg) {
         }
       }
     };
-    const cfgPath = join6(worktree, ".swarm-mcp.json");
-    writeFileSync6(cfgPath, JSON.stringify(mcpConfig, null, 2));
+    const cfgPath = join8(worktree, ".swarm-mcp.json");
+    writeFileSync7(cfgPath, JSON.stringify(mcpConfig, null, 2));
     const model = run.model ?? process.env.SWARM_DRONE_MODEL ?? void 0;
     const pluginDirs = roleDirs(worktree, run.kind);
     const realHome = cfg.droneIsolation?.realHome ?? homedir2();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
     const settings = cfg.droneIsolation ? droneSettingsJson(realHome, cfg.droneIsolation.swarmHome) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync7(join6(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync7(join8(cfg.droneIsolation.swarmHome, "token"))) {
       console.error(
-        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join6(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
+        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join8(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
       );
     }
     let stdio = "ignore";
@@ -6677,8 +6810,8 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync5, renameSync as renameSync5 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync6, renameSync as renameSync5 } from "fs";
+import { join as join9 } from "path";
 
 // src/pricing.ts
 var MODEL_PRICING = {
@@ -6729,23 +6862,23 @@ function launchCostUsd(result, model) {
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
 function unprocessedLogFiles(dir) {
   try {
-    return readdirSync5(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
+    return readdirSync6(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
   } catch {
     return [];
   }
 }
 function accountRunCost(deps, run) {
-  const dir = join7(deps.runLogsDir, String(run.id));
+  const dir = join9(deps.runLogsDir, String(run.id));
   const files = unprocessedLogFiles(dir);
   if (files.length === 0) return;
   const model = run.model ?? process.env.SWARM_DRONE_MODEL ?? null;
   let added = 0;
   const processed = [];
   for (const f of files) {
-    const full = join7(dir, f);
+    const full = join9(dir, f);
     let raw = null;
     try {
-      raw = readFileSync7(full, "utf8");
+      raw = readFileSync9(full, "utf8");
     } catch {
       continue;
     }
@@ -6772,14 +6905,14 @@ function makeCostAccountant(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync8 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
 var RESULT_FILE_RE = /^(\d+)\.json(\.done)?$/;
 function classifyExit(runLogsDir, runId) {
-  const dir = join8(runLogsDir, String(runId));
+  const dir = join10(runLogsDir, String(runId));
   let files;
   try {
-    files = readdirSync6(dir);
+    files = readdirSync7(dir);
   } catch {
     return "unknown";
   }
@@ -6793,7 +6926,7 @@ function classifyExit(runLogsDir, runId) {
   if (!latest) return "unknown";
   let raw;
   try {
-    raw = readFileSync8(join8(dir, latest.name), "utf8");
+    raw = readFileSync10(join10(dir, latest.name), "utf8");
   } catch {
     return "unknown";
   }
@@ -6807,8 +6940,8 @@ function makeExitClassifier(runLogsDir) {
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync9, readdirSync as readdirSync8, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync9, readFileSync as readFileSync11 } from "fs";
+import { join as join12 } from "path";
 import { execa } from "execa";
 var PREPARE_TIMEOUT_MS = 15 * 6e4;
 var MAX_PLAN_COMMANDS = 12;
@@ -6824,21 +6957,21 @@ async function runCommand(cmd, worktree) {
 }
 function safeReadText(p) {
   try {
-    return readFileSync9(p, "utf8");
+    return readFileSync11(p, "utf8");
   } catch {
     return null;
   }
 }
 function safeListDirs(p) {
   try {
-    return readdirSync8(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync9(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function safeListFiles(p) {
   try {
-    return readdirSync8(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
+    return readdirSync9(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -6866,19 +6999,19 @@ function overridePlan(override) {
 function detectPackageManager(worktree, io = {}) {
   const exists = io.exists ?? existsSync9;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join10(worktree, "package.json"));
+  const hasPkgJson = exists(join12(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join10(worktree, "deno.json")) || exists(join10(worktree, "deno.jsonc")) || exists(join10(worktree, "deno.lock"))) return "deno";
+    if (exists(join12(worktree, "deno.json")) || exists(join12(worktree, "deno.jsonc")) || exists(join12(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join10(worktree, "package.json"));
+  const pkg = readJson(readText, join12(worktree, "package.json"));
   const declared = typeof pkg?.packageManager === "string" ? pkg.packageManager.split("@")[0] : void 0;
   if (declared === "pnpm" || declared === "bun" || declared === "npm" || declared === "yarn") return declared;
-  if (exists(join10(worktree, "bun.lock")) || exists(join10(worktree, "bun.lockb"))) return "bun";
-  if (exists(join10(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join10(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join10(worktree, "package-lock.json"))) return "npm";
-  if (exists(join10(worktree, "deno.lock"))) return "deno";
+  if (exists(join12(worktree, "bun.lock")) || exists(join12(worktree, "bun.lockb"))) return "bun";
+  if (exists(join12(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join12(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join12(worktree, "package-lock.json"))) return "npm";
+  if (exists(join12(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -6939,7 +7072,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join10(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join12(worktree, "node_modules"), source: "detect" }
     ];
     for (const target of workspaceBuildTargets(worktree, io)) {
       commands.push({ label: `\u0441\u0431\u043E\u0440\u043A\u0430 ${target.name}`, run: jsRunScript(pm, "build"), cwd: target.dir, source: "detect" });
@@ -6947,12 +7080,12 @@ function detectPlan(worktree, io) {
     return { source: "detect", ecosystem: `node/${pm}`, commands };
   }
   for (const marker of ECOSYSTEM_MARKERS) {
-    const hit = marker.files.some((f) => exists(join10(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join12(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
     if (!hit) continue;
     let ecosystem = marker.ecosystem;
     let command = marker.command;
     for (const refine of marker.refine ?? []) {
-      if (!exists(join10(worktree, refine.file))) continue;
+      if (!exists(join12(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -7009,12 +7142,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join10(worktree, ".github", "workflows");
+  const dir = join12(worktree, ".github", "workflows");
   const files = listFiles(dir).filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
   const seen = /* @__PURE__ */ new Set();
   const commands = [];
   for (const name of files.sort()) {
-    const yaml = readText(join10(dir, name));
+    const yaml = readText(join12(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -7029,7 +7162,7 @@ function ciWorkflowPlan(worktree, io) {
   return commands.length ? { source: "ci-workflow", ecosystem: "ci-\u043A\u043E\u043D\u0444\u0438\u0433", commands } : null;
 }
 function workspaceGlobs(worktree, readText) {
-  const yaml = readText(join10(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join12(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -7049,7 +7182,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join10(worktree, "package.json"));
+  const pkg = readJson(readText, join12(worktree, "package.json"));
   const ws = pkg?.workspaces;
   const list = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
   return list.filter((g) => typeof g === "string");
@@ -7060,14 +7193,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join10(worktree, glob);
-      if (io.exists(join10(dir, "package.json"))) dirs.add(dir);
+      const dir = join12(worktree, glob);
+      if (io.exists(join12(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join10(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join12(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join10(base3, name);
-      if (io.exists(join10(dir, "package.json"))) dirs.add(dir);
+      const dir = join12(base3, name);
+      if (io.exists(join12(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -7095,11 +7228,11 @@ function workspaceBuildTargets(worktree, io = {}) {
   if (!globs.length) return [];
   const pkgs = [];
   for (const dir of workspaceDirs(worktree, globs, { exists, listDirs })) {
-    const pkg = readJson(readText, join10(dir, "package.json"));
+    const pkg = readJson(readText, join12(dir, "package.json"));
     if (!pkg || typeof pkg.name !== "string") continue;
     const scripts = pkg.scripts ?? {};
     const entries = entryPaths(pkg);
-    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join10(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join12(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -8673,7 +8806,7 @@ function makeExclusiveReader(opts) {
 
 // src/envGate.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join16, delimiter } from "path";
+import { join as join18, delimiter } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 var PROBE_TIMEOUT_MS = 2500;
@@ -8725,7 +8858,7 @@ var COMPOSE_MARKERS = [
 ];
 function detectRequirements(repo, io = {}) {
   const exists = io.exists ?? existsSync10;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join16(repo, f)));
+  const marker = COMPOSE_MARKERS.find((f) => exists(join18(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -8747,7 +8880,7 @@ async function hasCommand(name, env) {
   if (name.includes("/")) return existsSync10(name);
   const dirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
-  return dirs.some((dir) => exts.some((ext) => existsSync10(join16(dir, name + ext))));
+  return dirs.some((dir) => exts.some((ext) => existsSync10(join18(dir, name + ext))));
 }
 async function portOpen(host, port) {
   return new Promise((resolve3) => {
@@ -8864,8 +8997,8 @@ import { basename as basename3 } from "path";
 import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
-import { statSync as statSync5 } from "fs";
-import { join as join17 } from "path";
+import { statSync as statSync6 } from "fs";
+import { join as join19 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -9008,7 +9141,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync5(path).mtimeMs;
+    return statSync6(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -9033,7 +9166,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join17(worktree, b.path)) - mtime(join17(worktree, a.path)));
+  files.sort((a, b) => mtime(join19(worktree, b.path)) - mtime(join19(worktree, a.path)));
   const truncatedFiles = files.length > MAX_FILES;
   if (truncatedFiles) files = files.slice(0, MAX_FILES);
   const added = files.reduce((s, f) => s + f.added, 0);
@@ -9052,7 +9185,7 @@ async function collectRunDiff(worktree, opts = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.4.4",
+  version: "0.4.7",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -10784,16 +10917,16 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14, renameSync as renameSync6, writeFileSync as writeFileSync11 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync16, renameSync as renameSync6, writeFileSync as writeFileSync12 } from "fs";
+import { join as join20 } from "path";
 var KEY_TTL_MS = 7 * 24 * 60 * 6e4;
 var EMPTY = { since: {}, lastFiredAt: {}, fires: {}, stopQuiet: null };
 function anomalyStatePath(home) {
-  return join18(home, "anomaly-state.json");
+  return join20(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
   const exists = io.exists ?? existsSync11;
-  const readFile2 = io.readFile ?? ((p) => readFileSync14(p, "utf8"));
+  const readFile2 = io.readFile ?? ((p) => readFileSync16(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return { ...EMPTY };
   try {
@@ -10819,7 +10952,7 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
 function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile2 = io.writeFile ?? ((p, data) => {
-    writeFileSync11(`${p}.tmp`, data);
+    writeFileSync12(`${p}.tmp`, data);
     renameSync6(`${p}.tmp`, p);
   });
   writeFile2(path, JSON.stringify(state, null, 2));
@@ -11462,10 +11595,10 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join19(dirname5(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join21(dirname5(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
-  const charter = readFileSync15(HERO_CHARTER_PATH, "utf8");
+  const charter = readFileSync17(HERO_CHARTER_PATH, "utf8");
   const head = task ? `\u042D\u041F\u0418\u041A ${run.task_slug}: ${task.title}
 
 ${task.description}` : `\u042D\u041F\u0418\u041A ${run.task_slug} (\u0442\u0435\u043B\u043E \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E slug \u0438 \u0437\u0434\u0440\u0430\u0432\u043E\u043C\u0443 \u0441\u043C\u044B\u0441\u043B\u0443).`;
@@ -11801,9 +11934,9 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join19(base3, ".github", "workflows");
+    const dir = join21(base3, ".github", "workflows");
     try {
-      if (readdirSync9(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
+      if (readdirSync10(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
     }
   }
@@ -13092,7 +13225,7 @@ async function resolveConflict(deps, reviewRun) {
     workspace_id: reviewRun.workspace_id
     // та же задача, тот же воркспейс (TASWM-288)
   });
-  const wt = join19(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join21(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, resolver.name);
@@ -13144,7 +13277,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join19(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join21(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, reviewer.name);
@@ -13239,22 +13372,59 @@ async function syncCrashedOnStartup(deps) {
   }
   return { orphaned, merged, requeued };
 }
-async function makeStore(repo, worktreesDir) {
+async function makeStore(repo, worktreesDir, repoFlag) {
   const host = loadHostIdentity({
     home: SWARM_HOME,
     envHostId: process.env.SWARM_HOST_ID,
     envHostName: process.env.SWARM_HOST_NAME
   });
   console.log(`[overmind] \u043C\u0430\u0448\u0438\u043D\u0430: ${host.hostName} (${host.hostId})`);
+  const picked = pickRepoPaths({
+    flag: effectiveRepoPaths(repoFlag ?? "", []),
+    env: effectiveRepoPaths("", SWARM_REPO_PATHS),
+    remembered: effectiveRepoPaths("", loadRememberedRepos(SWARM_HOME))
+  });
+  const repoPaths = picked.paths;
+  if (picked.source === "memory") {
+    console.log(`[overmind] \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0432\u0437\u044F\u0442\u044B \u0438\u0437 \u043F\u0430\u043C\u044F\u0442\u0438 \u043F\u0440\u043E\u0448\u043B\u043E\u0433\u043E \u0437\u0430\u043F\u0443\u0441\u043A\u0430: ${repoPaths.join(", ")} (\u0441\u043C\u0435\u043D\u0438\u0442\u044C: swarm start --repo <\u043F\u0443\u0442\u044C>)`);
+  }
+  if (picked.source === "flag" || picked.source === "env") {
+    try {
+      rememberRepos(SWARM_HOME, repoPaths);
+    } catch (e) {
+      console.warn(`[overmind] \u043D\u0435 \u0441\u043C\u043E\u0433 \u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u044C \u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044E (${e instanceof Error ? e.message : e}) \u2014 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0437\u0430\u043F\u0443\u0441\u043A \u0441\u043D\u043E\u0432\u0430 \u043F\u043E\u043F\u0440\u043E\u0441\u0438\u0442 --repo`);
+    }
+  }
   if (SWARM_BACKEND !== "client") return { store: new SwarmDb(DB_PATH, repo), reconciled: true, host };
   const call = resilientSwarmMcp({
     onDown: (ms) => console.warn(`[overmind] \u043F\u0440\u043E\u0434-MCP \u043C\u043E\u043B\u0447\u0438\u0442 ${Math.round(ms / 1e3)}\u0441 \u2014 \u0440\u043E\u0439 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u0432\u0441\u043B\u0435\u043F\u0443\u044E, \u0441\u0434\u0430\u0447\u0438 \u0438 \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u044B \u043D\u0435 \u0434\u043E\u0435\u0437\u0436\u0430\u044E\u0442.`),
     onUp: () => console.warn("[overmind] \u043F\u0440\u043E\u0434-MCP \u0441\u043D\u043E\u0432\u0430 \u043D\u0430 \u0441\u0432\u044F\u0437\u0438.")
   });
-  const repoRegistry = await buildRepoRegistry(SWARM_REPO_PATHS);
-  if (SWARM_REPO_PATHS.length > 0 && repoRegistry.length < SWARM_REPO_PATHS.length) {
+  const explicitRegistry = await buildRepoRegistry(repoPaths);
+  const byName = new Map(explicitRegistry.map((e) => [e.repoFullName, e.path]));
+  const scanRootsList = defaultScanRoots(homedir3(), repoPaths);
+  const scanStartedAt = Date.now();
+  const scanned = scanRoots(scanRootsList, { maxDepth: SWARM_SCAN_DEPTH });
+  let addedByScan = 0;
+  for (const [full, path] of scanned) {
+    if (byName.has(full)) continue;
+    byName.set(full, path);
+    addedByScan++;
+  }
+  if (addedByScan > 0) {
+    console.log(
+      `[overmind] \u043D\u0430\u0448\u0451\u043B \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 ${addedByScan} \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439(\u0435\u0432) \u0441\u043A\u0430\u043D\u043E\u043C \u0437\u0430 ${Date.now() - scanStartedAt}\u043C\u0441: ${[...scanned.keys()].slice(0, 8).join(", ")}${scanned.size > 8 ? ` \u0438 \u0435\u0449\u0451 ${scanned.size - 8}` : ""}`
+    );
+  }
+  const repoRegistry = [...byName].map(([repoFullName, path]) => ({ repoFullName, path }));
+  if (repoPaths.length > 0 && repoRegistry.length < repoPaths.length) {
     console.warn(
-      `[overmind] \u0440\u0435\u043F\u043E-\u0440\u0435\u0435\u0441\u0442\u0440: ${repoRegistry.length}/${SWARM_REPO_PATHS.length} \u043F\u0443\u0442\u0435\u0439 \u0440\u0435\u0437\u043E\u043B\u0432\u043D\u0443\u043B\u0438\u0441\u044C \u0432 repoFullName (\u043E\u0441\u0442\u0430\u043B\u044C\u043D\u044B\u0435 \u2014 \u043D\u0435 git-\u0440\u0435\u043F\u043E \u0438\u043B\u0438 \u0431\u0435\u0437 remote origin)`
+      `[overmind] \u0440\u0435\u043F\u043E-\u0440\u0435\u0435\u0441\u0442\u0440: ${repoRegistry.length}/${repoPaths.length} \u043F\u0443\u0442\u0435\u0439 \u0440\u0435\u0437\u043E\u043B\u0432\u043D\u0443\u043B\u0438\u0441\u044C \u0432 repoFullName (\u043E\u0441\u0442\u0430\u043B\u044C\u043D\u044B\u0435 \u2014 \u043D\u0435 git-\u0440\u0435\u043F\u043E \u0438\u043B\u0438 \u0431\u0435\u0437 remote origin)`
+    );
+  }
+  if (repoRegistry.length === 0) {
+    console.warn(
+      `[overmind] \u041D\u0415 \u041D\u0410\u0428\u0401\u041B \u041D\u0418 \u041E\u0414\u041D\u041E\u0413\u041E \u0420\u0415\u041F\u041E\u0417\u0418\u0422\u041E\u0420\u0418\u042F \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u2014 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u044B \u0431\u0440\u0430\u0442\u044C\u0441\u044F \u043D\u0435 \u0431\u0443\u0434\u0443\u0442: \u0438\u0445 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 \u043F\u0440\u0438\u0445\u043E\u0434\u0438\u0442 \u0438\u043C\u0435\u043D\u0435\u043C owner/repo, \u0430 \u0441\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0435\u0433\u043E \u043D\u0435 \u0441 \u0447\u0435\u043C. \u0418\u0441\u043A\u0430\u043B \u0432: ${scanRootsList.slice(0, 6).join(", ")}. \u0415\u0441\u043B\u0438 \u043A\u043B\u043E\u043D\u044B \u043B\u0435\u0436\u0430\u0442 \u0432 \u0434\u0440\u0443\u0433\u043E\u043C \u043C\u0435\u0441\u0442\u0435 \u2014 \u0443\u043A\u0430\u0436\u0438: swarm start --repo <\u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E> (\u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u0441\u044F).`
     );
   }
   const client = new SwarmClient({ call, outboxPath: SWARM_OUTBOX, defaultRepo: repo, repoRegistry, host });
@@ -13291,7 +13461,7 @@ async function migrateWorktreesAtStartup() {
       exists: (d) => existsSync12(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync9(d).length > 0;
+          return readdirSync10(d).length > 0;
         } catch {
           return false;
         }
@@ -13322,7 +13492,11 @@ async function runDaemon(opts) {
   installCrashGuards();
   const daemonStart = await captureDaemonStart(THIS_FILE);
   const worktreesDir = await migrateWorktreesAtStartup();
-  const { store: db, reconciled, host } = await makeStore(opts.repo, worktreesDir);
+  if (!opts.repo) {
+    const remembered = effectiveRepoPaths("", loadRememberedRepos(SWARM_HOME))[0];
+    if (remembered) opts.repo = remembered;
+  }
+  const { store: db, reconciled, host } = await makeStore(opts.repo, worktreesDir, opts.repoFlag);
   await preflightAuth();
   const tl = await connectTaskless();
   const tlFor = (workspaceId) => tl ? tl.forWorkspace(workspaceId) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taskless-app/swarm",
-  "version": "0.4.4",
+  "version": "0.4.7",
   "type": "module",
   "description": "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   "keywords": [