@inerrata-corporation/errata 2.0.23-dev.4779 → 2.0.23-dev.4803

package/errata.mjs

@@ -37887,26 +37887,26 @@ function buildFileLexicon(store) {
   for (const n of store.findNodeFieldsByLabel("File", ["relPath"])) {
     const relPath = typeof n.attrs["relPath"] === "string" && n.attrs["relPath"].length > 0 ? n.attrs["relPath"] : n.description;
     if (!relPath) continue;
-    const basename10 = relPath.split("/").pop();
-    if (!basename10.includes(".")) continue;
-    entries.push({ relPath, basename: basename10 });
-    basenameCount.set(basename10, (basenameCount.get(basename10) ?? 0) + 1);
-    const stem = basename10.slice(0, basename10.indexOf("."));
+    const basename11 = relPath.split("/").pop();
+    if (!basename11.includes(".")) continue;
+    entries.push({ relPath, basename: basename11 });
+    basenameCount.set(basename11, (basenameCount.get(basename11) ?? 0) + 1);
+    const stem = basename11.slice(0, basename11.indexOf("."));
     if (isBareMatchableStem(stem)) {
       let s = stemRelPaths.get(stem);
       if (!s) stemRelPaths.set(stem, s = /* @__PURE__ */ new Set());
       s.add(relPath);
     }
   }
-  for (const { relPath, basename: basename10 } of entries) {
+  for (const { relPath, basename: basename11 } of entries) {
     const entry = { relPath };
-    if (relPath !== basename10) byKey.set(relPath, entry);
-    const conventional = CONVENTION_FILENAMES.has(basename10) || (basenameCount.get(basename10) ?? 0) >= CONVENTION_BASENAME_MIN_FILES;
-    if (!conventional && !byKey.has(basename10)) byKey.set(basename10, entry);
-    const list = byBasename.get(basename10);
+    if (relPath !== basename11) byKey.set(relPath, entry);
+    const conventional = CONVENTION_FILENAMES.has(basename11) || (basenameCount.get(basename11) ?? 0) >= CONVENTION_BASENAME_MIN_FILES;
+    if (!conventional && !byKey.has(basename11)) byKey.set(basename11, entry);
+    const list = byBasename.get(basename11);
     if (list) list.push(entry);
-    else byBasename.set(basename10, [entry]);
-    const stem = basename10.slice(0, basename10.indexOf("."));
+    else byBasename.set(basename11, [entry]);
+    const stem = basename11.slice(0, basename11.indexOf("."));
     if (isBareMatchableStem(stem) && !CONVENTION_STEMS.has(stem) && !byStem.has(stem)) {
       const dirStems = new Set(
         [...stemRelPaths.get(stem) ?? []].map((p) => {
@@ -37923,8 +37923,8 @@ function resolveFileToken(token, lexicon) {
   const exact = lexicon.byKey.get(token);
   if (exact) return exact;
   if (!token.includes("/")) return null;
-  const basename10 = token.split("/").pop();
-  for (const entry of lexicon.byBasename.get(basename10) ?? []) {
+  const basename11 = token.split("/").pop();
+  for (const entry of lexicon.byBasename.get(basename11) ?? []) {
     if (entry.relPath === token || entry.relPath.endsWith(`/${token}`)) return entry;
   }
   return null;
@@ -37949,9 +37949,9 @@ function fileRolePhrase(relPath, level = 1) {
   return "a source file";
 }
 function isSourceFileToken(token) {
-  const basename10 = token.split(/[/\\]/).pop() ?? token;
-  if (CONVENTION_FILENAMES.has(basename10)) return false;
-  const ext = basename10.split(".").pop();
+  const basename11 = token.split(/[/\\]/).pop() ?? token;
+  if (CONVENTION_FILENAMES.has(basename11)) return false;
+  const ext = basename11.split(".").pop();
   return ext !== void 0 && SOURCE_EXTENSIONS.has(ext.toLowerCase());
 }
 function generalizeFileRefs(text, fileLexicon, level = 1) {
@@ -57729,6 +57729,7 @@ var init_message_accumulator = __esm({
 var webui_exports = {};
 __export(webui_exports, {
   ContextBaselines: () => ContextBaselines,
+  FOCUS_NOTICE_FIELD: () => FOCUS_NOTICE_FIELD,
   SUBAGENT_REFRESH_MIN_MS: () => SUBAGENT_REFRESH_MIN_MS,
   asFailedPostToolUse: () => asFailedPostToolUse,
   buildWebUi: () => buildWebUi,
@@ -58438,7 +58439,9 @@ ${delta}${cue}`;
       block = own ?? readContextFileWithHash(deps.paths.root);
       storedCard = own ? own.card : block ? readContextCard(deps.paths.root, block.hash) : null;
     }
-    const decision = decideContextInject({
+    const focusNotice = typeof body2[FOCUS_NOTICE_FIELD] === "string" ? body2[FOCUS_NOTICE_FIELD] : null;
+    if (focusNotice && contextKey2) lastInjectedHash.reset(contextKey2, "focus");
+    const decided = decideContextInject({
       event: hookEvent,
       source: String(body2["source"] ?? ""),
       sessionId: contextKey2,
@@ -58448,6 +58451,9 @@ ${delta}${cue}`;
       // A subagent's injections land in its own transcript, not the one posted.
       ...subagent === null && typeof body2["transcript_path"] === "string" && body2["transcript_path"] ? { transcriptPath: body2["transcript_path"] } : {}
     });
+    const decision = focusNotice ? { hookEventName: decided?.hookEventName ?? hookEvent, additionalContext: decided ? `${focusNotice}
+
+${decided.additionalContext}` : focusNotice } : decided;
     if (decision && subagent !== null) lastSubagentInjectAt.set(contextKey2, Date.now());
     let systemMessage = null;
     const delivered = decision !== null && decision.additionalContext !== PROMPT_RECUE;
@@ -58646,7 +58652,7 @@ function proposalToIngest(p, profile, daemonVersion) {
     payloadDigest: p.id
   };
 }
-var messageAccumulator, GENERIC_ERROR_WORDS, wsPackagesCache, WS_PACKAGES_TTL_MS, loggedToolSessions, SUBAGENT_REFRESH_MIN_MS, WINDOW_RESET_SOURCES, FULL_BLOCK_PREFIX, META_LABELS;
+var messageAccumulator, GENERIC_ERROR_WORDS, wsPackagesCache, WS_PACKAGES_TTL_MS, loggedToolSessions, SUBAGENT_REFRESH_MIN_MS, WINDOW_RESET_SOURCES, FULL_BLOCK_PREFIX, FOCUS_NOTICE_FIELD, META_LABELS;
 var init_webui = __esm({
   "src/webui.ts"() {
     "use strict";
@@ -58713,6 +58719,7 @@ var init_webui = __esm({
     SUBAGENT_REFRESH_MIN_MS = 6e4;
     WINDOW_RESET_SOURCES = /* @__PURE__ */ new Set(["compact", "clear", "resume"]);
     FULL_BLOCK_PREFIX = "The errata daemon has updated your live workspace context. The block below REPLACES any earlier errata context block in this conversation \u2014 treat it as the current source of truth:\n\n";
+    FOCUS_NOTICE_FIELD = "errata_focus_notice";
     META_LABELS = /* @__PURE__ */ new Set([
       "Pattern",
       "Technique",
@@ -78858,10 +78865,10 @@ var ReaddirpStream = class extends Readable2 {
   }
   async _formatEntry(dirent, path3) {
     let entry;
-    const basename10 = this._isDirent ? dirent.name : dirent;
+    const basename11 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path3, basename10));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename10 };
+      const fullPath = presolve(pjoin(path3, basename11));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename11 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err2) {
       this._onError(err2);
@@ -79400,9 +79407,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path3, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path3);
-    const basename10 = sysPath.basename(path3);
+    const basename11 = sysPath.basename(path3);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename10);
+    parent.add(basename11);
     const absolutePath = sysPath.resolve(path3);
     const options = {
       persistent: opts.persistent
@@ -79412,7 +79419,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename11) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path3, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -79435,10 +79442,10 @@ var NodeFsHandler = class {
       return;
     }
     const dirname21 = sysPath.dirname(file2);
-    const basename10 = sysPath.basename(file2);
+    const basename11 = sysPath.basename(file2);
     const parent = this.fsw._getWatchedDir(dirname21);
     let prevStats = stats;
-    if (parent.has(basename10))
+    if (parent.has(basename11))
       return;
     const listener = async (path3, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -79463,9 +79470,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname21, basename10);
+          this.fsw._remove(dirname21, basename11);
         }
-      } else if (parent.has(basename10)) {
+      } else if (parent.has(basename11)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -87520,7 +87527,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.23-dev.4779" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.23-dev.4803" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -87563,15 +87570,43 @@ function loadTurnOffsets(path3) {
     return /* @__PURE__ */ new Map();
   }
 }
-function saveTurnCursors(path3, cursors, offsets) {
+function loadTurnMoves(path3) {
+  try {
+    const raw2 = JSON.parse(readFileSync33(path3, "utf8"));
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(raw2)) {
+      const to = typeof v === "object" && v !== null ? v.movedTo : void 0;
+      if (typeof to === "string" && to) out2.set(k, to);
+    }
+    return out2;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function saveTurnCursors(path3, cursors, offsets, moves = /* @__PURE__ */ new Map()) {
   try {
     const merged = {};
     for (const [k, uuid3] of cursors) merged[k] = { uuid: uuid3, offset: offsets.get(k) ?? 0 };
     for (const [k, offset] of offsets) if (!merged[k]) merged[k] = { uuid: "", offset };
+    for (const [k, movedTo] of moves) merged[k] = { ...merged[k] ?? { uuid: "", offset: 0 }, movedTo };
     writeFileSync24(path3, JSON.stringify(merged), "utf8");
   } catch {
   }
 }
+var turnCursorFile = (configDir) => join37(configDir, "turn-cursors.json");
+function turnCursorOnDisk(configDir, sessionId) {
+  const path3 = turnCursorFile(configDir);
+  const offset = loadTurnOffsets(path3).get(sessionId);
+  const movedTo = loadTurnMoves(path3).get(sessionId);
+  if (offset === void 0 && movedTo === void 0) return null;
+  return { uuid: loadTurnCursors(path3).get(sessionId) ?? "", offset: offset ?? 0, ...movedTo ? { movedTo } : {} };
+}
+function releaseTurnCursorOnDisk(configDir, sessionId, to) {
+  const path3 = turnCursorFile(configDir);
+  const moves = loadTurnMoves(path3);
+  moves.set(sessionId, to);
+  saveTurnCursors(path3, loadTurnCursors(path3), loadTurnOffsets(path3), moves);
+}
 function gitSourceWatchTargets(root) {
   const SOURCE = /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i;
   try {
@@ -88578,9 +88613,10 @@ function createWorkspaceEngine(opts) {
       resultSummary: { exitCode: e.exitCode ?? 1, errorTokens: e.errorTokens }
     });
   };
-  const turnCursorPath = join37(paths.configDir, "turn-cursors.json");
+  const turnCursorPath = turnCursorFile(paths.configDir);
   const lastTurnUuid = loadTurnCursors(turnCursorPath);
   const turnOffset = loadTurnOffsets(turnCursorPath);
+  const turnMovedTo = loadTurnMoves(turnCursorPath);
   const readLosses = { parseFailures: 0, ioFailures: 0, bytesUnreachable: 0, sliceGuardHits: 0 };
   const sessionLastProblem = /* @__PURE__ */ new Map();
   const sessionThreads = /* @__PURE__ */ new Map();
@@ -89588,7 +89624,7 @@ function createWorkspaceEngine(opts) {
         lastTurnUuid.set(sessionId, turns[turns.length - 1].uuid);
         await harvestTexts(sessionId, fresh);
       }
-      saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
+      saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset, turnMovedTo);
       if (slice >= 256) {
         readLosses.sliceGuardHits++;
         console.warn("[errata] harvest slice guard hit \u2014 backlog resumes next tick");
@@ -89605,7 +89641,7 @@ function createWorkspaceEngine(opts) {
       if (next.losses.ioFailed) readLosses.ioFailures++;
       if (next.turns.length === 0 && !next.more) {
         turnOffset.set(sessionId, next.nextOffset);
-        saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset);
+        saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset, turnMovedTo);
         break;
       }
       turns = next.turns;
@@ -89659,6 +89695,7 @@ function createWorkspaceEngine(opts) {
     }
   };
   const harvestSession = async (sessionId, transcriptPath) => {
+    if (turnMovedTo.has(sessionId)) return;
     await harvestTurns(sessionId, transcriptPath);
     for (const sub of subagentTranscripts(transcriptPath, sessionId)) {
       await yieldToLoop();
@@ -89894,6 +89931,28 @@ B: ${b}`,
     storeReconciled: () => storeReconciled,
     lastGitEventAt: () => lastGitEventTs,
     quarantinedSessions: () => sessions.originSessions(),
+    turnCursor(sessionId) {
+      const offset = turnOffset.get(sessionId);
+      const movedTo = turnMovedTo.get(sessionId);
+      if (offset === void 0 && movedTo === void 0) return null;
+      return { uuid: lastTurnUuid.get(sessionId) ?? "", offset: offset ?? 0, ...movedTo ? { movedTo } : {} };
+    },
+    releaseTurnCursor(sessionId, to) {
+      turnMovedTo.set(sessionId, to);
+      saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset, turnMovedTo);
+    },
+    adoptTurnCursor(sessionId, cursor) {
+      turnMovedTo.delete(sessionId);
+      if (cursor && cursor.offset > (turnOffset.get(sessionId) ?? -1)) {
+        turnOffset.set(sessionId, cursor.offset);
+        if (cursor.uuid) lastTurnUuid.set(sessionId, cursor.uuid);
+      }
+      saveTurnCursors(turnCursorPath, lastTurnUuid, turnOffset, turnMovedTo);
+    },
+    async settleTurns(sessionId) {
+      await (harvestInFlight.get(sessionId) ?? Promise.resolve()).catch(() => {
+      });
+    },
     markContextDirty() {
       contextDirty = true;
       refreshContextNow();
@@ -90943,7 +91002,7 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 init_dist();
 init_src5();
 import { existsSync as existsSync34, readFileSync as readFileSync40, writeFileSync as writeFileSync29 } from "node:fs";
-import { dirname as dirname17, join as join47, resolve as pathResolve } from "node:path";
+import { basename as basename10, dirname as dirname17, join as join47, resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
 init_src5();
@@ -95425,6 +95484,15 @@ function absolutePathsInCommand(command, platform = process.platform) {
   }
   return out2;
 }
+function leadingCdTarget(command, platform = process.platform) {
+  if (typeof command !== "string") return void 0;
+  const m = /^\s*(?:cd|pushd|Set-Location)\s+("[^"]+"|'[^']+'|[^\s;&|]+)\s*(?:&&|;|\|\||$)/.exec(command);
+  if (!m) return void 0;
+  const target = m[1].replace(/^["']|["']$/g, "");
+  if (/^[a-zA-Z]:[\\/]/.test(target)) return target;
+  if (platform === "win32") return /^\/[a-zA-Z](\/|$)/.test(target) ? msysToWindowsPath(target, platform) : void 0;
+  return target.startsWith("/") ? target : void 0;
+}
 function hookPathCandidates(body2, platform = process.platform) {
   const input = body2["tool_input"] ?? {};
   const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
@@ -95470,6 +95538,205 @@ var SessionAffinity = class {
     if (typeof sessionId === "string") this.bySession.delete(sessionId);
   }
 };
+var FOCUS_WINDOW = 5;
+var FOCUS_ROOT_HEADER = "x-errata-focus-root";
+var FOCUS_QUORUM = 3;
+var FOCUS_TTL_MS = 6 * 60 * 6e4;
+var SessionFocus = class {
+  constructor(ttlMs = FOCUS_TTL_MS, maxSessions = 500) {
+    this.ttlMs = ttlMs;
+    this.maxSessions = maxSessions;
+  }
+  bySession = /* @__PURE__ */ new Map();
+  live(sessionId, now) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+    const s = this.bySession.get(sessionId);
+    if (!s) return null;
+    if (now - s.at > this.ttlMs) {
+      this.bySession.delete(sessionId);
+      return null;
+    }
+    return s;
+  }
+  touch(sessionId, s, now) {
+    s.at = now;
+    this.bySession.delete(sessionId);
+    this.bySession.set(sessionId, s);
+    while (this.bySession.size > this.maxSessions) {
+      const oldest = this.bySession.keys().next().value;
+      if (oldest === void 0) break;
+      this.bySession.delete(oldest);
+    }
+  }
+  /** The workspace this session's hooks should go to instead of its cwd's, if any. */
+  focusFor(sessionId, now = Date.now()) {
+    return this.live(sessionId, now)?.focus ?? null;
+  }
+  pinnedFor(sessionId, now = Date.now()) {
+    return this.live(sessionId, now)?.pinned ?? false;
+  }
+  /** A tool hook's locator reached `root`; `cwdRoot` is where the session's cwd routes. */
+  observe(sessionId, root, cwdRoot, now = Date.now()) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+    const s = this.live(sessionId, now) ?? { recent: [], focus: null, pinned: false, at: now, reached: /* @__PURE__ */ new Set() };
+    s.reached.add(root);
+    s.recent.push(root);
+    if (s.recent.length > FOCUS_WINDOW) s.recent.shift();
+    this.touch(sessionId, s, now);
+    if (s.pinned) return null;
+    const current = s.focus ?? cwdRoot;
+    if (root === current) return null;
+    if (s.recent.filter((r) => r === root).length < FOCUS_QUORUM) return null;
+    s.focus = root === cwdRoot ? null : root;
+    return { from: current, to: root, reason: "inferred" };
+  }
+  pin(sessionId, root, cwdRoot, now = Date.now()) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+    const s = this.live(sessionId, now) ?? { recent: [], focus: null, pinned: false, at: now, reached: /* @__PURE__ */ new Set() };
+    const current = s.focus ?? cwdRoot;
+    s.pinned = true;
+    s.focus = root;
+    s.recent = [];
+    this.touch(sessionId, s, now);
+    return root === current ? null : { from: current, to: root, reason: "pinned" };
+  }
+  /** Drop the pin and any inferred focus: the session follows its cwd again. */
+  unpin(sessionId, cwdRoot, now = Date.now()) {
+    const s = this.live(sessionId, now);
+    if (!s) return null;
+    const current = s.focus ?? cwdRoot;
+    s.pinned = false;
+    s.focus = null;
+    s.recent = [];
+    this.touch(sessionId, s, now);
+    return cwdRoot && current !== cwdRoot ? { from: current, to: cwdRoot, reason: "unpinned" } : null;
+  }
+  /** A tool ran in the session's cwd without naming a path (a shell command, a search). */
+  ranIn(sessionId, root, now = Date.now()) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return;
+    const s = this.live(sessionId, now) ?? { recent: [], focus: null, pinned: false, at: now, reached: /* @__PURE__ */ new Set() };
+    s.reached.add(root);
+    this.touch(sessionId, s, now);
+  }
+  /** Whether the session's tools ever worked in `root`; undefined for a session this daemon has not watched. */
+  reached(sessionId, root, now = Date.now()) {
+    return this.live(sessionId, now)?.reached.has(root);
+  }
+  forget(sessionId) {
+    if (typeof sessionId === "string") this.bySession.delete(sessionId);
+  }
+  /** Every live focus, for `errata focus` to confirm a pin landed. */
+  entries(now = Date.now()) {
+    const out2 = [];
+    for (const [sessionId, s] of this.bySession) {
+      if (now - s.at > this.ttlMs || !s.focus) continue;
+      out2.push({ sessionId, root: s.focus, pinned: s.pinned, at: s.at });
+    }
+    return out2;
+  }
+};
+function misfiledTarget(roots, home) {
+  if (roots.includes(home)) return null;
+  const tally = /* @__PURE__ */ new Map();
+  for (const r of roots) tally.set(r, (tally.get(r) ?? 0) + 1);
+  const ranked = [...tally].sort((a, b) => b[1] - a[1]);
+  const [top, next] = ranked;
+  if (!top || top[1] < FOCUS_QUORUM || next && next[1] === top[1]) return null;
+  return top[0];
+}
+function focusCommandIn(command) {
+  if (typeof command !== "string") return void 0;
+  const m = /(?:^|[\s;&|(])errata(?:\.cmd|\.ps1)?\s+focus(?:\s+("[^"]+"|'[^']+'|[^\s;&|)]+))?/.exec(command);
+  if (!m) return void 0;
+  const arg = m[1]?.replace(/^["']|["']$/g, "");
+  if (!arg) return void 0;
+  if (arg === "--clear" || arg === "clear" || arg === "off") return { ref: null };
+  return arg.startsWith("-") ? void 0 : { ref: arg };
+}
+function resolveWorkspaceRef(ref, entries, ownerRoot) {
+  const byName = entries.filter((e) => e.name.toLowerCase() === ref.toLowerCase());
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) return null;
+  const root = ownerRoot(entries.map((e) => e.path), msysToWindowsPath(ref));
+  return root ? entries.find((e) => e.path === root) ?? null : null;
+}
+
+// src/rehome.ts
+init_src2();
+import { isAbsolute as isAbsolute6 } from "node:path";
+function sourcesOf(n) {
+  const s = n.attrs["sources"];
+  return Array.isArray(s) ? s.filter((x) => typeof x === "string") : [];
+}
+function rehomeSessionNodes(from, to, sessionIds, opts) {
+  const sessions = new Set(sessionIds);
+  const now = opts.now ?? Date.now();
+  const report = { moved: [], copied: [], vocabulary: [], edgesCarried: 0, edgesDropped: 0, cloudContributed: [] };
+  const picked = /* @__PURE__ */ new Map();
+  for (const row of from.selectNodes({ labels: SEMANTIC_NODE_LABELS, attrs: ["sources"] })) {
+    const sources = sourcesOf(row);
+    if (!sources.some((s) => sessions.has(s))) continue;
+    const node2 = from.getNode(row.id);
+    if (!node2) continue;
+    picked.set(node2.id, node2);
+    (sources.every((s) => sessions.has(s)) ? report.moved : report.copied).push(node2.id);
+    if (node2.attrs["cloudNodeId"]) report.cloudContributed.push(node2.id);
+  }
+  const edges = /* @__PURE__ */ new Map();
+  for (const id of picked.keys()) {
+    for (const e of [...from.outEdges(id), ...from.inEdges(id)]) edges.set(e.id, e);
+  }
+  const vocabulary = /* @__PURE__ */ new Map();
+  const carried = [];
+  for (const e of edges.values()) {
+    const other = picked.has(e.from) ? e.to : e.from;
+    if (picked.has(other)) {
+      carried.push(e);
+      continue;
+    }
+    const node2 = from.getNode(other);
+    if (!node2 || isCodeLabel(node2.label)) {
+      report.edgesDropped++;
+      continue;
+    }
+    if (!to.getNode(other)) vocabulary.set(other, node2);
+    carried.push(e);
+  }
+  report.vocabulary = [...vocabulary.keys()];
+  report.edgesCarried = carried.length;
+  if (!opts.apply) return report;
+  to.transaction(() => {
+    for (const n of [...vocabulary.values(), ...picked.values()]) to.mergeNode(n);
+    for (const e of carried) to.mergeEdge(e);
+  });
+  from.transaction(() => {
+    for (const id of report.moved) {
+      const n = picked.get(id);
+      from.updateNode(id, { attrs: { ...n.attrs, rehomedAt: now } });
+      from.closeNode(id, now);
+    }
+  });
+  return report;
+}
+function captureWorkPaths(store, home) {
+  const out2 = /* @__PURE__ */ new Map();
+  for (const row of store.selectNodes({ labels: ["Problem"], attrs: ["sources", "anchorHint"] })) {
+    const sources = sourcesOf(row);
+    if (sources.length === 0) continue;
+    let where = null;
+    if (store.outEdges(row.id, ["ANCHORED_AT"]).length > 0) where = home;
+    else {
+      const hint = row.attrs["anchorHint"];
+      if (typeof hint?.path === "string" && hint.path.length > 0) where = isAbsolute6(hint.path) ? hint.path : home;
+    }
+    for (const s of sources) {
+      const list = out2.get(s) ?? [];
+      if (where) list.push(where);
+      out2.set(s, list);
+    }
+  }
+  return out2;
+}
 
 // src/multi.ts
 init_checkout_root();
@@ -95527,6 +95794,14 @@ function pickOwnerRoot(roots, absPath) {
   }
   return best;
 }
+function withAdditionalContext(response, hookEventName, extra) {
+  const out2 = response["hookSpecificOutput"] ?? {};
+  const prior = typeof out2.additionalContext === "string" && out2.additionalContext ? `${out2.additionalContext}
+
+` : "";
+  const { ok: _ok, event: _event, tool: _tool, recognizedFile: _file2, ...rest2 } = response;
+  return { ...rest2, hookSpecificOutput: { ...out2, hookEventName, additionalContext: `${prior}${extra}` } };
+}
 function ownerOf(records, absPath) {
   const root = pickOwnerRoot(records.map((r) => r.root), absPath);
   return root == null ? null : records.find((r) => r.root === root) ?? null;
@@ -95933,6 +96208,8 @@ async function startMultiDaemon(opts = {}) {
   const app = new Hono2();
   const enqueueWakeIndex = serialQueue();
   const attaching = /* @__PURE__ */ new Map();
+  let afterAttach = () => {
+  };
   const attachWorkspace = (root) => {
     const norm = normPath(root);
     const pending = attaching.get(norm);
@@ -95982,6 +96259,7 @@ async function startMultiDaemon(opts = {}) {
       });
     }
     console.log(`[errata] hot-registered ${rec.entry.name} (${rec.id}) \u2014 now watching live`);
+    afterAttach(rec);
     return { attached: true, id: rec.id };
   };
   app.post("/api/attach", async (c) => {
@@ -96106,6 +96384,105 @@ async function startMultiDaemon(opts = {}) {
     })
   );
   const sessionAffinity = new SessionAffinity();
+  const sessionFocus = new SessionFocus();
+  const pendingSwitch = /* @__PURE__ */ new Map();
+  const turnHome = /* @__PURE__ */ new Map();
+  const registryRoots = () => listWorkspaceEntries().map((e) => e.path);
+  const rootOfPath = (p, roots) => p ? ownerOf(records, p)?.root ?? pickOwnerRoot((roots ?? registryRoots)(), p) : null;
+  const workspaceName = (root) => root ? listWorkspaceEntries().find((e) => e.path === root)?.name ?? basename10(root) : "its working directory";
+  const recordFor = async (root) => {
+    const running = records.find((r) => r.root === root);
+    if (running) return running;
+    return (await attachWorkspace(root)).attached ? records.find((r) => r.root === root) ?? null : null;
+  };
+  const focusNotice = (change, cwdRoot) => {
+    const to = workspaceName(change.to);
+    const from = workspaceName(change.from);
+    const where = `Captures from here on go to ${to}'s graph, and the block below is ${to}'s context: it replaces any earlier errata block.`;
+    if (change.reason === "pinned") return `errata: this session is now pinned to ${to} (\`errata focus\`). ${where} \`errata focus off\` returns it to ${workspaceName(cwdRoot)}.`;
+    if (change.reason === "unpinned") return `errata: focus cleared; this session follows its working directory, ${to}, again. ${where}`;
+    return `errata: this session's work moved from ${from} to ${to}: ${FOCUS_QUORUM} of the last ${FOCUS_WINDOW} paths your tools touched are in ${to}. ${where} Wrong workspace? Run \`errata focus ${from === "its working directory" ? "off" : from}\`.`;
+  };
+  const noteFocus = (sid, change) => {
+    if (!change) return;
+    pendingSwitch.set(sid, change);
+    console.log(`[errata] session ${sid.slice(0, 8)} focus ${workspaceName(change.from)} \u2192 ${workspaceName(change.to)} (${change.reason})`);
+  };
+  const observeFocus = (sid, body2) => {
+    const event = String(body2["hook_event_name"] ?? "");
+    const cwd = typeof body2["cwd"] === "string" ? msysToWindowsPath(body2["cwd"]) : void 0;
+    const cwdRoot = rootOfPath(cwd);
+    const input = body2["tool_input"] ?? {};
+    if (event === "PreToolUse") {
+      const pin = focusCommandIn(input["command"]);
+      if (!pin) return;
+      if (pin.ref === null) return noteFocus(sid, sessionFocus.unpin(sid, cwdRoot));
+      const entry = resolveWorkspaceRef(pin.ref, listWorkspaceEntries(), pickOwnerRoot);
+      if (entry) noteFocus(sid, sessionFocus.pin(sid, entry.path, cwdRoot));
+      return;
+    }
+    if (event !== "PostToolUse" && event !== "PostToolUseFailure") return;
+    let registered = null;
+    const roots = () => registered ??= registryRoots();
+    const located = hookPathCandidates(body2).filter((p) => p !== cwd).map((p) => rootOfPath(p, roots)).find((r) => r != null);
+    if (located) noteFocus(sid, sessionFocus.observe(sid, located, cwdRoot));
+    else if (cwdRoot && (typeof input["command"] === "string" || ["Grep", "Glob", "LS"].includes(String(body2["tool_name"])))) {
+      sessionFocus.ranIn(sid, cwdRoot);
+    }
+  };
+  const repositoryOf = (root) => {
+    const gitRoot = nearestGitRoot(root);
+    return normPath((gitRoot ? mainCheckoutOfWorktree(gitRoot) : null) ?? root);
+  };
+  const evidenceWorkspace = (home) => {
+    let registered = null;
+    const known = () => registered ??= registryRoots();
+    return (p) => {
+      if (p === home) return p;
+      const direct = rootOfPath(p, known);
+      if (direct) return direct;
+      const gitRoot = nearestGitRoot(p);
+      const main2 = gitRoot ? mainCheckoutOfWorktree(gitRoot) : null;
+      return main2 ? rootOfPath(main2, known) : null;
+    };
+  };
+  const rehomeMisfiled = async (sid, from, to, why) => {
+    if (repositoryOf(from.root) === repositoryOf(to.root)) return;
+    await from.engine.settleTurns(sid);
+    const workspaceOf = evidenceWorkspace(from.root);
+    if ((captureWorkPaths(from.engine.store, from.root).get(sid) ?? []).some((p) => workspaceOf(p) === from.root)) return;
+    const report = rehomeSessionNodes(from.engine.store, to.engine.store, [sid], { apply: true });
+    if (report.moved.length + report.copied.length === 0) return;
+    from.engine.markContextDirty();
+    to.engine.markContextDirty();
+    console.log(
+      `[errata] session ${sid.slice(0, 8)} captures ${from.entry.name} \u2192 ${to.entry.name} (${why}): ${report.moved.length} moved, ${report.copied.length} copied, ${report.edgesDropped} code edges dropped` + (report.cloudContributed.length > 0 ? `, ${report.cloudContributed.length} already in the cloud under ${from.entry.name}` : "")
+    );
+  };
+  const handOffTurns = (sid, owner, cwd) => {
+    const mine = owner.engine.turnCursor(sid);
+    let fromRoot = mine?.movedTo ?? turnHome.get(sid) ?? null;
+    if (!fromRoot && !mine) fromRoot = rootOfPath(cwd);
+    if (fromRoot && fromRoot !== owner.root) {
+      const from = records.find((r) => r.root === fromRoot);
+      const configDir = workspacePaths(fromRoot).configDir;
+      const cursor = from ? from.engine.turnCursor(sid) : turnCursorOnDisk(configDir, sid);
+      if (from) from.engine.releaseTurnCursor(sid, owner.root);
+      else releaseTurnCursorOnDisk(configDir, sid, owner.root);
+      owner.engine.adoptTurnCursor(sid, cursor?.movedTo ? null : cursor);
+      console.log(`[errata] session ${sid.slice(0, 8)} turns: ${workspaceName(fromRoot)} \u2192 ${owner.entry.name}`);
+      if (from && sessionFocus.focusFor(sid) === owner.root && sessionFocus.reached(sid, fromRoot) === false) {
+        void rehomeMisfiled(sid, from, owner, "its tools never worked there").catch(
+          (err2) => console.warn(`[errata] rehome of session ${sid.slice(0, 8)} failed: ${err2 instanceof Error ? err2.message : err2}`)
+        );
+      }
+    } else if (mine?.movedTo) {
+      owner.engine.adoptTurnCursor(sid, null);
+    }
+    turnHome.delete(sid);
+    turnHome.set(sid, owner.root);
+    if (turnHome.size > 500) turnHome.delete(turnHome.keys().next().value);
+  };
   const forward = async (c, pathInBody, opts2 = {}) => {
     const raw2 = await c.req.text();
     let body2 = {};
@@ -96115,9 +96492,13 @@ async function startMultiDaemon(opts = {}) {
       return c.json({ error: "bad-json" }, 400);
     }
     lastHook = { at: Date.now(), event: typeof body2["hook_event_name"] === "string" ? body2["hook_event_name"] : c.req.path };
+    const sid = typeof body2["session_id"] === "string" ? body2["session_id"] : "";
+    if (sid && opts2.affinity === "note") observeFocus(sid, body2);
+    const focusRoot = sid && opts2.affinity === "follow" ? sessionFocus.focusFor(sid) : null;
     const primary = pathInBody(body2);
     const others = (opts2.extraPaths?.(body2) ?? []).filter((p) => p !== primary);
-    let owner = ownerOf(records, primary);
+    let owner = focusRoot ? await recordFor(focusRoot) : null;
+    if (!owner) owner = ownerOf(records, primary);
     for (const p of others) {
       if (owner) break;
       owner = ownerOf(records, p);
@@ -96136,8 +96517,8 @@ async function startMultiDaemon(opts = {}) {
       }
     }
     if (!owner && others.length > 0) {
-      const registryRoots = listWorkspaceEntries().map((e) => e.path);
-      const registered = others.map((p) => pickOwnerRoot(registryRoots, p)).find((r) => r != null);
+      const registryRoots2 = listWorkspaceEntries().map((e) => e.path);
+      const registered = others.map((p) => pickOwnerRoot(registryRoots2, p)).find((r) => r != null);
       if (registered && (await attachWorkspace(registered)).attached) {
         owner = records.find((r) => r.root === registered) ?? null;
         if (owner) console.log(`[errata] woke workspace ${owner.entry.name}`);
@@ -96166,32 +96547,109 @@ async function startMultiDaemon(opts = {}) {
     if (opts2.affinity === "note") sessionAffinity.note(body2["session_id"], owner.root);
     owner.lastHookAt = Date.now();
     const sub = c.req.path;
+    const cwd = typeof body2["cwd"] === "string" ? msysToWindowsPath(body2["cwd"]) : void 0;
+    if (sid && (sub === "/api/turn" || sub === "/api/session-end")) handOffTurns(sid, owner, cwd);
+    const subagentHook = typeof body2["agent_id"] === "string" && body2["agent_id"] !== "";
+    const pending = sid && !subagentHook ? pendingSwitch.get(sid) : void 0;
+    let raw22 = raw2;
+    if (pending && sub === "/api/context-inject" && pending.to === owner.root) {
+      raw22 = JSON.stringify({ ...body2, [FOCUS_NOTICE_FIELD]: focusNotice(pending, rootOfPath(cwd)) });
+      pendingSwitch.delete(sid);
+    }
     const tag = (v) => typeof v === "string" ? ` ${v.slice(0, 40)}` : "";
     const done = markPass(`${sub}:${owner.entry.name}${tag(body2["hook_event_name"])}${tag(body2["tool_name"])}`);
+    const post = async (target, path3, payload) => await target.webApp.fetch(
+      new Request(`http://local${path3}`, {
+        method: "POST",
+        // The origin header (harness/fixture quarantine, session-registry.ts)
+        // is the one caller header the sub-app needs; nothing else crosses.
+        headers: {
+          "content-type": "application/json",
+          ...c.req.header(ORIGIN_HEADER) ? { [ORIGIN_HEADER]: c.req.header(ORIGIN_HEADER) } : {}
+        },
+        body: payload
+      })
+    );
+    const withFocusHeader = (res) => {
+      const focusedRoot = sid ? sessionFocus.focusFor(sid) : null;
+      if (!focusedRoot) return res;
+      const headers = new Headers(res.headers);
+      headers.set(FOCUS_ROOT_HEADER, focusedRoot);
+      return new Response(res.body, { status: res.status, headers });
+    };
     try {
-      return await owner.webApp.fetch(
-        new Request(`http://local${sub}`, {
-          method: "POST",
-          // The origin header (harness/fixture quarantine, session-registry.ts)
-          // is the one caller header the sub-app needs; nothing else crosses.
-          headers: {
-            "content-type": "application/json",
-            ...c.req.header(ORIGIN_HEADER) ? { [ORIGIN_HEADER]: c.req.header(ORIGIN_HEADER) } : {}
-          },
-          body: raw2
-        })
-      );
+      const res = await post(owner, sub, raw22);
+      if (sub === "/api/session-end" && sid) {
+        sessionFocus.forget(sid);
+        pendingSwitch.delete(sid);
+      }
+      const hookEvent = String(body2["hook_event_name"] ?? "");
+      if (pending && pendingSwitch.has(sid) && sub === "/api/hook" && ["PreToolUse", "PostToolUse", "PostToolUseFailure"].includes(hookEvent)) {
+        const target = await recordFor(pending.to);
+        if (target) {
+          pendingSwitch.delete(sid);
+          const inject = await post(target, "/api/context-inject", JSON.stringify({
+            session_id: sid,
+            hook_event_name: hookEvent,
+            cwd: target.root,
+            ...typeof body2["transcript_path"] === "string" ? { transcript_path: body2["transcript_path"] } : {},
+            [FOCUS_NOTICE_FIELD]: focusNotice(pending, rootOfPath(cwd))
+          }));
+          const extra = (await inject.json().catch(() => ({}))).hookSpecificOutput?.additionalContext;
+          if (extra) {
+            const base = res.status === 204 ? {} : await res.json().catch(() => ({}));
+            return withFocusHeader(c.json(withAdditionalContext(base, hookEvent, extra)));
+          }
+        }
+      }
+      return withFocusHeader(res);
     } finally {
       done();
     }
   };
+  const MISFILED_SWEEP_DELAY_MS = 2 * 6e4;
+  const sweepMisfiled = async (rec) => {
+    const checkedPath = join47(workspacePaths(rec.root).configDir, "rehome-checked.json");
+    let checked;
+    try {
+      checked = new Set(JSON.parse(readFileSync40(checkedPath, "utf8")));
+    } catch {
+      checked = /* @__PURE__ */ new Set();
+    }
+    const workspaceOf = evidenceWorkspace(rec.root);
+    let changed = false;
+    for (const [sid, paths] of captureWorkPaths(rec.engine.store, rec.root)) {
+      if (stopping) break;
+      if (checked.has(sid) || turnHome.has(sid) || sessionFocus.reached(sid, rec.root) !== void 0) continue;
+      checked.add(sid);
+      changed = true;
+      const target = misfiledTarget(paths.map(workspaceOf).filter((r) => r != null), rec.root);
+      const to = target ? await recordFor(target) : null;
+      if (to) await rehomeMisfiled(sid, rec, to, "its captures were raised in its files");
+      await new Promise((r) => setImmediate(r));
+    }
+    if (changed) writeFileSync29(checkedPath, JSON.stringify([...checked]), "utf8");
+  };
+  afterAttach = (rec) => {
+    const t = setTimeout(() => {
+      void sweepMisfiled(rec).catch(
+        (err2) => console.warn(`[errata] misfiled-session check of ${rec.entry.name} failed: ${err2 instanceof Error ? err2.message : err2}`)
+      );
+    }, MISFILED_SWEEP_DELAY_MS);
+    t.unref?.();
+  };
+  for (const rec of records) afterAttach(rec);
+  app.get(
+    "/api/focus",
+    (c) => c.json({ sessions: sessionFocus.entries().map((f) => ({ ...f, name: workspaceName(f.root) })) })
+  );
   app.post(
     "/api/hook",
     (c) => forward(c, (b) => {
       const input = b["tool_input"] ?? {};
       const fp = input["file_path"];
       const cwd = b["cwd"];
-      return (typeof fp === "string" ? fp : void 0) ?? (typeof cwd === "string" ? cwd : void 0);
+      return (typeof fp === "string" ? fp : void 0) ?? leadingCdTarget(input["command"]) ?? (typeof cwd === "string" ? cwd : void 0);
     }, { extraPaths: (b) => hookPathCandidates(b), affinity: "note" })
   );
   app.post(
@@ -98368,6 +98826,9 @@ try {
   // a changed snapshot can go out as only what changed (the daemon renders it).
   const bodyPath = statePath && statePath.replace(/\.json$/, '.body.md');
   let emittedBody = null;
+  // Set when the daemon routes this session to another workspace (errata focus):
+  // that workspace's block is the current one.
+  let focusRoot = null;
   const post = async (endpoint, relay = false) => {
     try {
       const response = await fetch('http://127.0.0.1:' + port + '/api/' + endpoint, {
@@ -98375,6 +98836,8 @@ try {
         body: JSON.stringify(payload), signal: AbortSignal.timeout(2000),
       });
       if (!response.ok) return false;
+      const focused = response.headers.get('x-errata-focus-root');
+      if (focused) focusRoot = focused;
       if (!relay) return true;
       const result = await response.json();
       const context = result.hookSpecificOutput?.additionalContext;
@@ -98395,17 +98858,20 @@ try {
   }
   if (workspaceRoot && ['SessionStart', 'UserPromptSubmit', 'PostToolUse'].includes(event)) {
     let body = '';
-    try { body = boundedRead(join(workspaceRoot, '.errata', 'context.md'), 128 * 1024).trim(); } catch {}
+    const blockRoot = focusRoot || workspaceRoot;
+    try { body = boundedRead(join(blockRoot, '.errata', 'context.md'), 128 * 1024).trim(); } catch {}
     if (body) {
       const digest = hash(body.replace(/\r\n?/g, '\n')).slice(0, 16);
+      // A different workspace's block than the one last sent: a delta between them is noise.
+      const switched = (previous.root || workspaceRoot) !== blockRoot;
       // Receipt is local to this graph + session, survives daemon restarts, and
       // records stdout emission, not a server's intention to send a response.
-      if (event === 'SessionStart' || previous.hash !== digest) {
+      if (event === 'SessionStart' || switched || previous.hash !== digest) {
         const normalized = body.replace(/\r\n?/g, '\n');
         // Every SessionStart (startup, resume, compact, clear) sends the whole
         // block: the window may no longer hold the last one.
         let delta = null;
-        if (event !== 'SessionStart' && previous.hash && bodyPath) {
+        if (event !== 'SessionStart' && !switched && previous.hash && bodyPath) {
           let prior = '';
           try { prior = boundedRead(bodyPath, 512 * 1024); } catch {}
           if (prior && hash(prior).slice(0, 16) === previous.hash) {
@@ -98423,7 +98889,7 @@ try {
           // Only bookkeeping moved: nothing to send, but this snapshot is now what the window holds.
           try {
             mkdirSync(stateDir, { recursive: true });
-            writeFileSync(statePath, JSON.stringify({ hash: digest, at: Date.now() }), { mode: 0o600 });
+            writeFileSync(statePath, JSON.stringify({ hash: digest, at: Date.now(), root: blockRoot }), { mode: 0o600 });
             writeFileSync(bodyPath, normalized, { mode: 0o600 });
           } catch { /* the next change just goes whole */ }
         } else {
@@ -98432,11 +98898,11 @@ try {
             : 'Errata loaded the maintained local workspace context. This block REPLACES any earlier errata context block in this conversation. It is the latest saved snapshot; the daemon maintains it as work proceeds.\n\n' + body);
           if (!/^(0|off|false|no)$/i.test((process.env.ERRATA_RECALL_CARD || '').trim())) {
             try {
-              const card = JSON.parse(boundedRead(join(workspaceRoot, '.errata', 'context-card.json'), 128 * 1024));
+              const card = JSON.parse(boundedRead(join(blockRoot, '.errata', 'context-card.json'), 128 * 1024));
               if (card.hash === digest && typeof card.line === 'string' && card.line) messages.push(card.line);
             } catch { /* Never show a card for a different snapshot. */ }
           }
-          receipt = { hash: digest, at: Date.now() };
+          receipt = { hash: digest, at: Date.now(), root: blockRoot };
           emittedBody = normalized;
         }
       }
@@ -99962,6 +100428,10 @@ async function main() {
       return cmdUpdate(rest);
     case "projects":
       return cmdProjects();
+    case "focus":
+      return cmdFocus(rest);
+    case "rehome":
+      return cmdRehome(rest);
     case "dash":
       return cmdDash(rest);
     case "notify-test":
@@ -99985,6 +100455,14 @@ function printHelp() {
 Commands:
   init                Auto-detect this workspace's profile, write .errata/workspace.json
   projects            List every initialized project + whether its daemon is running
+  focus <workspace|off>
+                      Run from an agent's shell tool: that session's captures and
+                      context follow the named workspace (name or path). Sessions
+                      also follow on their own once most of the paths their tools
+                      touch are in another workspace; this pins it.
+  rehome --session <id> --from <ws> --to <ws> [--apply]
+                      Move what a session captured into the workspace its work was
+                      about (a session started in the wrong repo). Dry run by default.
   dash [--port N] [--no-reindex] [--embed]
                       One daemon watching ALL initialized projects, routing hooks
                       to each project's graph (default port 7891). JSON endpoints
@@ -101102,9 +101580,11 @@ async function cmdLink(args2) {
           saveConfig(synced.config);
         }
       }
-      if (!consents.mineHistory) console.log("history: not mined (consent off)");
-      else if (reported?.stopRequested) console.log("history: a stop request is standing in the console; the daemon honours it");
-      else console.log(`history: consents recorded${consents.contributeHistory ? "" : " (mine only)"} \xB7 the daemon walks the repo on its next pass`);
+      if (historyIngestEnabled()) {
+        if (!consents.mineHistory) console.log("history: not mined (consent off)");
+        else if (reported?.stopRequested) console.log("history: a stop request is standing in the console; the daemon honours it");
+        else console.log(`history: consents recorded${consents.contributeHistory ? "" : " (mine only)"} \xB7 the daemon walks the repo on its next pass`);
+      }
       return;
     } catch (err2) {
       const message2 = err2 instanceof Error ? err2.message : String(err2);
@@ -103046,6 +103526,82 @@ async function cmdProjects() {
     console.log(`      ${w.path}`);
   }
 }
+async function cmdFocus(args2) {
+  const entries = listWorkspaceEntries();
+  const ref = args2.find((a) => !a.startsWith("-"));
+  const clear = args2.includes("--clear") || ref === "off" || ref === "clear";
+  const port = resolveHookPort();
+  const focused = async () => {
+    try {
+      const r = await fetch(`http://127.0.0.1:${port}/api/focus`, { signal: AbortSignal.timeout(2e3) });
+      return r.ok ? (await r.json()).sessions : [];
+    } catch {
+      return [];
+    }
+  };
+  if (!ref && !clear) {
+    const now = await focused();
+    console.log("usage: errata focus <workspace name or path> | errata focus off");
+    console.log("Run it from an agent's shell tool: the session that runs it follows that workspace.\n");
+    if (now.length === 0) console.log("No session is focused away from its working directory.");
+    for (const f of now) console.log(`  ${f.sessionId.slice(0, 8)}  ${f.pinned ? "pinned to" : "following"} ${f.name}  (${f.root})`);
+    return;
+  }
+  if (clear) {
+    console.log("focus cleared for the agent session that ran this: it follows its working directory again.");
+    return;
+  }
+  const entry = resolveWorkspaceRef(ref, entries, pickOwnerRoot);
+  if (!entry) {
+    const same = entries.filter((e) => e.name.toLowerCase() === ref.toLowerCase());
+    console.error(same.length > 1 ? `"${ref}" names ${same.length} workspaces; use a path instead:
+${same.map((e) => `  ${e.path}`).join("\n")}` : `no workspace named or containing "${ref}". Known workspaces:
+${entries.map((e) => `  ${e.name.padEnd(24)} ${e.path}`).join("\n")}`);
+    process.exit(2);
+  }
+  const pinned = (await focused()).filter((f) => f.pinned && f.root === entry.path && Date.now() - f.at < 3e4);
+  if (pinned.length === 0) {
+    console.error(`${entry.name} (${entry.path}) is a workspace, but no agent session was pinned to it.`);
+    console.error("Run this from an agent's shell tool, with the errata daemon running: the daemon pins the session whose hook reports the command.");
+    process.exit(1);
+  }
+  console.log(`focus: ${entry.name} (${entry.path}), pinned for session ${pinned.map((f) => f.sessionId.slice(0, 8)).join(", ")}.`);
+  console.log("Captures and context now come from this workspace. `errata focus off` returns the session to its working directory.");
+}
+async function cmdRehome(args2) {
+  const values = (flag) => args2.flatMap((a, i2) => a === flag && args2[i2 + 1] ? [args2[i2 + 1]] : []);
+  const sessions = values("--session");
+  const [fromRef] = values("--from");
+  const [toRef] = values("--to");
+  const apply = args2.includes("--apply");
+  if (sessions.length === 0 || !fromRef || !toRef) {
+    console.error("usage: errata rehome --session <id> [--session <id> \u2026] --from <workspace> --to <workspace> [--apply]");
+    process.exit(2);
+  }
+  const entries = listWorkspaceEntries();
+  const from = resolveWorkspaceRef(fromRef, entries, pickOwnerRoot);
+  const to = resolveWorkspaceRef(toRef, entries, pickOwnerRoot);
+  if (!from || !to || from.path === to.path) {
+    console.error(`--from and --to must name two different workspaces (got ${from?.name ?? fromRef} \u2192 ${to?.name ?? toRef}).`);
+    process.exit(2);
+  }
+  const { openGraphStore: openGraphStore2 } = await Promise.resolve().then(() => (init_src5(), src_exports2));
+  const src = openGraphStore2({ path: workspacePaths(from.path).castalia });
+  const dst = openGraphStore2({ path: workspacePaths(to.path).castalia });
+  try {
+    const r = rehomeSessionNodes(src, dst, sessions, { apply });
+    const verb = apply ? "" : "would ";
+    console.log(`${from.name} \u2192 ${to.name}${apply ? "" : " (dry run; --apply to write)"}`);
+    console.log(`  ${verb}move ${r.moved.length} node(s) (closed in ${from.name}), ${verb}copy ${r.copied.length} shared with other sessions`);
+    console.log(`  ${verb}carry ${r.edgesCarried} edge(s), ${verb}add ${r.vocabulary.length} vocabulary node(s) to ${to.name}; ${r.edgesDropped} edge(s) into ${from.name}'s code dropped`);
+    if (r.cloudContributed.length > 0) {
+      console.log(`  ${r.cloudContributed.length} of them were already contributed to the cloud under ${from.name}'s project; those cloud copies are not moved.`);
+    }
+  } finally {
+    src.close();
+    dst.close();
+  }
+}
 async function cmdNotifications(state) {
   const s = state.toLowerCase();
   if (s !== "on" && s !== "off") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.23-dev.4779",
+  "version": "2.0.23-dev.4803",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {

package/resources/context-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.23-dev.4779",
+  "version": "2.0.23-dev.4803",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,4 +1,4 @@
-8c2ed59e34694f0fbec381b67731aae53d87a289c92222a279d038f65e3bcad0  .codex-plugin/plugin.json
+08211bb4b884703471ec49f813c41d354603948bade76fd5acd9627748d4d7a3  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js