@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -22,6 +22,20 @@ test("resolveExtensionDirFromCandidates prefers user-local dir when both trees a
   assert.equal(resolved, agentDir);
 });
 
+test("resolveExtensionDirFromCandidates prefers source checkout dir when both trees are valid", () => {
+  const moduleDir = "/repo/src/resources/extensions/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});
+
 test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
   const moduleDir = "/npm/global/gsd";
   const agentDir = "/home/user/.gsd/agent/extensions/gsd";

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,7 +17,10 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
+import {
+  _buildCancelledUnitStopReason,
+  _classifyZeroToolProviderMessageForTest,
+} from "../auto/phases.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -53,6 +56,20 @@ test("classifyError treats usage-limit phrasing as transient rate-limit (#4373)"
   assert.equal(result.kind, "rate-limit");
 });
 
+test("zero-tool provider classifier treats Claude session-limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("Claude Code session limit reached. Limit resets at 5 PM.");
+  assert.ok(result, "session-limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
+test("zero-tool provider classifier treats weekly limit wording as transient rate-limit (#371)", () => {
+  const result = _classifyZeroToolProviderMessageForTest("You've reached your weekly limit. Try again later.");
+  assert.ok(result, "weekly limit wording should be recognized");
+  assert.ok(isTransient(result));
+  assert.equal(result.kind, "rate-limit");
+});
+
 test("classifyError treats extra-usage phrasing as transient rate-limit (#4397)", () => {
   const result = classifyError("You are out of extra usage. Please wait before retrying.");
   assert.ok(isTransient(result));

package/src/resources/extensions/gsd/tests/queued-discuss-fast-path.test.ts

@@ -24,25 +24,24 @@ describe("queued-discuss-fast-path", () => {
     );
   });
 
-  test("2. dispatchDiscussForMilestone computes fastPathInstruction and passes it to loadPrompt", () => {
+  test("2. dispatchDiscussForMilestone computes fastPathInstruction and passes it to buildDiscussMilestonePrompt", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
     assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
     const fnBody = extractSourceRegion(source, "async function dispatchDiscussForMilestone(");
     assert.ok(
       fnBody.includes("fastPathInstruction"),
       "dispatchDiscussForMilestone must compute fastPathInstruction",
     );
     assert.ok(
-      fnBody.includes("loadPrompt("),
-      "dispatchDiscussForMilestone must call loadPrompt",
+      fnBody.includes("buildDiscussMilestonePrompt("),
+      "dispatchDiscussForMilestone must call buildDiscussMilestonePrompt",
     );
-    const loadPromptIdx = fnBody.indexOf("loadPrompt(");
-    const fastPathIdx = fnBody.indexOf("fastPathInstruction", loadPromptIdx);
+    const buildPromptIdx = fnBody.indexOf("buildDiscussMilestonePrompt(");
+    const fastPathIdx = fnBody.indexOf("fastPathInstruction", buildPromptIdx);
     assert.ok(
-      fastPathIdx > loadPromptIdx,
-      "fastPathInstruction must be passed to loadPrompt in dispatchDiscussForMilestone",
+      fastPathIdx > buildPromptIdx,
+      "fastPathInstruction must be passed to buildDiscussMilestonePrompt in dispatchDiscussForMilestone",
     );
   });
 

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -17,6 +17,10 @@ import { validatePreferences } from "../preferences-validation.ts";
 import type { ReactiveExecutionState } from "../types.ts";
 import { parseUnitId } from "../unit-id.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
+import {
+  _getPlannedKeyFilesForTest,
+  _parseReactiveBatchTaskIdsForTest,
+} from "../auto-post-unit.ts";
 
 // ─── Preference Validation ────────────────────────────────────────────────
 
@@ -71,6 +75,38 @@ test("reactive_execution validation warns on unknown keys", () => {
   assert.ok(result.warnings.some((w) => w.includes("unknown_thing")));
 });
 
+test("reactive batch unit ids are parsed and deduped for commit context", () => {
+  assert.deepEqual(
+    _parseReactiveBatchTaskIdsForTest("M001/S01/reactive+T01,t02,T01"),
+    ["T01", "T02"],
+  );
+  assert.deepEqual(_parseReactiveBatchTaskIdsForTest("M001/S01/T01"), []);
+});
+
+test("reactive commit context key files include planned output, files, and key_files once", () => {
+  const result = _getPlannedKeyFilesForTest([
+    {
+      expected_output: ["src/new.ts", "src/shared.ts"],
+      files: ["src/input.ts", "src/shared.ts"],
+      key_files: ["src/key.ts"],
+    },
+    {
+      expected_output: ["src/new.ts"],
+      files: ["src/other.ts"],
+      key_files: ["src/key.ts", "src/final.ts"],
+    },
+  ]);
+
+  assert.deepEqual(result, [
+    "src/new.ts",
+    "src/shared.ts",
+    "src/input.ts",
+    "src/key.ts",
+    "src/other.ts",
+    "src/final.ts",
+  ]);
+});
+
 // ─── Dispatch Rule Matching Logic ─────────────────────────────────────────
 
 test("reactive dispatch requires enabled config and multiple ready tasks", async () => {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -10,6 +10,7 @@ import {
   resetWriteGateState,
   shouldBlockContextArtifactSave,
 } from "../bootstrap/write-gate.ts";
+import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
 
 function makeTempDir(prefix: string): string {
@@ -35,6 +36,40 @@ async function armDepthGate(
   }
 }
 
+test("destructive guard classifies infrastructure mutation commands", () => {
+  assert.deepEqual(classifyCommand("terraform destroy -auto-approve").labels, ["IaC apply/destroy"]);
+  assert.deepEqual(classifyCommand("terragrunt apply").labels, ["IaC apply/destroy"]);
+  assert.deepEqual(classifyCommand("aws s3 delete-bucket --bucket example").labels, ["AWS mutation"]);
+  assert.deepEqual(classifyCommand("kubectl delete namespace prod").labels, ["kubectl mutation"]);
+});
+
+test("register-hooks hard-blocks destructive bash commands outside auto-mode", async () => {
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  let block: any;
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({
+      toolCallId: "call-1",
+      toolName: "bash",
+      input: { command: "terraform apply -auto-approve" },
+    });
+    if (result?.block) block = result;
+  }
+
+  assert.equal(block?.block, true);
+  assert.match(block?.reason ?? "", /HARD BLOCK: destructive Bash command requires explicit human confirmation/);
+  assert.match(block?.reason ?? "", /IaC apply\/destroy/);
+});
+
 test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -51,7 +51,7 @@ test("discuss workflow scopes tools for the queued turn and restores the full to
     // discuss allowlist: gsd_summary_save and gsd_plan_milestone (the latter
     // is needed for the discuss.md output phase — see DISCUSS_TOOLS_ALLOWLIST).
     // gsd_task_complete and the broad shell_exec tool are scoped out.
-    assert.deepEqual(sentTools, ["gsd_summary_save", "gsd_plan_milestone", "ToolSearch"]);
+    assert.deepEqual(sentTools, ["gsd_plan_milestone", "gsd_summary_save", "ToolSearch"]);
     assert.deepEqual(activeTools, originalTools);
     assert.equal(triggerTurn, true);
   } finally {

package/src/resources/extensions/gsd/tests/rule-registry.test.ts

@@ -8,6 +8,7 @@ import { test, describe, beforeEach } from "node:test";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { emitJournalEvent } from "../journal.ts";
 import {
   RuleRegistry,
   getRegistry,
@@ -16,6 +17,7 @@ import {
   resetRegistry,
   convertDispatchRules,
   getOrCreateRegistry,
+  resolveHookArtifactPath,
 } from "../rule-registry.ts";
 import type { UnifiedRule } from "../rule-types.ts";
 import type { DispatchAction, DispatchContext } from "../auto-dispatch.ts";
@@ -443,6 +445,79 @@ describe("RuleRegistry", () => {
     }
   });
 
+  test("failed hook completion with an artifact does not dequeue the next hook", () => {
+    const originalGsdHome = process.env.GSD_HOME;
+    const projectRoot = mkdtempSync(join(tmpdir(), "gsd-hook-failed-"));
+    const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-hook-home-"));
+    const unitId = "M001/S01/T01";
+
+    try {
+      mkdirSync(join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+      writeFileSync(
+        join(projectRoot, ".gsd", "PREFERENCES.md"),
+        [
+          "---",
+          "version: 1",
+          "post_unit_hooks:",
+          "  - name: review-arbiter",
+          "    after: [execute-task]",
+          "    prompt: Review {taskId}",
+          "    artifact: REVIEW.md",
+          "    max_cycles: 1",
+          "  - name: follow-up-review",
+          "    after: [execute-task]",
+          "    prompt: Follow-up review {taskId}",
+          "---",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_HOME = tempGsdHome;
+
+      const registry = new RuleRegistry([]);
+      const firstHook = registry.evaluatePostUnit("execute-task", unitId, projectRoot);
+      assert.equal(firstHook?.hookName, "review-arbiter");
+
+      writeFileSync(
+        resolveHookArtifactPath(projectRoot, unitId, "REVIEW.md"),
+        "partial review output",
+        "utf-8",
+      );
+      emitJournalEvent(projectRoot, {
+        ts: "2026-06-03T12:00:00.000Z",
+        flowId: "flow-hook-failed",
+        seq: 3,
+        eventType: "unit-end",
+        data: {
+          unitType: "hook/review-arbiter",
+          unitId,
+          status: "cancelled",
+          artifactVerified: false,
+          errorContext: {
+            message: "Provider error: Stream ended without finish_reason",
+            category: "provider",
+          },
+        },
+      });
+
+      const nextHook = registry.evaluatePostUnit("hook/review-arbiter", unitId, projectRoot);
+      assert.equal(nextHook, null, "failed hook must not allow follow-up hook dispatch");
+      const failure = registry.consumeHookFailure();
+      assert.equal(failure?.hookName, "review-arbiter");
+      assert.match(failure?.reason ?? "", /status cancelled/);
+
+      const resumedRegistry = new RuleRegistry([]);
+      resumedRegistry.restoreState(projectRoot);
+      const resumedHook = resumedRegistry.evaluatePostUnit("execute-task", unitId, projectRoot);
+      assert.equal(resumedHook, null, "resumed hook evaluation must not skip failed hook artifact");
+      assert.equal(resumedRegistry.consumeHookFailure()?.hookName, "review-arbiter");
+    } finally {
+      if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = originalGsdHome;
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(tempGsdHome, { recursive: true, force: true });
+    }
+  });
+
   // ── matchedRule provenance (S02 journal support) ───────────────────
 
   test("evaluateDispatch result includes matchedRule on dispatch match", async () => {

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -298,6 +298,106 @@ test("session_start installs the welcome screen as the TUI header", async (t) =>
   assert.deepEqual(header.render(123), ["welcome 9.9.9-test none 123"]);
 });
 
+test("session hooks preserve closeout-boundary UI during completion reroot", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-closeout-session-hooks-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+  writeFileSync(
+    join(dir, "dist", "welcome-screen.js"),
+    "export function buildWelcomeScreenLines() { return ['welcome header']; }\n",
+    "utf-8",
+  );
+
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const originalGsdPkgRoot = process.env.GSD_PKG_ROOT;
+  process.chdir(dir);
+  process.env.GSD_HOME = tempGsdHome;
+  process.env.GSD_PKG_ROOT = dir;
+  autoSession.reset();
+  autoSession.completionStopInProgress = true;
+  t.after(() => {
+    autoSession.reset();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    if (originalGsdPkgRoot === undefined) delete process.env.GSD_PKG_ROOT;
+    else process.env.GSD_PKG_ROOT = originalGsdPkgRoot;
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  const sessionSwitch = handlers.get("session_switch");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  assert.ok(sessionSwitch, "session_switch handler must be registered");
+
+  const widgetCalls: Array<{ key: string; value: unknown }> = [];
+  let headerInstallCount = 0;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setFooter: () => {},
+      setHeader: () => {
+        headerInstallCount++;
+      },
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push({ key, value });
+      },
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  await sessionStart!({}, ctx);
+  assert.equal(
+    headerInstallCount,
+    0,
+    "completion reroot session_start must not reinstall the welcome/project-console header",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_start should hide the ambient health widget",
+  );
+
+  widgetCalls.length = 0;
+  await sessionSwitch!({ reason: "reroot" }, ctx);
+  assert.deepEqual(
+    widgetCalls
+      .filter((call) => call.key === "gsd-progress" || call.key === "gsd-outcome")
+      .map((call) => [call.key, call.value]),
+    [],
+    "completion reroot session_switch must not clear the preserved closeout surface",
+  );
+  assert.ok(
+    widgetCalls.some((call) => call.key === "gsd-health" && call.value === undefined),
+    "completion reroot session_switch should keep the ambient health widget hidden",
+  );
+});
+
 test("session_start and session_switch apply disabled model provider policy from current preferences", async (t) => {
   const dir = join(
     tmpdir(),

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
+  buildCompleteSlicePrompt,
   buildPlanMilestonePrompt,
   buildResearchMilestonePrompt,
   buildSkillActivationBlock,
@@ -143,6 +144,29 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
   }
 });
 
+test("buildSkillActivationBlock matches skill_rules against exact unit type context", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "complete-slice-policies", "Use for complete-slice closeout policy checks.");
+    writeSkill(base, "slice-broad", "Use for broad slice work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      unitType: "complete-slice",
+    }, {
+      skill_rules: [
+        { when: "complete-slice", use: ["complete-slice-policies"] },
+        { when: "slice", use: ["slice-broad"] },
+      ],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'complete-slice-policies' \}\)/);
+    assert.doesNotMatch(result, /slice-broad/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("buildSkillActivationBlock honors avoid_skills against always_use_skills", () => {
   const base = makeTempBase();
   try {
@@ -328,6 +352,37 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
   }
 });
 
+test("complete-slice prompt propagates always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n");
+    loadOnlyTestSkills(base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Test",
+        "",
+        "## Slices",
+        "",
+        "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01: Slice\n\n## Tasks\n\n- [x] **T01: Done**\n");
+
+    const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
+
+    assert.match(prompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
   const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
   const previousStderr = setStderrLoggingEnabled(false);

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -148,6 +148,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
   const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
   const resumeDbOpenIdx = resumeBody.indexOf("await openProjectDbIfPresent(base);");
+  const resumeMergeReconcileIdx = resumeBody.indexOf("reconcileMergedMilestonesFromJournal(base);");
   const resumeRegisterIdx = resumeBody.indexOf("registerAutoWorkerForSession(s, base);");
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
@@ -164,6 +165,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(resumeSectionIdx > -1, "startAuto should have resume milestone entry flow");
   assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
   assert.ok(resumeDbOpenIdx > -1, "resume should open DB before milestone entry");
+  assert.ok(resumeMergeReconcileIdx > -1, "resume should reconcile merged milestones before deriving dispatch state");
   assert.ok(resumeRegisterIdx > -1, "resume should register worker before milestone entry");
   assert.ok(resumeEnterMilestoneIdx > -1, "resume should enter milestones through lifecycle");
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
@@ -179,8 +181,10 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
     "bootstrap must open DB and register worker before first enterMilestone",
   );
   assert.ok(
-    resumeDbOpenIdx < resumeRegisterIdx && resumeRegisterIdx < resumeEnterMilestoneIdx,
-    "resume must open DB and register worker before first enterMilestone",
+    resumeDbOpenIdx < resumeMergeReconcileIdx &&
+      resumeMergeReconcileIdx < resumeRegisterIdx &&
+      resumeRegisterIdx < resumeEnterMilestoneIdx,
+    "resume must open DB, reconcile merged milestones, and register worker before first enterMilestone",
   );
 });