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

package/README.md

@@ -28,16 +28,16 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.9.0**
+Latest release: **v1.10.0**
 
-- **gsd:** Add task rework briefs.
-- **web:** Delete unused chart.tsx and recharts.
-- **deps:** Move ajv to devDependencies.
-- **daemon:** Dedupe @anthropic-ai/sdk to ^0.91.1.
-- **deps:** Override hono to >=4.12.25.
-- **gsd:** Batch plan-v2 task queries and skip unchanged graph writes.
-- **gsd:** Open the worker DB once per parallel-monitor tick.
-- **gsd:** Batch parallel-eligibility task queries.
+- **pi-ai:** Add Meta Muse Spark 1.1 to the model catalog.
+- **gsd:** Surface cacheRetention as a settable prompt-cache TTL preference.
+- **models:** Add `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna` as first-class models.
+- **models:** Add Grok 4.5 as a first-class xAI model.
+- **agent-core:** Pin compaction summarization reasoning to low, bound degenerate-chunk retry.
+- **gsd:** Filter superseded context injections from provider payload.
+- **gsd:** Stop advertising alias tool schemas on model-facing surfaces.
+- **gsd:** Cap execute-task and discuss-slice inlined context; provider-aware budgets.
 
 <!-- release-highlights:end -->
 
@@ -194,6 +194,7 @@ Then use slash commands inside the GSD session:
 | --- | --- |
 | `src/` | Core runtime resources and bundled extensions |
 | `packages/` | Workspace packages used by the CLI, agent, TUI, RPC, and native bridge |
+| `apps/` | Standalone native apps, such as the GSD Cloud Monitor menu bar app |
 | `native/` | Native engine packaging and platform binaries |
 | `studio/` | Desktop studio app |
 | `web/` | Web UI and API surface |

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-b54acda1c11b5a17
+d05c1e678c1d85d7

package/dist/resources/extensions/gsd/auto/loop.js

@@ -261,7 +261,22 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-function closeOutCrashedUnit(s, iterData, err) {
+async function snapshotCrashedUnitWork(ctx, s, deps, iterData) {
+    try {
+        const commitMsg = await deps.autoCommitUnit?.(s.basePath, iterData.unitType, iterData.unitId, ctx);
+        if (commitMsg) {
+            debugLog("autoLoop", {
+                phase: "crash-snapshot-commit",
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+        }
+    }
+    catch (snapshotErr) {
+        logWarning("dispatch", `unit crash snapshot failed: ${snapshotErr instanceof Error ? snapshotErr.message : String(snapshotErr)}`);
+    }
+}
+async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -278,6 +293,7 @@ function closeOutCrashedUnit(s, iterData, err) {
     catch (closeoutErr) {
         logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
     }
+    await snapshotCrashedUnitWork(ctx, s, deps, iterData);
 }
 /**
  * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
@@ -400,11 +416,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: Boolean(s.cmdCtx),
+            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
             sessionLockValid: true,
         });
         if (commandContextDecision.action === "stop" && commandContextDecision.reason === "missing-command-context") {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            if (s.currentUnit) {
+                await deps.autoCommitUnit?.(s.basePath, s.currentUnit.type, s.currentUnit.id, ctx);
+            }
+            await deps.stopAuto(ctx, pi, commandContextDecision.message, { preserveWorktree: true });
             finishTurn("stopped", "manual-attention", commandContextDecision.reason);
             break;
         }
@@ -586,7 +606,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    closeOutCrashedUnit(s, iterData, err);
+                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1109,7 +1129,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                closeOutCrashedUnit(s, iterData, err);
+                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -58,6 +58,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
+    const cmdCtx = s.cmdCtx;
+    if (typeof cmdCtx?.newSession !== "function") {
+        const msg = "command context is missing newSession";
+        debugLog("runUnit", {
+            phase: "session-error",
+            unitType,
+            unitId,
+            error: msg,
+        });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: `Session creation failed: ${msg}`,
+                category: "session-failed",
+                isTransient: false,
+            },
+        };
+    }
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
@@ -67,7 +85,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({
+        const sessionPromise = cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -314,6 +314,7 @@ const THINKING_LEVEL_ORDER = [
     "medium",
     "high",
     "xhigh",
+    "max",
 ];
 /**
  * Minimum reasoning level for code-writing units.

package/dist/resources/extensions/gsd/auto-start.js

@@ -46,9 +46,10 @@ import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.
 import { extractVerdict } from "./verdict-parser.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readFileSync, rmSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, } from "node:fs";
 import { join } from "node:path";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
@@ -73,6 +74,30 @@ const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
 export function hasGitIndexLockForTest(basePath) {
     return existsSync(join(basePath, ".git", "index.lock"));
 }
+function isEmptyDirectory(dirPath) {
+    try {
+        return existsSync(dirPath) && readdirSync(dirPath).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function reconcileFlatPhaseBootstrapLayout(basePath) {
+    const gsdDir = join(basePath, ".gsd");
+    const phasesPath = join(gsdDir, LAYOUT_SEGMENTS.level1);
+    const milestonesPath = join(gsdDir, "milestones");
+    if (isEmptyDirectory(milestonesPath)) {
+        if (!existsSync(phasesPath))
+            mkdirSync(phasesPath, { recursive: true });
+        rmSync(milestonesPath, { recursive: true, force: true });
+        return true;
+    }
+    if (!existsSync(phasesPath) && !existsSync(milestonesPath)) {
+        mkdirSync(phasesPath, { recursive: true });
+        return true;
+    }
+    return false;
+}
 export function _shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, dbAvailable, pathExists = existsSync) {
     return pathExists(gsdDbPath) && !dbAvailable;
 }
@@ -796,7 +821,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     // provider the user is not logged into and surface as "Not logged in · Please
     // run /login" before pausing and resetting to claude-code/claude-sonnet-4-6.
     const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
-    const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
+    const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider, ctx.modelRegistry);
     const profileModelIds = modelIdsForProfileResolution(ctx.modelRegistry, resolveProfileAnchorProvider(ctx.model?.provider), resolveDisabledModelProvidersFromPreferences());
     const preferredModel = sessionProviderIsCustom
         ? null
@@ -868,20 +893,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
             untrackRuntimeFiles(base);
-        // Bootstrap milestones/ if it doesn't exist.
-        // Check milestones/ directly — ensureGsdSymlink above already created .gsd/,
-        // so checking .gsd/ existence would be dead code (#2942).
-        const gsdDir = join(base, ".gsd");
-        const milestonesPath = join(gsdDir, "milestones");
-        if (!existsSync(milestonesPath)) {
-            mkdirSync(milestonesPath, { recursive: true });
+        // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
+        if (reconcileFlatPhaseBootstrapLayout(base)) {
             try {
                 nativeAddAll(base);
                 nativeCommit(base, "chore: init gsd");
             }
             catch (err) {
                 /* nothing to commit */
-                logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
+                logWarning("engine", `layout bootstrap commit failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         {

package/dist/resources/extensions/gsd/auto-verification.js

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { relMilestoneFile, resolveSlicePath } from "./paths.js";
+import { legacyMilestonesDir, relMilestoneFile, resolveMilestonePath, resolveSlicePath } from "./paths.js";
 import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
@@ -24,6 +24,20 @@ import { getLedger } from "./metrics.js";
 import { getUnitCostSpikeAction, resolveUnitCostSpikeMultiplier } from "./auto-budget.js";
 import { formatPostUnitStatusCard } from "./auto-status-message.js";
 import { detectWebApp } from "./web-app-uat.js";
+function resolveVerificationEvidenceLocation(basePath, milestoneId, sliceId) {
+    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) {
     const ledger = getLedger();
     if (!ledger || !Array.isArray(ledger.units) || ledger.units.length === 0) {
@@ -431,11 +445,10 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         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;
@@ -444,7 +457,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                             verdict.retryable &&
                             autoFixEnabled &&
                             nextAttempt <= maxRetries;
-                        writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id, includeRetryMetadata ? nextAttempt : undefined, includeRetryMetadata ? maxRetries : undefined);
+                        writeVerificationJSON(result, evidenceLocation.dir, tid, s.currentUnit.id, includeRetryMetadata ? nextAttempt : undefined, includeRetryMetadata ? maxRetries : undefined, evidenceLocation.fileSliceId);
                     }
                 }
             }
@@ -560,9 +573,8 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         // 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,
@@ -570,7 +582,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                         passed: result.passed && !postExecBlockingFailure,
                     };
                     // Manually write with postExecutionChecks field
-                    writeVerificationJSONWithPostExec(resultWithPostExec, tasksDir, tid, s.currentUnit.id, postExecChecks, postExecBlockingFailure ? attempt + 1 : undefined, postExecBlockingFailure ? maxRetries : undefined);
+                    writeVerificationJSONWithPostExec(resultWithPostExec, evidenceLocation.dir, tid, s.currentUnit.id, postExecChecks, postExecBlockingFailure ? attempt + 1 : undefined, postExecBlockingFailure ? maxRetries : undefined, evidenceLocation.fileSliceId);
                 }
             }
             catch (evidenceErr) {
@@ -738,7 +750,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
  * Write verification evidence JSON with post-execution checks included.
  * This is a variant of writeVerificationJSON that adds the postExecutionChecks field.
  */
-function writeVerificationJSONWithPostExec(result, tasksDir, taskId, unitId, postExecutionChecks, retryAttempt, maxRetries) {
+function writeVerificationJSONWithPostExec(result, tasksDir, taskId, unitId, postExecutionChecks, retryAttempt, maxRetries, sliceId) {
     mkdirSync(tasksDir, { recursive: true });
     const evidence = {
         schemaVersion: 1,
@@ -774,6 +786,7 @@ function writeVerificationJSONWithPostExec(result, tasksDir, taskId, unitId, pos
             fixAvailable: w.fixAvailable,
         }));
     }
-    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/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -5,7 +5,7 @@
 import { cpSync, existsSync, lstatSync as lstatSyncFn, mkdirSync, readdirSync, } from "node:fs";
 import { join } from "node:path";
 import { _isSamePath as isSamePath, } from "./auto-worktree-cleanup.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
@@ -143,10 +143,14 @@ function syncMilestoneLayout(mainGsd, wtGsd, layoutSegment, synced) {
     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(mainMilestonesDir, wtMilestonesDir, milestoneId, synced);
         }

package/dist/resources/extensions/gsd/auto.js

@@ -2440,7 +2440,18 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         startedAt: hookStartedAt,
         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/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -5,7 +5,7 @@ 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 } from "../unit-context-manifest.js";
 import { allowedPlanningDispatchAgentsList, isReadOnlyPlanningDispatchAgent, } from "../planning-subagent-registry.js";
 import { logWarning } from "../workflow-logger.js";
@@ -1118,6 +1118,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             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.
@@ -1131,9 +1132,9 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             if (requested.length === 0) {
                 return { block: false };
             }
-            const globallyDisallowed = requested.find(a => !isReadOnlyPlanningDispatchAgent(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`);
+                return planningBlock(unitType, policy.mode, `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));
             if (disallowedByPolicy) {

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -124,11 +124,11 @@ Diagnostics record the file path, scope (global/project), severity (error/warnin
   - `validation` — used for gate evaluation, roadmap reassessment, milestone validation, and doc rewrites. Falls back to `planning` if unset.
   - `uat` — used for UAT runs. Falls back to `completion` if unset.
 
-- `thinking`: per-phase reasoning effort (ADR-026), separate from `models`. Same phase keys as `models`. Values: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`. Thinking travels with the model — model choice and reasoning effort are independent controls, so you can run one model across phases at different reasoning levels.
+- `thinking`: per-phase reasoning effort (ADR-026), separate from `models`. Same phase keys as `models`. Values: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Thinking travels with the model — model choice and reasoning effort are independent controls, so you can run one model across phases at different reasoning levels.
   - Two equivalent ways to set it: inline as `models.<phase>.thinking`, or as a separate `thinking:` block keyed by phase. For the same phase, the inline value wins over the block; project preferences win over global; a phase that's unset inherits via the same sibling chain as `models` (e.g. `discuss → planning`).
   - If no thinking is configured for a phase, the session level (set via `/model`) is used, exactly as before — this is fully backward-compatible.
   - `execute-task` (code-writing) has a measured reasoning floor of `medium`: at lower levels models stop planning edits and thrash on file re-reads. The floor applies to the session/default path. An **explicit** `execution` thinking level bypasses the floor and is honored verbatim (with a one-time advisory) — set `execution: low` deliberately if you want it.
-  - Levels a model can't support are clamped to the nearest supported level at dispatch and never sent to the provider, so a model/level mismatch never fails a unit mid-run. `xhigh` support is model-dependent; current examples include OpenAI Codex Max models and Claude Sonnet 5 on Amazon Bedrock.
+  - Levels a model can't support are clamped to the nearest supported level at dispatch and never sent to the provider, so a model/level mismatch never fails a unit mid-run. `xhigh` and `max` support are model-dependent; current examples include `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`, which advertise both.
 
 - `skill_staleness_days`: number — skills unused for this many days get deprioritized during discovery. Set to `0` to disable staleness tracking. Default: `60`.
 
@@ -357,24 +357,33 @@ In `"parent"` mode, slice/task `targetRepositories` default to the declared chil
   - `"replace"` requires `prompt`.
   - `"skip"` is valid with no additional fields.
 
+- `planning_subagent_registry`: object — optional classification for custom planning agents. Each key is an agent id and must set:
+  - `read_only_specialist`: boolean — set to `true` to classify the custom agent as safe for planning dispatch.
+
 - `planning_subagents`: object — project-local widening for read-only planning subagent dispatch. Supported unit keys are `plan-milestone` and `plan-slice`; each has:
   - `allowed`: string[] — additional planning-safe agents for that unit.
 
-  Agents must already be classified by GSD as read-only planning specialists: `mnemo`, `scout`, `planner`, `reviewer`, `security`, or `tester`. The write gate still blocks source writes outside `.gsd/**`, unrestricted bash, stale subagent calls without agent identities, agents outside the global read-only registry, and agents not listed for the active unit.
+  Agents must be built-in read-only planning specialists (`mnemo`, `scout`, `planner`, `reviewer`, `security`, or `tester`) or registered in `planning_subagent_registry` with `read_only_specialist: true`. The write gate still blocks source writes outside `.gsd/**`, unrestricted bash, stale subagent calls without agent identities, agents outside the read-only registry, and agents not listed for the active unit.
 
   Example:
 
   ```yaml
+  planning_subagent_registry:
+    my-custom-planner:
+      read_only_specialist: true
+
   planning_subagents:
     plan-milestone:
       allowed:
         - scout
         - planner
+        - my-custom-planner
         - security
     plan-slice:
       allowed:
         - scout
         - planner
+        - my-custom-planner
         - reviewer
         - security
   ```

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -13,6 +13,7 @@ import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { parsePlan } from "./parsers-legacy.js";
 import { parseSummary } from "./files.js";
 import { LAYOUT_SEGMENTS } from "./layout-policy.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 const USER_AUTHORED_ARTIFACT_TYPES = new Set(["CONTEXT", "RESEARCH"]);
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -58,9 +59,27 @@ function reportCheckboxDbStatusDivergence(issues, basePath, filePath, scope, uni
         fixable: false,
     });
 }
+function bareDuplicateMilestoneId(milestoneId) {
+    const match = milestoneId.match(/^(M\d{3})-[a-z0-9]{6}$/i);
+    return match?.[1]?.toUpperCase() ?? null;
+}
+function checkboxDbStatusMilestoneIds(basePath, milestoneIds) {
+    if (!hasFlatPhaseLayout(basePath))
+        return milestoneIds;
+    // Flat-phase directories are keyed by phase number. A restored
+    // M003-xxxxxx row alongside M003 is a stale duplicate for the same
+    // phases/03-* projection, so checking both can compare DB status against two
+    // competing PLAN files and report a persistent false divergence.
+    const allIds = new Set(milestoneIds.map((id) => id.toUpperCase()));
+    return milestoneIds.filter((milestoneId) => {
+        const bareId = bareDuplicateMilestoneId(milestoneId);
+        return !bareId || !allIds.has(bareId);
+    });
+}
 function checkProjectionCheckboxDbStatus(basePath, milestoneIds, issues) {
     for (const milestoneId of milestoneIds) {
-        const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+        const roadmapPath = resolveMilestoneFile(artifactBasePath, milestoneId, "ROADMAP");
         const slices = getMilestoneSlices(milestoneId);
         if (roadmapPath && existsSync(roadmapPath)) {
             try {
@@ -78,7 +97,7 @@ function checkProjectionCheckboxDbStatus(basePath, milestoneIds, issues) {
             }
         }
         for (const slice of slices) {
-            const planPath = resolveSliceFile(basePath, milestoneId, slice.id, "PLAN");
+            const planPath = resolveSliceFile(artifactBasePath, milestoneId, slice.id, "PLAN");
             if (!planPath || !existsSync(planPath))
                 continue;
             try {
@@ -117,7 +136,7 @@ function isClearedByMilestoneShellProjectionFlush(basePath, issue, reRenderedMil
 function artifactExistsOnDisk(basePath, artifactPath, row) {
     return resolveArtifactDiskPath(basePath, artifactPath, row) !== null;
 }
-function resolveLiteralArtifactDiskPath(basePath, artifactPath) {
+function resolveLiteralArtifactDiskPath(basePath, artifactPath, row) {
     const relativeArtifactPath = artifactPathRelativeToGsd(artifactPath);
     if (isAbsolute(relativeArtifactPath)) {
         return existsSync(relativeArtifactPath) ? relativeArtifactPath : null;
@@ -127,6 +146,16 @@ function resolveLiteralArtifactDiskPath(basePath, artifactPath) {
         if (isPathInside(root, candidate) && existsSync(candidate))
             return candidate;
     }
+    if (row?.milestone_id) {
+        const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, row.milestone_id);
+        if (artifactBasePath !== basePath) {
+            for (const root of [gsdProjectionRoot(artifactBasePath), gsdRoot(artifactBasePath)]) {
+                const candidate = join(root, relativeArtifactPath);
+                if (isPathInside(root, candidate) && existsSync(candidate))
+                    return candidate;
+            }
+        }
+    }
     return null;
 }
 function relativeToGsdRoot(basePath, diskPath) {
@@ -166,7 +195,7 @@ function resolveArtifactDiskPath(basePath, artifactPath, row) {
         if (flatPath)
             return flatPath;
     }
-    return resolveLiteralArtifactDiskPath(basePath, artifactPath);
+    return resolveLiteralArtifactDiskPath(basePath, artifactPath, row);
 }
 function taskExistsInPlan(basePath, milestoneId, sliceId, taskId) {
     const planPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
@@ -322,7 +351,9 @@ function staleMilestonesArtifactRowFixable(basePath, row, artifactRows) {
 }
 function stalePhasesArtifactRowFixable(basePath, row, artifactRows) {
     const issuePath = artifactPathRelativeToGsd(row.path);
-    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) && hasPresentMilestonesReplacement(basePath, row, artifactRows);
+    return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) &&
+        (hasPresentFlatPhaseReplacement(basePath, row, artifactRows) ||
+            hasPresentMilestonesReplacement(basePath, row, artifactRows));
 }
 function staleArtifactRowFixable(basePath, row, artifactRows) {
     return staleMilestonesArtifactRowFixable(basePath, row, artifactRows) ||
@@ -658,7 +689,7 @@ export async function checkEngineHealth(basePath, issues, fixesApplied, options)
     // block doctor.
     try {
         if (isDbAvailable()) {
-            checkProjectionCheckboxDbStatus(basePath, getAllMilestones().map((milestone) => milestone.id), issues);
+            checkProjectionCheckboxDbStatus(basePath, checkboxDbStatusMilestoneIds(basePath, getAllMilestones().map((milestone) => milestone.id)), issues);
         }
     }
     catch {

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -130,6 +130,17 @@ function isInsideFlatProjectionBackup(backupDir, src) {
     const phaseBackupDir = join(backupDir, "__phases");
     return src === phaseBackupDir || src.startsWith(`${phaseBackupDir}/`) || src.startsWith(`${phaseBackupDir}\\`);
 }
+function removeFlatProjectionBackup(backupDir) {
+    const phaseBackupDir = join(backupDir, "__phases");
+    if (!existsSync(phaseBackupDir))
+        return;
+    try {
+        removePathWithRetries(phaseBackupDir);
+    }
+    catch (err) {
+        logWarning("migration", `flat-phase migration succeeded but could not remove temporary ${LAYOUT_SEGMENTS.level1}/ backup: ${err.message}`);
+    }
+}
 function restoreFlatProjectionFromBackup(basePath, backupDir) {
     const phaseBackupDir = join(backupDir, "__phases");
     if (!existsSync(phaseBackupDir))
@@ -433,4 +444,5 @@ export async function migrateToFlatPhase(basePath) {
     catch (err) {
         logWarning("migration", `flat-phase migration succeeded but could not remove ${LEGACY_MIGRATING_SEGMENT}: ${err.message}`);
     }
+    removeFlatProjectionBackup(backupDir);
 }