@javierkaiser/opencode-indexing 0.2.0 → 0.2.1

package/src/tools.ts

@@ -10,6 +10,13 @@ import type { Qdrant } from "./qdrant.ts"
 
 export interface ToolDeps {
   kv: KVStore
+  /**
+   * Fallback workspace, used when the host does not report one per call.
+   *
+   * This is the plugin instance's own directory — the one the service runs in,
+   * which is usually not the directory the user is working in. Prefer
+   * `context.directory`; this is the last resort, not the normal path.
+   */
   root: string
   /**
    * Live settings getter. Tools resolve settings on every execution so config
@@ -18,6 +25,31 @@ export interface ToolDeps {
   getSettings: () => IndexingSettings | Promise<IndexingSettings>
 }
 
+/**
+ * Host context as far as the tools read it.
+ *
+ * `directory` is the session's workspace. Older hosts omit it, which is why it
+ * is optional: `toolRoot` falls back rather than indexing nothing.
+ */
+export interface ToolContext {
+  signal?: AbortSignal
+  progress?: (m: unknown) => Promise<void>
+  directory?: string
+}
+
+/**
+ * The workspace one tool call is about.
+ *
+ * The host knows which directory the user is in; the plugin instance does not.
+ * Indexing the service's directory because that is what `deps.root` happened to
+ * hold writes a perfectly good index of the wrong codebase and reports it as the
+ * user's, so the session directory wins whenever the host reports one.
+ */
+function toolRoot(deps: ToolDeps, context: ToolContext): string {
+  const directory = context.directory
+  return typeof directory === "string" && directory.trim() !== "" ? directory : deps.root
+}
+
 export interface ToolDefinition {
   name: string
   description: string
@@ -30,10 +62,7 @@ export interface ToolDefinition {
    * is why configuration read and write are separate tools.
    */
   permission?: string
-  execute: (
-    input: Record<string, unknown>,
-    context: { signal?: AbortSignal; progress?: (m: unknown) => Promise<void> },
-  ) => Promise<{ output: string; metadata?: Record<string, unknown> }>
+  execute: (input: Record<string, unknown>, context: ToolContext) => Promise<{ output: string; metadata?: Record<string, unknown> }>
 }
 
 const SEARCH_DESCRIPTION = `Find code snippets by semantic meaning in the project's code index.
@@ -119,9 +148,10 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         },
         ["query"],
       ),
-      async execute(input) {
+      async execute(input, context) {
         const settings = await deps.getSettings()
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const query = typeof input.query === "string" ? input.query.trim() : ""
         if (!query) throw new Error("query is required")
         const pathPrefix = typeof input.path === "string" && input.path.trim() !== "" ? input.path.trim() : undefined
@@ -130,13 +160,13 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         // Skipped while indexing is paused, otherwise a search would keep writing.
         if (settings.autoRefresh && settings.enabled !== false) {
           try {
-            await maybeAutoRefresh(deps, settings, qdrant)
+            await maybeAutoRefresh(root, deps, settings, qdrant)
           } catch {
             // Auto-refresh failures never block the search.
           }
         }
 
-        const outcome = await searchCode({ qdrant, kv: deps.kv, root: deps.root, settings }, query, pathPrefix)
+        const outcome = await searchCode({ qdrant, kv: deps.kv, root, settings }, query, pathPrefix)
         const { hits, meta, errors } = outcome
         if (hits.length === 0) {
           const lines: string[] = [`No results for "${query}" in ${meta.root}.`]
@@ -184,10 +214,11 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
       input: jsonSchema({
         checkFreshness: { type: "boolean", description: "Scan the workspace to compute file freshness (slower)." },
       }),
-      async execute(input) {
+      async execute(input, context) {
         const settings = await deps.getSettings()
         const qdrant = createSettingsQdrant(settings)
-        const status = await getStatus({ qdrant, kv: deps.kv, root: deps.root, settings }, { checkFreshness: input.checkFreshness !== false })
+        const root = toolRoot(deps, context)
+        const status = await getStatus({ qdrant, kv: deps.kv, root, settings }, { checkFreshness: input.checkFreshness !== false })
         const lines: string[] = [
           `Workspace: ${status.root}`,
           `Qdrant: ${status.qdrant.url} (${status.qdrant.reachable ? "reachable" : "UNREACHABLE"})`,
@@ -224,11 +255,12 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const maxFiles = typeof input.maxFiles === "number" && input.maxFiles > 0 ? Math.floor(input.maxFiles) : undefined
         const report = await runIndex(
           {
             kv: deps.kv,
-            root: deps.root,
+            root,
             settings,
             qdrant,
             onProgress: makeProgress(context),
@@ -236,7 +268,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
           { mode: "refresh", maxFiles },
         )
         const summary = formatReport("refresh", report)
-        const warning = scopeWarning(deps.root)
+        const warning = scopeWarning(root)
         return {
           output: warning ? `${warning}\n${summary}` : summary,
           metadata: report as unknown as Record<string, unknown>,
@@ -254,10 +286,11 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
+        const root = toolRoot(deps, context)
         const report = await runIndex(
           {
             kv: deps.kv,
-            root: deps.root,
+            root,
             settings,
             qdrant,
             onProgress: makeProgress(context),
@@ -265,7 +298,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
           { mode: "build", rebuild: input.rebuild === true, skipImport: input.skipImport === true },
         )
         const summary = formatReport("build", report)
-        const warning = scopeWarning(deps.root)
+        const warning = scopeWarning(root)
         return {
           output: warning ? `${warning}\n${summary}` : summary,
           metadata: report as unknown as Record<string, unknown>,
@@ -283,7 +316,7 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         const settings = await deps.getSettings()
         assertIndexingEnabled(settings)
         const qdrant = createSettingsQdrant(settings)
-        const root = deps.root
+        const root = toolRoot(deps, context)
         const store = createOwnStore(settings, root)
         const profile = { provider: settings.provider, modelId: settings.modelId, dimension: settings.dimension }
 
@@ -304,8 +337,15 @@ export function createTools(deps: ToolDeps): ToolDefinition[] {
         }
         await store.ensure(dimension, targetProfile)
 
-        const sources = await discoverKiloSources(root, { qdrant, targetProfile })
-        if (sources.length === 0) throw new Error("No Kilo Code index found for this workspace (neither Qdrant collection nor local LanceDB)")
+        const problems: string[] = []
+        const sources = await discoverKiloSources(root, { qdrant, targetProfile, onProblem: (m) => problems.push(m) })
+        if (sources.length === 0) {
+          throw new Error(
+            problems.length > 0
+              ? `No Kilo Code index found for ${root}. ${problems.join(" · ")}`
+              : "No Kilo Code index found for this workspace (neither Qdrant collection nor local LanceDB)",
+          )
+        }
         const wanted = typeof input.source === "string" && input.source.trim() !== "" ? input.source.trim() : undefined
         const source = wanted ? sources.find((item) => item.name === wanted) : (sources.find((item) => item.compatible) ?? sources[0])
         if (!source) throw new Error(`Source not found: ${wanted}. Available: ${sources.map((s) => s.name).join(", ")}`)
@@ -362,12 +402,17 @@ function assertIndexingEnabled(settings: { enabled?: boolean }): void {
 /** Max changed files that trigger an inline refresh on search. */
 const AUTO_REFRESH_MAX_FILES = 200
 
-async function maybeAutoRefresh(deps: ToolDeps, settings: IndexingSettings, qdrant: Qdrant): Promise<void> {
+async function maybeAutoRefresh(
+  root: string,
+  deps: ToolDeps,
+  settings: IndexingSettings,
+  qdrant: Qdrant,
+): Promise<void> {
   // Cheap pre-check: diff the manifest against a bounded workspace scan.
   const { loadManifest, diffFiles } = await import("./manifest.ts")
   const { scanWorkspace } = await import("./scanner.ts")
-  const manifest = await loadManifest(deps.kv, deps.root)
-  const scan = await scanWorkspace(deps.root, {
+  const manifest = await loadManifest(deps.kv, root)
+  const scan = await scanWorkspace(root, {
     extensions: settings.fileExtensions,
     maxFileSizeBytes: settings.maxFileSizeBytes,
     maxFiles: AUTO_REFRESH_MAX_FILES + 1,
@@ -376,7 +421,7 @@ async function maybeAutoRefresh(deps: ToolDeps, settings: IndexingSettings, qdra
   const delta = diff.added.length + diff.maybeStale.length + diff.deleted.length
   if (delta === 0 || delta > AUTO_REFRESH_MAX_FILES) return
   await runIndex(
-    { kv: deps.kv, root: deps.root, settings, qdrant },
+    { kv: deps.kv, root, settings, qdrant },
     { mode: "refresh", maxFiles: AUTO_REFRESH_MAX_FILES },
   )
 }

package/tui/settings-page-data.ts

@@ -43,15 +43,23 @@ export interface StatusView {
   recommendation: string
 }
 
+/**
+ * The RPC slice this page needs.
+ *
+ * Every workspace-scoped method takes an optional `directory`. Callers normally
+ * never pass one: `bindWorkspace` injects it into the client the TUI hands this
+ * page, so the call sites below cannot forget it. The field stays on the types
+ * because the bound client is what actually sends it.
+ */
 export interface SettingsPageRpc {
   "settings.get": (input: Record<string, never>) => Promise<{ settings: SettingsView }>
   "settings.set": (input: { patch: Record<string, unknown> }) => Promise<{ settings: SettingsView }>
-  "settings.test": (input: { target: "qdrant" | "lancedb" | "provider" | "kilo" }) => Promise<{ ok: boolean; message: string }>
-  "kilo.discover": () => Promise<{ sources: KiloSourceView[] }>
-  "status.get": (input: { checkFreshness?: boolean }) => Promise<StatusView>
-  "index.build": (input: { rebuild?: boolean; skipImport?: boolean }) => Promise<{ summary: string; error?: string }>
-  "index.refresh": (input: { maxFiles?: number }) => Promise<{ summary: string; error?: string }>
-  "index.import": (input: { source?: string; rebuild?: boolean }) => Promise<{ summary: string; error?: string }>
+  "settings.test": (input: { target: "qdrant" | "lancedb" | "provider" | "kilo"; directory?: string }) => Promise<{ ok: boolean; message: string }>
+  "kilo.discover": (input?: { directory?: string }) => Promise<{ sources: KiloSourceView[]; problems?: string[] }>
+  "status.get": (input: { checkFreshness?: boolean; directory?: string }) => Promise<StatusView>
+  "index.build": (input: { rebuild?: boolean; skipImport?: boolean; directory?: string }) => Promise<{ summary: string; error?: string }>
+  "index.refresh": (input: { maxFiles?: number; directory?: string }) => Promise<{ summary: string; error?: string }>
+  "index.import": (input: { source?: string; rebuild?: boolean; directory?: string }) => Promise<{ summary: string; error?: string }>
   "workspaces.list": (input: Record<string, never>) => Promise<{ workspaces: WorkspaceRow[] }>
   "workspace.forget": (input: { store: string }) => Promise<{ ok: boolean; reason?: "refused" | "failed"; summary: string; pointsDeleted: number | null }>
 }
@@ -78,6 +86,14 @@ export interface SettingsPageProps {
 export interface SettingsPageData {
   settings: SettingsView
   sources: KiloSourceView[]
+  /**
+   * Sources that exist but could not be read.
+   *
+   * Kept apart from `sources` on purpose: an empty list with problems is a
+   * different answer from an empty list without them, and the page has to be
+   * able to tell the user which one they are looking at.
+   */
+  problems: string[]
   status: StatusView
   /** Indexed workspaces, so the page can show what exists on disk. */
   workspaces: WorkspacesView
@@ -116,7 +132,7 @@ export const UNKNOWN_SETTINGS: SettingsView = {
 export async function loadSettingsPageData(rpc: SettingsPageRpc): Promise<SettingsPageData> {
   const [settingsResponse, sourcesResponse, status, workspaces] = await Promise.all([
     rpc["settings.get"]({}).catch(() => ({ settings: UNKNOWN_SETTINGS })),
-    rpc["kilo.discover"]().catch(() => ({ sources: [] as KiloSourceView[] })),
+    rpc["kilo.discover"]({}).catch(() => ({ sources: [] as KiloSourceView[], problems: [] as string[] })),
     rpc["status.get"]({ checkFreshness: false }).catch(() => ({ summary: "(status unavailable)", recommendation: "" })),
     // loadWorkspaces already degrades to an empty view, so it cannot reject.
     loadWorkspaces(rpc),
@@ -124,6 +140,7 @@ export async function loadSettingsPageData(rpc: SettingsPageRpc): Promise<Settin
   return {
     settings: settingsResponse.settings,
     sources: sourcesResponse.sources,
+    problems: sourcesResponse.problems ?? [],
     status,
     workspaces,
   }

package/tui/settings-page.tsx

@@ -75,7 +75,13 @@ export function SettingsPage(props: SettingsPageProps): JSX.Element {
     const action = PAGE_ACTIONS.find((entry) => entry.id === id)
     if (!action) return
     if (action.kind === "source" && (data()?.sources ?? []).length === 0) {
-      props.toast("No Kilo index found for this workspace", "info")
+      // Report the reason when there is one: an index that exists but cannot be
+      // read is fixed by installing something, not by building one.
+      const problems = data()?.problems ?? []
+      props.toast(
+        problems.length > 0 ? `No importable Kilo index: ${problems.join(" · ")}` : "No Kilo index found for this workspace",
+        problems.length > 0 ? "error" : "info",
+      )
       return
     }
     // No source passed: the server picks the first compatible one. Use the

package/tui/workspace-rpc.ts

@@ -0,0 +1,98 @@
+/**
+ * Binds the caller's workspace directory to every workspace-scoped RPC.
+ *
+ * The server plugin is instantiated for the directory the service runs in, not
+ * the one the user has open, so a call that omits `directory` silently acts on
+ * the wrong workspace. Every method below takes one for that reason — and every
+ * one that takes one has to be passed it, which is a per-call-site obligation
+ * that was already forgotten once (the palette and the settings page read and
+ * wrote the service's index while the footer, using the same client, correctly
+ * reported the user's).
+ *
+ * Injecting the directory here rather than at each call site makes that class
+ * of bug impossible to reintroduce: there is one place that knows which methods
+ * are workspace-scoped, and adding a method to that list is the only edit a new
+ * workspace-scoped RPC needs.
+ */
+
+/** RPC methods that act on one workspace and therefore need a directory. */
+export const WORKSPACE_SCOPED_METHODS = [
+  "settings.test",
+  "kilo.discover",
+  "status.get",
+  "index.build",
+  "index.refresh",
+  "index.import",
+] as const
+
+/**
+ * The workspace-agnostic methods are deliberately absent: they span every
+ * workspace, so naming one would misreport what they act on. In this client
+ * that is `settings.get` and `settings.set`; the wider client adds
+ * `workspaces.list` and `workspace.forget`, which are global for the same
+ * reason.
+ */
+function isWorkspaceScoped(method: string): boolean {
+  return (WORKSPACE_SCOPED_METHODS as readonly string[]).includes(method)
+}
+
+/**
+ * Wrap `client` so the listed methods carry `directory` unless the caller set
+ * one explicitly.
+ *
+ * An explicit `directory` always wins: the footer reads reactively and a test
+ * (or a future caller) may legitimately want to ask about a different workspace
+ * than the one the user is sitting in.
+ *
+ * The real client methods take a second `options` argument (cancellation
+ * signals and headers), so the wrapper forwards everything it is given rather
+ * than modelling one signature and silently dropping the rest.
+ *
+ * Reads `Object.keys` on the client, which is what the host produces: its RPC
+ * client is built with `Object.fromEntries`, so every method is an own
+ * enumerable key. A client whose methods were reachable only through a proxy
+ * would yield an empty wrapper, and every call would fail loudly rather than
+ * quietly acting on the wrong workspace.
+ */
+export function bindWorkspace<T extends Record<string, unknown>>(client: T, workspace: () => string | undefined): T {
+  const bound: Record<string, unknown> = {}
+
+  for (const key of Object.keys(client)) {
+    const method = client[key]
+    if (typeof method !== "function" || !isWorkspaceScoped(key)) {
+      bound[key] = method
+      continue
+    }
+
+    bound[key] = (...args: unknown[]) => {
+      const input = args[0]
+      // An explicit directory wins, so it is checked before the workspace is
+      // resolved: a caller that already knows which workspace it means must not
+      // depend on the accessors answering, or on them answering at all.
+      const explicit =
+        input && typeof input === "object" && !Array.isArray(input)
+          ? (input as { directory?: unknown }).directory
+          : undefined
+      if (typeof explicit === "string" && explicit.trim() !== "") {
+        return (method as (...args: unknown[]) => unknown)(...args)
+      }
+
+      const directory = workspace()
+      if (typeof directory !== "string" || directory.trim() === "") {
+        // No workspace to name: the server falls back to its own directory,
+        // which is the only thing it can do.
+        return (method as (...args: unknown[]) => unknown)(...args)
+      }
+
+      return (method as (...args: unknown[]) => unknown)(
+        {
+          ...(input && typeof input === "object" && !Array.isArray(input) ? input : {}),
+          directory,
+        },
+        ...args.slice(1),
+      )
+    }
+  }
+
+  return bound as T
+}

package/tui.ts

@@ -24,6 +24,7 @@ import type { ThemeLike } from "./tui/page-style.ts"
 import { PAGE_ACTIONS, PAGE_ROWS, type SettingsPageRpc } from "./tui/settings-page-data.ts"
 import { footerAction, footerState, type IndexingState } from "./tui/footer.ts"
 import { activeWorkspace, type WorkspaceSources } from "./tui/footer.ts"
+import { bindWorkspace } from "./tui/workspace-rpc.ts"
 import { describeRow, forgetWorkspaceFlow, type WorkspacesRpc } from "./tui/workspaces.ts"
 import { pagePalette } from "./tui/page-style.ts"
 import type { FooterHandle, FooterState } from "./tui/footer-view.tsx"
@@ -48,8 +49,15 @@ const CUSTOM_MODEL = "\u0000custom-model"
 type RpcClient = {
   "settings.get": (input: Record<string, never>) => Promise<{ settings: SettingsView }>
   "settings.set": (input: { patch: Record<string, unknown> }) => Promise<{ settings: SettingsView }>
-  "settings.test": (input: { target: "qdrant" | "lancedb" | "provider" | "kilo" }) => Promise<{ ok: boolean; message: string }>
-  "kilo.discover": () => Promise<{ sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }> }>
+  "settings.test": (input: {
+    target: "qdrant" | "lancedb" | "provider" | "kilo"
+    directory?: string
+  }) => Promise<{ ok: boolean; message: string }>
+  "kilo.discover": (input?: { directory?: string }) => Promise<{
+    sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }>
+    /** Sources that exist but could not be read. */
+    problems?: string[]
+  }>
   "status.get": (input: { checkFreshness?: boolean; directory?: string }) => Promise<{ summary: string; recommendation: string; ownKind: string; ownStore: string; ownPoints?: number | null; ownComplete?: boolean | null; kiloCollection?: string | null; directory?: string; ownStoreReachable?: boolean }>
   "index.build": (input: { rebuild?: boolean; skipImport?: boolean; directory?: string }) => Promise<{ summary: string; error?: string }>
   "index.refresh": (input: { maxFiles?: number; directory?: string }) => Promise<{ summary: string; error?: string }>
@@ -77,10 +85,46 @@ interface SettingsView {
 const plugin = {
   id: ID,
   async setup(context: Plugin.Context): Promise<void> {
+    /**
+     * The workspace the caller is working in.
+     *
+     * The server plugin serves its own instance directory, so every RPC that
+     * reads or writes an index must be told which workspace it is about. Without
+     * this the footer would report — and the palette command would index — the
+     * service's directory instead of the user's: the ACTIVE tab is what follows
+     * the user, and the instance directory is the fallback for a host with tabs
+     * switched off.
+     *
+     * Every accessor is optional: a host may expose neither `ui.tabs` nor
+     * `data.session`, and resolving the workspace must degrade rather than
+     * throw. Read from a reactive context (the footer slot render) the lookups
+     * re-run when the host's tab or session state changes.
+     *
+     * Declared before `rpc` because `rpc` binds the directory into every
+     * workspace-scoped call: a call made before this binding exists would be
+     * answered against the service's own directory.
+     */
+    const workspaceSources: WorkspaceSources = {
+      tabsEnabled: () => context.ui.tabs?.enabled?.() === true,
+      tabs: () => context.ui.tabs?.list?.() ?? [],
+      sessions: () => context.data?.session?.list?.() ?? [],
+      instanceDirectory: () => context.location?.directory,
+    }
+
+    const workspace = (): string | undefined => activeWorkspace(workspaceSources)
+
     // Resolve the RPC subclient lazily: the TUI may start before the server
     // plugin is ready, and calls are retried on first use.
+    //
+    // Every call goes through `bindWorkspace`, so a workspace-scoped method
+    // always names the caller's directory. Passing it per call site is what
+    // failed before: the footer did it and the palette did not, and the palette
+    // silently read and wrote the service's index instead of the user's.
     const rpc = (): RpcClient =>
-      (context.client as unknown as { rpc: (def: unknown, options?: unknown) => RpcClient }).rpc(IndexingRpc)
+      bindWorkspace(
+        (context.client as unknown as { rpc: (def: unknown, options?: unknown) => RpcClient }).rpc(IndexingRpc),
+        workspace,
+      )
 
     const toast = (message: string, variant: "success" | "error" | "info" = "info"): void => {
       context.ui.toast.show({ title: "Indexing", message, variant, duration: 5000 })
@@ -446,14 +490,24 @@ const plugin = {
 
     async function kiloMenu(): Promise<void> {
       let sources: Array<{ kind: string; name: string; pointsCount: number | null; compatible: boolean; profile: string | null }> = []
+      let problems: string[] = []
       try {
-        sources = (await rpc()["kilo.discover"]()).sources
+        const found = await rpc()["kilo.discover"]({})
+        sources = found.sources
+        problems = found.problems ?? []
       } catch (error) {
         fail(error)
         return
       }
       if (sources.length === 0) {
-        toast("No Kilo index found for this workspace", "info")
+        // "Found but unreadable" and "never indexed" look identical from here,
+        // and only one of them is fixed by indexing. Say which one it is.
+        toast(
+          problems.length > 0
+            ? `No importable Kilo index: ${problems.join(" · ")}`
+            : "No Kilo index found for this workspace",
+          problems.length > 0 ? "error" : "info",
+        )
         return
       }
       const choice = await context.ui.dialog.select({
@@ -502,7 +556,7 @@ const plugin = {
       toast("Running…", "info")
       try {
         if (action === "refresh") {
-          reportRun(await rpc()["index.refresh"]({ directory: workspace() }))
+          reportRun(await rpc()["index.refresh"]({}))
         } else if (action === "build") {
           reportRun(await rpc()["index.build"]({}))
         } else if (action === "build-scratch") {
@@ -582,30 +636,6 @@ const plugin = {
       return route?.type === "plugin" && route.name === SETTINGS_PAGE_NAME
     }
 
-    /**
-     * The workspace the caller is working in.
-     *
-     * The server plugin serves its own instance directory, so every RPC that
-     * reads or writes an index must be told which workspace it is about. Without
-     * this the footer would report — and the palette command would index — the
-     * service's directory instead of the user's: the ACTIVE tab is what follows
-     * the user, and the instance directory is the fallback for a host with tabs
-     * switched off.
-     *
-     * Every accessor is optional: a host may expose neither `ui.tabs` nor
-     * `data.session`, and resolving the workspace must degrade rather than
-     * throw. Read from a reactive context (the footer slot render) the lookups
-     * re-run when the host's tab or session state changes.
-     */
-    const workspaceSources: WorkspaceSources = {
-      tabsEnabled: () => context.ui.tabs?.enabled?.() === true,
-      tabs: () => context.ui.tabs?.list?.() ?? [],
-      sessions: () => context.data?.session?.list?.() ?? [],
-      instanceDirectory: () => context.location?.directory,
-    }
-
-    const workspace = (): string | undefined => activeWorkspace(workspaceSources)
-
     /** Opens the dialog editor, holding the page keys off for its duration. */
     async function openEditor(): Promise<void> {
       dialogOpen = true
@@ -820,8 +850,8 @@ const plugin = {
         toast("Indexing started…", "info")
         const summary =
           from.state === "stale"
-            ? await rpc()["index.refresh"]({ directory: workspace() })
-            : await rpc()["index.build"]({ skipImport: false, directory: workspace() })
+            ? await rpc()["index.refresh"]({})
+            : await rpc()["index.build"]({ skipImport: false })
         // A failed run comes back as data, not as a rejection: the reason is far
         // more useful than "something went wrong", and it is already readable.
         reportRun(summary)