gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/collect-from-manifest.test.ts

@@ -91,140 +91,142 @@ async function loadGuidanceExport(): Promise<{ collectOneSecretWithGuidance: Fun
 
 // ─── collectSecretsFromManifest: categorization ───────────────────────────────
 
-test("collectSecretsFromManifest: categorizes entries — pending keys need collection, existing keys are skipped", async (t) => {
+test("collectSecretsFromManifest: categorizes entries — pending keys need collection, existing keys are skipped", async () => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-collect");
 	const savedA = process.env.EXISTING_KEY_A;
-	t.after(() => {
-		delete process.env.EXISTING_KEY_A;
-		if (savedA !== undefined) process.env.EXISTING_KEY_A = savedA;
-		rmSync(tmp, { recursive: true, force: true });
-	});
-
-	process.env.EXISTING_KEY_A = "already-set";
-
-	const manifest = makeManifest([
-		{ key: "EXISTING_KEY_A", status: "pending" },
-		{ key: "PENDING_KEY_B", status: "pending", guidance: ["Step 1: Go to dashboard", "Step 2: Click create key"] },
-		{ key: "SKIPPED_KEY_C", status: "skipped" },
-	]);
-	await writeManifestFile(tmp, manifest);
-
-	let callIndex = 0;
-	const mockCtx = {
-		cwd: tmp,
-		hasUI: true,
-		ui: {
-			custom: async (_factory: any) => {
-				callIndex++;
-				if (callIndex <= 1) return null; // summary screen dismiss
-				return "mock-secret-value"; // collect pending key
+	try {
+		process.env.EXISTING_KEY_A = "already-set";
+
+		const manifest = makeManifest([
+			{ key: "EXISTING_KEY_A", status: "pending" },
+			{ key: "PENDING_KEY_B", status: "pending", guidance: ["Step 1: Go to dashboard", "Step 2: Click create key"] },
+			{ key: "SKIPPED_KEY_C", status: "skipped" },
+		]);
+		await writeManifestFile(tmp, manifest);
+
+		let callIndex = 0;
+		const mockCtx = {
+			cwd: tmp,
+			hasUI: true,
+			ui: {
+				custom: async (_factory: any) => {
+					callIndex++;
+					if (callIndex <= 1) return null; // summary screen dismiss
+					return "mock-secret-value"; // collect pending key
+				},
 			},
-		},
-	};
+		};
 
-	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+		const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
 
-	// EXISTING_KEY_A should be in existingSkipped (it's in process.env)
-	assert.ok(result.existingSkipped?.includes("EXISTING_KEY_A"),
-		"EXISTING_KEY_A should be in existingSkipped");
+		// EXISTING_KEY_A should be in existingSkipped (it's in process.env)
+		assert.ok(result.existingSkipped?.includes("EXISTING_KEY_A"),
+			"EXISTING_KEY_A should be in existingSkipped");
 
-	// PENDING_KEY_B should have been collected (applied)
-	assert.ok(result.applied.includes("PENDING_KEY_B"),
-		"PENDING_KEY_B should be in applied");
+		// PENDING_KEY_B should have been collected (applied)
+		assert.ok(result.applied.includes("PENDING_KEY_B"),
+			"PENDING_KEY_B should be in applied");
 
-	// SKIPPED_KEY_C should remain skipped
-	assert.ok(result.skipped.includes("SKIPPED_KEY_C"),
-		"SKIPPED_KEY_C should be in skipped");
+		// SKIPPED_KEY_C should remain skipped
+		assert.ok(result.skipped.includes("SKIPPED_KEY_C"),
+			"SKIPPED_KEY_C should be in skipped");
+	} finally {
+		delete process.env.EXISTING_KEY_A;
+		if (savedA !== undefined) process.env.EXISTING_KEY_A = savedA;
+		rmSync(tmp, { recursive: true, force: true });
+	}
 });
 
-test("collectSecretsFromManifest: existing keys are excluded from the collection list — not prompted", async (t) => {
+test("collectSecretsFromManifest: existing keys are excluded from the collection list — not prompted", async () => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-collect-skip");
 	const savedA = process.env.ALREADY_SET_KEY;
-	t.after(() => {
-		delete process.env.ALREADY_SET_KEY;
-		if (savedA !== undefined) process.env.ALREADY_SET_KEY = savedA;
-		rmSync(tmp, { recursive: true, force: true });
-	});
-
-	process.env.ALREADY_SET_KEY = "present";
-
-	const manifest = makeManifest([
-		{ key: "ALREADY_SET_KEY", status: "pending" },
-		{ key: "NEEDS_COLLECTION", status: "pending" },
-	]);
-	await writeManifestFile(tmp, manifest);
-
-	const collectedKeyNames: string[] = [];
-	let summaryShown = false;
-	const mockCtx = {
-		cwd: tmp,
-		hasUI: true,
-		ui: {
-			custom: async (factory: any) => {
-				// Intercept the factory to check what key is being collected
-				if (!summaryShown) {
-					summaryShown = true;
-					return null; // dismiss summary
-				}
-				collectedKeyNames.push("prompted");
-				return "mock-value";
+	try {
+		process.env.ALREADY_SET_KEY = "present";
+
+		const manifest = makeManifest([
+			{ key: "ALREADY_SET_KEY", status: "pending" },
+			{ key: "NEEDS_COLLECTION", status: "pending" },
+		]);
+		await writeManifestFile(tmp, manifest);
+
+		const collectedKeyNames: string[] = [];
+		let summaryShown = false;
+		const mockCtx = {
+			cwd: tmp,
+			hasUI: true,
+			ui: {
+				custom: async (factory: any) => {
+					// Intercept the factory to check what key is being collected
+					if (!summaryShown) {
+						summaryShown = true;
+						return null; // dismiss summary
+					}
+					collectedKeyNames.push("prompted");
+					return "mock-value";
+				},
 			},
-		},
-	};
+		};
 
-	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+		const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
 
-	// ALREADY_SET_KEY should not have been prompted — only NEEDS_COLLECTION should
-	assert.ok(!result.applied.includes("ALREADY_SET_KEY"),
-		"ALREADY_SET_KEY should not be in applied (it was auto-skipped)");
-	assert.ok(result.existingSkipped?.includes("ALREADY_SET_KEY"),
-		"ALREADY_SET_KEY should be in existingSkipped");
+		// ALREADY_SET_KEY should not have been prompted — only NEEDS_COLLECTION should
+		assert.ok(!result.applied.includes("ALREADY_SET_KEY"),
+			"ALREADY_SET_KEY should not be in applied (it was auto-skipped)");
+		assert.ok(result.existingSkipped?.includes("ALREADY_SET_KEY"),
+			"ALREADY_SET_KEY should be in existingSkipped");
+	} finally {
+		delete process.env.ALREADY_SET_KEY;
+		if (savedA !== undefined) process.env.ALREADY_SET_KEY = savedA;
+		rmSync(tmp, { recursive: true, force: true });
+	}
 });
 
-test("collectSecretsFromManifest: manifest statuses are updated after collection", async (t) => {
+test("collectSecretsFromManifest: manifest statuses are updated after collection", async () => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-update");
-	t.after(() => rmSync(tmp, { recursive: true, force: true }));
-
-	const manifest = makeManifest([
-		{ key: "KEY_TO_COLLECT", status: "pending" },
-		{ key: "KEY_TO_SKIP", status: "pending" },
-	]);
-	const manifestPath = await writeManifestFile(tmp, manifest);
-
-	let callIndex = 0;
-	const mockCtx = {
-		cwd: tmp,
-		hasUI: true,
-		ui: {
-			custom: async (_factory: any) => {
-				callIndex++;
-				if (callIndex <= 1) return null; // summary screen dismiss
-				if (callIndex === 2) return "secret-value"; // KEY_TO_COLLECT
-				return null; // KEY_TO_SKIP — user skips
+	try {
+		const manifest = makeManifest([
+			{ key: "KEY_TO_COLLECT", status: "pending" },
+			{ key: "KEY_TO_SKIP", status: "pending" },
+		]);
+		const manifestPath = await writeManifestFile(tmp, manifest);
+
+		let callIndex = 0;
+		const mockCtx = {
+			cwd: tmp,
+			hasUI: true,
+			ui: {
+				custom: async (_factory: any) => {
+					callIndex++;
+					if (callIndex <= 1) return null; // summary screen dismiss
+					if (callIndex === 2) return "secret-value"; // KEY_TO_COLLECT
+					return null; // KEY_TO_SKIP — user skips
+				},
 			},
-		},
-	};
+		};
 
-	await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+		await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
 
-	// Read back the manifest file and verify statuses were updated
-	const { parseSecretsManifest } = await loadFilesExports();
-	const updatedContent = readFileSync(manifestPath, "utf8");
-	const updatedManifest = parseSecretsManifest(updatedContent);
+		// Read back the manifest file and verify statuses were updated
+		const { parseSecretsManifest } = await loadFilesExports();
+		const updatedContent = readFileSync(manifestPath, "utf8");
+		const updatedManifest = parseSecretsManifest(updatedContent);
 
-	const keyToCollect = updatedManifest.entries.find(e => e.key === "KEY_TO_COLLECT");
-	const keyToSkip = updatedManifest.entries.find(e => e.key === "KEY_TO_SKIP");
+		const keyToCollect = updatedManifest.entries.find(e => e.key === "KEY_TO_COLLECT");
+		const keyToSkip = updatedManifest.entries.find(e => e.key === "KEY_TO_SKIP");
 
-	assert.equal(keyToCollect?.status, "collected",
-		"KEY_TO_COLLECT should have status 'collected' after providing a value");
-	assert.equal(keyToSkip?.status, "skipped",
-		"KEY_TO_SKIP should have status 'skipped' after user skipped it");
+		assert.equal(keyToCollect?.status, "collected",
+			"KEY_TO_COLLECT should have status 'collected' after providing a value");
+		assert.equal(keyToSkip?.status, "skipped",
+			"KEY_TO_SKIP should have status 'skipped' after user skipped it");
+	} finally {
+		rmSync(tmp, { recursive: true, force: true });
+	}
 });
 
 // ─── showSecretsSummary: render output ────────────────────────────────────────
@@ -421,47 +423,47 @@ test("collectOneSecret: no guidance provided — render output has no guidance s
 
 // ─── collectSecretsFromManifest: returns structured result ────────────────────
 
-test("collectSecretsFromManifest: returns result with applied, skipped, and existingSkipped arrays", async (t) => {
+test("collectSecretsFromManifest: returns result with applied, skipped, and existingSkipped arrays", async () => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-result");
 	const savedKey = process.env.RESULT_TEST_EXISTING;
-	t.after(() => {
-		delete process.env.RESULT_TEST_EXISTING;
-		if (savedKey !== undefined) process.env.RESULT_TEST_EXISTING = savedKey;
-		rmSync(tmp, { recursive: true, force: true });
-	});
-
-	process.env.RESULT_TEST_EXISTING = "already-here";
-
-	const manifest = makeManifest([
-		{ key: "RESULT_TEST_EXISTING", status: "pending" },
-		{ key: "RESULT_TEST_NEW", status: "pending" },
-	]);
-	await writeManifestFile(tmp, manifest);
-
-	let callIndex = 0;
-	const mockCtx = {
-		cwd: tmp,
-		hasUI: true,
-		ui: {
-			custom: async (_factory: any) => {
-				callIndex++;
-				if (callIndex <= 1) return null; // summary dismiss
-				return "secret-value"; // collect the pending key
+	try {
+		process.env.RESULT_TEST_EXISTING = "already-here";
+
+		const manifest = makeManifest([
+			{ key: "RESULT_TEST_EXISTING", status: "pending" },
+			{ key: "RESULT_TEST_NEW", status: "pending" },
+		]);
+		await writeManifestFile(tmp, manifest);
+
+		let callIndex = 0;
+		const mockCtx = {
+			cwd: tmp,
+			hasUI: true,
+			ui: {
+				custom: async (_factory: any) => {
+					callIndex++;
+					if (callIndex <= 1) return null; // summary dismiss
+					return "secret-value"; // collect the pending key
+				},
 			},
-		},
-	};
+		};
 
-	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+		const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
 
-	// Verify result shape
-	assert.ok(Array.isArray(result.applied), "result should have applied array");
-	assert.ok(Array.isArray(result.skipped), "result should have skipped array");
-	assert.ok(Array.isArray(result.existingSkipped), "result should have existingSkipped array");
+		// Verify result shape
+		assert.ok(Array.isArray(result.applied), "result should have applied array");
+		assert.ok(Array.isArray(result.skipped), "result should have skipped array");
+		assert.ok(Array.isArray(result.existingSkipped), "result should have existingSkipped array");
 
-	assert.ok(result.existingSkipped.includes("RESULT_TEST_EXISTING"),
-		"existing key should be in existingSkipped");
-	assert.ok(result.applied.includes("RESULT_TEST_NEW"),
-		"collected key should be in applied");
+		assert.ok(result.existingSkipped.includes("RESULT_TEST_EXISTING"),
+			"existing key should be in existingSkipped");
+		assert.ok(result.applied.includes("RESULT_TEST_NEW"),
+			"collected key should be in applied");
+	} finally {
+		delete process.env.RESULT_TEST_EXISTING;
+		if (savedKey !== undefined) process.env.RESULT_TEST_EXISTING = savedKey;
+		rmSync(tmp, { recursive: true, force: true });
+	}
 });

package/src/resources/extensions/gsd/tests/commands-inspect-open-db.test.ts

@@ -7,40 +7,40 @@ import fs from "node:fs";
 import { handleInspect } from "../commands-inspect.ts";
 import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
-test("/gsd inspect opens existing database when it was not yet opened in session", async (t) => {
+test("/gsd inspect opens existing database when it was not yet opened in session", async () => {
   closeDatabase();
 
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-inspect-db-"));
   const prevCwd = process.cwd();
 
-  t.after(() => {
-    process.chdir(prevCwd);
-    closeDatabase();
-    fs.rmSync(tmp, { recursive: true, force: true });
-  });
+  try {
+    const gsdDir = path.join(tmp, ".gsd");
+    fs.mkdirSync(gsdDir, { recursive: true });
+    const dbPath = path.join(gsdDir, "gsd.db");
 
-  const gsdDir = path.join(tmp, ".gsd");
-  fs.mkdirSync(gsdDir, { recursive: true });
-  const dbPath = path.join(gsdDir, "gsd.db");
-
-  assert.equal(openDatabase(dbPath), true);
-  closeDatabase();
+    assert.equal(openDatabase(dbPath), true);
+    closeDatabase();
 
-  process.chdir(tmp);
+    process.chdir(tmp);
 
-  const notifications: Array<{ message: string; level: string }> = [];
-  const ctx = {
-    ui: {
-      notify(message: string, level: string) {
-        notifications.push({ message, level });
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: {
+        notify(message: string, level: string) {
+          notifications.push({ message, level });
+        },
       },
-    },
-  } as any;
+    } as any;
 
-  await handleInspect(ctx);
+    await handleInspect(ctx);
 
-  assert.equal(notifications.length, 1);
-  assert.equal(notifications[0].level, "info");
-  assert.match(notifications[0].message, /=== GSD Database Inspect ===/);
-  assert.doesNotMatch(notifications[0].message, /No GSD database available/);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0].level, "info");
+    assert.match(notifications[0].message, /=== GSD Database Inspect ===/);
+    assert.doesNotMatch(notifications[0].message, /No GSD database available/);
+  } finally {
+    process.chdir(prevCwd);
+    closeDatabase();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/commands-logs.test.ts

@@ -42,22 +42,22 @@ function writeDebugLog(dir: string, name: string, entries: Record<string, unknow
 
 // ─── Tests ──────────────────────────────────────────────────────────────────
 
-test("logs shows empty state message when no logs exist", async (t) => {
+test("logs shows empty state message when no logs exist", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
   process.chdir(dir);
-  t.after(() => {
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("No logs found"));
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  assert.ok(ctx.notifications[0].msg.includes("No logs found"));
+  }
 });
 
-test("logs lists activity logs", async (t) => {
+test("logs lists activity logs", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -71,21 +71,21 @@ test("logs lists activity logs", async (t) => {
     { role: "assistant", content: "Completing slice S01" },
   ]);
 
-  t.after(() => {
+  try {
+    await handleLogs("", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Logs"), "should show activity logs header");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("complete-slice"), "should show second log");
+    assert.ok(msg.includes("/gsd logs <#>"), "should show usage hint");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  const msg = ctx.notifications[0].msg;
-  assert.ok(msg.includes("Activity Logs"), "should show activity logs header");
-  assert.ok(msg.includes("execute-task"), "should show unit type");
-  assert.ok(msg.includes("complete-slice"), "should show second log");
-  assert.ok(msg.includes("/gsd logs <#>"), "should show usage hint");
+  }
 });
 
-test("logs <N> shows activity log details", async (t) => {
+test("logs <N> shows activity log details", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -99,40 +99,40 @@ test("logs <N> shows activity log details", async (t) => {
     { role: "assistant", content: "I ran the tests and wrote a file" },
   ]);
 
-  t.after(() => {
+  try {
+    await handleLogs("1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Activity Log #1"), "should show log number");
+    assert.ok(msg.includes("execute-task"), "should show unit type");
+    assert.ok(msg.includes("Tool calls: 2"), "should count tool calls");
+    assert.ok(msg.includes("Errors: 1"), "should count errors");
+    assert.ok(msg.includes("/tmp/test.ts"), "should show files written");
+    assert.ok(msg.includes("npm test"), "should show commands run");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("1", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  const msg = ctx.notifications[0].msg;
-  assert.ok(msg.includes("Activity Log #1"), "should show log number");
-  assert.ok(msg.includes("execute-task"), "should show unit type");
-  assert.ok(msg.includes("Tool calls: 2"), "should count tool calls");
-  assert.ok(msg.includes("Errors: 1"), "should count errors");
-  assert.ok(msg.includes("/tmp/test.ts"), "should show files written");
-  assert.ok(msg.includes("npm test"), "should show commands run");
+  }
 });
 
-test("logs <N> shows not found for invalid seq", async (t) => {
+test("logs <N> shows not found for invalid seq", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
   process.chdir(dir);
 
-  t.after(() => {
+  try {
+    await handleLogs("999", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    assert.ok(ctx.notifications[0].msg.includes("not found"));
+    assert.equal(ctx.notifications[0].level, "warning");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("999", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  assert.ok(ctx.notifications[0].msg.includes("not found"));
-  assert.equal(ctx.notifications[0].level, "warning");
+  }
 });
 
-test("logs debug lists debug logs", async (t) => {
+test("logs debug lists debug logs", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -143,19 +143,19 @@ test("logs debug lists debug logs", async (t) => {
     { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
   ]);
 
-  t.after(() => {
+  try {
+    await handleLogs("debug", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Logs"), "should show debug logs header");
+    assert.ok(msg.includes("debug-2026-03-18T10-30-00.log"), "should show filename");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("debug", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  const msg = ctx.notifications[0].msg;
-  assert.ok(msg.includes("Debug Logs"), "should show debug logs header");
-  assert.ok(msg.includes("debug-2026-03-18T10-30-00.log"), "should show filename");
+  }
 });
 
-test("logs debug <N> shows debug log summary", async (t) => {
+test("logs debug <N> shows debug log summary", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -167,21 +167,21 @@ test("logs debug <N> shows debug log summary", async (t) => {
     { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
   ]);
 
-  t.after(() => {
+  try {
+    await handleLogs("debug 1", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Debug Log:"), "should show debug log header");
+    assert.ok(msg.includes("Events: 3"), "should count events");
+    assert.ok(msg.includes("Dispatches: 5"), "should show dispatch count");
+    assert.ok(msg.includes("dispatch-error"), "should show errors");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("debug 1", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  const msg = ctx.notifications[0].msg;
-  assert.ok(msg.includes("Debug Log:"), "should show debug log header");
-  assert.ok(msg.includes("Events: 3"), "should count events");
-  assert.ok(msg.includes("Dispatches: 5"), "should show dispatch count");
-  assert.ok(msg.includes("dispatch-error"), "should show errors");
+  }
 });
 
-test("logs tail shows recent activity summaries", async (t) => {
+test("logs tail shows recent activity summaries", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -195,20 +195,20 @@ test("logs tail shows recent activity summaries", async (t) => {
     { role: "toolResult", toolCallId: "1", toolName: "bash", isError: true },
   ]);
 
-  t.after(() => {
+  try {
+    await handleLogs("tail 2", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    const msg = ctx.notifications[0].msg;
+    assert.ok(msg.includes("Last 2 activity log(s)"), "should show count");
+    assert.ok(msg.includes("#1"), "should show first log");
+    assert.ok(msg.includes("#2"), "should show second log");
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("tail 2", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  const msg = ctx.notifications[0].msg;
-  assert.ok(msg.includes("Last 2 activity log(s)"), "should show count");
-  assert.ok(msg.includes("#1"), "should show first log");
-  assert.ok(msg.includes("#2"), "should show second log");
+  }
 });
 
-test("logs clear removes old logs", async (t) => {
+test("logs clear removes old logs", async () => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -225,17 +225,17 @@ test("logs clear removes old logs", async (t) => {
     writeActivityLog(dir, i, "execute-task", `M001/S01/T0${i}`, [{ type: "toolCall" }]);
   }
 
-  t.after(() => {
+  try {
+    await handleLogs("clear", ctx as any);
+    assert.equal(ctx.notifications.length, 1);
+    // Old log should be removed, recent ones kept
+    assert.ok(!existsSync(oldFile), "old log should be removed");
+    assert.ok(
+      existsSync(join(dir, ".gsd", "activity", "007-execute-task-M001-S01-T07.jsonl")),
+      "most recent log should be kept",
+    );
+  } finally {
     process.chdir(origCwd);
     rmSync(dir, { recursive: true, force: true });
-  });
-
-  await handleLogs("clear", ctx as any);
-  assert.equal(ctx.notifications.length, 1);
-  // Old log should be removed, recent ones kept
-  assert.ok(!existsSync(oldFile), "old log should be removed");
-  assert.ok(
-    existsSync(join(dir, ".gsd", "activity", "007-execute-task-M001-S01-T07.jsonl")),
-    "most recent log should be kept",
-  );
+  }
 });