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

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

@@ -24,36 +24,35 @@ export const CACHE_MAX = 50;
  * By scoping tools to this allowlist during discuss dispatches, the grammar
  * sent to the provider stays well under provider limits.
  *
- * Included tools and why:
+ * Included tools and why (canonical names only — aliases are no longer
+ * advertised to models by default, see plan 035):
  *   - gsd_summary_save: writes CONTEXT.md artifacts (all discuss prompts)
- *   - gsd_save_summary: alias for above
  *   - gsd_decision_save: records decisions (discuss.md output phase)
- *   - gsd_save_decision: alias for above
  *   - gsd_plan_milestone: writes roadmap (discuss.md single/multi milestone)
- *   - gsd_milestone_plan: alias for above
  *   - gsd_milestone_generate_id: generates milestone IDs (discuss.md multi-milestone)
- *   - gsd_generate_milestone_id: alias for above
  *   - gsd_requirement_save: creates requirements during discuss
- *   - gsd_save_requirement: alias for above
  *   - gsd_requirement_update: updates requirements during discuss
- *   - gsd_update_requirement: alias for above
  */
 export const DISCUSS_TOOLS_ALLOWLIST = [
     // Context / summary writing
     "gsd_summary_save",
-    "gsd_save_summary",
     // Decision recording
     "gsd_decision_save",
-    "gsd_save_decision",
     // Milestone planning (needed for discuss.md output phase)
     "gsd_plan_milestone",
-    "gsd_milestone_plan",
     // Milestone ID generation (multi-milestone flow)
     "gsd_milestone_generate_id",
-    "gsd_generate_milestone_id",
     // Requirement updates
     "gsd_requirement_save",
-    "gsd_save_requirement",
     "gsd_requirement_update",
-    "gsd_update_requirement",
 ];
+// ─── Context Injection ────────────────────────────────────────────────────────
+/**
+ * Leading marker stamped on every buildContextMessage() output
+ * (bootstrap/system-context.ts). Single source of truth for the producer and
+ * the consumer: the provider payload policy (filterSupersededContextInjections
+ * in context-masker.ts) matches this prefix to find and dedupe injected
+ * memory/guided/forensics messages after convertToLlm strips their customType.
+ * Both sides import it from here — do not inline the literal in either module.
+ */
+export const GSD_CONTEXT_MESSAGE_SENTINEL = "[GSD Context Injection]";

package/dist/resources/extensions/gsd/context-masker.js

@@ -1,22 +1,4 @@
-/**
- * Observation masking for GSD auto-mode sessions.
- *
- * Replaces tool result content older than N turns with a placeholder.
- * Reduces context bloat between compactions with zero LLM overhead.
- * Preserves message ordering, roles, and all assistant/user messages.
- *
- * Operates on provider payloads after convertToLlm:
- *
- * pi-ai Message[] payloads:
- *   - toolResult messages: { role: "toolResult", content: TextContent[] }
- *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
- *     and start with "Ran `" from bashExecutionToText.
- *
- * OpenAI/Codex Responses payloads:
- *   - conversation items live in `input`, not `messages`
- *   - tool results are { type: "function_call_output", output: string | content[] }
- *   - bash results are user items with input_text content starting with "Ran `"
- */
+import { GSD_CONTEXT_MESSAGE_SENTINEL } from "./constants.js";
 const MASK_PLACEHOLDER = "[result masked — within summarized history]";
 const MASK_CONTENT_BLOCK = [{ type: "text", text: MASK_PLACEHOLDER }];
 const RESPONSES_MASK_CONTENT_BLOCK = [{ type: "input_text", text: MASK_PLACEHOLDER }];
@@ -52,6 +34,26 @@ function findTurnBoundary(messages, keepRecentTurns) {
     }
     return 0;
 }
+function countRealUserTurns(messages) {
+    let count = 0;
+    for (const m of messages) {
+        if (m.role === "user" && !isBashResultUserMessage(m))
+            count++;
+    }
+    return count;
+}
+/**
+ * Quantizes how many recent turns stay unmasked so the boundary only moves
+ * forward once per full block of `keepRecentTurns` new turns, instead of
+ * every turn. Keeps the masked prefix byte-stable within a block, which is
+ * what lets the LLM provider's prompt cache survive across turns.
+ */
+function quantizedKeepTurns(totalTurns, keepRecentTurns) {
+    if (keepRecentTurns <= 0 || totalTurns < 2 * keepRecentTurns)
+        return totalTurns;
+    const maskedTurns = Math.floor((totalTurns - keepRecentTurns) / keepRecentTurns) * keepRecentTurns;
+    return totalTurns - maskedTurns;
+}
 /**
  * Detect user messages that originated from bashExecution.
  * After convertToLlm, these are {role: "user", content: [{type:"text", text:"Ran `cmd`\n..."}]}.
@@ -73,7 +75,8 @@ function isMaskableMessage(m) {
 }
 export function createObservationMask(keepRecentTurns = 8) {
     return (messages) => {
-        const boundary = findTurnBoundary(messages, keepRecentTurns);
+        const totalTurns = countRealUserTurns(messages);
+        const boundary = findTurnBoundary(messages, quantizedKeepTurns(totalTurns, keepRecentTurns));
         if (boundary === 0)
             return messages;
         return messages.map((m, i) => {
@@ -104,6 +107,14 @@ function findResponsesTurnBoundary(items, keepRecentTurns) {
     }
     return 0;
 }
+function countResponsesRealUserTurns(items) {
+    let count = 0;
+    for (const item of items) {
+        if (item.role === "user" && !isResponsesBashResultUserItem(item))
+            count++;
+    }
+    return count;
+}
 /**
  * Observation masking for OpenAI/Codex Responses API payloads.
  *
@@ -113,7 +124,8 @@ function findResponsesTurnBoundary(items, keepRecentTurns) {
  */
 export function createResponsesInputObservationMask(keepRecentTurns = 8) {
     return (items) => {
-        const boundary = findResponsesTurnBoundary(items, keepRecentTurns);
+        const totalTurns = countResponsesRealUserTurns(items);
+        const boundary = findResponsesTurnBoundary(items, quantizedKeepTurns(totalTurns, keepRecentTurns));
         if (boundary === 0)
             return items;
         return items.map((item, i) => {
@@ -190,3 +202,67 @@ export function truncateResponsesInputResultItems(items, maxChars = 800) {
         return item;
     });
 }
+// GSD injects at most one context message per turn (memory/guided/forensics —
+// see buildContextMessage in bootstrap/system-context.ts), marked with
+// GSD_CONTEXT_MESSAGE_SENTINEL. convertToLlm strips the distinguishing
+// customType before the payload reaches this hook, so detection is by content
+// prefix instead. Pre-sentinel session history lacks the sentinel, so we also
+// match the stable *bracketed* GSD block labels those injections begin with,
+// letting resumed sessions dedupe older memory/guided blocks.
+//
+// Only GSD-specific bracketed markers belong here — never generic prose. A
+// message is dropped from the payload when it matches, so a natural-language
+// prefix (e.g. the forensics prompt "Debug GSD itself.") could silently delete
+// a real user message that happens to start the same way. Legacy forensics
+// injections without memory are therefore left un-deduped by design; those
+// with memory still match via the "[GSD Context Metadata]" wrapper.
+const LEGACY_GSD_CONTEXT_INJECTION_PREFIXES = [
+    "[GSD Context Metadata]",
+    "[MEMORY — Critical and prompt-relevant memories from the GSD memory store]",
+    "[GSD Guided Execute Context]",
+];
+function isGsdContextInjectionText(text) {
+    if (typeof text !== "string")
+        return false;
+    if (text.startsWith(GSD_CONTEXT_MESSAGE_SENTINEL))
+        return true;
+    return LEGACY_GSD_CONTEXT_INJECTION_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function isGsdContextInjectionMessage(m) {
+    if (m.role !== "user")
+        return false;
+    return isGsdContextInjectionText(firstTextFromContent(m.content));
+}
+/**
+ * Removes every GSD context-injection user message except the latest one.
+ * Each turn re-injects a near-identical memory/guided/forensics block; left
+ * in place they duplicate verbatim across an N-turn session. Removal (not
+ * masking) — an empty placeholder still costs tokens and shifts message
+ * positions, breaking cache byte-stability. Pure function: stored history is
+ * never mutated, only the outgoing payload array.
+ */
+export function filterSupersededContextInjections(messages) {
+    let lastIndex = -1;
+    for (let i = 0; i < messages.length; i++) {
+        if (isGsdContextInjectionMessage(messages[i]))
+            lastIndex = i;
+    }
+    if (lastIndex === -1)
+        return messages;
+    return messages.filter((m, i) => i === lastIndex || !isGsdContextInjectionMessage(m));
+}
+function isResponsesGsdContextInjectionItem(item) {
+    if (item.role !== "user")
+        return false;
+    return isGsdContextInjectionText(firstTextFromContent(item.content));
+}
+export function filterSupersededResponsesContextInjections(items) {
+    let lastIndex = -1;
+    for (let i = 0; i < items.length; i++) {
+        if (isResponsesGsdContextInjectionItem(items[i]))
+            lastIndex = i;
+    }
+    if (lastIndex === -1)
+        return items;
+    return items.filter((item, i) => i === lastIndex || !isResponsesGsdContextInjectionItem(item));
+}

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

@@ -357,6 +357,28 @@ In `"parent"` mode, slice/task `targetRepositories` default to the declared chil
   - `"replace"` requires `prompt`.
   - `"skip"` is valid with no additional fields.
 
+- `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.
+
+  Example:
+
+  ```yaml
+  planning_subagents:
+    plan-milestone:
+      allowed:
+        - scout
+        - planner
+        - security
+    plan-slice:
+      allowed:
+        - scout
+        - planner
+        - reviewer
+        - security
+  ```
+
   **Known unit types for `before`/`after`:** `research-milestone`, `plan-milestone`, `research-slice`, `plan-slice`, `execute-task`, `complete-slice`, `replan-slice`, `reassess-roadmap`, `run-uat`.
 
 - `experimental`: opt-in experimental features. All features here are **off by default** — you must explicitly set each one to `true` to enable it. Features in this block may change or be removed without a deprecation cycle while in experimental status. Keys:

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

@@ -3,7 +3,7 @@ import { isAbsolute, join, relative, sep } from "node:path";
 import { deleteArtifactByPath, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, isMemoriesFtsAvailable, repairTaskCompletionFromSummary, _getAdapter, } from "./gsd-db.js";
 import { MEMORIES_FTS_REBUILT_KEY } from "./db-memory-fts-schema.js";
 import { isAfter, latestExplicitReopenAt } from "./milestone-reopen-events.js";
-import { buildTaskFileName, gsdProjectionRoot, gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, } from "./paths.js";
+import { gsdProjectionRoot, gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { deriveState } from "./state.js";
 import { isClosedStatus } from "./status-guards.js";
 import { workflowEventLogPath } from "./workflow-event-ledger.js";
@@ -152,11 +152,8 @@ function resolveFlatPhaseArtifactDiskPath(basePath, row) {
     if (!artifactType)
         return null;
     if (row.slice_id && row.task_id) {
-        const phaseDir = resolveMilestonePath(basePath, row.milestone_id);
-        if (!phaseDir || !isFlatPhaseDiskPath(basePath, phaseDir))
-            return null;
-        const candidate = join(phaseDir, buildTaskFileName(row.task_id, artifactType));
-        return existsSync(candidate) ? candidate : null;
+        const candidate = resolveTaskFile(basePath, row.milestone_id, row.slice_id, row.task_id, artifactType);
+        return candidate && isFlatPhaseDiskPath(basePath, candidate) ? candidate : null;
     }
     const candidate = row.slice_id
         ? resolveSliceFile(basePath, row.milestone_id, row.slice_id, artifactType)

package/dist/resources/extensions/gsd/git-service.js

@@ -229,10 +229,15 @@ export const RUNTIME_EXCLUSION_PATHS = [
 const runtimeFilesCleanedUpRepos = new Set();
 // ─── Integration Branch Metadata ───────────────────────────────────────────
 /**
- * Path to the milestone metadata file that stores the integration branch.
- * Format: .gsd/milestones/<MID>/<MID>-META.json
+ * Path to the milestone integration-branch metadata file.
+ * Format: .gsd/<MID>-META.json  (deliberately OUTSIDE milestones/<MID>/ so it
+ * cannot poison isLegacyMilestonesLayout — see ADR-045).
  */
-function milestoneMetaPath(basePath, milestoneId) {
+export function milestoneMetaPath(basePath, milestoneId) {
+    return join(gsdRoot(basePath), `${milestoneId}-META.json`);
+}
+/** Legacy location (pre-ADR-045). Read-only fallback for existing on-disk trees. */
+function legacyMilestoneMetaPath(basePath, milestoneId) {
     return join(gsdRoot(basePath), "milestones", milestoneId, `${milestoneId}-META.json`);
 }
 /**
@@ -241,9 +246,13 @@ function milestoneMetaPath(basePath, milestoneId) {
  */
 export function readIntegrationBranch(basePath, milestoneId) {
     try {
-        const metaFile = milestoneMetaPath(basePath, milestoneId);
-        if (!existsSync(metaFile))
-            return null;
+        let metaFile = milestoneMetaPath(basePath, milestoneId);
+        if (!existsSync(metaFile)) {
+            const legacy = legacyMilestoneMetaPath(basePath, milestoneId);
+            if (!existsSync(legacy))
+                return null;
+            metaFile = legacy;
+        }
         const data = JSON.parse(readFileSync(metaFile, "utf-8"));
         const branch = data?.integrationBranch;
         if (typeof branch === "string" && branch.trim() !== "" && VALID_BRANCH_NAME.test(branch)) {
@@ -295,7 +304,10 @@ export function writeIntegrationBranch(basePath, milestoneId, branch) {
     if (existingBranch === branch)
         return;
     const metaFile = milestoneMetaPath(basePath, milestoneId);
-    mkdirSync(join(gsdRoot(basePath), "milestones", milestoneId), { recursive: true });
+    // Ensure the flat .gsd/ root exists (never milestones/<MID>/ — that would
+    // poison layout detection, ADR-045). In production .gsd/ already exists; this
+    // guards fresh trees so the write below can't ENOENT.
+    mkdirSync(gsdRoot(basePath), { recursive: true });
     // Merge with existing metadata if present
     let existing = {};
     try {

package/dist/resources/extensions/gsd/guided-flow.js

@@ -11,7 +11,7 @@ import { loadFile, saveFile } from "./files.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices } from "./gsd-db.js";
 import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, } from "./auto-prompts.js";
+import { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, capPreamble, } from "./auto-prompts.js";
 import { deriveState, isGhostMilestone } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAutoDetached } from "./auto.js";
@@ -855,7 +855,9 @@ function resolveDiscussSliceBasePath(basePath, milestoneId) {
  * slice summaries so the agent can ask grounded UX/behaviour questions
  * without wasting a turn reading files.
  */
-async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
+// Exported for tests (`prompt-budget-enforcement.test.ts`) — verifies the
+// inlined-context cap. Not part of the public flow surface otherwise.
+export async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
     const inlined = [];
     // Roadmap — always included so the agent sees surrounding slices
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -906,8 +908,12 @@ async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
             }
         }
     }
+    // Cap the inlined block: it grows unbounded with each completed slice's full
+    // SUMMARY. `capPreamble` truncates at `### ` section boundaries — roadmap and
+    // milestone context come first (survive), completed-slice summaries come last
+    // (dropped first) when the executor's window can't hold everything.
     const inlinedContext = inlined.length > 0
-        ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
+        ? capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`)
         : `## Inlined Context\n\n_(no context files found yet — go in blind and ask broad questions)_`;
     const sliceDirPath = `.gsd/milestones/${mid}/slices/${sid}`;
     const sliceContextPath = `${sliceDirPath}/${sid}-CONTEXT.md`;

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -13,7 +13,7 @@ import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
 import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
-import { resolveDir, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
+import { resolveDir, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, targetTaskFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
@@ -612,17 +612,7 @@ export async function renderTaskSummary(basePath, milestoneId, sliceId, taskId)
     if (!task || !task.full_summary_md) {
         return false; // No summary to render — skip silently
     }
-    // Resolve the tasks directory, creating path if needed
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-    if (!slicePath) {
-        process.stderr.write(`markdown-renderer: cannot resolve slice path for ${milestoneId}/${sliceId}\n`);
-        return false;
-    }
-    // Use the tasks/ subdir when it exists (legacy layout), otherwise use the
-    // slice path directly (flat-phase: task summaries live alongside plan files).
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId) ?? slicePath;
-    const fileName = buildTaskFileName(taskId, "SUMMARY");
-    const absPath = join(tasksDir, fileName);
+    const absPath = targetTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title);
     const artifactPath = toArtifactPath(absPath, basePath);
     await writeAndStore(absPath, artifactPath, task.full_summary_md, {
         artifact_type: "SUMMARY",

package/dist/resources/extensions/gsd/md-importer.js

@@ -7,7 +7,7 @@ import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
 import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, transaction, updateMilestoneStatus, updateSliceStatus, getMilestoneSlices, getSliceTasks, _getAdapter, } from './gsd-db.js';
 import { openWorkflowDatabasePath } from './db-workspace.js';
-import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveMilestonePath, } from './paths.js';
+import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveTaskFile, resolveMilestonePath, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
 import { milestoneIdToPhaseNum } from './layout-policy.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
@@ -762,8 +762,7 @@ export function migrateHierarchyToDb(basePath, opts) {
                     legacyTasksDir = isLegacySlice
                         ? resolveTasksDir(basePath, milestoneId, sliceEntry.id)
                         : null;
-                    const summaryDir = legacyTasksDir ?? slicePath;
-                    taskSummaryFile = join(summaryDir, `${taskEntry.id}-SUMMARY.md`);
+                    taskSummaryFile = resolveTaskFile(basePath, milestoneId, sliceEntry.id, taskEntry.id, 'SUMMARY');
                 }
                 const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
                 // Pre-migration consistency (legacy tasks/ layout only): if a task is
@@ -783,9 +782,9 @@ export function migrateHierarchyToDb(basePath, opts) {
                 // first execute-task. The surviving SUMMARY wins over a stale checkbox.
                 // reopen-task removes the SUMMARY, so this never re-completes an
                 // intentionally reopened task.
-                // Flat-phase summaries are phase-scoped (T01-SUMMARY.md); when a milestone
-                // has multiple slices, require the summary parent frontmatter to match so
-                // one slice's completion does not attest a sibling's same-named task.
+                // Flat-phase summaries are phase-scoped; when a milestone has multiple
+                // slices, require the summary parent frontmatter to match so one slice's
+                // completion does not attest a sibling's same-named task.
                 let summaryAttestsCompletion = hasTaskSummary;
                 if (summaryAttestsCompletion && !isLegacySlice && roadmap.slices.length > 1 && taskSummaryFile) {
                     try {

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -48,6 +48,8 @@ export const BUNDLED_COST_TABLE = [
     // GPT-5.5 API list price, also used for live Codex OAuth routing.
     // Source: https://openai.com/api/pricing/
     { id: "gpt-5.5", inputPer1k: 0.005, outputPer1k: 0.03, updatedAt: "2026-04-23" },
+    // Mirrors gpt-5.5 list pricing until OpenAI publishes official gpt-5.6 pricing.
+    { id: "gpt-5.6", inputPer1k: 0.005, outputPer1k: 0.03, updatedAt: "2026-07-08" },
     // Google
     { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
     { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },

package/dist/resources/extensions/gsd/model-router.js

@@ -46,10 +46,12 @@ export const MODEL_CAPABILITY_TIER = {
     "gpt-5.3-codex": "heavy",
     "gpt-5.4": "heavy",
     "gpt-5.5": "heavy",
+    "gpt-5.6": "heavy",
     "o1": "heavy",
     "o3": "heavy",
     "o4-mini": "heavy",
     "o4-mini-deep-research": "heavy",
+    "grok-4.5": "heavy",
 };
 // ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
 // Used for cross-provider cost comparison when multiple providers offer
@@ -82,11 +84,13 @@ const MODEL_COST_PER_1K_INPUT = {
     "gpt-5.3-codex-spark": 0.0003,
     "gpt-5.4": 0.005,
     "gpt-5.5": 0.005,
+    "gpt-5.6": 0.005,
     "o4-mini": 0.005,
     "o4-mini-deep-research": 0.005,
     "gemini-2.0-flash": 0.0001,
     "gemini-2.5-pro": 0.00125,
     "deepseek-chat": 0.00014,
+    "grok-4.5": 0.002,
 };
 // ─── Capability Profiles Data Table ──────────────────────────────────────────
 // Per-model capability profiles (0–100 scale). Used for capability-aware
@@ -128,6 +132,9 @@ export const MODEL_CAPABILITY_PROFILES = {
     // OpenAI's 2026-04-23 published eval deltas across coding, tool use, and long context.
     // Source: https://openai.com/index/introducing-gpt-5-5/
     "gpt-5.5": { coding: 96, debugging: 93, research: 89, reasoning: 95, speed: 42, longContext: 90, instruction: 93 },
+    // GPT-5.6 profile is provisional: a small uniform step over gpt-5.5, to be
+    // recalibrated once OpenAI publishes official eval results.
+    "gpt-5.6": { coding: 97, debugging: 94, research: 90, reasoning: 96, speed: 42, longContext: 91, instruction: 94 },
     // ── OpenAI o-series (reasoning-first) ──────────────────────────────────────
     "o1": { coding: 78, debugging: 82, research: 78, reasoning: 90, speed: 20, longContext: 65, instruction: 82 },
     "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
@@ -139,6 +146,10 @@ export const MODEL_CAPABILITY_PROFILES = {
     "gemini-flash-2.0": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
     // ── DeepSeek ───────────────────────────────────────────────────────────────
     "deepseek-chat": { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
+    // ── xAI ────────────────────────────────────────────────────────────────────
+    // Grok 4.5 (2026-07): Opus-class frontier model tuned for coding and agentic
+    // work; notably faster and more token-efficient than peer heavy models.
+    "grok-4.5": { coding: 95, debugging: 90, research: 82, reasoning: 93, speed: 55, longContext: 80, instruction: 90 },
 };
 // ─── Base Task Requirements Data Table ───────────────────────────────────────
 // Per-unit-type base requirement vectors. Weights indicate how important each

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

@@ -198,6 +198,25 @@ export function buildTaskFileName(taskId, suffix) {
     // This helper is deprecated but kept for backward-compat callers.
     return `${taskId}-${suffix}.md`;
 }
+/**
+ * Build a flat-phase task artifact file name.
+ * ("S06", "T03", "SUMMARY") → "S06-T03-SUMMARY.md"
+ */
+export function buildFlatTaskFileName(sliceId, taskId, suffix) {
+    return `${sliceId}-${taskId}-${suffix}.md`;
+}
+/**
+ * Extract the task ID from a task artifact filename.
+ * Supports flat-phase S##-T##-SUFFIX.md plus legacy T##-SUFFIX.md and
+ * T##-DESCRIPTOR-SUFFIX.md names.
+ */
+export function taskIdFromTaskFileName(fileName, suffix) {
+    const flat = new RegExp(`^S\\d+-(T\\d+)-${suffix}\\.md$`, "i").exec(fileName);
+    if (flat?.[1])
+        return flat[1].toUpperCase();
+    const legacy = new RegExp(`^(T\\d+)(?:-.*)?-${suffix}\\.md$`, "i").exec(fileName);
+    return legacy?.[1]?.toUpperCase() ?? null;
+}
 // ─── Resolvers ─────────────────────────────────────────────────────────────
 /**
  * Find a directory entry by ID prefix within a parent directory.
@@ -259,19 +278,16 @@ export function resolveFile(dir, idPrefix, suffix) {
     }
 }
 /**
- * Find all task files matching a pattern in a tasks directory.
- * Returns sorted file names matching T##-SUFFIX.md or legacy T##-*-SUFFIX.md
+ * Find all task files matching a pattern in a tasks directory or flat phase dir.
+ * Returns sorted file names matching S##-T##-SUFFIX.md, T##-SUFFIX.md,
+ * or legacy T##-*-SUFFIX.md.
  */
 export function resolveTaskFiles(tasksDir, suffix) {
     if (!existsSync(tasksDir))
         return [];
     try {
-        // Current convention: T01-PLAN.md
-        const currentPattern = new RegExp(`^T\\d+-${suffix}\\.md$`, "i");
-        // Legacy convention: T01-INSTALL-PACKAGES-PLAN.md
-        const legacyPattern = new RegExp(`^T\\d+-.*-${suffix}\\.md$`, "i");
         return cachedReaddir(tasksDir)
-            .filter(f => currentPattern.test(f) || legacyPattern.test(f))
+            .filter(f => taskIdFromTaskFileName(f, suffix) !== null)
             .sort();
     }
     catch {
@@ -893,8 +909,11 @@ export function resolveTaskFile(basePath, milestoneId, sliceId, taskId, suffix)
     const legacyBase = legacyMilestonesDir(basePath);
     const isLegacy = phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\");
     if (suffix !== "PLAN" && !isLegacy) {
-        const flatPath = join(phaseDir, buildTaskFileName(taskId, suffix));
-        return existsSync(flatPath) ? flatPath : null;
+        const flatPath = join(phaseDir, buildFlatTaskFileName(sliceId, taskId, suffix));
+        if (existsSync(flatPath))
+            return flatPath;
+        const legacyFlatPath = join(phaseDir, buildTaskFileName(taskId, suffix));
+        return existsSync(legacyFlatPath) ? legacyFlatPath : null;
     }
     const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
     if (tDir) {
@@ -1006,6 +1025,28 @@ export function targetSliceFile(basePath, milestoneId, sliceId, suffix, mileston
         : planFileName(milestoneIdToPhaseNum(milestoneId), sliceIdToPlanNum(sliceId), suffix);
     return join(dir, fileName);
 }
+/**
+ * Build the canonical absolute write target for a task file.
+ * Readers that need legacy flat-phase fallback should call resolveTaskFile.
+ */
+export function targetTaskFile(basePath, milestoneId, sliceId, taskId, suffix, milestoneTitle) {
+    if (suffix === "PLAN") {
+        return targetSliceFile(basePath, milestoneId, sliceId, "PLAN", milestoneTitle);
+    }
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = mDir
+        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
+        : isLegacyMilestonesLayout(basePath);
+    const milestoneDir = mDir
+        ?? dirname(targetMilestoneFile(basePath, milestoneId, "ROADMAP", milestoneTitle));
+    if (isLegacy) {
+        const slicesDir = join(milestoneDir, "slices");
+        const sliceDir = join(slicesDir, resolveDir(slicesDir, sliceId) ?? sliceId);
+        return join(sliceDir, "tasks", buildTaskFileName(taskId, suffix));
+    }
+    return join(milestoneDir, buildFlatTaskFileName(sliceId, taskId, suffix));
+}
 /**
  * Build relative .gsd/ path to a slice file.
  * Preserves an existing compatibility filename when present; otherwise falls
@@ -1036,5 +1077,5 @@ export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix, mile
         return relSliceFile(basePath, milestoneId, sliceId, "PLAN");
     }
     const relS = relSlicePath(basePath, milestoneId, sliceId, milestoneTitle);
-    return `${relS}/${buildTaskFileName(taskId, suffix)}`;
+    return `${relS}/${buildFlatTaskFileName(sliceId, taskId, suffix)}`;
 }

package/dist/resources/extensions/gsd/planning-subagent-policy.js

@@ -0,0 +1,37 @@
+import { CONFIGURABLE_PLANNING_SUBAGENT_UNITS } from "./preferences-types.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+const CONFIGURABLE_UNITS = new Set(CONFIGURABLE_PLANNING_SUBAGENT_UNITS);
+function configuredAllowedSubagents(unitType, preferences) {
+    if (!CONFIGURABLE_UNITS.has(unitType))
+        return [];
+    return preferences?.planning_subagents?.[unitType]?.allowed ?? [];
+}
+function mergeAllowedSubagents(current, configured) {
+    return Array.from(new Set([...current, ...configured]));
+}
+export function applyPlanningSubagentPreferences(unitType, policy, preferences) {
+    if (!policy)
+        return policy;
+    const configured = configuredAllowedSubagents(unitType, preferences);
+    if (configured.length === 0)
+        return policy;
+    if (policy.mode === "planning") {
+        return {
+            mode: "planning-dispatch",
+            allowedSubagents: mergeAllowedSubagents([], configured),
+        };
+    }
+    if (policy.mode === "planning-dispatch") {
+        return {
+            ...policy,
+            allowedSubagents: mergeAllowedSubagents(policy.allowedSubagents, configured),
+        };
+    }
+    return policy;
+}
+export function resolveEffectivePlanningToolsPolicy(unitType, policy, basePath) {
+    if (!basePath)
+        return policy;
+    const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+    return applyPlanningSubagentPreferences(unitType, policy, preferences);
+}

package/dist/resources/extensions/gsd/planning-subagent-registry.js

@@ -0,0 +1,25 @@
+/**
+ * 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 },
+};
+export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set(Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
+    .filter(([, metadata]) => metadata.readOnlySpecialist)
+    .map(([agentId]) => agentId));
+export function isReadOnlyPlanningDispatchAgent(agentId) {
+    const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId];
+    return metadata?.readOnlySpecialist === true;
+}
+export function allowedPlanningDispatchAgentsList() {
+    return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
+}

package/dist/resources/extensions/gsd/preferences-types.js

@@ -61,6 +61,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "git",
     "post_unit_hooks",
     "pre_dispatch_hooks",
+    "planning_subagents",
     "dynamic_routing",
     "disabled_model_providers",
     "uok",
@@ -134,6 +135,10 @@ export const KNOWN_UNIT_LABELS = [
     "workflow-preferences", "discuss-project", "discuss-requirements",
     "research-decision", "research-project",
 ];
+export const CONFIGURABLE_PLANNING_SUBAGENT_UNITS = [
+    "plan-milestone",
+    "plan-slice",
+];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 /** The nine model-routing phase buckets. */
 export const GSD_MODEL_PHASE_KEYS = [