@dosu/cli 0.67.0-beta.1 → 0.67.0-beta.2

package/README.md

@@ -99,18 +99,15 @@ Or right-click the binary, select "Open", and click "Open" in the dialog.
 | `dosu upgrade` | Update Dosu through the package manager that installed it, re-running `dosu setup` when the update changes agent config |
 | `dosu mcp list` | List supported AI tools |
 | `dosu mcp add <tool>` | Add the Dosu MCP server to a specific tool |
-| `dosu mcp refresh` | Rewrite the Dosu MCP entry in every already-configured tool from the current setup, and re-apply the hooks of every agent that has them on |
-| `dosu mcp serve --client <agent>` | The local (stdio) Dosu MCP server that tools' MCP entries run; not run by hand |
-| `dosu project show\|link\|unlink [dir]` | Show the project key Dosu memory scopes a directory by, or link a directory to a key |
-| `dosu memory search <query>` / `dosu memory evidence <id>` | Search Dosu memory, or read the evidence behind one memory, as an agent's MCP tools do |
+| `dosu mcp refresh` | Rewrite the Dosu MCP entry in every already-configured tool from the current setup |
 | `dosu logs` | View or manage debug logs (`--tail`, `--clear`) |
 | `dosu telemetry` | Manage usage analytics and error diagnostics (`status`, `enable`, `disable`, `reset`) |
 
-`dosu mcp add` takes `-g, --global` to install for all projects instead of project-local, and `--show-secret` to print the full manual config. The entry it writes runs `dosu mcp serve`, a local proxy to Dosu's MCP endpoint that adds the API key from the CLI config and the project, branch, and agent of the session, so memory lookups are scoped to the codebase you are in. The entry runs the Dosu install that wrote it, by absolute path (the npm package through the `node` that ran it), so an older `dosu` elsewhere on PATH or a PATH without `node` does not matter. A one-off `npx @dosu/cli setup` (or `bunx`, `pnpm dlx`) writes a remote entry instead, since the runner's copy does not last.
+`dosu mcp add` takes `-g, --global` to install for all projects instead of project-local, and `--show-secret` to print the full manual config.
 
-`dosu upgrade` delegates to npm, pnpm, Yarn Classic, or Homebrew only after confirming which manager owns the current installation. Temporary package-runner invocations stay ephemeral, ambiguous or local installs are left unchanged, and standalone binaries receive the latest safe manual download path. After a successful update it hands off to the new version, which re-applies bundled skills and enabled agent hooks. If configured MCP entries differ from the shape the new version writes, it runs `dosu setup`, or refreshes only those entries without a TTY. Upgrades done outside `dosu upgrade` get the same safety net on the first command after each version change, including between betas: stale MCP entries are rewritten and enabled hooks and skills are re-applied. Disabled hooks stay disabled.
+`dosu upgrade` delegates to npm, pnpm, Yarn Classic, or Homebrew only after confirming which manager owns the current installation. Temporary package-runner invocations stay ephemeral, ambiguous or local installs are left unchanged, and standalone binaries receive the latest safe manual download path. After a successful update it hands off to the new version, which re-applies the bundled skills and, only when a configured agent's MCP entry is out of date, runs `dosu setup` (or the non-interactive `dosu mcp refresh` without a TTY). An entry is out of date when it doesn't match the shape the current provider code writes. Upgrades done outside `dosu upgrade` (npm, brew, `npx @dosu/cli@latest`) get a safety net: on the first command of a new version, the CLI checks each configured provider, silently rewrites only the out-of-date entries, and prompts you to run `dosu setup` for the rest; the bundled agent skills are always re-applied on the first command after any version change.
 
-Dosu also updates itself automatically. When the update check (every six hours) finds a newer release, npm, pnpm, Yarn Classic, and Homebrew installs start the same package-manager update in a detached background process. The current command runs unchanged, and your next command uses the new version, whose first run applies the skill, MCP, and hooks refreshes above. Rules and the status line still need `dosu setup` when a release changes them. Background updates never run for `npx` invocations, standalone binaries, CI, or `DOSU_DEV=true`. A failed install (for example, a global npm prefix that needs `sudo`) falls back to the "Run `dosu upgrade`" notice and is retried after six hours. Turn background updates off with `dosu upgrade --auto off` (and back on with `--auto on`), or with `DOSU_DISABLE_AUTOUPDATE=1` for a single environment.
+Dosu also updates itself automatically. When the update check (every six hours) finds a newer release, npm, pnpm, Yarn Classic, and Homebrew installs start the same package-manager update in a detached background process. The current command runs unchanged, and your next command uses the new version, whose first run applies the skill and MCP refreshes above. Hooks, rules, and the status line still need `dosu setup` when a release changes them. Background updates never run for `npx` invocations, standalone binaries, CI, or `DOSU_DEV=true`. A failed install (for example, a global npm prefix that needs `sudo`) falls back to the "Run `dosu upgrade`" notice and is retried after six hours. Turn background updates off with `dosu upgrade --auto off` (and back on with `--auto on`), or with `DOSU_DISABLE_AUTOUPDATE=1` for a single environment.
 
 ### Platform commands
 
@@ -158,7 +155,6 @@ To change a skill, edit `skills/<name>/…` and run `bun run embed:skills` to re
 | `cline-cli` | Cline CLI |
 | `copilot` | GitHub Copilot CLI |
 | `opencode` | OpenCode |
-| `pi` | Pi (installs the Dosu pi extension; global only) |
 | `antigravity` | Antigravity |
 | `mcporter` | MCPorter |
 | `factory` | Factory |
@@ -174,63 +170,36 @@ dosu setup --agent --tool claude
 
 Combine with `dosu login --request` / `--check <ticket>` for human-in-the-loop authentication, and `--mode oss|cloud` to skip the mode prompt.
 
-### Syncing sessions to Dosu memory: status line and incognito
-
-With `dosu knowledge hooks enable`, finished coding-agent sessions ship to Dosu memory in the
-background (secrets redacted locally first), and Dosu learns from them server-side. A Claude Code
-or Codex (0.160+) session ships as soon as it ends, an OpenCode session as soon as the opencode
-process that ran it exits, however it exits, and a pi session as soon as pi shuts it down. OpenCode
-gets a plugin and pi an extension rather than a hook; both also add memory digests to prompts, and
-pi's registers Dosu's MCP server (the `dosu mcp serve` proxy) with pi's built-in MCP and adds
-`/dosu-incognito` (pi run with `--no-extensions` skips it, see
-[docs/syncing.md](docs/syncing.md#pi)). Cursor sessions ship with a
-later sync once they have been quiet for five minutes (its end event fires every turn). A resumed
-session later ships only what is new. Shipping is on by default; `dosu knowledge transcripts
-disable` turns it off.
-`dosu knowledge sync --status` and `dosu knowledge sessions` show what shipped and why anything did
-not (too short, rejected by the server, or from an agent not supported yet);
-`dosu knowledge sync --retry-rejected` tries refused sessions again. On a throwaway machine (a VM
-destroyed after its last task), run `dosu knowledge sync --flush` as the last step before teardown:
-it ships every session not shipped yet right away, including the ones no end event named (Cursor's,
-a Codex session killed with SIGTERM, pi run with `--no-extensions`); see
-[docs/syncing.md](docs/syncing.md#throwaway-machines). Running `claude -p` from an eval
-harness? Some flags (`--bare`, `--safe-mode`, `--no-session-persistence`, ...) keep sessions from
-reaching Dosu; see [docs/syncing.md](docs/syncing.md#claude-code-in-an-eval-harness).
-
-When the deployment has no linked repository, memory is scoped by the codebase a session worked in:
-its `origin` remote, else the repository's root commit, else its path. Set `DOSU_PROJECT` in the
-agent's environment, or run `dosu project link [dir] <key>`, to name it yourself
-(`dosu project show` prints the key in use). A session keeps the key it was first resolved under. See
-[docs/syncing.md](docs/syncing.md#project-key).
-
-Two switches make shipping visible and controllable. `dosu setup` installs the status line and each
-agent's incognito command alongside the hook (`dosu knowledge hooks enable` installs the incognito
-command with each agent's hooks); they can also be managed directly:
+### Studying sessions: status line and incognito
+
+With `dosu knowledge hooks enable`, Dosu studies finished coding-agent sessions in the background
+and turns what it learns into shared knowledge. Two switches make that visible and controllable per
+session. `dosu setup` installs both alongside the hook; they can also be managed directly:
 
 ```bash
-dosu knowledge statusline enable|disable [claude|cursor]          # status-bar line in Claude Code / Cursor CLI
-dosu knowledge incognito on|off [claude|cursor|codex|opencode|pi]  # turn Dosu off/on for an agent
-dosu knowledge incognito status                                     # which agents are incognito
+dosu knowledge statusline enable|disable [claude|cursor]   # status-bar line in Claude Code / Cursor CLI
+dosu knowledge incognito on|off [claude|cursor|codex]      # stop/resume studying an agent's sessions
+dosu knowledge incognito status                            # which agents are incognito
 ```
 
-The status line shows one of `📚 Dosu shipping…` (a sync run is live), `📚 Dosu on`,
-`👻 Dosu incognito`, `⚪ Dosu paused`, `⚪ Dosu not learning from this repo`, or `⚪ Dosu off`.
-Every session is shipped unless you limit syncing to picked repos under `dosu` → settings → sync
-scope (or `dosu knowledge scope set <checkout>...`; `dosu knowledge skip-backlog` passes over the
-sessions waiting to ship, see [docs/syncing.md](docs/syncing.md#repo-scope)). Neither setup nor
-`enable` replaces a status line you already have; they print the one-liner to add to your own
-script instead.
-
-`incognito on` is a saved per-agent setting: none of that agent's sessions ship, its prompts get no
-memory lookup, and its Dosu tool calls (and `dosu memory` run as it) are refused without leaving the
-machine. Turning it off later does not ship the sessions that ran while it was on, even if you
-resume them, nor their subagents or forks (`off` seals any no sync has settled yet; see
-[docs/syncing.md](docs/syncing.md#per-agent-incognito)). To keep a single session out instead, run
-`/dosu-incognito` in it (in Codex, which has no user slash commands, mention the skill
-`$dosu-incognito`); setup installs it with the hook. It marks that session's transcript so it is
-never shipped (the whole session, and for the rest of it — start a new session to turn Dosu back
-on) and tells the model not to use Dosu tools. See
-[docs/syncing.md](docs/syncing.md#per-session-incognito).
+The status line shows one of `📚 Dosu studying…` (a sync run is live), `📚 Dosu on`,
+`👻 Dosu incognito`, `⚪ Dosu paused`, `⚪ Dosu not studying this repo`, or `⚪ Dosu off`. Every
+session is studied unless you limit studying to picked repos under `dosu` → settings → study
+scope. In an interactive terminal with more than one repo, `dosu setup` asks which repos' sessions
+to ship before offering the backfill of recent sessions. Selecting every repo clears the scope, so
+new repos are included automatically. The choice is saved as the study scope; change it later under
+`dosu` → settings → study scope or with `dosu knowledge scope set`. Notes from a session with a
+known repo and branch are anchored to that branch; the rest are unanchored and reach topics
+immediately. Neither setup nor `enable` replaces a status line you
+already have; they print the one-liner to add to your own script instead.
+
+`incognito on` is a saved per-agent setting: none of that agent's sessions are studied until you
+turn it off. Turning it off resumes studying only new sessions going forward; sessions that
+finished while incognito was on stay unstudied permanently, even if a later sync picks them up.
+To keep a single chat out instead, type `/dosu-incognito` in it; setup installs that command with
+the hook. It marks the session's transcript so studying skips it (the whole session, and for the
+rest of it — start a new session to turn Dosu back on) and tells the model not to use Dosu
+tools. See [docs/studying.md](docs/studying.md).
 
 ### Telemetry and privacy
 
@@ -252,8 +221,11 @@ and may include documented coarse setup choices. `DO_NOT_TRACK=1` and
 `DOSU_TELEMETRY_DISABLED=1` disable all telemetry for the process. Dosu never collects
 prompts, raw command lines, free-form argument or option values, user source code, file contents,
 local paths, credentials, raw error messages, or `debug.log`. Environment-variable names and values
-are not collected. See [Telemetry and privacy](docs/telemetry.md) for the exact event fields,
-destinations, retention, and controls.
+are not collected, with one exception: when a managed Claude Code settings conflict prevents a
+study run, Dosu reports the allowlisted public Claude Code setting/variable names that caused the
+conflict (never their values) to help diagnose why knowledge sync fails due to settings conflicts.
+See [Telemetry and privacy](docs/telemetry.md) for the exact event fields, destinations, retention,
+and controls.
 
 ## Configuration
 

package/bin/dosu.js

@@ -450,7 +450,7 @@ function isNpxInvocation(channel = INSTALL_CHANNEL, env = process.env) {
 function getVersionString() {
   return `v${VERSION}`;
 }
-var VERSION = "0.67.0-beta.1", INSTALL_CHANNEL = "npm";
+var VERSION = "0.67.0-beta.2", INSTALL_CHANNEL = "npm";
 
 // src/debug/logger.ts
 import {
@@ -7688,6 +7688,10 @@ function saveSyncState(state, configDir = getConfigDir()) {
   writeFileSync3(tmp, JSON.stringify(state, null, 2), { mode: 384 });
   renameSync2(tmp, path);
 }
+function saveRepoFilter(repos, configDir = getConfigDir()) {
+  const { repo_filter: _repos, project_filter: _folders, ...rest } = loadSyncState(configDir);
+  saveSyncState(repos ? { ...rest, repo_filter: [...repos] } : rest, configDir);
+}
 function setSyncPaused(paused, configDir = getConfigDir()) {
   const state = loadSyncState(configDir);
   if (paused)
@@ -9589,7 +9593,7 @@ var init_repo = __esm(() => {
 });
 
 // src/sync/lock.ts
-import { existsSync as existsSync12, readFileSync as readFileSync15, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync15, rmSync as rmSync2, statSync as statSync5, utimesSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join15 } from "node:path";
 function processAlive(pid) {
   try {
@@ -9652,6 +9656,16 @@ function fileLock(configDir = getConfigDir(), now = () => new Date) {
       } catch {}
       return false;
     },
+    refresh() {
+      if (!held)
+        return;
+      try {
+        if (readFileSync15(path, "utf8") === String(process.pid)) {
+          const at = now();
+          utimesSync(path, at, at);
+        }
+      } catch {}
+    },
     release() {
       if (!held)
         return;
@@ -21945,7 +21959,8 @@ async function runKnowledgeSync(options = {}) {
     offRecord = gate.ready.filter((s) => agentOff(s) && isUnanswered(s, state.sessions[sessionKey(s)]));
     const gatedReady = gate.ready.filter((s) => !agentOff(s));
     const gatedOpen = gate.open.filter((s) => !agentOff(s));
-    const inScope = (sessions) => filterSessionsByRepo(sessions, repoFilter, (s) => locator.resolveRepo(s));
+    const scope = options.everyRepo && !deps.ship ? null : repoFilter;
+    const inScope = (sessions) => filterSessionsByRepo(sessions, scope, (s) => locator.resolveRepo(s));
     ready = inScope(holdBack === "backoff" ? gatedReady.filter(isEnded) : gatedReady);
     open = inScope(gatedOpen);
     if (holdBack === "backoff")
@@ -22019,22 +22034,47 @@ async function runKnowledgeSync(options = {}) {
       failed: 0
     };
     const rank = (s) => ended.some((e) => namesSession(e, s)) ? 0 : isEnded(s) ? 1 : 2;
-    const ordered = [...todo].sort((a, b) => rank(a) - rank(b) || Date.parse(a.updated) - Date.parse(b.updated));
-    const batch = ordered.slice(0, Math.max(SHIP_BATCH_LIMIT, ordered.filter(isEnded).length));
-    logger.debug("sync", `shipping ${batch.length} of ${todo.length} ready sessions`);
+    const batch = [...todo].sort((a, b) => rank(a) - rank(b) || Date.parse(a.updated) - Date.parse(b.updated));
+    logger.debug("sync", `shipping ${batch.length} ready sessions`);
     const hold = (s) => {
       const current = loadState();
       if (!isShippingEnabled(current))
         return "stop";
       return isAgentIncognito(current, s, lineage) ? "agent" : null;
     };
+    const saved = new Map;
+    const reported = [];
+    let savedShipped = 0;
+    const settle = (result) => {
+      reported.push(result);
+      lock.refresh?.();
+      const key = sessionKey(result.session);
+      const entry = ledgerEntry(result, locked.sessions[key], now().toISOString(), cliVersion);
+      if (!entry)
+        return;
+      saved.set(key, entry);
+      try {
+        const counted = result.outcome === "shipped" && !result.session.parentId ? 1 : 0;
+        const next = loadState();
+        next.sessions[key] = entry;
+        next.total_shipped = (next.total_shipped ?? 0) + counted;
+        next.run = run;
+        saveState(next);
+        savedShipped += counted;
+      } catch {}
+    };
     let results = [];
     if (batch.length > 0) {
       try {
-        results = await deps.ship(batch, (s) => shippedPrefix(locked.sessions[sessionKey(s)]), hold);
+        results = await deps.ship(batch, (s) => shippedPrefix(locked.sessions[sessionKey(s)]), hold, settle);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        results = [{ session: batch[0], outcome: "failed", message }];
+        const answered = new Set(reported.map((r) => sessionKey(r.session)));
+        const next = batch.find((s) => !answered.has(sessionKey(s)));
+        results = [
+          ...reported,
+          ...next ? [{ session: next, outcome: "failed", message }] : []
+        ];
       }
     }
     const resultOf = new Map(results.map((r) => [sessionKey(r.session), r]));
@@ -22050,7 +22090,7 @@ async function runKnowledgeSync(options = {}) {
         counts[result.outcome] += 1;
       else
         counts.subagents[result.outcome] += 1;
-      const entry = ledgerEntry(result, locked.sessions[key], at, cliVersion);
+      const entry = saved.get(key) ?? ledgerEntry(result, locked.sessions[key], at, cliVersion);
       if (!entry) {
         error = result.message ?? "unknown error";
         logger.debug("sync", `shipping failed at ${key}: ${error}`);
@@ -22077,7 +22117,7 @@ async function runKnowledgeSync(options = {}) {
       if (batch.length > 0) {
         next.last_attempt_at = at;
         next.consecutive_failures = counts.failed > 0 ? next.consecutive_failures + 1 : 0;
-        next.total_shipped = (next.total_shipped ?? 0) + counts.shipped;
+        next.total_shipped = (next.total_shipped ?? 0) + counts.shipped - savedShipped;
         next.run = run;
       }
       if (resumes)
@@ -22097,7 +22137,7 @@ async function runKnowledgeSync(options = {}) {
     lock.release();
   }
 }
-var SCAN_WINDOW_DAYS = 30, LEDGER_GRACE_DAYS = 7, SHIP_BATCH_LIMIT = 20, DAY_MS, ENDED_LOCK_WAIT_MS, LOCK_POLL_MS = 2000, LOG_PREVIEW_LIMIT = 10;
+var SCAN_WINDOW_DAYS = 30, LEDGER_GRACE_DAYS = 7, DAY_MS, ENDED_LOCK_WAIT_MS, LOCK_POLL_MS = 2000, LOG_PREVIEW_LIMIT = 10;
 var init_sync = __esm(() => {
   init_logger();
   init_lineage();
@@ -22178,7 +22218,7 @@ var init_backlog = __esm(() => {
 });
 
 // src/telemetry/debug-id.ts
-var BUNDLE_DEBUG_ID_PLACEHOLDER = "32ee4cf3-5398-61c9-6475-6e2164756e21";
+var BUNDLE_DEBUG_ID_PLACEHOLDER = "c8a0f0e8-7cd4-1cd4-6475-6e2164756e21";
 
 // src/telemetry/telemetry.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -23147,10 +23187,6 @@ function isDirectory(path) {
     return false;
   }
 }
-function saveScope(repos) {
-  const { repo_filter: _repos, project_filter: _folders, ...rest } = loadSyncState();
-  saveSyncState(repos ? { ...rest, repo_filter: repos } : rest);
-}
 function scopeCommand() {
   const cmd = new Command("scope").description("Show or set which repos' sessions ship to Dosu memory (the TUI's sync scope)");
   cmd.command("show").description("Show the repos whose sessions ship").option("--json", "Output as JSON").action((opts) => {
@@ -23180,11 +23216,11 @@ function scopeCommand() {
       repos.add(repo);
     }
     const sorted = [...repos].sort();
-    saveScope(sorted);
+    saveRepoFilter(sorted);
     console.log(`✓ Sessions ship only from ${sorted.join(", ")}.`);
   });
   cmd.command("clear").description("Ship sessions from every repo, and sessions outside any repo").action(() => {
-    saveScope(null);
+    saveRepoFilter(null);
     console.log("✓ Sessions from every repo ship, and sessions outside any repo.");
   });
   return cmd;
@@ -23598,7 +23634,7 @@ function createShipStep(options) {
   }
   return async (sessions, shippedOf = () => {
     return;
-  }, hold = () => null) => {
+  }, hold = () => null, settled = () => {}) => {
     const resolver = options.resolveProject && options.resolveBranch ? undefined : createProjectDirResolver();
     const resolve = {
       resolveProject: options.resolveProject ?? ((session) => resolver?.resolveProject(session) ?? null),
@@ -23610,6 +23646,7 @@ function createShipStep(options) {
       if (!result)
         break;
       results.push(result);
+      settled(result);
       if (result.outcome === "failed")
         break;
     }
@@ -23999,21 +24036,11 @@ ${results.length - opts.limit} more results not shown.`));
       ...opts.retryRejected ? { retryRejectedBefore: new Date } : {},
       deps
     };
-    let outcome = await runKnowledgeSync(syncOptions);
-    let sessionsShipped = outcome.counts?.shipped ?? 0;
-    if ((opts.bootstrap || opts.flush) && deps.ship) {
-      const maxRounds = Math.ceil(outcome.readySessions / SHIP_BATCH_LIMIT) + 2;
-      for (let round = 1;outcome.status === "shipped" && (outcome.settledSessions ?? 0) > 0 && (outcome.settledSessions ?? 0) < outcome.readySessions && round < maxRounds; round++) {
-        if (!opts.quiet && !opts.json)
-          printSyncOutcome(outcome);
-        outcome = await runKnowledgeSync(syncOptions);
-        sessionsShipped += outcome.counts?.shipped ?? 0;
-      }
-    }
+    const outcome = await runKnowledgeSync(syncOptions);
     recordCommandFacets({
       sync_trigger: trigger,
       sync_status: outcome.status,
-      sessions_shipped: sessionsShipped
+      sessions_shipped: outcome.counts?.shipped ?? 0
     });
     if (opts.quiet)
       return;
@@ -24345,9 +24372,9 @@ function printSyncOutcome(outcome) {
         process.exitCode = 1;
         break;
       }
-      const remaining = outcome.readySessions - (outcome.settledSessions ?? 0);
-      if (remaining > 0) {
-        console.log(import_picocolors23.default.dim(`${remaining} more in the backlog; run sync again to continue.`));
+      if (outcome.inFlightSessions > 0) {
+        const n = outcome.inFlightSessions;
+        console.log(import_picocolors23.default.dim(`${n} session${plural(n)} still in progress will ship once ${n === 1 ? "it ends" : "they end"}.`));
       }
       break;
     }
@@ -30566,6 +30593,58 @@ var init_rules_step = __esm(() => {
   init_styles();
 });
 
+// src/setup/scope-step.ts
+function scopeCandidates(sessions, current) {
+  const byRepo = new Map;
+  for (const { repo, updated } of sessions) {
+    if (!repo)
+      continue;
+    const candidate = byRepo.get(repo);
+    if (!candidate)
+      byRepo.set(repo, { repo, sessions: 1, updated });
+    else {
+      candidate.sessions += 1;
+      if (updated > candidate.updated)
+        candidate.updated = updated;
+    }
+  }
+  for (const repo of current ?? []) {
+    if (!byRepo.has(repo))
+      byRepo.set(repo, { repo, sessions: 0, updated: "" });
+  }
+  return [...byRepo.values()].sort((a, b) => b.sessions - a.sessions || b.updated.localeCompare(a.updated) || a.repo.localeCompare(b.repo));
+}
+function canPickScope(candidates) {
+  return process.stdin.isTTY === true && candidates.length > 1;
+}
+async function stepPickSyncScope(candidates, current) {
+  const repos = candidates.map((candidate) => candidate.repo);
+  const plural = (n) => n === 1 ? "" : "s";
+  const selected = await multiselect2({
+    message: "Ship sessions to Dosu memory from which repos?",
+    options: candidates.map(({ repo, sessions }) => ({
+      value: repo,
+      label: displayRepo(repo),
+      hint: sessions > 0 ? `${sessions} session${plural(sessions)}` : "no recent sessions"
+    })),
+    initialValues: current ?? repos,
+    summary: (picked) => picked.length === repos.length ? "all repos · new ones included automatically" : `${picked.length} of ${repos.length} repos`,
+    validate: (picked) => picked.length === 0 ? "Select at least one repo." : undefined
+  });
+  if (isCancel2(selected))
+    return current;
+  const scope = selected.length === repos.length ? null : selected;
+  saveRepoFilter(scope);
+  log2.success(`Sync scope ${dim(`· ${scope ? scope.map(displayRepo).join(", ") : "all repos"}`)}`);
+  return scope;
+}
+var init_scope_step = __esm(() => {
+  init_repo();
+  init_state();
+  init_prompts();
+  init_styles();
+});
+
 // src/auth/server.ts
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -31130,17 +31209,32 @@ async function stepOfferInitialSync(cfg) {
   logger.info("setup", "Step: offer initial knowledge sync");
   const s = spinner2();
   s.start("Checking for agent sessions from the last 30 days...");
-  const outcome = await runKnowledgeSync();
-  const backlog = outcome.status === "backlog" ? unsettledSessions(outcome.sessions, state) : [];
+  const outcome = await runKnowledgeSync({ everyRepo: true });
+  const storedScope = loadSyncState().repo_filter ?? null;
+  const everyBacklog = outcome.status === "backlog" ? unsettledSessions(outcome.sessions, state) : [];
   const lineage = sessionLineage(outcome.sessions);
-  const n = withoutSubagents(backlog).filter((session) => !isAgentIncognito(state, session, lineage)).length;
+  const offered = (sessions) => withoutSubagents(sessions).filter((session) => !isAgentIncognito(state, session, lineage));
+  const inScope = (scope) => filterSessionsByRepo(everyBacklog, scope, (session) => session.repo ?? null);
+  const candidates = scopeCandidates(offered(everyBacklog), storedScope);
+  const pickScope = canPickScope(candidates);
+  let backlog = pickScope ? everyBacklog : inScope(storedScope);
+  let n = offered(backlog).length;
   if (n === 0) {
     s.stop("No recent agent sessions. Dosu memory learns from new ones as you work.");
     recordCommandFacets({ backfill_offer: "not-offered" });
     return;
   }
-  const them = n === 1 ? "it" : "them";
   s.stop(`Found ${n} agent session${n === 1 ? "" : "s"} from the last 30 days on this machine.`);
+  if (pickScope) {
+    backlog = inScope(await stepPickSyncScope(candidates, storedScope));
+    n = offered(backlog).length;
+    if (n === 0) {
+      log2.info("No sessions from those repos are waiting. Dosu memory learns from new ones.");
+      recordCommandFacets({ backfill_offer: "not-offered" });
+      return;
+    }
+  }
+  const them = n === 1 ? "it" : "them";
   const incognito = installedIncognitoCommands();
   log2.message(wrapLog([
     "Dosu memory learns from finished agent sessions: where things live, commands that work, approaches that failed, so the next agent starts from what the last one learned.",
@@ -31922,6 +32016,7 @@ var init_flow2 = __esm(() => {
   init_agents_md_step();
   init_analytics2();
   init_rules_step();
+  init_scope_step();
   init_styles();
   import_picocolors38 = __toESM(require_picocolors(), 1);
   OAUTH_ANALYTICS_REASONS = new Set([
@@ -33534,43 +33629,27 @@ async function runSettings(cfg) {
   }
 }
 function discoverSessionRepos(current) {
-  const counts = new Map;
+  const inRepos = [];
   try {
     const resolver = createProjectDirResolver();
     for (const session of scanAgentSessions({})) {
       const repo = resolver.resolveRepo(session);
       if (repo)
-        counts.set(repo, (counts.get(repo) ?? 0) + 1);
+        inRepos.push({ ...session, repo });
     }
     resolver.flush();
   } catch {}
-  for (const repo of current ?? [])
-    if (!counts.has(repo))
-      counts.set(repo, 0);
-  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([repo]) => repo);
+  return scopeCandidates(inRepos, current);
 }
 async function runStudyingProjectsSetting() {
   const state = loadSyncState();
   const current = studyRepoFilter(state, () => scanAgentSessions({}), createProjectDirResolver());
-  const repos = discoverSessionRepos(current);
-  if (repos.length === 0) {
+  const candidates = discoverSessionRepos(current);
+  if (candidates.length === 0) {
     log2.info("No agent sessions inside a git repo found yet; nothing to scope.");
     return;
   }
-  const selected = await multiselect2({
-    message: "Ship sessions to Dosu memory from which repos?",
-    options: repos.map((repo) => ({ label: displayRepo(repo), hint: repo, value: repo })),
-    initialValues: current ?? repos,
-    summary: (picked) => picked.length === repos.length ? "all repos · new ones included automatically" : `${picked.length} of ${repos.length} repos`,
-    validate: (picked) => picked.length === 0 ? "Select at least one repo." : undefined
-  });
-  if (isCancel2(selected))
-    return;
-  const { repo_filter: _repos, project_filter: _folders, ...fresh } = loadSyncState();
-  const all = selected.length === repos.length;
-  saveSyncState(all ? fresh : { ...fresh, repo_filter: [...selected] });
-  const scope = all ? "all repos" : selected.map(displayRepo).join(", ");
-  log2.success(`Sync scope ${dim(`· ${scope}`)}`);
+  await stepPickSyncScope(candidates, current);
 }
 async function handleAuthenticate(cfg) {
   const shouldLogin = await confirm2({ message: "Open browser to log in?" });
@@ -33626,6 +33705,7 @@ var init_tui = __esm(() => {
   init_scan();
   init_agents_md_step();
   init_flow2();
+  init_scope_step();
   init_styles();
   init_state();
   init_status();
@@ -34900,4 +34980,4 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=32ee4cf3-5398-61c9-6475-6e2164756e21
+//# debugId=c8a0f0e8-7cd4-1cd4-6475-6e2164756e21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dosu/cli",
-  "version": "0.67.0-beta.1",
+  "version": "0.67.0-beta.2",
   "type": "module",
   "description": "Dosu CLI - Set up Dosu MCP for AI tools and work with Dosu Libraries, docs, and reviews",
   "license": "MIT",