gsd-pi 2.41.0-dev.9446b20 → 2.41.0-dev.97349b1

package/src/resources/extensions/gsd/service-tier.ts

@@ -0,0 +1,171 @@
+/**
+ * Service Tier — gating, status formatting, icon resolution, and
+ * the /gsd fast command handler.
+ *
+ * Service tiers (priority/flex) are an OpenAI feature that only applies
+ * to gpt-5.4 variants. This module centralizes the model-gating logic
+ * so that icons, preferences, and the before_provider_request hook all
+ * use a single source of truth.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync } from "node:fs";
+import { saveFile } from "./files.js";
+import {
+  getGlobalGSDPreferencesPath,
+  loadEffectiveGSDPreferences,
+  loadGlobalGSDPreferences,
+} from "./preferences.js";
+import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type ServiceTierSetting = "priority" | "flex" | undefined;
+
+// ─── Gating ──────────────────────────────────────────────────────────────────
+
+/**
+ * Returns true when the given model ID supports OpenAI service tiers.
+ * Currently only gpt-5.4 variants qualify.
+ */
+export function supportsServiceTier(modelId: string): boolean {
+  if (!modelId) return false;
+  // Strip provider prefix if present (e.g. "openai/gpt-5.4" → "gpt-5.4")
+  const bare = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  return bare.startsWith("gpt-5.4");
+}
+
+// ─── Status Formatting ───────────────────────────────────────────────────────
+
+/**
+ * Human-readable description of the current service tier setting.
+ */
+export function formatServiceTierStatus(tier: ServiceTierSetting): string {
+  if (!tier) {
+    return [
+      "Service tier: disabled",
+      "",
+      "Usage:",
+      "  /gsd fast on     Set to priority (2x cost, faster)",
+      "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+      "  /gsd fast off    Disable service tier",
+      "",
+      "Only affects gpt-5.4 models.",
+    ].join("\n");
+  }
+
+  const label = tier === "priority" ? "priority (2x cost, faster)" : "flex (0.5x cost, slower)";
+  return [
+    `Service tier: ${label}`,
+    "",
+    "Usage:",
+    "  /gsd fast on     Set to priority (2x cost, faster)",
+    "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+    "  /gsd fast off    Disable service tier",
+    "",
+    "Only affects gpt-5.4 models.",
+  ].join("\n");
+}
+
+// ─── Icon Resolution ─────────────────────────────────────────────────────────
+
+/**
+ * Returns the appropriate icon for the active service tier and model.
+ * Returns empty string when the tier is inactive or the model doesn't
+ * support service tiers.
+ */
+export function resolveServiceTierIcon(tier: ServiceTierSetting, modelId: string): string {
+  if (!tier || !supportsServiceTier(modelId)) return "";
+  return tier === "priority" ? "⚡" : "💰";
+}
+
+// ─── Preference Read ─────────────────────────────────────────────────────────
+
+/**
+ * Read the effective service_tier setting from preferences.
+ */
+export function getEffectiveServiceTier(): ServiceTierSetting {
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const raw = prefs?.service_tier;
+  if (raw === "priority" || raw === "flex") return raw;
+  return undefined;
+}
+
+// ─── Preference Write ────────────────────────────────────────────────────────
+
+function extractBodyAfterFrontmatter(content: string): string | null {
+  const start = content.startsWith("---\n") ? 4 : content.startsWith("---\r\n") ? 5 : -1;
+  if (start === -1) return null;
+  const closingIdx = content.indexOf("\n---", start);
+  if (closingIdx === -1) return null;
+  const after = content.slice(closingIdx + 4);
+  return after.trim() ? after : null;
+}
+
+async function writeGlobalServiceTier(
+  ctx: ExtensionCommandContext,
+  tier: ServiceTierSetting,
+): Promise<void> {
+  const path = getGlobalGSDPreferencesPath();
+  await ensurePreferencesFile(path, ctx, "global");
+
+  const existing = loadGlobalGSDPreferences();
+  const prefs: Record<string, unknown> = existing?.preferences ? { ...existing.preferences } : {};
+  prefs.version = prefs.version || 1;
+
+  if (tier) {
+    prefs.service_tier = tier;
+  } else {
+    delete prefs.service_tier;
+  }
+
+  const frontmatter = serializePreferencesToFrontmatter(prefs);
+  let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+  if (existsSync(path)) {
+    const preserved = extractBodyAfterFrontmatter(readFileSync(path, "utf-8"));
+    if (preserved) body = preserved;
+  }
+
+  await saveFile(path, `---\n${frontmatter}---${body}`);
+  await ctx.waitForIdle();
+  await ctx.reload();
+}
+
+// ─── Command Handler ─────────────────────────────────────────────────────────
+
+/**
+ * Handle `/gsd fast [on|off|flex|status]`.
+ */
+export async function handleFast(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const trimmed = args.trim().toLowerCase();
+
+  if (!trimmed || trimmed === "status") {
+    const tier = getEffectiveServiceTier();
+    ctx.ui.notify(formatServiceTierStatus(tier), "info");
+    return;
+  }
+
+  if (trimmed === "on") {
+    await writeGlobalServiceTier(ctx, "priority");
+    ctx.ui.notify("Service tier set to priority (2x cost, faster responses). Only affects gpt-5.4 models.", "info");
+    return;
+  }
+
+  if (trimmed === "off") {
+    await writeGlobalServiceTier(ctx, undefined);
+    ctx.ui.notify("Service tier disabled.", "info");
+    return;
+  }
+
+  if (trimmed === "flex") {
+    await writeGlobalServiceTier(ctx, "flex");
+    ctx.ui.notify("Service tier set to flex (0.5x cost, slower responses). Only affects gpt-5.4 models.", "info");
+    return;
+  }
+
+  ctx.ui.notify(
+    "Usage: /gsd fast [on|off|flex|status]\n\n  on    Priority tier (2x cost, faster)\n  off   Disable service tier\n  flex  Flex tier (0.5x cost, slower)\n  status Show current setting",
+    "warning",
+  );
+}

package/src/resources/extensions/gsd/structured-data-formatter.ts

@@ -25,6 +25,7 @@ interface DecisionInput {
   choice: string;
   rationale: string;
   revisable: string;
+  made_by?: string;
 }
 
 interface RequirementInput {
@@ -61,6 +62,7 @@ export function formatDecisionCompact(decision: DecisionInput): string {
     decision.choice,
     decision.rationale,
     decision.revisable,
+    decision.made_by ?? 'agent',
   ].join(" | ");
 }
 
@@ -70,7 +72,7 @@ export function formatDecisionsCompact(decisions: DecisionInput[]): string {
     return "# Decisions (compact)\n(none)";
   }
 
-  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable";
+  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable | made_by";
   const lines = decisions.map(formatDecisionCompact);
   return `${header}\n\n${lines.join("\n")}`;
 }

package/src/resources/extensions/gsd/templates/decisions.md

@@ -4,5 +4,5 @@
      To reverse a decision, add a new row that supersedes it.
      Read this file at the start of any planning or research phase. -->
 
-| # | When | Scope | Decision | Choice | Rationale | Revisable? |
-|---|------|-------|----------|--------|-----------|------------|
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|

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

@@ -337,7 +337,7 @@ function makeMockDeps(
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false }),
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},
@@ -416,6 +416,7 @@ function makeMockDeps(
     getSessionFile: () => "/tmp/session.json",
     rebuildState: async () => {},
     resolveModelId: (id: string, models: any[]) => models.find((m: any) => m.id === id),
+    emitJournalEvent: () => {},
   };
 
   const merged = { ...baseDeps, ...overrides, callLog };
@@ -594,7 +595,6 @@ test("autoLoop calls deriveState → resolveDispatch → runUnit in sequence", a
   ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
   const pi = makeMockPi();
 
-  let loopCount = 0;
   const s = makeLoopSession();
 
   const deps = makeMockDeps({
@@ -620,11 +620,8 @@ test("autoLoop calls deriveState → resolveDispatch → runUnit in sequence", a
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
-      loopCount++;
-      // After first iteration, deactivate to exit the loop
-      if (loopCount >= 1) {
-        s.active = false;
-      }
+      // Deactivate after first iteration to exit the loop
+      s.active = false;
       return "continue" as const;
     },
   });
@@ -682,7 +679,6 @@ test("crash lock records session file from AFTER newSession, not before (#1710)"
   };
   const pi = makeMockPi();
 
-  let loopCount = 0;
   const s = makeLoopSession({
     cmdCtx: {
       newSession: () => {
@@ -730,10 +726,8 @@ test("crash lock records session file from AFTER newSession, not before (#1710)"
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
-      loopCount++;
-      if (loopCount >= 1) {
-        s.active = false;
-      }
+      // Deactivate after first iteration to exit the loop
+      s.active = false;
       return "continue" as const;
     },
   });
@@ -790,6 +784,23 @@ test("autoLoop handles verification retry by continuing loop", async (t) => {
   let deriveCallCount = 0;
   const s = makeLoopSession();
 
+  // Pre-queued verification actions: each entry provides a side-effect + return value
+  type VerifyAction = { sideEffect?: () => void; response: "retry" | "continue" };
+  const verificationActions: VerifyAction[] = [
+    {
+      sideEffect: () => {
+        // Simulate retry — set pendingVerificationRetry on session
+        s.pendingVerificationRetry = {
+          unitId: "M001/S01/T01",
+          failureContext: "test failed: expected X got Y",
+          attempt: 1,
+        };
+      },
+      response: "retry",
+    },
+    { response: "continue" },
+  ];
+
   const deps = makeMockDeps({
     deriveState: async () => {
       deriveCallCount++;
@@ -804,19 +815,11 @@ test("autoLoop handles verification retry by continuing loop", async (t) => {
       } as any;
     },
     runPostUnitVerification: async () => {
+      const action = verificationActions[verifyCallCount] ?? { response: "continue" as const };
       verifyCallCount++;
       deps.callLog.push("runPostUnitVerification");
-      if (verifyCallCount === 1) {
-        // First call: simulate retry — set pendingVerificationRetry on session
-        s.pendingVerificationRetry = {
-          unitId: "M001/S01/T01",
-          failureContext: "test failed: expected X got Y",
-          attempt: 1,
-        };
-        return "retry" as const;
-      }
-      // Second call: pass
-      return "continue" as const;
+      action.sideEffect?.();
+      return action.response;
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
@@ -893,19 +896,17 @@ test("autoLoop handles dispatch skip action by continuing", async (t) => {
   const s = makeLoopSession();
 
   let dispatchCallCount = 0;
+  // Pre-queued dispatch responses: first call returns "skip", second returns "stop"
+  const dispatchResponses = [
+    { action: "skip" as const },
+    { action: "stop" as const, reason: "done", level: "info" as const },
+  ];
   const deps = makeMockDeps({
     resolveDispatch: async () => {
+      const response = dispatchResponses[dispatchCallCount] ?? dispatchResponses[dispatchResponses.length - 1];
       dispatchCallCount++;
       deps.callLog.push("resolveDispatch");
-      if (dispatchCallCount === 1) {
-        return { action: "skip" as const };
-      }
-      // Second time: stop to exit the loop
-      return {
-        action: "stop" as const,
-        reason: "done",
-        level: "info" as const,
-      };
+      return response;
     },
   });
 
@@ -935,22 +936,26 @@ test("autoLoop drains sidecar queue after postUnitPostVerification enqueues item
   const s = makeLoopSession();
 
   let postVerCallCount = 0;
+  const postVerActions: Array<() => void> = [
+    () => {
+      // First call (main unit): enqueue a sidecar item
+      s.sidecarQueue.push({
+        kind: "hook" as const,
+        unitType: "hook/review",
+        unitId: "M001/S01/T01/review",
+        prompt: "review the code",
+      });
+    },
+    () => {
+      // Second call (sidecar unit completed): deactivate
+      s.active = false;
+    },
+  ];
   const deps = makeMockDeps({
     postUnitPostVerification: async () => {
+      postVerActions[postVerCallCount]?.();
       postVerCallCount++;
       deps.callLog.push("postUnitPostVerification");
-      if (postVerCallCount === 1) {
-        // First call (main unit): enqueue a sidecar item
-        s.sidecarQueue.push({
-          kind: "hook" as const,
-          unitType: "hook/review",
-          unitId: "M001/S01/T01/review",
-          prompt: "review the code",
-        });
-        return "continue" as const;
-      }
-      // Second call (sidecar unit completed): done
-      s.active = false;
       return "continue" as const;
     },
   });
@@ -1118,13 +1123,13 @@ test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", () => {
   assert.ok(healIdx > -1, "startAuto must call selfHealRuntimeRecords");
   assert.ok(healIdx < loopIdx, "selfHealRuntimeRecords must be called before autoLoop");
 
-  // Verify the second autoLoop call site also has selfHeal before it
+  // Verify the second autoLoop call site also has selfHeal before it (if present)
   const secondLoopIdx = fnBlock.indexOf("autoLoop(", loopIdx + 1);
-  if (secondLoopIdx > -1) {
-    const secondHealIdx = fnBlock.indexOf("selfHealRuntimeRecords", healIdx + 1);
-    assert.ok(secondHealIdx > -1, "second autoLoop call must also have selfHealRuntimeRecords");
-    assert.ok(secondHealIdx < secondLoopIdx, "second selfHealRuntimeRecords must precede second autoLoop");
-  }
+  const secondHealIdx = fnBlock.indexOf("selfHealRuntimeRecords", healIdx + 1);
+  assert.ok(
+    secondLoopIdx === -1 || (secondHealIdx > -1 && secondHealIdx < secondLoopIdx),
+    "if a second autoLoop call exists, it must also be preceded by selfHealRuntimeRecords",
+  );
 });
 
 test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
@@ -1286,25 +1291,29 @@ test("stuck detection: window resets recovery when deriveState returns a differe
   const s = makeLoopSession();
 
   let deriveCallCount = 0;
+  let postVerCallCount = 0;
   let stopCalled = false;
 
+  // First 3 derives return T01, 4th returns T02; dispatch follows the derived task
+  const derivedTaskIds = ["T01", "T01", "T01", "T02"];
+
   const deps = makeMockDeps({
     deriveState: async () => {
+      const taskId = derivedTaskIds[Math.min(deriveCallCount, derivedTaskIds.length - 1)];
       deriveCallCount++;
       deps.callLog.push("deriveState");
       return {
         phase: "executing",
         activeMilestone: { id: "M001", title: "Test", status: "active" },
         activeSlice: { id: "S01", title: "Slice 1" },
-        activeTask: { id: deriveCallCount <= 3 ? "T01" : "T02" },
+        activeTask: { id: taskId },
         registry: [{ id: "M001", status: "active" }],
         blockers: [],
       } as any;
     },
     resolveDispatch: async () => {
+      const taskId = derivedTaskIds[Math.min(deriveCallCount - 1, derivedTaskIds.length - 1)];
       deps.callLog.push("resolveDispatch");
-      // Return dispatch matching the task from deriveState
-      const taskId = deriveCallCount <= 3 ? "T01" : "T02";
       return {
         action: "dispatch" as const,
         unitType: "execute-task",
@@ -1318,11 +1327,11 @@ test("stuck detection: window resets recovery when deriveState returns a differe
       s.active = false;
     },
     postUnitPostVerification: async () => {
+      postVerCallCount++;
       deps.callLog.push("postUnitPostVerification");
-      // After 4th iteration (unit changed on iter 4), exit
-      if (deriveCallCount >= 4) {
-        s.active = false;
-      }
+      // Exit on the 4th call (after T02 unit completes)
+      const shouldExit = postVerCallCount >= 4;
+      s.active = !shouldExit;
       return "continue" as const;
     },
   });
@@ -1361,6 +1370,14 @@ test("stuck detection: does not push to window during verification retry", async
   let verifyCallCount = 0;
   let stopReason = "";
 
+  // Pre-queued responses: 3 retries then a continue (exit)
+  const verifyActions: Array<() => "retry" | "continue"> = [
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 1 }; return "retry"; },
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 2 }; return "retry"; },
+    () => { s.pendingVerificationRetry = { unitId: "M001/S01/T01", failureContext: "test failed", attempt: 3 }; return "retry"; },
+    () => { s.active = false; return "continue"; },
+  ];
+
   const deps = makeMockDeps({
     deriveState: async () =>
       ({
@@ -1378,20 +1395,10 @@ test("stuck detection: does not push to window during verification retry", async
       prompt: "do the thing",
     }),
     runPostUnitVerification: async () => {
+      const action = verifyActions[verifyCallCount] ?? (() => { s.active = false; return "continue" as const; });
       verifyCallCount++;
       deps.callLog.push("runPostUnitVerification");
-      if (verifyCallCount <= 3) {
-        // Set pendingVerificationRetry — should prevent stuck counter increment
-        s.pendingVerificationRetry = {
-          unitId: "M001/S01/T01",
-          failureContext: "test failed",
-          attempt: verifyCallCount,
-        };
-        return "retry" as const;
-      }
-      // After 3 retries, exit gracefully
-      s.active = false;
-      return "continue" as const;
+      return action();
     },
     stopAuto: async (_ctx?: any, _pi?: any, reason?: string) => {
       deps.callLog.push("stopAuto");
@@ -1543,7 +1550,7 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
   const dispatchedUnitTypes: string[] = [];
 
   // Phase sequence: each deriveState call returns a different phase.
-  // On the 6th call (start of iteration 6), we deactivate to exit.
+  // The 6th entry (index 5) is the terminal "complete" phase that stops the loop.
   const phases = [
     // Call 1: researching → dispatches research-slice
     {
@@ -1575,6 +1582,12 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
       activeSlice: { id: "S01", title: "Complete Slice" },
       activeTask: null,
     },
+    // Call 6: terminal — deactivate to exit the loop
+    {
+      phase: "complete",
+      activeSlice: null,
+      activeTask: null,
+    },
   ];
 
   const dispatches = [
@@ -1587,46 +1600,26 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
 
   const deps = makeMockDeps({
     deriveState: async () => {
+      const p = phases[Math.min(deriveCallCount, phases.length - 1)];
       deriveCallCount++;
       deps.callLog.push("deriveState");
 
-      if (deriveCallCount > phases.length) {
-        // 6th+ call: deactivate to exit the loop
-        s.active = false;
-        return {
-          phase: "complete",
-          activeMilestone: { id: "M001", title: "Test", status: "complete" },
-          activeSlice: null,
-          activeTask: null,
-          registry: [{ id: "M001", status: "complete" }],
-          blockers: [],
-        } as any;
-      }
-
-      const p = phases[deriveCallCount - 1];
+      const terminalPhases: Record<string, string> = { complete: "complete" };
+      s.active = p.phase !== "complete";
+      const milestoneStatus = terminalPhases[p.phase] ?? "active";
       return {
         phase: p.phase,
-        activeMilestone: { id: "M001", title: "Test", status: "active" },
-        activeSlice: p.activeSlice,
-        activeTask: p.activeTask,
-        registry: [{ id: "M001", status: "active" }],
+        activeMilestone: { id: "M001", title: "Test", status: milestoneStatus },
+        activeSlice: p.activeSlice ?? null,
+        activeTask: p.activeTask ?? null,
+        registry: [{ id: "M001", status: milestoneStatus }],
         blockers: [],
       } as any;
     },
     resolveDispatch: async () => {
+      const d = dispatches[Math.min(dispatchCallCount, dispatches.length - 1)];
       dispatchCallCount++;
       deps.callLog.push("resolveDispatch");
-
-      if (dispatchCallCount > dispatches.length) {
-        // Safety: shouldn't reach here, but stop if it does
-        return {
-          action: "stop" as const,
-          reason: "done",
-          level: "info" as const,
-        };
-      }
-
-      const d = dispatches[dispatchCallCount - 1];
       dispatchedUnitTypes.push(d.unitType);
       return {
         action: "dispatch" as const,
@@ -1691,18 +1684,11 @@ test("autoLoop lifecycle: advances through research → plan → execute → ver
     `callLog should have at least 5 resolveDispatch entries (got ${dispatchEntries.length})`,
   );
 
-  // Verify interleaving: each resolveDispatch should follow a deriveState
-  let dispatchSeen = 0;
-  for (const entry of deps.callLog) {
-    if (entry === "resolveDispatch") {
-      dispatchSeen++;
-    }
-    if (entry === "deriveState" && dispatchSeen > 0) {
-      // A deriveState after a resolveDispatch confirms the loop advanced
-      break;
-    }
-  }
-  assert.ok(dispatchSeen > 0, "resolveDispatch should appear in callLog");
+  // Verify interleaving: a deriveState must follow a resolveDispatch (confirms loop advanced)
+  const firstDispatchIdx = deps.callLog.indexOf("resolveDispatch");
+  const firstDeriveAfterDispatch = deps.callLog.indexOf("deriveState", firstDispatchIdx + 1);
+  assert.ok(firstDispatchIdx >= 0, "resolveDispatch should appear in callLog");
+  assert.ok(firstDeriveAfterDispatch > firstDispatchIdx, "deriveState should follow resolveDispatch to confirm loop advanced");
 
   // Assert the exact sequence of dispatched unit types
   assert.deepEqual(
@@ -1775,6 +1761,8 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
   const s = makeLoopSession();
 
   let preVerifyCallCount = 0;
+  // Pre-queued responses: first call returns "retry", second returns "continue"
+  const preVerifyResponses = ["retry", "continue"] as const;
 
   const deps = makeMockDeps({
     deriveState: async () => {
@@ -1790,11 +1778,7 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
     },
     postUnitPreVerification: async () => {
       deps.callLog.push("postUnitPreVerification");
-      preVerifyCallCount++;
-      if (preVerifyCallCount === 1) {
-        return "retry" as const;
-      }
-      return "continue" as const;
+      return preVerifyResponses[preVerifyCallCount++] ?? "continue";
     },
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
@@ -1907,9 +1891,8 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
       iterationCount++;
-      if (iterationCount >= 2) {
-        s.active = false;
-      }
+      // Deactivate after 2nd iteration
+      s.active = iterationCount < 2;
       return "continue" as const;
     },
   });
@@ -2122,7 +2105,7 @@ test("autoLoop stops when worktree has no project files for execute-task (#1833)
     "should stop auto-mode when worktree has no project files",
   );
   const healthNotification = notifications.find(
-    (n) => n.includes("Worktree health check failed") && n.includes("no package.json or src/"),
+    (n) => n.includes("Worktree health check failed") && n.includes("no recognized project files"),
   );
   assert.ok(
     healthNotification,