@opengsd/gsd-pi 1.9.0 → 1.10.0-dev.a5e42e99

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

@@ -15,7 +15,7 @@
 
 import type { ExtensionContext, ExtensionAPI } from "@gsd/pi-coding-agent";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { gsdProjectionRoot, relMilestoneFile, resolveSliceFile, resolveSlicePath } from "./paths.js";
+import { gsdProjectionRoot, legacyMilestonesDir, relMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "./paths.js";
 import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
@@ -62,6 +62,30 @@ export interface VerificationContext {
 export type VerificationResult = "continue" | "retry" | "pause";
 type PauseAutoFn = (ctx?: ExtensionContext, pi?: ExtensionAPI, errorContext?: ErrorContext) => Promise<void>;
 
+interface VerificationEvidenceLocation {
+  dir: string;
+  fileSliceId?: string;
+}
+
+function resolveVerificationEvidenceLocation(
+  basePath: string,
+  milestoneId: string,
+  sliceId: string,
+): VerificationEvidenceLocation | null {
+  const mDir = resolveMilestonePath(basePath, milestoneId);
+  if (!mDir) return null;
+
+  const legacyBase = legacyMilestonesDir(basePath);
+  const isLegacy = mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\");
+  if (!isLegacy) {
+    return { dir: mDir, fileSliceId: sliceId };
+  }
+
+  const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
+  if (!sDir) return null;
+  return { dir: join(sDir, "tasks") };
+}
+
 function getCurrentUnitCostStats(unitId: string): { unitCostUsd: number; rollingAvgUsd: number } {
   const ledger = getLedger();
   if (!ledger || !Array.isArray(ledger.units) || ledger.units.length === 0) {
@@ -551,11 +575,18 @@ export async function runPostUnitVerification(
     const taskAlreadyComplete = taskRow?.status === "complete" || taskRow?.status === "done";
     if (mid && sid && tid) {
       try {
-        const sDir = resolveSlicePath(s.basePath, mid, sid);
-        if (sDir) {
-          const tasksDir = join(sDir, "tasks");
+        const evidenceLocation = resolveVerificationEvidenceLocation(s.basePath, mid, sid);
+        if (evidenceLocation) {
           if (result.passed) {
-            writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id);
+            writeVerificationJSON(
+              result,
+              evidenceLocation.dir,
+              tid,
+              s.currentUnit.id,
+              undefined,
+              undefined,
+              evidenceLocation.fileSliceId,
+            );
           } else {
             const nextAttempt = attempt + 1;
             const includeRetryMetadata =
@@ -566,11 +597,12 @@ export async function runPostUnitVerification(
               nextAttempt <= maxRetries;
             writeVerificationJSON(
               result,
-              tasksDir,
+              evidenceLocation.dir,
               tid,
               s.currentUnit.id,
               includeRetryMetadata ? nextAttempt : undefined,
               includeRetryMetadata ? maxRetries : undefined,
+              evidenceLocation.fileSliceId,
             );
           }
         }
@@ -718,9 +750,8 @@ export async function runPostUnitVerification(
     // Re-write verification evidence JSON with post-execution checks
     if (postExecChecks && postExecChecks.length > 0 && mid && sid && tid) {
       try {
-        const sDir = resolveSlicePath(s.basePath, mid, sid);
-        if (sDir) {
-          const tasksDir = join(sDir, "tasks");
+        const evidenceLocation = resolveVerificationEvidenceLocation(s.basePath, mid, sid);
+        if (evidenceLocation) {
           // Add postExecutionChecks to the result for the JSON write
           const resultWithPostExec = {
             ...result,
@@ -730,12 +761,13 @@ export async function runPostUnitVerification(
           // Manually write with postExecutionChecks field
           writeVerificationJSONWithPostExec(
             resultWithPostExec,
-            tasksDir,
+            evidenceLocation.dir,
             tid,
             s.currentUnit.id,
             postExecChecks,
             postExecBlockingFailure ? attempt + 1 : undefined,
-            postExecBlockingFailure ? maxRetries : undefined
+            postExecBlockingFailure ? maxRetries : undefined,
+            evidenceLocation.fileSliceId,
           );
         }
       } catch (evidenceErr) {
@@ -940,6 +972,7 @@ function writeVerificationJSONWithPostExec(
   postExecutionChecks: PostExecutionCheckJSON[],
   retryAttempt?: number,
   maxRetries?: number,
+  sliceId?: string,
 ): void {
   mkdirSync(tasksDir, { recursive: true });
 
@@ -980,6 +1013,7 @@ function writeVerificationJSONWithPostExec(
     }));
   }
 
-  const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+  const fileName = sliceId ? `${sliceId}-${taskId}-VERIFY.json` : `${taskId}-VERIFY.json`;
+  const filePath = join(tasksDir, fileName);
   writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }

package/src/resources/extensions/gsd/auto-worktree-cleanup.ts

@@ -10,6 +10,7 @@ import { existsSync, realpathSync, unlinkSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 
 import { gsdRoot } from "./paths.js";
+import { milestoneMetaPath } from "./git-service.js";
 import { logWarning } from "./workflow-logger.js";
 
 function isSamePath(a: string, b: string): boolean {
@@ -93,6 +94,9 @@ export function clearProjectRootStateFiles(
   // worth removing on teardown.
   const transientFiles = [
     join(gsdDir, "STATE.md"),
+    // Integration-branch META now lives flat at .gsd/<MID>-META.json (ADR-045).
+    milestoneMetaPath(basePath, milestoneId),
+    // Legacy location — still cleaned for pre-migration trees.
     join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
   ];
 

package/src/resources/extensions/gsd/auto-worktree-sync.ts

@@ -16,7 +16,7 @@ import {
   _isSamePath as isSamePath,
   _shouldReconcileWorktreeDb,
 } from "./auto-worktree-cleanup.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import type { MilestoneScope } from "./workspace.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
@@ -211,10 +211,17 @@ function syncMilestoneLayout(
   if (!existsSync(mainMilestonesDir)) return;
 
   try {
-    mkdirSync(wtMilestonesDir, { recursive: true });
     const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name);
+      .map((entry) => entry.name)
+      .filter((name) =>
+        layoutSegment !== "milestones" ||
+        dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)),
+      );
+
+    if (mainMilestones.length === 0) return;
+
+    mkdirSync(wtMilestonesDir, { recursive: true });
 
     for (const milestoneId of mainMilestones) {
       syncMilestoneDirectory(

package/src/resources/extensions/gsd/auto-worktree-teardown.ts

@@ -65,7 +65,7 @@ export function teardownAutoWorktree(
 
     // Mirror cleanup steps from mergeMilestoneToMain abort path:
 
-    // 1. Remove transient state files (STATE.md, auto.lock, {MID}-META.json).
+    // 1. Remove transient state files (STATE.md, auto.lock, .gsd/{MID}-META.json).
     //    Non-fatal — must not block teardown.
     try {
       clearProjectRootStateFiles(originalBasePath, milestoneId);

package/src/resources/extensions/gsd/auto.ts

@@ -110,9 +110,7 @@ import {
   getOldestInFlightToolStart,
   hasInteractiveToolInFlight,
   clearInFlightTools,
-  isToolInvocationError,
-  isQueuedUserMessageSkip,
-  isDeterministicPolicyError,
+  updateToolInvocationError,
 } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
@@ -1001,14 +999,17 @@ export function markToolEnd(toolCallId: string): void {
  * Called from tool_execution_end when a GSD tool fails with isError.
  * Stores the error if it matches:
  *   - tool-invocation-error pattern (malformed/truncated JSON)
+ *   - failed ScheduleWakeup continuation validation (#1379)
  *   - queued-user-message skip pattern
  *   - deterministic policy rejection (#4973, e.g. context_write_blocked)
  */
 export function recordToolInvocationError(toolName: string, errorMsg: string): void {
   if (!s.active) return;
-  if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
-    s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
-  }
+  s.lastToolInvocationError = updateToolInvocationError(
+    s.lastToolInvocationError,
+    toolName,
+    errorMsg,
+  );
 }
 
 export function getOldestInFlightToolAgeMs(): number {
@@ -3162,7 +3163,19 @@ export async function dispatchHookUnit(
     workspaceRoot: s.basePath,
   });
 
-  const result = await s.cmdCtx!.newSession({ workspaceRoot: s.basePath });
+  const cmdCtx = s.cmdCtx;
+  if (typeof cmdCtx?.newSession !== "function") {
+    const message = "Auto-mode has no command context for dispatch.";
+    ctx.ui.notify(message, "error");
+    const unitToCommit = previousCurrentUnit ?? s.currentUnit;
+    if (unitToCommit) {
+      await autoCommitUnit(s.basePath, unitToCommit.type, unitToCommit.id, ctx);
+    }
+    await stopAuto(ctx, pi, message, { preserveWorktree: true });
+    return false;
+  }
+
+  const result = await cmdCtx.newSession({ workspaceRoot: s.basePath });
   if (result.cancelled) {
     await stopAuto(ctx, pi);
     return false;

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -58,6 +58,7 @@ function registerAlias(pi: ExtensionAPI, toolDef: any, aliasName: string, canoni
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- toolDef shape matches ToolDefinition but varies by schema
 function registerWorkflowTool(pi: ExtensionAPI, toolDef: any): void {
   pi.registerTool(toolDef);
+  if (process.env.GSD_ADVERTISE_TOOL_ALIASES !== "1") return; // canonical-only model surface (see plan 035)
   for (const alias of aliasesForWorkflowTool(toolDef.name)) {
     registerAlias(pi, toolDef, alias, toolDef.name);
   }

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -51,7 +51,9 @@ import {
   confirmDestructiveCommand,
   consumeDestructiveConfirmation,
   isDestructiveConfirmGateId,
+  peekPendingDestructiveCommand,
   requestDestructiveConfirmation,
+  resetDestructiveConfirmation,
 } from "../safety/destructive-confirmation.js";
 import { logWarning as safetyLogWarning, setStderrLoggingEnabled } from "../workflow-logger.js";
 import { isUnitCloseoutTool, runInteractiveUnitCloseout } from "../unit-closeout.js";
@@ -59,6 +61,7 @@ import { installNotifyInterceptor } from "./notify-interceptor.js";
 import { initNotificationStore } from "../notification-store.js";
 import { initNotificationWidget } from "../notification-widget.js";
 import { notifyPreferenceDiagnostics } from "../preferences-diagnostics.js";
+import { resolveEffectivePlanningToolsPolicy } from "../planning-subagent-policy.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import {
@@ -187,6 +190,7 @@ function suppressWelcomeHeader(ctx: ExtensionContext): void {
  * are bounded — cleared on activation, session boundaries, and verification.
  */
 const deferredApprovalGates = new Map<string, string>();
+const deferredDestructiveConfirmationPauses = new Set<string>();
 
 export const MINIMAL_GSD_TOOL_NAMES = [
   "gsd_exec",
@@ -618,6 +622,23 @@ function clearDeferredApprovalGate(basePath?: string): void {
   }
 }
 
+function deferDestructiveConfirmationPause(basePath: string): void {
+  deferredDestructiveConfirmationPauses.add(basePath);
+}
+
+function clearDeferredDestructiveConfirmationPause(basePath?: string): void {
+  if (!basePath) {
+    deferredDestructiveConfirmationPauses.clear();
+  } else {
+    deferredDestructiveConfirmationPauses.delete(basePath);
+  }
+}
+
+function isDestructiveConfirmationBlocking(basePath: string): boolean {
+  return deferredDestructiveConfirmationPauses.has(basePath)
+    && Boolean(peekPendingDestructiveCommand(basePath));
+}
+
 function deferApprovalGate(gateId: string, basePath: string): void {
   // Verified-on-disk wins (same adapter policy as activation/re-arm): if the
   // workflow MCP child already verified this gate, deferring would block
@@ -1015,6 +1036,7 @@ export function registerHooks(
     await applyToolCallLoopGuardConfig(basePath);
     approvalQuestionAbortInFlight = false;
     clearDeferredApprovalGate();
+    clearDeferredDestructiveConfirmationPause();
     await resetAskUserQuestionsTurnCache();
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
@@ -1106,6 +1128,7 @@ export function registerHooks(
     resetToolCallLoopGuard();
     await applyToolCallLoopGuardConfig(basePath);
     clearDeferredApprovalGate();
+    clearDeferredDestructiveConfirmationPause();
     await resetAskUserQuestionsTurnCache();
     clearDiscussionFlowState(basePath);
     // /clear or /new destroys the conversation holding a discuss interview, so
@@ -1157,6 +1180,7 @@ export function registerHooks(
       }
     }
     clearDeferredApprovalGate(beforeAgentBasePath);
+    clearDeferredDestructiveConfirmationPause(beforeAgentBasePath);
 
     // session_start can fire before the active provider has settled. By
     // before_agent_start, Claude Code CLI sessions should get the same
@@ -1244,12 +1268,20 @@ export function registerHooks(
       await handleAgentEnd(pi, event, ctx);
     } finally {
       activateDeferredApprovalGate(agentEndBasePath);
+      const destructiveConfirmationBlocking = isDestructiveConfirmationBlocking(agentEndBasePath);
+      clearDeferredDestructiveConfirmationPause(agentEndBasePath);
       await maybePauseAutoForApprovalGate(
         ctx,
         pi,
         isApprovalGateBlocking(agentEndBasePath),
         "Depth confirmation is waiting for your answer — pausing auto-mode.",
       );
+      await maybePauseAutoForApprovalGate(
+        ctx,
+        pi,
+        destructiveConfirmationBlocking,
+        "Destructive-command confirmation is waiting for your answer — pausing auto-mode.",
+      );
     }
   });
 
@@ -1559,6 +1591,7 @@ export function registerHooks(
     const activeUnitType = dash.currentUnit?.type ?? guidedUnit?.unitType;
     if (activeUnitType) {
       const manifest = resolveManifest(activeUnitType);
+      const planningBasePath = dash.basePath || guidedUnit?.basePath || discussionBasePath;
       let planningInput = "";
       let agentClasses: string[] | undefined;
       if (isToolCallEventType("write", event)) {
@@ -1574,9 +1607,9 @@ export function registerHooks(
       const planningGuard = shouldBlockPlanningUnit(
         event.toolName,
         planningInput,
-        dash.basePath || guidedUnit?.basePath || discussionBasePath,
+        planningBasePath,
         activeUnitType,
-        manifest?.tools,
+        resolveEffectivePlanningToolsPolicy(activeUnitType, manifest?.tools, planningBasePath),
         agentClasses,
         (event as { input?: unknown }).input,
         dash.currentUnit?.id,
@@ -1685,6 +1718,7 @@ export function registerHooks(
         // Record the command as pending so an affirmative answer to a
         // destructive_confirm gate (handled in tool_result) can confirm it.
         requestDestructiveConfirmation(command, guardBasePath);
+        deferDestructiveConfirmationPause(guardBasePath);
         const reason = [
           "HARD BLOCK: destructive Bash command requires explicit human confirmation.",
           `Detected: ${classification.labels.join(", ")}`,
@@ -1695,14 +1729,6 @@ export function registerHooks(
         safetyLogWarning("safety", `destructive command: ${classification.labels.join(", ")}`, {
           command: String(command).slice(0, 200),
         });
-        if (ctx) {
-          await maybePauseAutoForApprovalGate(
-            ctx,
-            pi,
-            isAutoActive(),
-            "Destructive-command confirmation is waiting for your answer — pausing auto-mode.",
-          );
-        }
         return { block: true, reason };
       }
     }
@@ -1743,7 +1769,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
       recordRetryableHarnessToolError(toolName, resultPayload, errorText);
     } else if (isAutoActive()) {
-      clearToolInvocationError();
+      clearToolInvocationError(event.toolName);
     }
     // Interactive Closeout adapter (ADR-032): auto-mode owns closeout for its
     // own units; interactive completions get the durable git subset (commit +
@@ -1884,7 +1910,10 @@ export function registerHooks(
         const answer = details.response?.answers?.[question.id];
         if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
           confirmDestructiveCommand(basePath);
+        } else {
+          resetDestructiveConfirmation(basePath);
         }
+        clearDeferredDestructiveConfirmationPause(basePath);
         break;
       }
     }
@@ -1951,7 +1980,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
       recordRetryableHarnessToolError(toolName, event.result, errorText);
     } else if (isAutoActive()) {
-      clearToolInvocationError();
+      clearToolInvocationError(event.toolName);
     }
     // Safety harness: record tool execution results for evidence cross-referencing
     if (isAutoActive()) {

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -21,6 +21,14 @@ import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile,
 import { toPosixPath } from "../../shared/mod.js";
 import { autoEnableCmuxPreferences } from "../commands-cmux.js";
 import { gsdHome } from "../gsd-home.js";
+import { GSD_CONTEXT_MESSAGE_SENTINEL } from "../constants.js";
+
+// Single source of truth lives in ../constants.js; re-exported here because
+// buildContextMessage() stamps this marker on every context injection and the
+// provider payload policy (filterSupersededContextInjections in
+// context-masker.ts) matches it to dedupe. Adding a new context customType?
+// Ensure buildContextMessage still prepends this sentinel.
+export { GSD_CONTEXT_MESSAGE_SENTINEL };
 
 const DEFAULT_CONTEXT_MESSAGE_MAX_CHARS = 4_000;
 const DEFAULT_KNOWLEDGE_MAX_CHARS = 12_000;
@@ -448,14 +456,14 @@ export function buildContextMessage(opts: {
   const memoryContent = markMemoryContextSupplied(opts.memoryBlock.trim());
   if (opts.injection) {
     const content = limitContextMessageContent(
-      memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection,
+      `${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection}`,
       contextCharLimit,
     );
     return { customType: "gsd-guided-context", content, display: false as const };
   }
   if (opts.forensicsInjection) {
     const content = limitContextMessageContent(
-      memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection,
+      `${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection}`,
       contextCharLimit,
     );
     return { customType: "gsd-forensics", content, display: false as const };
@@ -463,7 +471,7 @@ export function buildContextMessage(opts: {
   if (memoryContent) {
     return {
       customType: "gsd-memory",
-      content: limitContextMessageContent(memoryContent, contextCharLimit),
+      content: limitContextMessageContent(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent}`, contextCharLimit),
       display: false as const,
     };
   }

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -7,8 +7,12 @@ import { minimatch } from "minimatch";
 import { GSD_PHASE_SCOPE_DISPLAY_REASON, shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import { canonicalToolName } from "../engine-hook-contract.js";
 import { loadJsonFileOrNull } from "../json-persistence.js";
-import { getIsolationMode } from "../preferences.js";
+import { getIsolationMode, loadEffectiveGSDPreferences } from "../preferences.js";
 import { compileSubagentPermissionContract, type ToolsPolicy } from "../unit-context-manifest.js";
+import {
+  allowedPlanningDispatchAgentsList,
+  isReadOnlyPlanningDispatchAgent,
+} from "../planning-subagent-registry.js";
 import { logWarning } from "../workflow-logger.js";
 import { acquireSyncLock, releaseSyncLock } from "../sync-lock.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "../worktree-root.js";
@@ -1191,36 +1195,10 @@ export function shouldBlockQueueExecutionInSnapshot(
 const PLANNING_WRITE_TOOLS = new Set(["write", "edit", "multi_edit", "notebook_edit"]);
 const PLANNING_SUBAGENT_TOOLS = new Set(["subagent", "task"]);
 
-/**
- * Canonical registry for agents that planning-dispatch may consider. Unit
- * manifests still declare per-unit subsets via ToolsPolicy.allowedSubagents.
- */
-const PLANNING_DISPATCH_AGENT_REGISTRY = {
-  mnemo: { readOnlySpecialist: true },
-  scout: { readOnlySpecialist: true },
-  planner: { readOnlySpecialist: true },
-  reviewer: { readOnlySpecialist: true },
-  security: { readOnlySpecialist: true },
-  tester: { readOnlySpecialist: true },
-} as const satisfies Record<string, { readonly readOnlySpecialist: boolean }>;
-
-export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set<string>(
-  Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
-    .filter(([, metadata]) => metadata.readOnlySpecialist)
-    .map(([agentId]) => agentId),
-);
+export { ALLOWED_PLANNING_DISPATCH_AGENTS } from "../planning-subagent-registry.js";
 
 let warnedMissingControlledDispatchAgentClasses = false;
 
-function isReadOnlySpecialist(agentId: string): boolean {
-  const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId as keyof typeof PLANNING_DISPATCH_AGENT_REGISTRY];
-  return metadata?.readOnlySpecialist === true;
-}
-
-function allowedPlanningDispatchAgentsList(): string {
-  return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
-}
-
 function allowsControlledSubagentDispatch(
   policy: ToolsPolicy,
 ): policy is ToolsPolicy & { readonly allowedSubagents: readonly string[] } {
@@ -1376,6 +1354,7 @@ export function shouldBlockPlanningUnit(
       const dispatchContract = compileSubagentPermissionContract(policy);
       const allowedSubagents = dispatchContract.allowedSubagents;
       const allowed = new Set(allowedSubagents);
+      const planningSubagentRegistry = loadEffectiveGSDPreferences(basePath)?.preferences.planning_subagent_registry;
       // When agentClasses is undefined, the caller has not been updated to extract
       // agent identities yet. Block and warn so stale callers surface in telemetry
       // instead of silently bypassing the gate.
@@ -1393,12 +1372,12 @@ export function shouldBlockPlanningUnit(
       if (requested.length === 0) {
         return { block: false };
       }
-      const globallyDisallowed = requested.find(a => !isReadOnlySpecialist(a));
+      const globallyDisallowed = requested.find(a => !isReadOnlyPlanningDispatchAgent(a, planningSubagentRegistry));
       if (globallyDisallowed) {
         return planningBlock(
           unitType,
           policy.mode,
-          `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from ${policy.mode} units`,
+          `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList(planningSubagentRegistry)}) may be dispatched from ${policy.mode} units`,
         );
       }
       const disallowedByPolicy = requested.find(a => !allowed.has(a));
@@ -1406,7 +1385,7 @@ export function shouldBlockPlanningUnit(
         return planningBlock(
           unitType,
           policy.mode,
-          `subagent dispatch of "${disallowedByPolicy}" not permitted by ToolsPolicy.allowedSubagents; permitted agents for this unit: ${allowedSubagents.join(", ")}`,
+          `subagent dispatch of "${disallowedByPolicy}" not permitted by unit allowlist (ToolsPolicy.allowedSubagents/planning_subagents); permitted agents for this unit: ${allowedSubagents.join(", ")}`,
         );
       }
       return { block: false };

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

@@ -11,6 +11,7 @@ import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getLatestAssessmentByScope } from "./gsd-db.js";
 import { checkpointWorkflowDatabase } from "./db-workspace.js";
+import { formatVerdictRecordedNotice, formatVerdictRejectedNotice } from "./stop-notice.js";
 import {
   VALIDATION_VERDICTS,
   extractVerdict,
@@ -165,17 +166,17 @@ export async function handleVerdict(
   basePath: string,
 ): Promise<void> {
   if (!rawArgs.trim()) {
-    ctx.ui.notify(USAGE, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
     return;
   }
 
   const parsed = parseArgs(rawArgs);
   if ("error" in parsed) {
-    ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(`${parsed.error}\n${USAGE}`), "warning");
     return;
   }
   if (!parsed.verdict) {
-    ctx.ui.notify(USAGE, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
     return;
   }
 
@@ -184,7 +185,7 @@ export async function handleVerdict(
     const state = await deriveState(basePath);
     if (!state.activeMilestone) {
       ctx.ui.notify(
-        "No active milestone — pass --milestone Mxxx to target a specific milestone.",
+        formatVerdictRejectedNotice("No active milestone — pass --milestone Mxxx to target a specific milestone."),
         "warning",
       );
       return;
@@ -195,7 +196,9 @@ export async function handleVerdict(
   const existingValidation = await loadExistingValidation(basePath, milestoneId);
   if (!existingValidation) {
     ctx.ui.notify(
-      `No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`,
+      formatVerdictRejectedNotice(
+        `No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`,
+      ),
       "warning",
     );
     return;
@@ -205,7 +208,7 @@ export async function handleVerdict(
 
   if (parsed.verdict !== "pass" && !parsed.rationale) {
     ctx.ui.notify(
-      `--rationale is required when overriding to ${parsed.verdict}.`,
+      formatVerdictRejectedNotice(`--rationale is required when overriding to ${parsed.verdict}.`),
       "warning",
     );
     return;
@@ -234,7 +237,7 @@ export async function handleVerdict(
   if (result.isError) {
     const msg =
       result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
-    ctx.ui.notify(msg, "error");
+    ctx.ui.notify(formatVerdictRejectedNotice(msg), "error");
     return;
   }
 
@@ -244,12 +247,16 @@ export async function handleVerdict(
   const effectiveVerdict = extractEffectiveVerdict(result.details, parsed.verdict);
   if (effectiveVerdict !== parsed.verdict) {
     ctx.ui.notify(
-      `Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`,
+      formatVerdictRecordedNotice(
+        `Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`,
+      ),
       "warning",
     );
   } else {
     ctx.ui.notify(
-      `Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`,
+      formatVerdictRecordedNotice(
+        `Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`,
+      ),
       "success",
     );
   }