fix(vscode-extension): rebuild the log channel after disposal

Log caches its output channel for the life of the process, and
activate registered that channel as a subscription. Disposing the
subscriptions closed it while the cached reference stayed, so every
later write threw 'Channel has been closed' — including the first line
of a second activate.

Activate now registers a disposable that drops the cache instead, so
the next caller builds a fresh channel.

Reverting this makes the new test fail with that exact error, plus
cascades into 19 other failures, which is what surfaced it while
covering the entry point.

Signed-off-by: Stephen Whitlock <s.whitlock@live.com>

Author: jshwi

plugin/vscode/CHANGELOG.md

@@ -10,6 +10,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Added
 - Drop stale results when a file changes outside the editor
 
+### Fixed
+- Rebuild the log channel after disposal, so logging survives a second
+  activation instead of failing with 'Channel has been closed'
+
 [1.0.1](https://github.com/jshwi/docsig/releases/tag/vscode-extension-v1.0.1) - 2026-07-10
 ------------------------------------------------------------------------
 ### Fixed

plugin/vscode/src/main/extension.ts

@@ -87,7 +87,9 @@ export function activate(context: vscode.ExtensionContext): void {
   const watcher = vscode.workspace.createFileSystemWatcher("**/*.py");
 
   context.subscriptions.push(
-    Log.outputChannel(),
+    // not the channel itself: Log caches it, so disposing it directly
+    // would leave the cached reference pointing at a closed channel
+    { dispose: () => Log.disposeChannel() },
     collection,
     service,
     vscode.workspace.onDidOpenTextDocument((document) =>

plugin/vscode/src/main/messages/Log.ts

@@ -13,6 +13,19 @@ export function outputChannel(): vscode.OutputChannel {
   return channel;
 }
 
+/**
+ * Close the shared channel so the next caller gets a fresh one.
+ *
+ * The channel is cached for the life of the process, so disposing it
+ * without dropping the reference leaves every later write throwing
+ * "Channel has been closed". Activate registers this rather than the
+ * channel itself, which is what makes a second activate work.
+ */
+export function disposeChannel(): void {
+  channel?.dispose();
+  channel = undefined;
+}
+
 function emit(message: string): void {
   const line = `${PREFIX} ${message}`;
   outputChannel().appendLine(line);

plugin/vscode/src/test/Extension.test.ts

@@ -63,13 +63,11 @@ function configurationEvent(
   };
 }
 
-function disposeAllButChannel(context: vscode.ExtensionContext): void {
-  const channel = Log.outputChannel();
-  context.subscriptions
-    .filter((subscription) => subscription !== channel)
-    .forEach((subscription) => {
-      subscription.dispose();
-    });
+function disposeAll(context: vscode.ExtensionContext): void {
+  context.subscriptions.forEach((subscription) => {
+    subscription.dispose();
+  });
+  context.subscriptions.length = 0;
 }
 
 suite("extension", () => {
@@ -174,9 +172,7 @@ suite("extension", () => {
     try {
       assert.ok(context.subscriptions.length > 0);
     } finally {
-      // the output channel is cached by Log for the life of the
-      // process, so disposing it here closes it for every later test
-      disposeAllButChannel(context);
+      disposeAll(context);
     }
   });
 
@@ -192,9 +188,27 @@ suite("extension", () => {
     try {
       assert.ok(context.subscriptions.length > 0);
     } finally {
-      // the output channel is cached by Log for the life of the
-      // process, so disposing it here closes it for every later test
-      disposeAllButChannel(context);
+      disposeAll(context);
+    }
+  });
+
+  test("activate runs a second time after a full dispose", () => {
+    const context = mockExtensionContext("/tmp/docsig-ext", "/tmp/docsig-st");
+    sinon.stub(vscode.window, "visibleTextEditors").value([]);
+
+    activate(context);
+    disposeAll(context);
+
+    // the channel registered above is Log's cached one; if disposing it
+    // did not drop the cache, this second run would throw "Channel has
+    // been closed" from the first line of activate
+    activate(context);
+
+    try {
+      Log.debug("still writable");
+      assert.ok(context.subscriptions.length > 0);
+    } finally {
+      disposeAll(context);
     }
   });
 

plugin/vscode/src/test/messages/Log.test.ts

@@ -0,0 +1,29 @@
+import * as assert from "node:assert/strict";
+import { disposeChannel, outputChannel } from "../../main/messages/Log";
+
+suite("Log", () => {
+  test("outputChannel returns the same channel while cached", () => {
+    assert.equal(outputChannel(), outputChannel());
+  });
+
+  test("disposeChannel drops the cache so the next call rebuilds", () => {
+    const first = outputChannel();
+
+    disposeChannel();
+
+    const second = outputChannel();
+
+    assert.notEqual(first, second);
+
+    // the replacement is usable; the old one is closed for good
+    second.appendLine("after dispose");
+  });
+
+  test("disposeChannel is safe with nothing cached", () => {
+    disposeChannel();
+
+    assert.doesNotThrow(() => {
+      disposeChannel();
+    });
+  });
+});