fixes

Author: MelbourneDeveloper

coverage-thresholds.json

@@ -1,8 +1,8 @@
 {
   "_agent_pmo": "f481f8d",
   "_doc": "Single source of truth for code coverage thresholds. See REPO-STANDARDS-SPEC [COVERAGE-THRESHOLDS-JSON]. Enforced by tools/check-coverage.mjs via `make test`. Ratchet UP only. Extended format (per-metric) overrides the spec's single default_threshold to enforce both line AND branch coverage per [COVERAGE-THRESHOLDS] (VS Code extension: 80% line / 70% branch — measured values here are well above).",
-  "lines": 91.19,
-  "functions": 93.08,
-  "branches": 86.76,
-  "statements": 91.19
+  "lines": 91.29,
+  "functions": 93.16,
+  "branches": 86.59,
+  "statements": 91.29
 }

src/db/lifecycle.ts

@@ -1,6 +1,6 @@
 /**
  * SPEC: database-schema, DB-LOCK-RECOVERY
- * Singleton lifecycle management for the database.
+ * Lifecycle management for the database. State lives in appState.
  */
 
 import * as fs from "fs";
@@ -11,23 +11,22 @@ import { openDatabase, initSchema, closeDatabase } from "./db";
 import type { Result } from "../models/Result";
 import { ok, err } from "../models/Result";
 import { isLockError, removeLockFiles as removeLockFilesPure } from "./lockArtifacts";
+import { appState } from "../state";
 
 const COMMANDTREE_DIR = ".commandtree";
 const DB_FILENAME = "commandtree.sqlite3";
 const LOCK_RETRY_INTERVAL_MS = 1000;
 const LOCK_RETRY_MAX_MS = 10000;
 
-let dbHandle: DbHandle | null = null;
-
 /**
  * SPEC: DB-LOCK-RECOVERY
- * Initialises the SQLite database singleton.
+ * Initialises the SQLite database.
  * If the database is locked, retries for 10 seconds then
  * forcefully removes lock/journal files and retries.
  */
 export async function initDb(workspaceRoot: string): Promise<Result<DbHandle, string>> {
-  if (dbHandle !== null && fs.existsSync(dbHandle.path)) {
-    return ok(dbHandle);
+  if (appState.dbHandle !== null && fs.existsSync(appState.dbHandle.path)) {
+    return ok(appState.dbHandle);
   }
   resetStaleHandle();
 
@@ -60,8 +59,8 @@ export async function initDb(workspaceRoot: string): Promise<Result<DbHandle, st
  * Returns error if the database has not been initialised.
  */
 export function getDb(): Result<DbHandle, string> {
-  if (dbHandle !== null && fs.existsSync(dbHandle.path)) {
-    return ok(dbHandle);
+  if (appState.dbHandle !== null && fs.existsSync(appState.dbHandle.path)) {
+    return ok(appState.dbHandle);
   }
   resetStaleHandle();
   return err("Database not initialised. Call initDb first.");
@@ -80,18 +79,18 @@ export function getDbOrThrow(): DbHandle {
 }
 
 function resetStaleHandle(): void {
-  if (dbHandle !== null) {
-    closeDatabase(dbHandle);
-    dbHandle = null;
+  if (appState.dbHandle !== null) {
+    closeDatabase(appState.dbHandle);
+    appState.dbHandle = null;
   }
 }
 
 /**
  * Disposes the database connection.
  */
 export function disposeDb(): void {
-  const currentDb = dbHandle;
-  dbHandle = null;
+  const currentDb = appState.dbHandle;
+  appState.dbHandle = null;
   if (currentDb !== null) {
     closeDatabase(currentDb);
   }
@@ -110,7 +109,7 @@ function tryOpenAndInit(dbPath: string): Result<DbHandle, string> {
     const msg = e instanceof Error ? e.message : String(e);
     return err(msg);
   }
-  dbHandle = openResult.value;
+  appState.dbHandle = openResult.value;
   logger.info("SQLite database initialised", { path: dbPath });
   return ok(openResult.value);
 }
@@ -154,5 +153,5 @@ async function sleep(ms: number): Promise<void> {
 
 // Test-only: reset internal state
 export function resetForTesting(): void {
-  dbHandle = null;
+  appState.dbHandle = null;
 }

src/extension.ts

@@ -16,37 +16,60 @@ import { forceSelectModel } from "./semantic/summariser";
 import { syncTagsFromConfig } from "./tags/tagSync";
 import { setupFileWatchers } from "./watchers";
 import { PrivateTaskDecorationProvider } from "./tree/PrivateTaskDecorationProvider";
+import { appState } from "./state";
 
 const MAKE_EXECUTABLE_COMMAND = "commandtree.makeExecutable";
 const EXECUTE_PERMISSION_BITS = 0o111;
 const WINDOWS_PLATFORM = "win32";
 
-let treeProvider: CommandTreeProvider;
-let quickTasksProvider: QuickTasksProvider;
-let taskRunner: TaskRunner;
-
 export interface ExtensionExports {
   commandTreeProvider: CommandTreeProvider;
   quickTasksProvider: QuickTasksProvider;
 }
 
+function getTreeProvider(): CommandTreeProvider {
+  if (appState.treeProvider === undefined) {
+    throw new Error("CommandTree extension not activated");
+  }
+  return appState.treeProvider;
+}
+
+function getQuickTasksProvider(): QuickTasksProvider {
+  if (appState.quickTasksProvider === undefined) {
+    throw new Error("CommandTree extension not activated");
+  }
+  return appState.quickTasksProvider;
+}
+
+function getTaskRunner(): TaskRunner {
+  if (appState.taskRunner === undefined) {
+    throw new Error("CommandTree extension not activated");
+  }
+  return appState.taskRunner;
+}
+
 export async function activate(context: vscode.ExtensionContext): Promise<ExtensionExports | undefined> {
   const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
   logger.info("Extension activating", { workspaceRoot });
   if (workspaceRoot === undefined) {
     logger.warn("No workspace root found, extension not activating");
     return undefined;
   }
-  await initDatabaseSafe(workspaceRoot);
-  treeProvider = new CommandTreeProvider(workspaceRoot);
-  quickTasksProvider = new QuickTasksProvider();
-  taskRunner = new TaskRunner();
+  if (appState.activated && appState.treeProvider !== undefined && appState.quickTasksProvider !== undefined) {
+    logger.info("Extension already activated; reusing existing state");
+    return { commandTreeProvider: appState.treeProvider, quickTasksProvider: appState.quickTasksProvider };
+  }
+  appState.treeProvider = new CommandTreeProvider(workspaceRoot);
+  appState.quickTasksProvider = new QuickTasksProvider();
+  appState.taskRunner = new TaskRunner();
+  appState.activated = true;
   registerTreeViews(context);
   registerCommands(context);
   setupWatchers(context, workspaceRoot);
+  await initDatabaseSafe(workspaceRoot);
   runBackgroundStartup(workspaceRoot);
   logger.info("Extension activation complete");
-  return { commandTreeProvider: treeProvider, quickTasksProvider };
+  return { commandTreeProvider: appState.treeProvider, quickTasksProvider: appState.quickTasksProvider };
 }
 
 function runBackgroundStartup(workspaceRoot: string): void {
@@ -90,22 +113,24 @@ function setupWatchers(context: vscode.ExtensionContext, workspaceRoot: string):
 
 async function initialDiscovery(workspaceRoot: string): Promise<void> {
   await syncQuickTasks();
-  logger.info("syncQuickTasks complete", { taskCount: treeProvider.getAllTasks().length });
+  logger.info("syncQuickTasks complete", { taskCount: getTreeProvider().getAllTasks().length });
   await registerDiscoveredCommands(workspaceRoot);
   await syncTagsFromJson(workspaceRoot);
 }
 
 function registerTreeViews(context: vscode.ExtensionContext): void {
+  const tp = getTreeProvider();
+  const qp = getQuickTasksProvider();
   context.subscriptions.push(
     vscode.window.createTreeView("commandtree", {
-      treeDataProvider: treeProvider,
+      treeDataProvider: tp,
       showCollapseAll: true,
-      dragAndDropController: treeProvider,
+      dragAndDropController: tp,
     }),
     vscode.window.createTreeView("commandtree-quick", {
-      treeDataProvider: quickTasksProvider,
+      treeDataProvider: qp,
       showCollapseAll: true,
-      dragAndDropController: quickTasksProvider,
+      dragAndDropController: qp,
     }),
     vscode.window.registerFileDecorationProvider(new PrivateTaskDecorationProvider())
   );
@@ -123,18 +148,18 @@ function registerCommands(context: vscode.ExtensionContext): void {
 function registerCoreCommands(context: vscode.ExtensionContext): void {
   context.subscriptions.push(
     vscode.commands.registerCommand("commandtree.refresh", async () => {
-      await treeProvider.refresh();
-      quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+      await getTreeProvider().refresh();
+      getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
       vscode.window.showInformationMessage("CommandTree refreshed");
     }),
     vscode.commands.registerCommand("commandtree.run", async (item: CommandTreeItem | undefined) => {
       if (item !== undefined && isCommandItem(item.data)) {
-        await taskRunner.run(item.data, "newTerminal");
+        await getTaskRunner().run(item.data, "newTerminal");
       }
     }),
     vscode.commands.registerCommand("commandtree.runInCurrentTerminal", async (item: CommandTreeItem | undefined) => {
       if (item !== undefined && isCommandItem(item.data)) {
-        await taskRunner.run(item.data, "currentTerminal");
+        await getTaskRunner().run(item.data, "currentTerminal");
       }
     }),
     vscode.commands.registerCommand("commandtree.openPreview", async (item: CommandTreeItem | undefined) => {
@@ -160,7 +185,7 @@ function registerFilterCommands(context: vscode.ExtensionContext): void {
   context.subscriptions.push(
     vscode.commands.registerCommand("commandtree.filterByTag", handleFilterByTag),
     vscode.commands.registerCommand("commandtree.clearFilter", () => {
-      treeProvider.clearFilters();
+      getTreeProvider().clearFilters();
       updateFilterContext();
     }),
     vscode.commands.registerCommand("commandtree.generateSummaries", async () => {
@@ -198,9 +223,9 @@ function registerQuickCommands(context: vscode.ExtensionContext): void {
       async (item: CommandTreeItem | CommandItem | undefined) => {
         const task = extractTask(item);
         if (task !== undefined) {
-          quickTasksProvider.addToQuick(task);
-          await treeProvider.refresh();
-          quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+          getQuickTasksProvider().addToQuick(task);
+          await getTreeProvider().refresh();
+          getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
         }
       }
     ),
@@ -209,20 +234,20 @@ function registerQuickCommands(context: vscode.ExtensionContext): void {
       async (item: CommandTreeItem | CommandItem | undefined) => {
         const task = extractTask(item);
         if (task !== undefined) {
-          quickTasksProvider.removeFromQuick(task);
-          await treeProvider.refresh();
-          quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+          getQuickTasksProvider().removeFromQuick(task);
+          await getTreeProvider().refresh();
+          getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
         }
       }
     ),
     vscode.commands.registerCommand("commandtree.refreshQuick", () => {
-      quickTasksProvider.refresh();
+      getQuickTasksProvider().refresh();
     })
   );
 }
 
 async function handleFilterByTag(): Promise<void> {
-  const tags = treeProvider.getAllTags();
+  const tags = getTreeProvider().getAllTags();
   if (tags.length === 0) {
     await vscode.window.showInformationMessage("No tags defined. Right-click commands to add tags.");
     return;
@@ -235,7 +260,7 @@ async function handleFilterByTag(): Promise<void> {
     placeHolder: "Select tag to filter by",
   });
   if (selected) {
-    treeProvider.setTagFilter(selected.tag);
+    getTreeProvider().setTagFilter(selected.tag);
     updateFilterContext();
   }
 }
@@ -296,12 +321,12 @@ async function handleAddTag(item: CommandTreeItem | CommandItem | undefined, tag
   if (task === undefined) {
     return;
   }
-  const tagName = tagNameArg ?? (await pickOrCreateTag(treeProvider.getAllTags(), task.label));
+  const tagName = tagNameArg ?? (await pickOrCreateTag(getTreeProvider().getAllTags(), task.label));
   if (tagName === undefined || tagName === "") {
     return;
   }
-  await treeProvider.addTaskToTag(task, tagName);
-  quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+  await getTreeProvider().addTaskToTag(task, tagName);
+  getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
 }
 
 async function handleRemoveTag(item: CommandTreeItem | CommandItem | undefined, tagNameArg?: string): Promise<void> {
@@ -324,22 +349,22 @@ async function handleRemoveTag(item: CommandTreeItem | CommandItem | undefined,
     }
     tagToRemove = selected.tag;
   }
-  await treeProvider.removeTaskFromTag(task, tagToRemove);
-  quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+  await getTreeProvider().removeTaskFromTag(task, tagToRemove);
+  getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
 }
 
 async function syncQuickTasks(): Promise<void> {
-  await treeProvider.refresh();
-  const allTasks = treeProvider.getAllTasks();
-  quickTasksProvider.updateTasks(allTasks);
+  await getTreeProvider().refresh();
+  const allTasks = getTreeProvider().getAllTasks();
+  getQuickTasksProvider().updateTasks(allTasks);
 }
 
 async function syncTagsFromJson(workspaceRoot: string): Promise<void> {
-  const allTasks = treeProvider.getAllTasks();
+  const allTasks = getTreeProvider().getAllTasks();
   const synced = syncTagsFromConfig({ allTasks, workspaceRoot });
   if (synced) {
-    await treeProvider.refresh();
-    quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+    await getTreeProvider().refresh();
+    getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
   }
 }
 
@@ -370,7 +395,7 @@ async function pickOrCreateTag(existingTags: string[], taskLabel: string): Promi
 }
 
 async function registerDiscoveredCommands(workspaceRoot: string): Promise<void> {
-  const tasks = treeProvider.getAllTasks();
+  const tasks = getTreeProvider().getAllTasks();
   if (tasks.length === 0) {
     return;
   }
@@ -400,7 +425,7 @@ function initAiSummaries(workspaceRoot: string): void {
 }
 
 async function runSummarisation(workspaceRoot: string): Promise<void> {
-  const tasks = treeProvider.getAllTasks();
+  const tasks = getTreeProvider().getAllTasks();
   logger.info("[SUMMARY] Starting", { taskCount: tasks.length });
   if (tasks.length === 0) {
     logger.warn("[SUMMARY] No tasks to summarise");
@@ -420,8 +445,8 @@ async function runSummarisation(workspaceRoot: string): Promise<void> {
     return;
   }
   if (summaryResult.value > 0) {
-    await treeProvider.refresh();
-    quickTasksProvider.updateTasks(treeProvider.getAllTasks());
+    await getTreeProvider().refresh();
+    getQuickTasksProvider().updateTasks(getTreeProvider().getAllTasks());
   }
   vscode.window.showInformationMessage(`CommandTree: Summarised ${summaryResult.value} commands`);
 }
@@ -436,7 +461,7 @@ async function syncAndSummarise(workspaceRoot: string): Promise<void> {
 }
 
 function updateFilterContext(): void {
-  vscode.commands.executeCommand("setContext", "commandtree.hasFilter", treeProvider.hasFilter());
+  vscode.commands.executeCommand("setContext", "commandtree.hasFilter", getTreeProvider().hasFilter());
 }
 
 export function deactivate(): void {

src/state.ts

@@ -0,0 +1,28 @@
+/**
+ * Centralized runtime state for the CommandTree extension.
+ * All mutable global state lives here — no module-level `let` anywhere else.
+ * A single `appState` instance owns the DB handle, tree providers, and runner.
+ */
+
+import type { DbHandle } from "./db/db";
+import type { CommandTreeProvider } from "./CommandTreeProvider";
+import type { QuickTasksProvider } from "./QuickTasksProvider";
+import type { TaskRunner } from "./runners/TaskRunner";
+
+class AppState {
+  public dbHandle: DbHandle | null = null;
+  public treeProvider: CommandTreeProvider | undefined = undefined;
+  public quickTasksProvider: QuickTasksProvider | undefined = undefined;
+  public taskRunner: TaskRunner | undefined = undefined;
+  public activated = false;
+
+  public reset(): void {
+    this.dbHandle = null;
+    this.treeProvider = undefined;
+    this.quickTasksProvider = undefined;
+    this.taskRunner = undefined;
+    this.activated = false;
+  }
+}
+
+export const appState = new AppState();