pi-weave 0.3.8 → 0.3.9

package/src/core/view/rawTail.ts

@@ -0,0 +1,153 @@
+/**
+ * Where a note's append-only `## Raw` tail begins (weave-workspace §1.2).
+ *
+ * Pure and node-free on purpose: the vault uses it to keep the on-disk tail
+ * whatever a save says, and the browser editor uses the same function,
+ * through `src/web/shared/view.ts`, to keep the tail out of the textarea.
+ * Two implementations would disagree about a fenced `## Raw` sample, and the
+ * editor would then hide text the server is willing to overwrite.
+ */
+
+/**
+ * The append-only tail heading.
+ *
+ * `../links/repair` and `../vault` re-export it, so their public API is
+ * unchanged.
+ */
+export const RAW_NOTES_HEADING = "## Raw";
+
+const FENCE_RE = /^[ \t]*(`{3,}|~{3,})(.*)$/gm;
+/** A `## Raw` heading on a line of its own — not `## Rawhide`. */
+const RAW_HEADING_RE = new RegExp(`^${RAW_NOTES_HEADING}[ \\t]*\\r?$`, "m");
+
+/**
+ * Half-open `[start, end)` ranges covering fenced code blocks.
+ *
+ * CommonMark, not "every third-backtick-line toggles": a fence is closed only
+ * by the **same marker character**, at **at least the opening length**, and
+ * with no info string. Treating fences as a blind alternation gets two cases
+ * backwards — a `~~~` nested inside a ``` block would close it, and a ```
+ * inside a ```` block would too — and each mistake ends the protected region
+ * early, exposing example links in documentation to rewriting.
+ */
+export function fenceRanges(body: string): [number, number][] {
+  const ranges: [number, number][] = [];
+  let open: { at: number; marker: string; length: number } | null = null;
+  for (const match of body.matchAll(FENCE_RE)) {
+    const run = match[1]!;
+    // Group 2 is `(.*)`, which always participates: the info string.
+    const info = match[2]!;
+    if (open === null) {
+      open = { at: match.index, marker: run[0]!, length: run.length };
+    } else if (run[0] === open.marker && run.length >= open.length && info.trim() === "") {
+      ranges.push([open.at, match.index + match[0].length]);
+      open = null;
+    }
+  }
+  // An unterminated fence runs to the end of the body, the way a renderer
+  // treats it.
+  if (open !== null) ranges.push([open.at, body.length]);
+  return ranges;
+}
+
+/**
+ * The byte offset where the `## Raw` tail begins, or the body length when
+ * there is none.
+ *
+ * The tail is append-only and verbatim — "NEVER edit below this line" is
+ * written into every note that has one. A link inside a user's dictation is
+ * *their* text, quoted; repairing it would edit words the vault promises not
+ * to touch.
+ *
+ * Fence-aware, and for the opposite reason to everything else here: a note
+ * *documenting* the raw-tail convention contains `## Raw` inside a code
+ * sample, and treating that as the real tail would silently protect — and so
+ * refuse to repair — every link below it. Matching a whole heading line also
+ * keeps `## Rawhide` from starting a tail.
+ */
+export function rawTailStart(body: string, fences: readonly [number, number][]): number {
+  let from = 0;
+  for (;;) {
+    const rest = body.slice(from);
+    const hit = RAW_HEADING_RE.exec(rest);
+    if (hit === null) return body.length;
+    const at = from + hit.index;
+    const fence = fences.find(([a, b]) => at >= a && at < b);
+    if (fence === undefined) return at;
+    from = fence[1]; // skip the whole fenced block and keep looking
+  }
+}
+
+/** A `---` rule, alone on the line, with only blank space after it. */
+const TAIL_RULE_RE = /(?:^|\n)-{3,}[ \t]*\r?\n\s*$/;
+
+/**
+ * Where the tail's text begins — the `---` rule, not the heading
+ * `rawTailStart` returns. Splitting at the heading orphans the rule.
+ * The body length when there is no tail.
+ */
+export function rawTailBoundary(body: string): number {
+  const heading = rawTailStart(body, fenceRanges(body));
+  if (heading === body.length) return heading;
+  const rule = TAIL_RULE_RE.exec(body.slice(0, heading));
+  if (rule === null) return heading;
+  // `index` is the newline before the rule when there is one; step over it.
+  return rule.index === 0 && !body.startsWith("\n") ? 0 : rule.index + 1;
+}
+
+/** A body split at its tail: the editable `head`, and the verbatim `tail` ("" when none). */
+export interface RawTailSplit {
+  head: string;
+  tail: string;
+}
+
+/**
+ * Split a body into the part a person may edit and the tail nobody may.
+ *
+ * The head loses only trailing whitespace, so the editor's cursor lands
+ * right after the last word rather than on the blank lines before the rule.
+ */
+export function splitRawTail(body: string): RawTailSplit {
+  const at = rawTailBoundary(body);
+  return { head: body.slice(0, at).trimEnd(), tail: body.slice(at).trimEnd() };
+}
+
+/** Put a head back above its tail, the inverse of {@link splitRawTail}. */
+export function joinRawTail(head: string, tail: string): string {
+  if (tail === "") return head;
+  // An emptied head leaves the tail alone, not a leading blank line.
+  return head === "" ? tail : `${head}\n\n${tail}`;
+}
+
+/** A tail split below its heading: the fixed `opening`, and the `entries` a person may edit. */
+export interface RawOpeningSplit {
+  opening: string;
+  entries: string;
+}
+
+/** The notice comment written under the heading; `<!-- appended … -->` starts an entry instead. */
+const NOTICE_RE = /^<!--(?! appended\b).*-->[ \t]*\r?$/;
+
+/**
+ * Split a tail (as {@link splitRawTail} returns it) after its `## Raw`
+ * heading and the notice line under it. The editor shows only `entries`, so
+ * clearing the box cannot leave an orphaned rule or heading in the body.
+ */
+export function splitRawOpening(tail: string): RawOpeningSplit {
+  const heading = rawTailStart(tail, fenceRanges(tail));
+  if (heading === tail.length) return { opening: tail, entries: "" };
+  let end = tail.indexOf("\n", heading);
+  if (end !== -1) {
+    const next = tail.indexOf("\n", end + 1);
+    const line = tail.slice(end + 1, next === -1 ? tail.length : next);
+    if (NOTICE_RE.test(line)) end = next;
+  }
+  if (end === -1) return { opening: tail.trimEnd(), entries: "" };
+  return { opening: tail.slice(0, end).trimEnd(), entries: tail.slice(end).replace(/^\s*\n/, "").trimEnd() };
+}
+
+/** Put edited entries back under their opening; no entries means no tail at all. */
+export function joinRawOpening(opening: string, entries: string): string {
+  const text = entries.trim();
+  return text === "" ? "" : `${opening}\n\n${entries.replace(/^\s*\n/, "").trimEnd()}`;
+}

package/src/core/workspace.ts

@@ -1,5 +1,5 @@
 import { findGitRoot } from "./git";
-import { assessStaleness, readRepoIndex } from "./repoIndex";
+import { readRepoIndex } from "./repoIndex";
 import { readSummaries } from "./summaries";
 import { basename } from "node:path";
 import { resolveVaultRoot } from "./paths";
@@ -35,24 +35,27 @@ export async function getWorkspaceStatus(cwd: string, options: WorkspaceOptions
   if (!repoRoot) return status;
 
   const index = await readRepoIndex(repoRoot);
-  const staleness = await assessStaleness(repoRoot);
   status.repository = {
     root: repoRoot,
     name: index?.identity.name ?? basename(repoRoot),
-    indexed: index !== null,
-    staleness,
-    summaryCount: index === null ? 0 : (await readSummaries(repoRoot)).length,
+    summaryCount: (await readSummaries(repoRoot)).length,
   };
   return status;
 }
 
-/** One-line status string for footers/status bars. */
+/**
+ * One-line status string for footers/status bars. It counts notes; the
+ * repository appears only once a deep scan has written summaries, because
+ * the structure index is plumbing the user never has to think about.
+ */
 export function formatStatusLine(status: WorkspaceStatus): string {
-  const vault = `vault:${status.vault.noteCount}`;
-  if (!status.repository) return `🕸️ ${vault}`;
-  if (!status.repository.indexed) return `🕸️ ${vault} · repo:unindexed`;
-  const mark = status.repository.staleness.state === "fresh" ? "ok" : status.repository.staleness.state;
-  return `🕸️ ${vault} · ${status.repository.name}:${mark}`;
+  const notes = plural(status.vault.noteCount, "note", "notes");
+  const summaries = status.repository?.summaryCount ?? 0;
+  return summaries > 0 ? `🕸️ ${notes} · ${plural(summaries, "summary", "summaries")}` : `🕸️ ${notes}`;
+}
+
+function plural(count: number, one: string, many: string): string {
+  return `${count} ${count === 1 ? one : many}`;
 }
 
 /** Multi-line dashboard used by the /weave command and notifications. */
@@ -64,22 +67,13 @@ export function formatDashboard(status: WorkspaceStatus): string {
       ? `  ${status.vault.noteCount} note(s)`
       : "  not initialized — add a note to create it",
   );
-  if (!status.repository) {
-    lines.push("Repository: none (not inside a git repository)");
-    return lines.join("\n");
-  }
   const repo = status.repository;
+  if (!repo) return lines.join("\n");
   lines.push(`Repository (${repo.name} @ ${repo.root}):`);
-  if (!repo.indexed) {
-    lines.push("  not indexed — run /weave-scan or ask your agent to explore");
-    return lines.join("\n");
-  }
-  lines.push(`  index: ${repo.staleness.state}`);
-  for (const reason of repo.staleness.reasons) {
-    lines.push(`    - ${reason}`);
-  }
-  if (repo.summaryCount > 0) {
-    lines.push(`  summaries: ${repo.summaryCount} file(s) — run /weave-scan deep to refresh`);
-  }
+  lines.push(
+    repo.summaryCount > 0
+      ? `  summaries: ${repo.summaryCount} file(s) — run /weave-scan to refresh`
+      : "  no file summaries yet — run /weave-scan to write them with your session model",
+  );
   return lines.join("\n");
 }

package/src/core/workspaceCommands.ts

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { findGitRoot } from "./git";
 import { resolveVaultRoot } from "./paths";
-import { buildRepoIndex, summarizeIndex, writeRepoIndex } from "./repoIndex";
+import { ensureRepoIndex } from "./repoIndex";
 import { formatDashboard, getWorkspaceStatus } from "./workspace";
 import { DEEP_SCAN_SYSTEM_PROMPT, formatDeepScanResult, runDeepScan, type SummarizeFn } from "./summaries";
 import { formatSessionScanResult, renderSessionDigest, runSessionDigestScan, runSessionScan, SESSION_SCAN_SYSTEM_PROMPT, type SessionDigest } from "./sessions";
@@ -91,7 +91,7 @@ export function createWorkspaceCommands(
 
   commands.push({
     name: "weave-scan",
-    description: "Refresh the index; use 'deep' or 'sessions [path]' for model-backed scans",
+    description: "Summarize this repository's files with the session model; 'sessions [path]' summarizes session history",
     async execute(sessionID, args) {
       const [mode = "", ...rest] = args.trim().split(/\s+/).filter(Boolean);
       const key = String(sessionID);
@@ -141,24 +141,24 @@ export function createWorkspaceCommands(
         return;
       }
 
+      if (mode !== "" && mode.toLowerCase() !== "deep") {
+        await output(sessionID, "usage: /weave-scan [sessions [path]]");
+        return;
+      }
       const root = await findGitRoot(cwd);
       if (!root) {
         await output(sessionID, "pi-weave: not inside a git repository.");
         return;
       }
-      const index = await buildRepoIndex(root);
-      if (!index) {
-        await output(sessionID, "pi-weave: cannot index — the repository has no commits yet.");
-        return;
-      }
-      await writeRepoIndex(root, index);
-      await output(sessionID, `pi-weave: index refreshed\n${summarizeIndex(index).join("\n")}`);
-      onStatus({ sessionID: key, text: "pi-weave: index refreshed", active: false });
-      if (mode.toLowerCase() !== "deep") return;
-
       const session = await host.getSession(sessionID);
       if (!session.model) {
-        await output(sessionID, "pi-weave: deep scan needs an active session model — none configured. Light index only.");
+        await output(sessionID, "pi-weave: deep scan needs an active session model — none configured.");
+        return;
+      }
+      // The structure index is plumbing the deep scan and graph rely on;
+      // refresh it silently rather than reporting it as a result.
+      if (!(await ensureRepoIndex(root))) {
+        await output(sessionID, "pi-weave: nothing to scan — the repository has no commits yet.");
         return;
       }
       start(sessionID, async (signal) => {
@@ -182,7 +182,7 @@ export function createWorkspaceCommands(
 
   commands.push({
     name: "weave-scan-cancel",
-    description: "Cancel the active pi-weave deep or session scan",
+    description: "Cancel the active pi-weave scan",
     async execute(sessionID) {
       const scan = running.get(String(sessionID));
       if (!scan) {

package/src/opencode/tools.ts

@@ -8,7 +8,7 @@ const noteInput = {
     text: { type: "string", description: "Markdown body (add), addition (append), or restructured body (finalize)" },
     tags: { type: "array", items: { type: "string" }, description: "Tags (add)" },
     slug: { type: "string", description: "Note slug (get, append, finalize)" },
-    raw: { type: "boolean", description: "append: preserve text verbatim in the ## Raw tail" },
+    raw: { type: "boolean", description: "add/append: preserve text verbatim in the ## Raw tail (use for the user's own words)" },
     source: { type: "string", enum: ["human", "agent"], description: "Provenance (add; defaults to agent)" },
     query: { type: "string", description: "Search query (search)" },
     fix: { type: "boolean", description: "links: apply unambiguous repairs" },
@@ -21,7 +21,7 @@ const noteInput = {
 const repoInput = {
   type: "object",
   properties: {
-    action: { type: "string", enum: ["status", "scan", "overview"] },
+    action: { type: "string", enum: ["overview"] },
   },
   required: ["action"],
   additionalProperties: false,
@@ -38,6 +38,6 @@ export const weaveTools = [
     name: "weave_repo",
     description: WEAVE_REPO_DESCRIPTION,
     input: repoInput,
-    execute: (input: unknown, cwd: string, progress?: (text: string) => Promise<void>) => executeRepoAction(input as RepoActionInput, cwd, progress),
+    execute: (input: unknown, cwd: string) => executeRepoAction(input as RepoActionInput, cwd),
   },
 ];

package/src/opencode/tui.ts

@@ -55,13 +55,7 @@ const weaveTui = {
   async setup(context) {
     const rpc = context.client.rpc(WEAVE_RPC);
     try {
-      const initial = await rpc.status({});
-      const text = String(record(initial).text ?? "");
-      if (text.includes("repo:unindexed")) {
-        context.ui.toast.show({ message: "This repository is not indexed yet. Run /weave-scan.", variant: "info" });
-      } else if (text.includes(":stale")) {
-        context.ui.toast.show({ message: "The pi-weave repository index is stale. Run /weave-scan.", variant: "warning" });
-      }
+      await rpc.status({});
     } catch {
       context.ui.toast.show({ message: "pi-weave unavailable", variant: "warning" });
     }

package/src/pi/index.ts

@@ -2,20 +2,18 @@ import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@e
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import {
-  buildRepoIndex,
+  ensureRepoIndex,
   findGitRoot,
   formatDashboard,
   formatStatusLine,
   getWorkspaceStatus,
-  summarizeIndex,
-  writeRepoIndex,
+  recallTrail,
   type WorkspaceStatus,
 } from "../core";
 import { registerNoteTool } from "./tools/noteTool";
 import { registerRepoTool } from "./tools/repoTool";
 import { formatSessionScanResult, scanPiSessions } from "./sessionScan";
 import { deepScanRepository, formatDeepScanResult } from "./summarize";
-import { runWeaveViewTui } from "./viewer/tui/run";
 import { WebWorkspaceController } from "./viewer/web/run";
 
 /**
@@ -31,10 +29,9 @@ export default function piWeave(pi: ExtensionAPI): void {
   registerNoteTool(pi);
   registerRepoTool(pi);
 
-  // /weave-view opens the browser workspace by default (weave-workspace §13);
-  // `tui` selects the in-terminal explorer. The browser workspace owns a
-  // server, a file watcher and live SSE streams for the rest of the session,
-  // so unlike the TUI it has a real teardown — see `session_shutdown` below.
+  // /weave-view opens the browser workspace. It owns a server, a file watcher
+  // and live SSE streams for the rest of the session, so it has a real
+  // teardown — see `session_shutdown` below.
   let lastCtx: ExtensionContext | ExtensionCommandContext | null = null;
   let lastStatusText: string | undefined = undefined;
   let isActive = false;
@@ -66,7 +63,11 @@ export default function piWeave(pi: ExtensionAPI): void {
     // server was listening. The browser-launch-failure path is exactly that
     // shape, which is why it was the case that caught it.
     const port = web.port();
-    const suffix = port === null ? "" : ` · web:${port}`;
+    // The recall trail's one terminal echo: how many notes this turn
+    // actually read or wrote. Resets when the next turn begins.
+    const used = recallTrail.usedThisTurn();
+    const recall = used === 0 ? "" : ` · used ${used} note${used === 1 ? "" : "s"}`;
+    const suffix = `${recall}${port === null ? "" : ` · web:${port}`}`;
 
     // Clear only when there is genuinely nothing to say: no base text *and*
     // no server.
@@ -91,8 +92,7 @@ export default function piWeave(pi: ExtensionAPI): void {
   }
 
   pi.on("session_shutdown", async () => {
-    // The TUI explorer owns nothing session-scoped, but the browser workspace
-    // owns an HTTP server, a recursive file watcher and any number of open SSE
+    // The browser workspace owns an HTTP server, a recursive file watcher and any number of open SSE
     // streams. `close()` releases all three (server.ts closes the hub and
     // awaits the watcher); a leaked listener outliving the pi session is a
     // real bug, not a tidiness concern.
@@ -100,30 +100,27 @@ export default function piWeave(pi: ExtensionAPI): void {
   });
 
   pi.on("agent_start", async (_event, ctx) => {
+    recallTrail.beginTurn();
     isActive = true;
     updateStatus(ctx);
   });
 
   pi.on("agent_end", async (_event, ctx) => {
     isActive = false;
-    updateStatus(ctx);
+    // The agent may have written notes this turn, so recount them — unless a
+    // background scan owns the status line with its progress, or no session
+    // ever seeded a status line to recount.
+    const cwd = ctx?.cwd ?? lastCtx?.cwd;
+    if (cwd && lastStatusText !== undefined && inFlightDeepScans.size === 0 && inFlightSessionScans.size === 0) {
+      updateStatus(ctx, formatStatusLine(await getWorkspaceStatus(cwd)));
+    } else {
+      updateStatus(ctx);
+    }
   });
 
   pi.on("session_start", async (_event, ctx) => {
     const status = await getWorkspaceStatus(ctx.cwd);
     updateStatus(ctx, formatStatusLine(status));
-
-    if (!ctx.hasUI) return;
-    const repo = status.repository;
-    if (repo && !repo.indexed) {
-      ctx.ui.notify(
-        "pi-weave: this repository has no knowledge index yet — ask pi to explore it, or run /weave-scan.",
-        "info",
-      );
-    } else if (repo && repo.staleness.state === "stale") {
-      const reason = repo.staleness.reasons[0] ?? "index is stale";
-      ctx.ui.notify(`pi-weave: repository index is stale (${reason}). Run /weave-scan to refresh.`, "warning");
-    }
   });
 
   pi.registerCommand("weave", {
@@ -135,32 +132,28 @@ export default function piWeave(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("weave-view", {
-    description: "Open the knowledge workspace in your browser ('tui' for the in-terminal explorer, '--no-open' to just print the URL)",
+    description: "Open the knowledge workspace in your browser ('--no-open' to just print the URL)",
     handler: async (args, ctx) => {
       const parsed = parseWeaveViewArgs(args);
-      if (parsed === null) {
-        ctx.ui.notify(WEAVE_VIEW_USAGE, "warning");
+      if (parsed === "retired-tui") {
+        ctx.ui.notify(WEAVE_VIEW_TUI_RETIRED, "warning");
         return;
       }
-      if (parsed.surface === "tui") {
-        await runWeaveViewTui(ctx);
+      if (parsed === null) {
+        ctx.ui.notify(WEAVE_VIEW_USAGE, "warning");
         return;
       }
-      const outcome = await web.run(ctx, { open: parsed.open });
-      // A browser that would not launch on a machine that has a terminal
-      // still leaves the user somewhere to go. The server stays up — the URL
-      // in the notification remains valid — and the TUI opens on top of it.
-      if (outcome.fallbackToTui && ctx.mode === "tui") await runWeaveViewTui(ctx);
-      // Unconditionally, and last: the TUI writes its own status line on
-      // close, which would otherwise drop the `· web:PORT` marker for a
-      // server that is still running.
+      // A browser that will not launch still leaves the URL in the
+      // notification, and the server stays up behind it.
+      await web.run(ctx, { open: parsed.open });
+      // Last, so the status line gains the `· web:PORT` marker.
       updateStatus(ctx);
     },
   });
 
   pi.registerCommand("weave-scan", {
     description:
-      "Build or refresh the repository index; 'deep' summarizes files; 'sessions [dir]' summarizes session history",
+      "Summarize this repository's files with the session model; 'sessions [dir]' summarizes session history",
     handler: async (args, ctx) => {
       const input = args.trim();
       const [mode = "", ...rest] = input.split(/\s+/);
@@ -176,38 +169,33 @@ export default function piWeave(pi: ExtensionAPI): void {
         return; // the background scan owns the status line until it settles
       }
 
+      if (mode !== "" && mode.toLowerCase() !== "deep") {
+        ctx.ui.notify(WEAVE_SCAN_USAGE, "warning");
+        return;
+      }
+
       const root = await findGitRoot(ctx.cwd);
       if (!root) {
         ctx.ui.notify("pi-weave: not inside a git repository.", "warning");
         return;
       }
-      const index = await buildRepoIndex(root);
-      if (!index) {
-        ctx.ui.notify("pi-weave: cannot index — the repository has no commits yet.", "warning");
+      if (inFlightDeepScans.has(root)) {
+        ctx.ui.notify("pi-weave: a deep scan is already running for this repository — run /weave-scan-cancel to stop it.", "warning");
         return;
       }
-      await writeRepoIndex(root, index);
-      ctx.ui.notify(`pi-weave: index refreshed\n${summarizeIndex(index).join("\n")}`, "info");
-
-      if (mode.toLowerCase() === "deep") {
-        if (inFlightDeepScans.has(root)) {
-          ctx.ui.notify("pi-weave: a deep scan is already running for this repository — run /weave-scan-cancel to stop it.", "warning");
-        } else {
-          // Compute the settled status here (no git-lock contention) and let
-          // the background scan restore it when it finishes.
-          const status = await getWorkspaceStatus(ctx.cwd);
-          startDeepScan(root, ctx, status, updateStatus);
-        }
-        return; // the background scan owns the status line until it settles
+      // The structure index is plumbing the deep scan and graph rely on;
+      // refresh it silently rather than reporting it as a result.
+      if (!(await ensureRepoIndex(root))) {
+        ctx.ui.notify("pi-weave: nothing to scan — the repository has no commits yet.", "warning");
+        return;
       }
-
       const status = await getWorkspaceStatus(ctx.cwd);
-      updateStatus(ctx, formatStatusLine(status));
+      startDeepScan(root, ctx, status, updateStatus);
     },
   });
 
   pi.registerCommand("weave-scan-cancel", {
-    description: "Cancel an in-flight /weave-scan deep or sessions run",
+    description: "Cancel an in-flight /weave-scan run",
     handler: async (_args, ctx) => {
       const root = await findGitRoot(ctx.cwd);
       const deep = root ? inFlightDeepScans.get(root) : undefined;
@@ -241,30 +229,33 @@ export function resolveHistoryPath(cwd: string, input: string): string {
   return resolve(cwd, trimmed);
 }
 
-export const WEAVE_VIEW_USAGE = "usage: /weave-view [tui|web] [--no-open]";
+export const WEAVE_SCAN_USAGE = "usage: /weave-scan [sessions [dir]]";
+
+export const WEAVE_VIEW_USAGE = "usage: /weave-view [--no-open]";
 
-/** Which explorer `/weave-view` was asked for. */
+/** Shown for the retired `/weave-view tui` argument (issue #61). */
+export const WEAVE_VIEW_TUI_RETIRED =
+  "pi-weave: the terminal explorer was retired. /weave-view opens the browser workspace; use /weave-view --no-open to print its URL (e.g. over SSH).";
+
+/** What `/weave-view` was asked to do. */
 export interface WeaveViewArgs {
-  surface: "tui" | "web";
-  /** `false` for `--no-open`. Meaningless for `tui`, which never opens one. */
+  /** `false` for `--no-open`. */
   open: boolean;
 }
 
 /**
- * Parse `/weave-view`'s argument string, or `null` for "print the usage".
+ * Parse `/weave-view`'s argument string: the options, `"retired-tui"` for the
+ * removed terminal explorer, or `null` for "print the usage".
  *
- * Bare `/weave-view` is the **browser** workspace (weave-workspace §13):
- * the default is the thing most people want most of the time, and `tui` is
- * one word away for the SSH case. `--no-open` is accepted on the web
- * surface only — silently ignoring it after `tui` would be a lie about what
- * happened.
+ * `web` is still accepted as a no-op so muscle memory from the two-surface
+ * days keeps working.
  *
  * Exported because a parser is exactly the kind of thing that should be
  * tested as a table rather than through eight command invocations.
  */
-export function parseWeaveViewArgs(args: string): WeaveViewArgs | null {
+export function parseWeaveViewArgs(args: string): WeaveViewArgs | "retired-tui" | null {
   const tokens = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
-  let surface: "tui" | "web" = "web";
+  if (tokens.includes("tui")) return "retired-tui";
   let open = true;
   let sawSurface = false;
   for (const token of tokens) {
@@ -274,13 +265,10 @@ export function parseWeaveViewArgs(args: string): WeaveViewArgs | null {
       open = false;
       continue;
     }
-    if (sawSurface) return null;
-    if (token !== "tui" && token !== "web") return null;
-    surface = token;
+    if (sawSurface || token !== "web") return null;
     sawSurface = true;
   }
-  if (surface === "tui" && !open) return null;
-  return { surface, open };
+  return { open };
 }
 
 /* ------------------------------------------------------------------ */
@@ -365,7 +353,7 @@ function startBackgroundScan(
 
 /**
  * Kick off a deep scan in the background. `baseStatus` is the workspace
- * status captured before the scan and restored when it settles.
+ * status captured before the scan, the fallback if recounting fails.
  */
 function startDeepScan(
   root: string,
@@ -387,7 +375,7 @@ function startDeepScan(
     }
     if (outcome.kind === "no-model") {
       return {
-        text: "pi-weave: deep scan needs an active session model — none configured. Light index only.",
+        text: "pi-weave: deep scan needs an active session model — none configured.",
         level: "warning",
       };
     }
@@ -395,7 +383,9 @@ function startDeepScan(
       return { text: `pi-weave: deep scan complete — ${formatDeepScanResult(outcome.result)}`, level: "info" };
     }
     return null;
-  });
+  },
+  // The status line counts summaries, so recount them once the scan settles.
+  () => getWorkspaceStatus(ctx.cwd));
 }
 
 /**
@@ -439,9 +429,7 @@ function startSessionScan(
       }
       return { text: `pi-weave: session scan complete — ${formatSessionScanResult(result)}`, level: "info" };
     },
-    // Unlike the deep scan (whose settled status is precomputed to avoid git
-    // contention), the session scan writes vault notes and takes no git lock:
-    // recompute the workspace status so the settled line counts the notes it
+    // Recompute the workspace status so the settled line counts the notes it
     // just wrote.
     () => getWorkspaceStatus(ctx.cwd),
   );

package/src/pi/tools/noteTool.ts

@@ -26,7 +26,7 @@ export function registerNoteTool(pi: ExtensionAPI): void {
       text: Type.Optional(Type.String({ description: "Markdown body (add), addition (append), or restructured body above the raw tail (finalize)" })),
       tags: Type.Optional(Type.Array(Type.String(), { description: "Tags (add)" })),
       slug: Type.Optional(Type.String({ description: "Note slug (get, append, finalize)" })),
-      raw: Type.Optional(Type.Boolean({ description: "append: add text as verbatim dictation to the ## Raw tail (timestamped fenced block; tail created if missing). Use for dictation/scribbles; omit for structured Markdown additions" })),
+      raw: Type.Optional(Type.Boolean({ description: "add/append: keep text as verbatim dictation in the ## Raw tail (timestamped fenced block; tail created if missing). Use for the user's own words, including the first words of a dictated note; omit for structured Markdown" })),
       source: Type.Optional(StringEnum(["human", "agent"] as const, { description: "Provenance (add): human for user-scribbled notes, agent for Pi-drafted (default agent)" })),
       query: Type.Optional(Type.String({ description: "Search query (search)" })),
       fix: Type.Optional(Type.Boolean({ description: "links: apply the unambiguous repairs. Omit for a read-only report" })),

package/src/pi/tools/repoTool.ts

@@ -12,15 +12,12 @@ export function registerRepoTool(pi: ExtensionAPI): void {
     promptSnippet: "Explore the repository's structure via its .okf knowledge index",
     promptGuidelines: [
       "Use weave_repo action=overview to learn repository structure before broad code exploration instead of scanning files one by one.",
-      "Use weave_repo action=scan when the user asks to explore or index this repository.",
     ],
     parameters: Type.Object({
-      action: StringEnum(["status", "scan", "overview"] as const),
+      action: StringEnum(["overview"] as const),
     }),
-    async execute(_toolCallId, params, _signal, onUpdate, ctx) {
-      const result = await executeRepoAction(params, ctx.cwd, (text) => {
-        onUpdate?.({ content: [{ type: "text", text }], details: {} });
-      });
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await executeRepoAction(params, ctx.cwd);
       return { content: [{ type: "text", text: result.text }], details: result.details };
     },
   });