@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

package/src/resources/extensions/gsd/planning-subagent-registry.ts

@@ -0,0 +1,31 @@
+/**
+ * Read-only planning specialists that controlled planning dispatch may use.
+ *
+ * Unit manifests and project preferences still declare per-unit subsets. This
+ * registry is the global safety classification checked by the write gate and
+ * preference validation before any configured planning allowlist takes effect.
+ */
+
+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 function isReadOnlyPlanningDispatchAgent(agentId: string): boolean {
+  const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId as keyof typeof PLANNING_DISPATCH_AGENT_REGISTRY];
+  return metadata?.readOnlySpecialist === true;
+}
+
+export function allowedPlanningDispatchAgentsList(): string {
+  return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+}

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -318,12 +318,12 @@ export function checkImportResolution(
     const imports = extractRelativeImports(source);
 
     for (const { importPath, lineNum } of imports) {
-      // Framework-generated type modules may not exist on disk during post-exec
-      // checks (typically generated during framework builds/typegen). Don't
-      // block task completion on these imports.
+      // Framework/codegen-generated modules may not exist on disk during
+      // post-exec checks. Don't block task completion on these imports.
       if (
         /^\.{1,2}\/\+types\//.test(importPath) ||
-        /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath)
+        /^(?:\.{1,2}\/)+(?:[^/]+\/)*\$types(?:$|\/)/.test(importPath) ||
+        /^(?:\.{1,2}\/)+(?:[^/]+\/)*_generated(?:$|\/)/.test(importPath)
       ) {
         continue;
       }

package/src/resources/extensions/gsd/preferences-types.ts

@@ -141,6 +141,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "git",
   "post_unit_hooks",
   "pre_dispatch_hooks",
+  "planning_subagents",
   "dynamic_routing",
   "disabled_model_providers",
   "uok",
@@ -217,6 +218,20 @@ export const KNOWN_UNIT_LABELS = [
 ] as const;
 export type UnitLabel = (typeof KNOWN_UNIT_LABELS)[number];
 
+export const CONFIGURABLE_PLANNING_SUBAGENT_UNITS = [
+  "plan-milestone",
+  "plan-slice",
+] as const;
+export type ConfigurablePlanningSubagentUnit = (typeof CONFIGURABLE_PLANNING_SUBAGENT_UNITS)[number];
+
+export interface PlanningSubagentUnitConfig {
+  allowed?: string[];
+}
+
+export type PlanningSubagentsConfig = Partial<
+  Record<ConfigurablePlanningSubagentUnit, PlanningSubagentUnitConfig>
+>;
+
 
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 
@@ -476,6 +491,7 @@ export interface GSDPreferences {
   git?: GitPreferences;
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
+  planning_subagents?: PlanningSubagentsConfig;
   dynamic_routing?: DynamicRoutingConfig;
   /** Provider IDs to exclude from /model and automatic model routing while leaving tool auth intact. */
   disabled_model_providers?: string[];

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -17,6 +17,7 @@ import { getGateIdsForTurn } from "./gate-registry.js";
 import {
   KNOWN_PREFERENCE_KEYS,
   KNOWN_UNIT_LABELS,
+  CONFIGURABLE_PLANNING_SUBAGENT_UNITS,
   GSD_MODEL_PHASE_KEYS,
 
   SKILL_ACTIONS,
@@ -26,6 +27,10 @@ import {
   type GSDSkillRule,
   type GSDThinkingLevel,
 } from "./preferences-types.js";
+import {
+  ALLOWED_PLANNING_DISPATCH_AGENTS,
+  allowedPlanningDispatchAgentsList,
+} from "./planning-subagent-registry.js";
 
 const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 const VALID_THINKING_LEVELS = new Set<GSDThinkingLevel>([
@@ -747,6 +752,63 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Planning Subagents ─────────────────────────────────────────────────
+  if (preferences.planning_subagents !== undefined) {
+    if (
+      !preferences.planning_subagents ||
+      typeof preferences.planning_subagents !== "object" ||
+      Array.isArray(preferences.planning_subagents)
+    ) {
+      errors.push("planning_subagents must be an object keyed by planning unit type");
+    } else {
+      const validUnits = new Set<string>(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+      const validPlanningSubagents: NonNullable<GSDPreferences["planning_subagents"]> = {};
+
+      for (const [unitType, rawConfig] of Object.entries(preferences.planning_subagents as Record<string, unknown>)) {
+        if (!validUnits.has(unitType)) {
+          errors.push(
+            `planning_subagents unknown or unsupported unit "${unitType}" — supported units: ` +
+            `${CONFIGURABLE_PLANNING_SUBAGENT_UNITS.join(", ")}`,
+          );
+          continue;
+        }
+        if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
+          errors.push(`planning_subagents.${unitType} must be an object with an allowed array`);
+          continue;
+        }
+
+        const allowed = normalizeStringArray((rawConfig as Record<string, unknown>).allowed);
+        if (allowed.length === 0) {
+          errors.push(`planning_subagents.${unitType}.allowed must include at least one read-only planning specialist`);
+          continue;
+        }
+
+        const sanitizedAllowed: string[] = [];
+        for (const agentId of allowed) {
+          if (!ALLOWED_PLANNING_DISPATCH_AGENTS.has(agentId)) {
+            errors.push(
+              `planning_subagents.${unitType}.allowed includes "${agentId}", which is not classified as a ` +
+              `read-only planning specialist. Allowed agents: ${allowedPlanningDispatchAgentsList()}`,
+            );
+            continue;
+          }
+          sanitizedAllowed.push(agentId);
+        }
+
+        const dedupedAllowed = Array.from(new Set(sanitizedAllowed));
+        if (dedupedAllowed.length > 0) {
+          validPlanningSubagents[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>] = {
+            allowed: dedupedAllowed,
+          };
+        }
+      }
+
+      if (Object.keys(validPlanningSubagents).length > 0) {
+        validated.planning_subagents = validPlanningSubagents;
+      }
+    }
+  }
+
   // ─── Dynamic Routing ─────────────────────────────────────────────────
   if (preferences.dynamic_routing !== undefined) {
     if (typeof preferences.dynamic_routing === "object" && preferences.dynamic_routing !== null) {

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

@@ -817,6 +817,7 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
       : undefined,
     post_unit_hooks: mergePostUnitHooks(base.post_unit_hooks, override.post_unit_hooks),
     pre_dispatch_hooks: mergePreDispatchHooks(base.pre_dispatch_hooks, override.pre_dispatch_hooks),
+    planning_subagents: mergePlanningSubagents(base.planning_subagents, override.planning_subagents),
     dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
       ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) } as DynamicRoutingConfig
       : undefined,
@@ -943,6 +944,30 @@ function mergePreDispatchHooks(
   return merged.length > 0 ? merged : undefined;
 }
 
+function mergePlanningSubagents(
+  base?: GSDPreferences["planning_subagents"],
+  override?: GSDPreferences["planning_subagents"],
+): GSDPreferences["planning_subagents"] | undefined {
+  if (!base && !override) return undefined;
+  const merged: NonNullable<GSDPreferences["planning_subagents"]> = {};
+  const unitTypes = new Set([
+    ...Object.keys(base ?? {}),
+    ...Object.keys(override ?? {}),
+  ]);
+
+  for (const unitType of unitTypes) {
+    const allowed = mergeStringLists(
+      base?.[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>]?.allowed,
+      override?.[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>]?.allowed,
+    );
+    if (allowed?.length) {
+      merged[unitType as keyof NonNullable<GSDPreferences["planning_subagents"]>] = { allowed };
+    }
+  }
+
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
 // ─── System Prompt Rendering ──────────────────────────────────────────────────
 
 export function renderPreferencesForSystemPrompt(

package/src/resources/extensions/gsd/prompts/refine-slice.md

@@ -66,12 +66,12 @@ Then:
    **Web apps:** when inlined Web App UAT guidance is present, follow it for Playwright scaffolding and browser-capable verification commands.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
 5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`). `expectedOutput` is path-only: list only files the task creates or overwrites, and use `[]` for pure verification tasks. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
-6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
+6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` with embedded task planning automatically. Do NOT rely on direct `PLAN.md` writes.
 7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should be true. Every must-have maps to a task. Inputs and Expected Output are backtick-wrapped file paths.
 8. If refinement produced structural decisions that diverge from the sketch, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 9. {{commitInstruction}}
 
-The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.
+The slice plan path already exists. Do NOT mkdir.
 
 **Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. Document assumptions in the plan.
 

package/src/resources/extensions/gsd/provider-payload-policy.ts

@@ -2,10 +2,12 @@
  * Provider Payload Policy - ordered shaping of provider request payloads.
  *
  * The order is intentional:
- * 1. observation budgeting masks old tool results in auto-mode,
- * 2. display truncation caps tool-result text for every mode,
- * 3. the protected Source Context Block is appended after truncation,
- * 4. supported models receive the configured service tier.
+ * 1. superseded GSD context injections (memory/guided/forensics) are removed,
+ *    keeping only the latest, for every mode,
+ * 2. observation budgeting masks old tool results in auto-mode,
+ * 3. display truncation caps tool-result text for every mode,
+ * 4. the protected Source Context Block is appended after truncation,
+ * 5. supported models receive the configured service tier.
  */
 
 import type { ContextManagementConfig } from "./preferences-types.js";
@@ -14,6 +16,8 @@ import type { ServiceTierSetting } from "./service-tier.js";
 import {
   createObservationMask,
   createResponsesInputObservationMask,
+  filterSupersededContextInjections,
+  filterSupersededResponsesContextInjections,
   truncateContextResultMessages,
   truncateResponsesInputResultItems,
 } from "./context-masker.js";
@@ -80,10 +84,20 @@ function applyContextManagement(
   deps: ProviderPayloadPolicyDeps,
 ): void {
   const config = deps.loadContextManagementConfig();
+  applyContextInjectionFilter(payload);
   applyObservationBudget(payload, config, deps.isAutoActive());
   applyDisplayTruncation(payload, config);
 }
 
+function applyContextInjectionFilter(payload: Record<string, unknown>): void {
+  if (Array.isArray(payload.messages)) {
+    payload.messages = filterSupersededContextInjections(payload.messages as MessagePayload);
+  }
+  if (Array.isArray(payload.input)) {
+    payload.input = filterSupersededResponsesContextInjections(payload.input as ResponsesInputPayload);
+  }
+}
+
 function applyObservationBudget(
   payload: Record<string, unknown>,
   config: ContextManagementConfig | undefined,

package/src/resources/extensions/gsd/safety/destructive-guard.ts

@@ -14,7 +14,7 @@ interface DestructivePattern {
 }
 
 const DESTRUCTIVE_PATTERNS: readonly DestructivePattern[] = [
-  { pattern: /\brm\s+(-[^\s]*[rfRF][^\s]*\s+|.*\s+-[^\s]*[rfRF])/, label: "recursive delete" },
+  { pattern: /\brm\s+((?:-(?!-)[^\s]*[rR][^\s]*|--recursive)\s+|.*\s+(?:-(?!-)[^\s]*[rR][^\s]*|--recursive)(?:\s|$))/, label: "recursive delete" },
   { pattern: /\bgit\s+push\s+.*--force/, label: "force push" },
   { pattern: /\bgit\s+push\s+-f\b/, label: "force push" },
   { pattern: /\bgit\s+reset\s+--hard/, label: "hard reset" },

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -232,7 +232,7 @@ export function recordToolCall(toolCallId: string, toolName: string, input: Reco
       toolCallId,
       // gsd_exec / gsd_uat_exec carry the script body in `script` (or `code`);
       // bash-style tools use `command`/`cmd`; gsd_exec_search uses `query`.
-      command: String(input.command ?? input.script ?? input.cmd ?? input.code ?? input.query ?? ""),
+      command: formatExecutionEvidenceCommand(toolName, input),
       exitCode: -1,
       outputSnippet: "",
       timestamp: Date.now(),
@@ -254,6 +254,33 @@ export function recordToolCall(toolCallId: string, toolName: string, input: Reco
   }
 }
 
+function pickString(input: Record<string, unknown>, ...keys: string[]): string {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return "";
+}
+
+function canonicalExecutionToolLabel(toolName: string): string {
+  const normalized = toolName.trim().toLowerCase();
+  const mcpMatch = normalized.match(/^mcp__.+__(gsd_(?:uat_)?exec(?:_search)?)$/);
+  return mcpMatch?.[1] ?? normalized;
+}
+
+function formatExecutionEvidenceCommand(toolName: string, input: Record<string, unknown>): string {
+  const body = pickString(input, "command", "script", "cmd", "code", "query");
+  const tool = canonicalExecutionToolLabel(toolName);
+  const purpose = pickString(input, "purpose");
+  const runtime = pickString(input, "runtime").toLowerCase();
+  const label = purpose && (tool === "gsd_exec" || tool === "gsd_uat_exec")
+    ? `${tool}${runtime ? ` ${runtime}` : ""}: ${purpose}`
+    : "";
+
+  if (label && body) return `${label}\n${body}`;
+  return body || label;
+}
+
 /**
  * Record a tool execution result. Matches the entry by toolCallId (assigned
  * at dispatch time) and fills in exit code + output. Prior versions matched

package/src/resources/extensions/gsd/safety/evidence-cross-ref.ts

@@ -161,9 +161,18 @@ function findMatches(
 ): BashEvidence[] {
   const normalized = claimedCommand.trim();
 
-  // Exact matches first
-  const exact = bashCalls.filter(b => b.command.trim() === normalized);
-  if (exact.length > 0) return exact;
+  const exact = bashCalls.filter((b) => b.command.trim() === normalized);
+
+  // When an exact run exists, also consider wrapper-equivalent reruns (e.g.
+  // `cd ... && <command>`) so a newer pass is not shadowed by a stale exact
+  // failure. Do not merge arbitrary containing scripts: their exit code may
+  // belong to later work, not to the claimed verification command.
+  const scriptWrapped = bashCalls.filter((b) => {
+    const command = b.command.trim();
+    if (command.length === 0 || command === normalized) return false;
+    return isWrapperEquivalentCommand(command, normalized);
+  });
+  if (exact.length > 0) return [...exact, ...scriptWrapped];
 
   // Substring match: claimed is contained in actual or actual in claimed.
   // A claimed verification command typically appears verbatim inside a
@@ -171,7 +180,7 @@ function findMatches(
   // script-containing-claim is the common direction. Blank-command entries
   // must be excluded — `"x".includes("")` is true, so they'd match anything.
   const substring = bashCalls.filter(
-    b => b.command.trim().length > 0 &&
+    (b) => b.command.trim().length > 0 &&
       (b.command.includes(normalized) || normalized.includes(b.command)),
   );
   if (substring.length > 0) return substring;
@@ -199,6 +208,23 @@ function findMatches(
 
 function latestMatch(matches: readonly BashEvidence[]): BashEvidence {
   return matches.reduce((latest, match) => (
-    match.timestamp > latest.timestamp ? match : latest
+    match.timestamp >= latest.timestamp ? match : latest
   ));
 }
+
+/** True when `actual` is the same command with only shell wrapper noise. */
+function isWrapperEquivalentCommand(actual: string, claimed: string): boolean {
+  const claimIndex = actual.lastIndexOf(claimed);
+  if (claimIndex < 0) return false;
+
+  const prefix = actual.slice(0, claimIndex).trim();
+  if (prefix.length > 0 && !/^cd\s+.+\s+&&$/.test(prefix)) return false;
+
+  const suffix = actual.slice(claimIndex + claimed.length).trim();
+  return suffix.length === 0 || isBenignWrapperSuffix(suffix);
+}
+
+function isBenignWrapperSuffix(suffix: string): boolean {
+  if (/^;\s*echo\s+["']?[A-Z_]*EXIT=\$\?["']?$/.test(suffix)) return true;
+  return /^(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d)(?:\s+(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d))*$/.test(suffix);
+}

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

@@ -131,10 +131,23 @@ function resolvePreferredSkillNames(
  *  to prevent prompt injection via crafted directory names. */
 const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
 
-function formatSkillActivationBlock(skillNames: string[]): string {
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function formatSkillActivationBlock(skillNames: string[], skillPaths: Map<string, string>): string {
   const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
   if (safe.length === 0) return "";
-  const reads = safe.map(name => `Read the installed '${name}' skill file from <available_skills>`).join(". ");
+  const reads = safe.map(name => {
+    const path = skillPaths.get(name);
+    if (path) return `Read the skill file at \`${escapeXml(path)}\``;
+    return `Find '${name}' in <available_skills>, copy its <location> value, and pass that exact path to read`;
+  }).join(". ");
   return `<skill_activation>${reads}.</skill_activation>`;
 }
 
@@ -203,6 +216,7 @@ export function buildSkillActivationBlock(params: {
   const visibleSkills = loaded;
   const manifestScopedSkills = filterSkillsByManifest(visibleSkills, params.unitType);
   const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
+  const installedSkillPaths = new Map(visibleSkills.map(skill => [normalizeSkillReference(skill.name), skill.filePath]));
   warnIfManifestHasMissingSkills(params.unitType, installedNames);
   const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
   const matched = new Set<string>();
@@ -252,7 +266,7 @@ export function buildSkillActivationBlock(params: {
   const ordered = [...matched]
     .filter(name => installedNames.has(name) && !avoided.has(name))
     .sort();
-  const activationBlock = formatSkillActivationBlock(ordered);
+  const activationBlock = formatSkillActivationBlock(ordered, installedSkillPaths);
 
   // Omit recommendations when the system catalog is manifest-scoped for this
   // unit — skill names are already listed in <available_skills>.

package/src/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.ts

@@ -3,9 +3,10 @@
 //
 // gsd-pi's DB is canonical, but .gsd/*.md is the inter-tool contract. When
 // gsd-core edits a projection file, this handler detects the sha drift vs the
-// recorded baseline in .gsd/.compat.json and re-imports the affected entities
-// into the DB. The next renderAllFromDb pass re-projects; the write-time
-// invalidation hook then refreshes the marker entry, closing the loop.
+// recorded baseline in .gsd/.compat.json and re-imports from markdown with
+// status authority scoped to the affected milestone ids. The next
+// renderAllFromDb pass re-projects; the write-time invalidation hook then
+// refreshes the marker entry, closing the loop.
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -59,10 +60,11 @@ function detectExternalMarkdownEdit(
 }
 
 /**
- * Idempotent repair: re-import hierarchy for the affected entities from
- * markdown into the DB, then update the marker entry so the next detect pass
- * sees the file as expected. migrateHierarchyToDb is itself idempotent
- * (upsert), so re-running this repair after a successful one is a no-op.
+ * Idempotent repair: re-import the hierarchy from markdown while allowing
+ * markdown status authority only for milestones named by the drifted file's
+ * marker entities, then update the marker entry so the next detect pass sees
+ * the file as expected. migrateHierarchyToDb is itself idempotent (upsert), so
+ * re-running this repair after a successful one is a no-op.
  */
 async function repairExternalMarkdownEdit(
   record: ExternalMarkdownEditDrift,
@@ -72,13 +74,28 @@ async function repairExternalMarkdownEdit(
     // Dynamic imports break a module-init cycle: this handler ← registry ←
     // state.ts ← guided-flow.ts ← md-importer.ts ← (this handler's old static
     // import). Deferring to repair time keeps module load cycle-free.
-    const { migrateHierarchyToDb } = await import("../../md-importer.js");
+    const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
     const { invalidateStateCache } = await import("../../state.js");
-    // Scoped re-import. migrateHierarchyToDb walks the whole tree but is a
-    // cheap upsert; per-entity scoping would require decomposing it, which is
-    // out of scope for v1. The cost is bounded by tree size and runs at most
-    // once per reconcile pass (MAX_PASSES=2).
-    migrateHierarchyToDb(ctx.basePath);
+    // #027: migrateHierarchyToDb walks the whole tree (a cheap upsert), so
+    // without scoping every projection rides along with markdown *status*
+    // authority. That lets an unrelated file that is stale from gsd-pi's own
+    // miss silently revert a reopened slice/milestone. Scope status authority to
+    // exactly the milestone(s) this drifted file projects.
+    //
+    // Step 1: the marker's `entities` are DB ids (`M001`, `M001/S01`,
+    // `M001/S01/T01`), so the milestone id is always the first `/`-segment —
+    // layout-independent (legacy `milestones/<MID>/…` and flat `phases/NN-slug/…`
+    // both resolve the same way), no projectionPath parsing needed. An empty set
+    // (no resolvable entities) preserves DB status everywhere: fail toward
+    // protecting the DB, not toward markdown authority.
+    const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+    if (statusAuthoritativeMilestones.size === 0) {
+      logWarning(
+        "reconcile",
+        `external-markdown-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`,
+      );
+    }
+    migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
     invalidateStateCache();
   } catch (err) {
     logWarning(

package/src/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.ts

@@ -3,7 +3,8 @@
 // Parallel to external-markdown-edit.ts. Detects sha drift between the compat
 // marker's planning.projections/passthrough and current .planning/ files.
 //
-// Modeled files (projections): re-imported via parsePlanningDirectory → DB.
+// Modeled files (projections): re-imported via parsePlanningDirectory → DB,
+// with markdown status authority scoped to their marker entity milestone ids.
 // Passthrough files (un-modeled docs): sha refreshed, content untouched.
 
 import { existsSync, readFileSync } from "node:fs";
@@ -148,13 +149,25 @@ async function repairExternalPlanningEdit(
     const { parsePlanningDirectory } = await import("../../migrate/parser.js");
     const { transformToGSD } = await import("../../migrate/transformer.js");
     const { writeGSDDirectory } = await import("../../migrate/writer.js");
-    const { migrateHierarchyToDb } = await import("../../md-importer.js");
+    const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
     const { invalidateStateCache } = await import("../../state.js");
 
     const parsed = await parsePlanningDirectory(join(ctx.basePath, ".planning"));
     const gsdProject = transformToGSD(parsed);
     await writeGSDDirectory(gsdProject, ctx.basePath);
-    migrateHierarchyToDb(ctx.basePath);
+    // #027: scope status authority to the milestone(s) this drifted .planning/
+    // file projects (first `/`-segment of its DB entity ids), so a stale
+    // checkbox in an unrelated projection can't revert a reopened slice/milestone
+    // in the DB. Unseeded files carry no entities → empty set → preserve DB
+    // status everywhere (fail toward the DB, log the breadcrumb).
+    const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+    if (statusAuthoritativeMilestones.size === 0) {
+      logWarning(
+        "reconcile",
+        `external-planning-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`,
+      );
+    }
+    migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
     invalidateStateCache();
   } catch (err) {
     logWarning(

package/src/resources/extensions/gsd/state-reconciliation/types.ts

@@ -49,14 +49,14 @@ export type DriftRecord =
       projectionPath: string;       // relative to basePath, e.g. "m1/plan.md"
       expectedSha: string;          // sha recorded in .compat.json
       actualSha: string;            // freshly computed from disk
-      entities: string[];           // DB entity ids to re-import
+      entities: string[];           // DB entity ids used to scope status authority
     }
   | {
       kind: "external-planning-edit";
       projectionPath: string;       // relative to .planning/, e.g. "phases/01-foo/01-01-PLAN.md"
       expectedSha: string;
       actualSha: string;
-      entities: string[];
+      entities: string[];           // DB entity ids used to scope status authority
       passthrough: boolean;         // true = content-only, no re-import, just refresh sha
     };
 

package/src/resources/extensions/gsd/stop-notice.ts

@@ -66,10 +66,27 @@ export function isNonBlockingPauseNotice(message: string): boolean {
   return message.includes("idempotent advance: unit already active");
 }
 
+/**
+ * A picker / next-action menu that could not render in a non-interactive
+ * (headless / RPC) session. Both wordings originate from the menu-unavailable
+ * helpers (`notifyCommandMenuUnavailable` and `notifyPickerCommandNeedsInteractiveMenu`
+ * in next-action-ui.ts / command-feedback.ts). Headless `auto`/`next` cannot
+ * answer such a menu, so the run has dead-ended and needs operator intervention.
+ * Classify it as blocked so the headless host exits 10 instead of idling
+ * forever waiting for a completion signal that never comes. (#1294)
+ */
+export function isInteractiveMenuUnavailableNotice(message: string): boolean {
+  return (
+    message.includes("menu could not be shown in this session") ||
+    message.includes("did not start:")
+  );
+}
+
 export function isBlockedNoticeMessage(message: string): boolean {
   return (
     message.includes("blocked:") ||
     (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
-    isManualResolutionNotice(message)
+    isManualResolutionNotice(message) ||
+    isInteractiveMenuUnavailableNotice(message)
   );
 }

package/src/resources/extensions/gsd/sync-lock.ts

@@ -9,8 +9,10 @@ import { dirname, join } from "node:path";
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
 const DEFAULT_TIMEOUT_MS = 0;      // fail fast; sync waits block the JS event loop
 
-function lockFilePath(basePath: string): string {
-  return join(basePath, ".gsd", "sync.lock");
+const DEFAULT_LOCK_NAME = "sync.lock";
+
+function lockFilePath(basePath: string, lockName: string = DEFAULT_LOCK_NAME): string {
+  return join(basePath, ".gsd", lockName);
 }
 
 /** True if the given PID is alive in the current process namespace. */
@@ -74,8 +76,9 @@ function tryCreateLockFile(lp: string, payload: string): boolean {
 export function acquireSyncLock(
   basePath: string,
   _timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  lockName: string = DEFAULT_LOCK_NAME,
 ): { acquired: boolean } {
-  const lp = lockFilePath(basePath);
+  const lp = lockFilePath(basePath, lockName);
   const lockData = JSON.stringify(
     { pid: process.pid, acquired_at: new Date().toISOString() },
     null,
@@ -89,7 +92,12 @@ export function acquireSyncLock(
         return { acquired: true };
       }
     } catch {
-      /* unexpected — fall through to retry */
+      // tryCreateLockFile only throws for non-EEXIST errors — a persistently
+      // uncreatable lock path (dangling-symlink parent, ENOTDIR, read-only FS).
+      // Retrying would spin the loop forever with no progress condition,
+      // blocking the JS event loop. Fail open like a contended lock so callers
+      // proceed (racy but functional) instead of hanging.
+      return { acquired: false };
     }
 
     // File exists. Decide whether to steal (stale + owner dead) or skip.
@@ -131,8 +139,8 @@ export function acquireSyncLock(
 /**
  * Release the advisory sync lock. No-op if lock file does not exist.
  */
-export function releaseSyncLock(basePath: string): void {
-  const lp = lockFilePath(basePath);
+export function releaseSyncLock(basePath: string, lockName: string = DEFAULT_LOCK_NAME): void {
+  const lp = lockFilePath(basePath, lockName);
   try {
     if (existsSync(lp)) {
       unlinkSync(lp);

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

@@ -92,6 +92,11 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# planning_subagents:
+#   plan-milestone:
+#     allowed: [scout, planner, security]
+#   plan-slice:
+#     allowed: [scout, planner, reviewer, security]
 # language:
 # experimental:
 #   rtk: false