gsd-pi 2.75.0-dev.2203010a0 → 2.75.0-dev.b6ad8c5f7

package/dist/onboarding.d.ts

@@ -20,6 +20,10 @@ type PicoModule = {
     red: (s: string) => string;
     reset: (s: string) => string;
 };
+interface RunOnboardingOptions {
+    /** Show logo + intro banner. Disable when onboarding is launched inside an active TUI session. */
+    showIntro?: boolean;
+}
 /**
  * Determine if the onboarding wizard should run.
  *
@@ -46,7 +50,7 @@ export declare function shouldRunOnboarding(authStorage: AuthStorage, settingsDe
  * All steps are skippable. All errors are recoverable.
  * Writes status to stderr during execution.
  */
-export declare function runOnboarding(authStorage: AuthStorage): Promise<void>;
+export declare function runOnboarding(authStorage: AuthStorage, opts?: RunOnboardingOptions): Promise<void>;
 export declare function runLlmStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage): Promise<boolean>;
 export declare function runWebSearchStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage, isAnthropicAuth: boolean): Promise<string | null>;
 export declare function runToolKeysStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage): Promise<number>;

package/dist/onboarding.js

@@ -194,7 +194,7 @@ export function shouldRunOnboarding(authStorage, settingsDefaultProvider) {
  * All steps are skippable. All errors are recoverable.
  * Writes status to stderr during execution.
  */
-export async function runOnboarding(authStorage) {
+export async function runOnboarding(authStorage, opts = {}) {
     let p;
     let pc;
     try {
@@ -207,8 +207,10 @@ export async function runOnboarding(authStorage) {
         return;
     }
     // ── Intro ─────────────────────────────────────────────────────────────────
-    process.stderr.write(renderLogo(pc.cyan));
-    p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
+    if (opts.showIntro !== false) {
+        process.stderr.write(renderLogo(pc.cyan));
+        p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
+    }
     const completedSteps = [];
     // ── LLM Provider Selection ────────────────────────────────────────────────
     const llmResult = await runStep(p, 'LLM setup failed', () => runLlmStep(p, pc, authStorage), {

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

@@ -150,7 +150,7 @@ sessionModelOverride) {
             const shouldClassify = !isHook || routingConfig.hooks !== false;
             if (shouldClassify) {
                 let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct, taskMetadataForPolicy);
-                const availableModelIds = routingEligibleModels.map(m => m.id);
+                const availableModelIds = routingEligibleModels.map(m => `${m.provider}/${m.id}`);
                 // Escalate tier on retry when escalate_on_failure is enabled (default: true)
                 if (retryContext?.isRetry &&
                     retryContext.previousTier &&

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -708,28 +708,23 @@ export function registerDbTools(pi) {
             };
         }
         try {
-            const { getSlice, updateSliceStatus } = await import("../gsd-db.js");
+            const { handleSkipSlice } = await import("../tools/skip-slice.js");
             const { invalidateStateCache } = await import("../state.js");
-            const slice = getSlice(params.milestoneId, params.sliceId);
-            if (!slice) {
+            const result = handleSkipSlice({
+                milestoneId: params.milestoneId,
+                sliceId: params.sliceId,
+                reason: params.reason,
+            });
+            if (result.error) {
                 return {
-                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} not found in milestone ${params.milestoneId}` }],
-                    details: { operation: "skip_slice", error: "slice_not_found" },
+                    content: [{ type: "text", text: `Error: ${result.error}` }],
+                    details: {
+                        operation: "skip_slice",
+                        error: result.error,
+                        errorCode: result.errorCode ?? "skip_failed",
+                    },
                 };
             }
-            if (slice.status === "complete" || slice.status === "done") {
-                return {
-                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} is already complete — cannot skip.` }],
-                    details: { operation: "skip_slice", error: "already_complete" },
-                };
-            }
-            if (slice.status === "skipped") {
-                return {
-                    content: [{ type: "text", text: `Slice ${params.sliceId} is already skipped.` }],
-                    details: { operation: "skip_slice", sliceId: params.sliceId, milestoneId: params.milestoneId },
-                };
-            }
-            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
             invalidateStateCache();
             // Rebuild STATE.md so it reflects the skip immediately (#3477).
             // Without this, /gsd auto reads stale STATE.md and resumes the skipped slice.
@@ -741,13 +736,20 @@ export function registerDbTools(pi) {
             catch (err) {
                 logError("tool", `skip_slice rebuildState failed: ${err.message}`, { tool: "gsd_skip_slice" });
             }
+            const suffix = result.wasAlreadySkipped
+                ? result.tasksSkipped > 0
+                    ? ` (already skipped; cascaded ${result.tasksSkipped} leftover task(s) to skipped).`
+                    : " (already skipped; no pending tasks to cascade)."
+                : ` Cascaded ${result.tasksSkipped} task(s) to skipped. Auto-mode will advance past this slice.`;
             return {
-                content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
+                content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}.${suffix}` }],
                 details: {
                     operation: "skip_slice",
                     sliceId: params.sliceId,
                     milestoneId: params.milestoneId,
                     reason: params.reason,
+                    tasksSkipped: result.tasksSkipped,
+                    wasAlreadySkipped: result.wasAlreadySkipped,
                 },
             };
         }
@@ -764,12 +766,14 @@ export function registerDbTools(pi) {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
+            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks (#4375). " +
             "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
         promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
         promptGuidelines: [
             "Use gsd_skip_slice when a slice should be bypassed — descoped, superseded, or no longer relevant.",
             "Cannot skip a slice that is already complete.",
             "Skipped slices satisfy downstream dependencies just like completed slices.",
+            "All pending/active tasks in the slice are cascaded to skipped; completed tasks are never downgraded.",
         ],
         parameters: Type.Object({
             sliceId: Type.String({ description: "Slice ID (e.g. S02)" }),

package/dist/resources/extensions/gsd/commands/handlers/onboarding.js

@@ -5,7 +5,8 @@
 // this handler lets users re-launch it on demand.
 import { AuthStorage } from "@gsd/pi-coding-agent";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { ONBOARDING_STEPS, isValidStepId, nearestResumeStep, } from "../../setup-catalog.js";
 import { isOnboardingComplete, readOnboardingRecord, resetOnboarding, } from "../../onboarding-state.js";
 // Inline auth path (mirrors src/app-paths.ts) — keep this module rootDir-clean
@@ -14,8 +15,31 @@ import { isOnboardingComplete, readOnboardingRecord, resetOnboarding, } from "..
 const AUTH_FILE_PATH = join(process.env.GSD_CODING_AGENT_DIR ||
     join(process.env.GSD_HOME || join(homedir(), ".gsd"), "agent"), "auth.json");
 async function loadFirstRunWizard() {
-    const specifier = "../../../../../onboarding.js";
-    return (await import(/* @vite-ignore */ specifier));
+    const candidates = [];
+    // Primary deployed path: loader sets GSD_PKG_ROOT (gsd package root).
+    if (process.env.GSD_PKG_ROOT) {
+        candidates.push(pathToFileURL(join(process.env.GSD_PKG_ROOT, "dist", "onboarding.js")).href);
+    }
+    // Fallback: derive package root from process entry (typically dist/loader.js).
+    // This keeps /gsd onboarding resilient if GSD_PKG_ROOT is absent.
+    const argvEntry = process.argv[1];
+    if (argvEntry) {
+        const pkgRootFromArgv = resolve(dirname(argvEntry), "..");
+        candidates.push(pathToFileURL(join(pkgRootFromArgv, "dist", "onboarding.js")).href);
+    }
+    // Source-tree/dev fallback (works in dist/resources/... and ts test loaders).
+    candidates.push("../../../../../onboarding.js");
+    let lastError = null;
+    for (const specifier of candidates) {
+        try {
+            return (await import(/* @vite-ignore */ specifier));
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    const reason = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`[gsd] Failed to load onboarding wizard module. Tried: ${candidates.join(", ")}. Last error: ${reason}`);
 }
 function parseArgs(raw) {
     const tokens = raw.split(/\s+/).filter(Boolean);
@@ -55,7 +79,7 @@ async function runWholeWizard(ctx, fromStep) {
         ctx.ui.notify(`Resuming from step: ${fromStep}. The wizard runs all remaining steps; press skip on any you've already configured.`, "info");
     }
     const { runOnboarding } = await loadFirstRunWizard();
-    await runOnboarding(authStorage);
+    await runOnboarding(authStorage, { showIntro: false });
 }
 async function runSingleStep(ctx, stepId) {
     const authStorage = await getAuthStorage();

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

@@ -189,8 +189,9 @@ export function computeTaskRequirements(unitType, metadata) {
  */
 export function scoreEligibleModels(eligibleModelIds, requirements, capabilityOverrides) {
     const scored = eligibleModelIds.map(modelId => {
-        const builtin = MODEL_CAPABILITY_PROFILES[modelId];
-        const override = capabilityOverrides?.[modelId];
+        const bareId = bareModelId(modelId);
+        const builtin = MODEL_CAPABILITY_PROFILES[bareId];
+        const override = capabilityOverrides?.[modelId] ?? capabilityOverrides?.[bareId];
         const profile = builtin
             ? override ? { ...builtin, ...override } : builtin
             : { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
@@ -400,7 +401,7 @@ export function defaultRoutingConfig() {
 // ─── Internal ────────────────────────────────────────────────────────────────
 function getModelTier(modelId) {
     // Strip provider prefix if present
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    const bareId = bareModelId(modelId);
     // Check exact match first
     if (MODEL_CAPABILITY_TIER[bareId])
         return MODEL_CAPABILITY_TIER[bareId];
@@ -414,7 +415,7 @@ function getModelTier(modelId) {
 }
 /** Check if a model ID has a known capability tier mapping. (#2192) */
 function isKnownModel(modelId) {
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    const bareId = bareModelId(modelId);
     if (MODEL_CAPABILITY_TIER[bareId])
         return true;
     for (const knownId of Object.keys(MODEL_CAPABILITY_TIER)) {
@@ -424,7 +425,7 @@ function isKnownModel(modelId) {
     return false;
 }
 function getModelCost(modelId) {
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    const bareId = bareModelId(modelId);
     if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
         return MODEL_COST_PER_1K_INPUT[bareId];
     }
@@ -436,6 +437,9 @@ function getModelCost(modelId) {
     // Unknown cost — assume expensive to avoid routing to unknown cheap models
     return 999;
 }
+function bareModelId(modelId) {
+    return modelId.includes("/") ? modelId.split("/").pop() : modelId;
+}
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 /**
  * Check if a tool is compatible with a provider's capabilities.

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -1,7 +1,7 @@
 // GSD Extension — Notification History Overlay
 // Scrollable panel showing all persisted notifications with severity filtering.
 // Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
 import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { padRight, joinColumns } from "../shared/mod.js";
@@ -15,29 +15,14 @@ function severityIcon(severity) {
         default: return "●";
     }
 }
-/** Word-wrap plain text to fit within maxWidth columns. */
+/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
 function wrapText(text, maxWidth) {
-    if (text.length <= maxWidth)
+    if (maxWidth <= 0)
         return [text];
-    const words = text.split(/\s+/);
-    const lines = [];
-    let current = "";
-    for (const word of words) {
-        if (current.length === 0) {
-            current = word;
-        }
-        else if (current.length + 1 + word.length <= maxWidth) {
-            current += " " + word;
-        }
-        else {
-            lines.push(current);
-            current = word;
-        }
-    }
-    if (current.length > 0)
-        lines.push(current);
-    // If a single word exceeds maxWidth, truncate it
-    return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+    const lines = wrapTextWithAnsi(text, maxWidth);
+    // Safety clamp: if any line still exceeds maxWidth (e.g. unbreakable long token),
+    // truncate it with an ellipsis so it cannot bleed past the box border.
+    return lines.map((l) => visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l);
 }
 function formatTimestamp(ts) {
     try {

package/dist/resources/extensions/gsd/tools/skip-slice.js

@@ -0,0 +1,78 @@
+/**
+ * skip-slice handler — the core operation behind gsd_skip_slice.
+ *
+ * Marks a slice as skipped and cascades the skip to every non-closed task in
+ * that slice. Without the task cascade the deep-check in
+ * executeCompleteMilestone reports pending tasks inside the skipped slice and
+ * blocks milestone completion (see #4375).
+ *
+ * This function performs DB writes only. The MCP wrapper in
+ * bootstrap/db-tools.ts handles state-cache invalidation and STATE.md rebuild.
+ */
+import { getSlice, getSliceTasks, isDbAvailable, transaction, updateSliceStatus, updateTaskStatus, } from "../gsd-db.js";
+import { isClosedStatus } from "../status-guards.js";
+/**
+ * Mark a slice as "skipped" and cascade the skip to every non-closed task in
+ * that slice. Runs as a single transaction so slice status and task statuses
+ * are always consistent.
+ *
+ * Behaviour summary:
+ * - Unknown slice → returns {@link SkipSliceResult} with `error`.
+ * - Slice already complete/done → returns `error` (cannot un-complete).
+ * - Slice already skipped → still cascades leftover non-closed tasks
+ *   (heals inconsistent historical state from projects that ran older
+ *   versions before the #4375 cascade fix).
+ * - Tasks in closed status (complete/done/skipped) are never downgraded.
+ */
+export function handleSkipSlice(params) {
+    const base = {
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        tasksSkipped: 0,
+        wasAlreadySkipped: false,
+        reason: params.reason,
+    };
+    // Fail loudly on a closed DB so a `null` from getSlice() inside the
+    // transaction unambiguously means "slice not found", never "DB unavailable".
+    // The MCP wrapper in bootstrap/db-tools.ts runs ensureDbOpen() before calling
+    // this helper; this guard protects direct callers (tests, future code).
+    if (!isDbAvailable()) {
+        throw new Error("handleSkipSlice: GSD database is not available");
+    }
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ────
+    let guardError = null;
+    let guardCode = null;
+    let wasAlreadySkipped = false;
+    let tasksSkipped = 0;
+    transaction(() => {
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (!slice) {
+            guardError = `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`;
+            guardCode = "slice_not_found";
+            return;
+        }
+        if (slice.status === "complete" || slice.status === "done") {
+            guardError = `Slice ${params.sliceId} is already complete — cannot skip.`;
+            guardCode = "already_complete";
+            return;
+        }
+        wasAlreadySkipped = slice.status === "skipped";
+        if (!wasAlreadySkipped) {
+            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
+        }
+        // Cascade: mark every non-closed task as skipped so milestone completion
+        // doesn't trip the deep-task guard (#4375). Closed tasks (complete/done/
+        // skipped) are left untouched — we never downgrade.
+        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+        for (const task of tasks) {
+            if (!isClosedStatus(task.status)) {
+                updateTaskStatus(params.milestoneId, params.sliceId, task.id, "skipped");
+                tasksSkipped++;
+            }
+        }
+    });
+    if (guardError) {
+        return { ...base, error: guardError, errorCode: guardCode ?? undefined };
+    }
+    return { ...base, tasksSkipped, wasAlreadySkipped };
+}