gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -91,142 +91,140 @@ async function loadGuidanceExport(): Promise<{ collectOneSecretWithGuidance: Fun
 
 // ─── collectSecretsFromManifest: categorization ───────────────────────────────
 
-test("collectSecretsFromManifest: categorizes entries — pending keys need collection, existing keys are skipped", async () => {
+test("collectSecretsFromManifest: categorizes entries — pending keys need collection, existing keys are skipped", async (t) => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-collect");
 	const savedA = process.env.EXISTING_KEY_A;
-	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
-				},
+	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
 			},
-		};
+		},
+	};
 
-		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");
-	} finally {
-		delete process.env.EXISTING_KEY_A;
-		if (savedA !== undefined) process.env.EXISTING_KEY_A = savedA;
-		rmSync(tmp, { recursive: true, force: true });
-	}
+	// SKIPPED_KEY_C should remain skipped
+	assert.ok(result.skipped.includes("SKIPPED_KEY_C"),
+		"SKIPPED_KEY_C should be in skipped");
 });
 
-test("collectSecretsFromManifest: existing keys are excluded from the collection list — not prompted", async () => {
+test("collectSecretsFromManifest: existing keys are excluded from the collection list — not prompted", async (t) => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-collect-skip");
 	const savedA = process.env.ALREADY_SET_KEY;
-	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);
-
-		// 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 {
+	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";
+			},
+		},
+	};
+
+	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");
 });
 
-test("collectSecretsFromManifest: manifest statuses are updated after collection", async () => {
+test("collectSecretsFromManifest: manifest statuses are updated after collection", async (t) => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-update");
-	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
-				},
+	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
 			},
-		};
+		},
+	};
 
-		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");
-	} finally {
-		rmSync(tmp, { recursive: true, force: true });
-	}
+	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");
 });
 
 // ─── showSecretsSummary: render output ────────────────────────────────────────
@@ -423,47 +421,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 () => {
+test("collectSecretsFromManifest: returns result with applied, skipped, and existingSkipped arrays", async (t) => {
 	const { collectSecretsFromManifest } = await loadOrchestrator();
 
 	const tmp = makeTempDir("manifest-result");
 	const savedKey = process.env.RESULT_TEST_EXISTING;
-	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
-				},
+	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
 			},
-		};
+		},
+	};
 
-		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");
-	} finally {
-		delete process.env.RESULT_TEST_EXISTING;
-		if (savedKey !== undefined) process.env.RESULT_TEST_EXISTING = savedKey;
-		rmSync(tmp, { recursive: true, force: true });
-	}
+	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");
 });

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 () => {
+test("/gsd inspect opens existing database when it was not yet opened in session", async (t) => {
   closeDatabase();
 
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-inspect-db-"));
   const prevCwd = process.cwd();
 
-  try {
-    const gsdDir = path.join(tmp, ".gsd");
-    fs.mkdirSync(gsdDir, { recursive: true });
-    const dbPath = path.join(gsdDir, "gsd.db");
-
-    assert.equal(openDatabase(dbPath), true);
+  t.after(() => {
+    process.chdir(prevCwd);
     closeDatabase();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
 
-    process.chdir(tmp);
+  const gsdDir = path.join(tmp, ".gsd");
+  fs.mkdirSync(gsdDir, { recursive: true });
+  const dbPath = path.join(gsdDir, "gsd.db");
+
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
 
-    const notifications: Array<{ message: string; level: string }> = [];
-    const ctx = {
-      ui: {
-        notify(message: string, level: string) {
-          notifications.push({ message, level });
-        },
+  process.chdir(tmp);
+
+  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/);
-  } finally {
-    process.chdir(prevCwd);
-    closeDatabase();
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
+  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/);
 });

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 () => {
+test("logs shows empty state message when no logs exist", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
   process.chdir(dir);
-  try {
-    await handleLogs("", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    assert.ok(ctx.notifications[0].msg.includes("No logs found"));
-  } finally {
+  t.after(() => {
     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 () => {
+test("logs lists activity logs", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -71,21 +71,21 @@ test("logs lists activity logs", async () => {
     { role: "assistant", content: "Completing slice S01" },
   ]);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs <N> shows activity log details", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -99,40 +99,40 @@ test("logs <N> shows activity log details", async () => {
     { role: "assistant", content: "I ran the tests and wrote a file" },
   ]);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs <N> shows not found for invalid seq", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
   process.chdir(dir);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs debug lists debug logs", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -143,19 +143,19 @@ test("logs debug lists debug logs", async () => {
     { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
   ]);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs debug <N> shows debug log summary", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -167,21 +167,21 @@ test("logs debug <N> shows debug log summary", async () => {
     { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
   ]);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs tail shows recent activity summaries", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -195,20 +195,20 @@ test("logs tail shows recent activity summaries", async () => {
     { role: "toolResult", toolCallId: "1", toolName: "bash", isError: true },
   ]);
 
-  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 {
+  t.after(() => {
     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 () => {
+test("logs clear removes old logs", async (t) => {
   const dir = createTestDir();
   const ctx = createMockCtx();
   const origCwd = process.cwd();
@@ -225,17 +225,17 @@ test("logs clear removes old logs", async () => {
     writeActivityLog(dir, i, "execute-task", `M001/S01/T0${i}`, [{ type: "toolCall" }]);
   }
 
-  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 {
+  t.after(() => {
     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",
+  );
 });