gsd-pi 2.81.0 → 2.82.0-dev.2841a1e44

package/src/resources/extensions/gsd/tests/worktree-telemetry.test.ts

@@ -89,14 +89,59 @@ test("emitAutoExit records reason and unmerged-work signal", () => {
       reason: "pause",
       milestoneId: "M003",
       milestoneMerged: false,
+      isolationMode: "worktree",
+      worktreeActive: true,
     });
     const entries = queryJournal(base, { eventType: "auto-exit" });
     assert.equal(entries.length, 1);
     assert.equal(entries[0].data?.reason, "pause");
     assert.equal(entries[0].data?.milestoneMerged, false);
+    assert.equal(entries[0].data?.isolationMode, "worktree");
+    assert.equal(entries[0].data?.worktreeActive, true);
   } finally { cleanup(base); }
 });
 
+test("summarizeWorktreeTelemetry only counts unmerged exits from active worktrees", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  emitAutoExit(base, {
+    reason: "pause",
+    milestoneId: "M003",
+    milestoneMerged: false,
+    isolationMode: "none",
+    worktreeActive: false,
+  });
+  emitAutoExit(base, {
+    reason: "stop",
+    milestoneId: "M004",
+    milestoneMerged: false,
+    isolationMode: "branch",
+    worktreeActive: false,
+  });
+  emitAutoExit(base, {
+    reason: "other",
+    milestoneId: "M005",
+    milestoneMerged: false,
+    isolationMode: "worktree",
+    worktreeActive: false,
+  });
+  emitAutoExit(base, {
+    reason: "blocked",
+    milestoneId: "M006",
+    milestoneMerged: false,
+  });
+
+  const summary = summarizeWorktreeTelemetry(base);
+  assert.equal(summary.exitsWithUnmergedWork, 0);
+  assert.deepStrictEqual(summary.exitsByReason, {
+    "pause": 1,
+    "stop": 1,
+    "other": 1,
+    "blocked": 1,
+  });
+});
+
 test("summarizeWorktreeTelemetry aggregates events correctly", () => {
   const base = makeTmpBase();
   try {
@@ -110,8 +155,20 @@ test("summarizeWorktreeTelemetry aggregates events correctly", () => {
     emitWorktreeOrphaned(base, "M002", { reason: "in-progress-unmerged", commitsAhead: 2 });
     emitWorktreeOrphaned(base, "M003", { reason: "complete-unmerged" });
 
-    emitAutoExit(base, { reason: "pause", milestoneId: "M002", milestoneMerged: false });
-    emitAutoExit(base, { reason: "stop", milestoneId: "M002", milestoneMerged: false });
+    emitAutoExit(base, {
+      reason: "pause",
+      milestoneId: "M002",
+      milestoneMerged: false,
+      isolationMode: "worktree",
+      worktreeActive: true,
+    });
+    emitAutoExit(base, {
+      reason: "stop",
+      milestoneId: "M002",
+      milestoneMerged: false,
+      isolationMode: "worktree",
+      worktreeActive: true,
+    });
     emitAutoExit(base, { reason: "all-complete", milestoneId: "M001", milestoneMerged: true });
 
     const summary = summarizeWorktreeTelemetry(base);

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -172,6 +172,22 @@ test('planning-dispatch: extracts subagent classes from single, parallel, and ch
     extractSubagentAgentClasses({ chain: [{ agent: 'reviewer' }, { agent: 'security' }] }),
     ['reviewer', 'security'],
   );
+  assert.deepEqual(
+    extractSubagentAgentClasses({
+      chain: [
+        { agent: 'scout' },
+        { parallel: [{ agent: 'reviewer' }, { agent: ' security ' }] },
+      ],
+    }),
+    ['scout', 'reviewer', 'security'],
+  );
+});
+
+test('planning-dispatch: extracts subagent classes without recursing through cycles', () => {
+  const input: { agent: string; parallel?: unknown[] } = { agent: 'scout' };
+  input.parallel = [input, { agent: 'reviewer' }];
+
+  assert.deepEqual(extractSubagentAgentClasses(input), ['scout', 'reviewer']);
 });
 
 test('planning-dispatch: blocks subagent dispatch when agentClasses is undefined (stale caller shim)', () => {
@@ -242,6 +258,24 @@ test('planning-dispatch: blocks recon agent under closeout policy', () => {
   assert.doesNotMatch(r.reason!, /read-only specialists/);
 });
 
+test('complete-slice closeout policy blocks edits to user source', () => {
+  const r = shouldBlockPlanningUnit('edit', join(BASE, 'src', 'main.ts'), BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /complete-slice/);
+  assert.match(r.reason!, /writes are restricted to \.gsd/);
+});
+
+test('complete-slice closeout policy blocks non-allowlisted verification bash', () => {
+  const r = shouldBlockPlanningUnit('bash', 'go test ./...', BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW);
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /bash is restricted/);
+});
+
+test('complete-slice closeout policy allows gsd_exec verification surface', () => {
+  const r = shouldBlockPlanningUnit('gsd_exec', '', BASE, 'complete-slice', PLANNING_DISPATCH_REVIEW);
+  assert.strictEqual(r.block, false);
+});
+
 test('planning-dispatch: still blocks writes to user source (write isolation preserved)', () => {
   const r = shouldBlockPlanningUnit('write', join(BASE, 'src', 'main.ts'), BASE, 'plan-slice', PLANNING_DISPATCH);
   assert.strictEqual(r.block, true);

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Adapts shared GSD workflow handlers for MCP executor calls.
+
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
@@ -25,6 +28,12 @@ import type { PlanSliceParams } from "./plan-slice.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import type { ReplanSliceParams } from "./replan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import type { ReopenMilestoneParams } from "./reopen-milestone.js";
+import { handleReopenMilestone } from "./reopen-milestone.js";
+import type { ReopenSliceParams } from "./reopen-slice.js";
+import { handleReopenSlice } from "./reopen-slice.js";
+import type { ReopenTaskParams } from "./reopen-task.js";
+import { handleReopenTask } from "./reopen-task.js";
 import type { ReassessRoadmapParams } from "./reassess-roadmap.js";
 import { handleReassessRoadmap } from "./reassess-roadmap.js";
 import type { ValidateMilestoneParams } from "./validate-milestone.js";
@@ -311,6 +320,9 @@ export type SliceCompleteExecutorParams = CompleteSliceParams;
 export type PlanMilestoneExecutorParams = PlanMilestoneParams;
 export type PlanSliceExecutorParams = PlanSliceParams;
 export type ReplanSliceExecutorParams = ReplanSliceParams;
+export type ReopenTaskExecutorParams = ReopenTaskParams;
+export type ReopenSliceExecutorParams = ReopenSliceParams;
+export type ReopenMilestoneExecutorParams = ReopenMilestoneParams;
 export type ValidateMilestoneExecutorParams = ValidateMilestoneParams;
 export type ReassessRoadmapExecutorParams = ReassessRoadmapParams;
 
@@ -371,6 +383,129 @@ export async function executeTaskComplete(
   }
 }
 
+export async function executeTaskReopen(
+  params: ReopenTaskExecutorParams,
+  basePath: string = process.cwd(),
+): Promise<ToolExecutionResult> {
+  const dbAvailable = await ensureDbOpen(basePath);
+  if (!dbAvailable) {
+    return {
+      content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
+      details: { operation: "reopen_task", error: "db_unavailable" },
+      isError: true,
+    };
+  }
+  try {
+    const result = await handleReopenTask(params, basePath);
+    if ("error" in result) {
+      return {
+        content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
+        details: { operation: "reopen_task", error: result.error },
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Reopened task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+      details: {
+        operation: "reopen_task",
+        taskId: result.taskId,
+        sliceId: result.sliceId,
+        milestoneId: result.milestoneId,
+      },
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logError("tool", `reopen_task tool failed: ${msg}`, { tool: "gsd_task_reopen", error: String(err) });
+    return {
+      content: [{ type: "text", text: `Error reopening task: ${msg}` }],
+      details: { operation: "reopen_task", error: msg },
+      isError: true,
+    };
+  }
+}
+
+export async function executeSliceReopen(
+  params: ReopenSliceExecutorParams,
+  basePath: string = process.cwd(),
+): Promise<ToolExecutionResult> {
+  const dbAvailable = await ensureDbOpen(basePath);
+  if (!dbAvailable) {
+    return {
+      content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
+      details: { operation: "reopen_slice", error: "db_unavailable" },
+      isError: true,
+    };
+  }
+  try {
+    const result = await handleReopenSlice(params, basePath);
+    if ("error" in result) {
+      return {
+        content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
+        details: { operation: "reopen_slice", error: result.error },
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Reopened slice ${result.sliceId} (${result.milestoneId})` }],
+      details: {
+        operation: "reopen_slice",
+        sliceId: result.sliceId,
+        milestoneId: result.milestoneId,
+        tasksReset: result.tasksReset,
+      },
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logError("tool", `reopen_slice tool failed: ${msg}`, { tool: "gsd_slice_reopen", error: String(err) });
+    return {
+      content: [{ type: "text", text: `Error reopening slice: ${msg}` }],
+      details: { operation: "reopen_slice", error: msg },
+      isError: true,
+    };
+  }
+}
+
+export async function executeMilestoneReopen(
+  params: ReopenMilestoneExecutorParams,
+  basePath: string = process.cwd(),
+): Promise<ToolExecutionResult> {
+  const dbAvailable = await ensureDbOpen(basePath);
+  if (!dbAvailable) {
+    return {
+      content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
+      details: { operation: "reopen_milestone", error: "db_unavailable" },
+      isError: true,
+    };
+  }
+  try {
+    const result = await handleReopenMilestone(params, basePath);
+    if ("error" in result) {
+      return {
+        content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
+        details: { operation: "reopen_milestone", error: result.error },
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Reopened milestone ${result.milestoneId}` }],
+      details: {
+        operation: "reopen_milestone",
+        milestoneId: result.milestoneId,
+        slicesReset: result.slicesReset,
+        tasksReset: result.tasksReset,
+      },
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logError("tool", `reopen_milestone tool failed: ${msg}`, { tool: "gsd_milestone_reopen", error: String(err) });
+    return {
+      content: [{ type: "text", text: `Error reopening milestone: ${msg}` }],
+      details: { operation: "reopen_milestone", error: msg },
+      isError: true,
+    };
+  }
+}
+
 export async function executeSliceComplete(
   params: SliceCompleteExecutorParams,
   basePath: string = process.cwd(),

package/src/resources/extensions/gsd/tui/render-kit.ts

@@ -0,0 +1,109 @@
+// Project/App: GSD-2
+// File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
+
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+
+export interface ThemeLike {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+}
+
+export function safeLine(text: string, width: number, ellipsis = "…"): string {
+  if (width <= 0) return "";
+  return truncateToWidth(text, width, ellipsis);
+}
+
+export function padRightVisible(text: string, width: number): string {
+  if (width <= 0) return "";
+  const truncated = safeLine(text, width);
+  const pad = Math.max(0, width - visibleWidth(truncated));
+  return truncated + " ".repeat(pad);
+}
+
+export function rightAlign(left: string, right: string, width: number): string {
+  if (width <= 0) return "";
+  if (!right) return safeLine(left, width);
+  if (!left) return safeLine(" ".repeat(Math.max(0, width - visibleWidth(right))) + right, width);
+  const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+  return safeLine(left + " ".repeat(gap) + right, width);
+}
+
+export function wrapVisibleText(text: string, width: number): string[] {
+  if (width <= 0) return [text];
+  return wrapTextWithAnsi(text, width).map((line) =>
+    visibleWidth(line) > width ? truncateToWidth(line, width, "…") : line,
+  );
+}
+
+export function renderBar(theme: ThemeLike, width: number, color = "muted"): string {
+  return safeLine(theme.fg(color, "─".repeat(Math.max(0, width))), width, "");
+}
+
+export function renderKeyHints(theme: ThemeLike, hints: string[], width: number): string {
+  return safeLine(theme.fg("dim", hints.filter(Boolean).join("  │  ")), width);
+}
+
+export function renderProgressBar(
+  theme: ThemeLike,
+  done: number,
+  total: number,
+  width: number,
+  options: {
+    filledColor?: string;
+    emptyColor?: string;
+    filledChar?: string;
+    emptyChar?: string;
+  } = {},
+): string {
+  const barWidth = Math.max(0, width);
+  const pct = total > 0 ? Math.max(0, Math.min(1, done / total)) : 0;
+  const filled = Math.round(pct * barWidth);
+  const filledChar = options.filledChar ?? "█";
+  const emptyChar = options.emptyChar ?? "░";
+  return (
+    theme.fg(options.filledColor ?? "success", filledChar.repeat(filled)) +
+    theme.fg(options.emptyColor ?? "dim", emptyChar.repeat(barWidth - filled))
+  );
+}
+
+export function statusGlyph(
+  theme: ThemeLike,
+  level: "active" | "idle" | "warning" | "error" | "success",
+): string {
+  switch (level) {
+    case "active": return theme.fg("success", "●");
+    case "success": return theme.fg("success", "✓");
+    case "warning": return theme.fg("warning", "!");
+    case "error": return theme.fg("error", "x");
+    case "idle":
+    default: return theme.fg("dim", "○");
+  }
+}
+
+export function renderFrame(
+  theme: ThemeLike,
+  inner: string[],
+  width: number,
+  options: { borderColor?: string; paddingX?: number } = {},
+): string[] {
+  if (width < 4) return inner.map((line) => safeLine(line, width));
+
+  const borderColor = options.borderColor ?? "borderAccent";
+  const paddingX = Math.max(0, options.paddingX ?? 1);
+  const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+  const border = (text: string) => theme.fg(borderColor, text);
+  const pad = " ".repeat(paddingX);
+
+  const lines = [border("╭" + "─".repeat(width - 2) + "╮")];
+  for (const line of inner) {
+    lines.push(
+      border("│") +
+      pad +
+      padRightVisible(line, contentWidth) +
+      pad +
+      border("│"),
+    );
+  }
+  lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+  return lines.map((line) => safeLine(line, width, ""));
+}

package/src/resources/extensions/gsd/unit-context-manifest.ts

@@ -447,7 +447,9 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     codebaseMap: true,
     preferences: "active-only",
     contextMode: "research",
-    tools: TOOLS_PLANNING,
+    // Multi-slice research dispatches use the research-slice unit contract to
+    // fan out scout subagents that write .gsd research artifacts.
+    tools: TOOLS_PLANNING_DISPATCH_RECON,
     artifacts: {
       inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
       excerpt: [],
@@ -606,7 +608,9 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
     codebaseMap: false,
     preferences: "active-only",
     contextMode: "verification",
-    tools: TOOLS_PLANNING,
+    // Gate evaluation fans out tester-style subagents, which read the slice
+    // plan and report via the DB-backed gate-result tool.
+    tools: TOOLS_PLANNING_DISPATCH_REVIEW,
     artifacts: {
       inline: ["slice-plan", "prior-task-summaries"],
       excerpt: [],
@@ -734,3 +738,32 @@ export const UNIT_MANIFESTS: Record<UnitType, UnitContextManifest> = {
 export function resolveManifest(unitType: string): UnitContextManifest | null {
   return (UNIT_MANIFESTS as Record<string, UnitContextManifest>)[unitType] ?? null;
 }
+
+export interface SubagentPermissionContract {
+  readonly allowed: boolean;
+  readonly allowedSubagents: readonly string[];
+  readonly toolsMode: ToolsPolicy["mode"] | "unknown";
+}
+
+export function compileSubagentPermissionContract(
+  policy: ToolsPolicy | null | undefined,
+): SubagentPermissionContract {
+  if (!policy) {
+    return { allowed: false, allowedSubagents: [], toolsMode: "unknown" };
+  }
+  if (policy.mode === "all") {
+    return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
+  }
+  if (policy.mode === "planning-dispatch") {
+    return {
+      allowed: true,
+      allowedSubagents: [...policy.allowedSubagents],
+      toolsMode: policy.mode,
+    };
+  }
+  return { allowed: false, allowedSubagents: [], toolsMode: policy.mode };
+}
+
+export function resolveSubagentPermissionContract(unitType: string): SubagentPermissionContract {
+  return compileSubagentPermissionContract(resolveManifest(unitType)?.tools);
+}

package/src/resources/extensions/gsd/verification-verdict.ts

@@ -0,0 +1,47 @@
+// Project/App: GSD-2
+// File Purpose: Host-owned verification verdict policy for auto-mode units.
+
+import type { VerificationResult as VerificationGateResult } from "./types.js";
+
+export type VerificationVerdictReason =
+  | "passed"
+  | "no-host-checks"
+  | "checks-failed";
+
+export interface VerificationVerdict {
+  passed: boolean;
+  reason: VerificationVerdictReason;
+  retryable: boolean;
+  failureContext: string;
+}
+
+export function decideVerificationVerdict(
+  unitType: string,
+  result: VerificationGateResult,
+): VerificationVerdict {
+  if (unitType === "execute-task" && result.discoverySource === "none" && result.checks.length === 0) {
+    return {
+      passed: false,
+      reason: "no-host-checks",
+      retryable: false,
+      failureContext:
+        "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+    };
+  }
+
+  if (!result.passed) {
+    return {
+      passed: false,
+      reason: "checks-failed",
+      retryable: true,
+      failureContext: "",
+    };
+  }
+
+  return {
+    passed: true,
+    reason: "passed",
+    retryable: false,
+    failureContext: "",
+  };
+}