@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -4,6 +4,8 @@ import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { VISUAL_BRIEF_MODES } from "../../visual-brief/prompts.js";
+import { GSD_CORE_ALIAS_CATALOG } from "./gsd-core-aliases.js";
+import { GSD_CORE_IMPLEMENTED_CATALOG } from "../commands-gsd-core.js";
 export const GSD_COMMAND_DESCRIPTION = "GSD — Git Ship Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|report|queue|quick|discuss|capture|triage|dispatch|verdict|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|closeout|rebuild|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|memory|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|upgrade|fast|mcp|rethink|workflow|codebase|notifications|ship|do|usage|context|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -84,6 +86,10 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "language", desc: "Set or clear the global response language (e.g. /gsd language Chinese)" },
     { cmd: "worktree", desc: "Manage worktrees from the TUI (list, merge, clean, remove)" },
     { cmd: "eval-review", desc: "Audit a slice's AI evaluation strategy and write a scored EVAL-REVIEW.md (--force, --show)" },
+    // Additional commands (commands-gsd-core.ts) run real prompt-driven workflows;
+    // namespace aliases (gsd-core-aliases.ts) redirect to /gsd help.
+    ...GSD_CORE_IMPLEMENTED_CATALOG,
+    ...GSD_CORE_ALIAS_CATALOG,
 ];
 const NESTED_COMPLETIONS = {
     brief: VISUAL_BRIEF_MODES.map((mode) => ({ cmd: mode.mode, desc: mode.description })),

package/dist/resources/extensions/gsd/commands/dispatcher.js

@@ -6,6 +6,7 @@ import { handleCoreCommand } from "./handlers/core.js";
 import { handleOpsCommand } from "./handlers/ops.js";
 import { handleParallelCommand } from "./handlers/parallel.js";
 import { handleWorkflowCommand } from "./handlers/workflow.js";
+import { handleGsdCoreAlias } from "./gsd-core-aliases-handler.js";
 import { getValidationBlockMessageForBase, isValidationBlockAllowedCommand, } from "../validation-block-guard.js";
 import { getUnmergedMilestoneBlockMessageForBase, isUnmergedMilestoneAllowedCommand, } from "../unmerged-milestone-guard.js";
 import { getWorkspaceGitBlockMessageForBase } from "../workspace-git-guard.js";
@@ -24,6 +25,8 @@ function emitVisibleCommandBlock(ctx, pi, message) {
 export async function handleGSDCommand(args, ctx, pi) {
     const trimmed = (typeof args === "string" ? args : "").trim();
     const handlers = [
+        // Namespace alias redirects (ns-*) run first so they resolve before the standard handlers.
+        () => handleGsdCoreAlias(trimmed, ctx, pi),
         () => handleCoreCommand(trimmed, ctx, pi),
         () => handleAutoCommand(trimmed, ctx, pi),
         () => handleParallelCommand(trimmed, ctx, pi),

package/dist/resources/extensions/gsd/commands/gsd-core-aliases-handler.js

@@ -0,0 +1,39 @@
+// Project/App: gsd-pi
+// File Purpose: Handler that resolves namespace alias redirects (ns-*).
+//
+// Returns true (handled) when the input matches a namespace alias. Redirects
+// re-dispatch through the main dispatcher so safety guards apply to the target
+// command too. Unavailable aliases print a helpful message and stop.
+import { matchGsdCoreAlias } from "./gsd-core-aliases.js";
+function formatUnavailable(cmd, alias) {
+    const lines = [
+        `/gsd ${cmd} is not available.`,
+        `Previously it: ${alias.legacy}`,
+    ];
+    if (alias.alternative)
+        lines.push(`Alternative: ${alias.alternative}`);
+    lines.push("Run /gsd help for the command reference.");
+    return lines.join("\n");
+}
+export async function handleGsdCoreAlias(trimmed, ctx, pi) {
+    const match = matchGsdCoreAlias(trimmed);
+    if (!match)
+        return false;
+    const { alias, cmd, rest } = match;
+    if (alias.kind === "unavailable") {
+        ctx.ui.notify(formatUnavailable(cmd, alias), "warning");
+        return true;
+    }
+    // Redirect: rebuild the target command with any trailing args, then re-dispatch
+    // through the main dispatcher so guards + handlers run against the target.
+    const targetWithArgs = rest ? `${alias.target} ${rest}` : alias.target;
+    if (alias.note) {
+        ctx.ui.notify(`${cmd} → /gsd ${alias.target} (${alias.note})`, "info");
+    }
+    else {
+        ctx.ui.notify(`${cmd} → /gsd ${alias.target}`, "info");
+    }
+    const { handleGSDCommand } = await import("./dispatcher.js");
+    await handleGSDCommand(targetWithArgs, ctx, pi);
+    return true;
+}

package/dist/resources/extensions/gsd/commands/gsd-core-aliases.js

@@ -0,0 +1,44 @@
+// Project/App: gsd-pi
+// File Purpose: Alias redirects for namespace-grouping commands (ns-*).
+//
+// The ns-* names were command-grouping menus in an earlier CLI; gsd-pi uses a flat
+// `/gsd help`, so these redirect there. Every other additional command is implemented
+// natively as an adapted workflow in commands-gsd-core.ts.
+/**
+ * Namespace-grouping aliases (ns-*). Each redirects to the flat /gsd help.
+ */
+export const GSD_CORE_ALIASES = new Map([
+    ["ns-context", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+    ["ns-ideate", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+    ["ns-manage", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+    ["ns-project", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+    ["ns-review", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+    ["ns-workflow", { kind: "redirect", target: "help", note: "Namespace command — use /gsd help to browse all commands." }],
+]);
+/**
+ * Catalog entries (for autocomplete) derived from the alias table.
+ * Surfaced as top-level subcommands so users discover them while typing.
+ */
+export const GSD_CORE_ALIAS_CATALOG = [
+    { cmd: "ns-context", desc: "Alias for /gsd help" },
+    { cmd: "ns-ideate", desc: "Alias for /gsd help" },
+    { cmd: "ns-manage", desc: "Alias for /gsd help" },
+    { cmd: "ns-project", desc: "Alias for /gsd help" },
+    { cmd: "ns-review", desc: "Alias for /gsd help" },
+    { cmd: "ns-workflow", desc: "Alias for /gsd help" },
+];
+/**
+ * Tries to resolve a `/gsd <cmd> [args]` string against the namespace alias table.
+ * Returns the matched alias (and remaining args) or null if no alias matches.
+ */
+export function matchGsdCoreAlias(trimmed) {
+    const spaceIdx = trimmed.indexOf(" ");
+    const cmd = (spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx)).trim();
+    if (!cmd)
+        return null;
+    const alias = GSD_CORE_ALIASES.get(cmd);
+    if (!alias)
+        return null;
+    const rest = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1).trim();
+    return { alias, cmd, rest };
+}

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

@@ -190,7 +190,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             }
             return true;
         }
-        await pauseAuto(ctx, pi);
+        await pauseAuto(ctx, pi, undefined, { abortActiveTurn: true });
         return true;
     }
     if (trimmed === "rate" || trimmed.startsWith("rate ")) {

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

@@ -1,6 +1,8 @@
 import { createRequire } from "node:module";
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
-import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.js";
+import { isRepositoryDirty } from "../../git-service.js";
+import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.js";
+import { createRepositoryRegistryFromPreferences } from "../../repository-registry.js";
 import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
@@ -10,6 +12,8 @@ import { projectRoot } from "../context.js";
 import { formattedShortcutPair } from "../../shortcut-defs.js";
 import { getVisualBriefOutputDir } from "../../../visual-brief/artifact-policy.js";
 import { buildVisualBriefPrompt, parseVisualBriefArgs, VISUAL_BRIEF_USAGE } from "../../../visual-brief/prompts.js";
+import { GSD_CORE_IMPLEMENTED_CATALOG } from "../../commands-gsd-core.js";
+import { GSD_CORE_ALIAS_CATALOG } from "../gsd-core-aliases.js";
 export function showHelp(ctx, args = "") {
     const summaryLines = [
         "GSD — Git Ship Done\n",
@@ -53,6 +57,11 @@ export function showHelp(ctx, args = "") {
         "  /gsd closeout       Recover failed git closeout actions",
         "  /gsd rebuild        Rebuild markdown projections from the DB  [markdown]",
         "",
+        "ADDITIONAL COMMANDS",
+        "  /gsd map-codebase, /gsd stats, /gsd code-review, /gsd spike, /gsd explore …",
+        "  Additional workflows for exploration, review, codebase intel, and more.",
+        "  See /gsd help full for the complete list.",
+        "",
         "Use /gsd help full for the complete command reference.",
     ];
     const fullLines = [
@@ -152,10 +161,32 @@ export function showHelp(ctx, args = "") {
         "  /gsd update         Update GSD to the latest version via npm",
         "  /gsd upgrade        Alias for /gsd update",
         "  /gsd language       Set or clear the global response language  [off|clear|<language>]",
+        "",
+        // The ADDITIONAL COMMANDS block is generated below from the implemented + alias catalogs
+        // so it can never drift from TOP_LEVEL_SUBCOMMANDS (which the help-coverage test asserts).
+        ...buildAdditionalCommandsHelpLines(),
     ];
     const full = ["full", "--full", "all"].includes(args.trim().toLowerCase());
     ctx.ui.notify((full ? fullLines : summaryLines).join("\n"), "info");
 }
+/**
+ * Build the ADDITIONAL COMMANDS help lines from the implemented-workflow and alias catalogs.
+ * Kept in sync with TOP_LEVEL_SUBCOMMANDS automatically — every command appears here.
+ */
+function buildAdditionalCommandsHelpLines() {
+    const lines = [
+        "ADDITIONAL COMMANDS",
+        "  Additional workflows for exploration, review, codebase intel, and project management.",
+    ];
+    const pad = (cmd, width = 20) => cmd.padEnd(width);
+    for (const entry of GSD_CORE_IMPLEMENTED_CATALOG) {
+        lines.push(`  /gsd ${pad(entry.cmd)} ${entry.desc}`);
+    }
+    for (const entry of GSD_CORE_ALIAS_CATALOG) {
+        lines.push(`  /gsd ${pad(entry.cmd)} ${entry.desc}`);
+    }
+    return lines;
+}
 export async function handleStatus(ctx) {
     const basePath = projectRoot();
     // Open DB in cold sessions so status uses DB-backed state, not filesystem fallback (#3385)
@@ -177,7 +208,7 @@ export async function handleStatus(ctx) {
         },
     });
     if (result === undefined) {
-        ctx.ui.notify(formatTextStatus(state), "info");
+        ctx.ui.notify(formatTextStatus(state, basePath), "info");
     }
 }
 export async function fireStatusViaCommand(ctx) {
@@ -483,6 +514,7 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         const configOptions = {
             basePath,
             ...(availableModelIds && availableModelIds.length > 0 ? { availableModelIds } : {}),
+            ...(ctx.model ? { preferredModelId: `${ctx.model.provider}/${ctx.model.id}` } : {}),
         };
         const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true), configOptions), {
             overlay: true,
@@ -509,7 +541,8 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
     }
     return false;
 }
-export function formatTextStatus(state) {
+export function formatTextStatus(state, basePath) {
+    const root = basePath ?? projectRoot();
     const lines = ["GSD Status\n"];
     lines.push(formatProgressLine(computeProgressScore()));
     lines.push("");
@@ -552,7 +585,7 @@ export function formatTextStatus(state) {
             lines.push(`  ${icon} ${milestone.id}: ${milestone.title} (${milestone.status})`);
         }
     }
-    const envResults = runEnvironmentChecks(projectRoot());
+    const envResults = runEnvironmentChecks(root);
     const envIssues = envResults.filter((result) => result.status !== "ok");
     if (envIssues.length > 0) {
         lines.push("");
@@ -561,5 +594,38 @@ export function formatTextStatus(state) {
             lines.push(`  ${issue.status === "error" ? "✗" : "⚠"} ${issue.message}`);
         }
     }
+    // Parent-workspace per-repository git health (#818). No-op for single-repo
+    // projects; surfaces which declared child repos have uncommitted changes.
+    const repoBlock = buildWorkspaceRepoStatusBlock(root);
+    if (repoBlock) {
+        lines.push("");
+        lines.push("Repositories:");
+        lines.push(repoBlock);
+    }
     return lines.join("\n");
 }
+/**
+ * Build a per-repository dirty/clean summary for parent-workspace status.
+ * Returns "" for single-repo (project-mode) projects so the status output is
+ * unchanged; otherwise one line per declared child repository.
+ */
+function buildWorkspaceRepoStatusBlock(basePath) {
+    let registry;
+    try {
+        registry = createRepositoryRegistryFromPreferences(basePath, loadEffectiveGSDPreferences(basePath)?.preferences);
+    }
+    catch {
+        return "";
+    }
+    if (registry.mode !== "parent")
+        return "";
+    const childRepos = registry.repositories.filter((repo) => repo.id !== "project");
+    if (childRepos.length === 0)
+        return "";
+    return childRepos
+        .map((repo) => {
+        const dirty = isRepositoryDirty(repo.root);
+        return `  ${dirty ? "✗" : "✓"} ${repo.id}${repo.role ? ` — ${repo.role}` : ""}${dirty ? " (uncommitted changes)" : " (clean)"}`;
+    })
+        .join("\n");
+}

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

@@ -4,7 +4,7 @@ import { handleDoctor, handleCapture, handleKnowledge, handleRunHook, handleSkil
 import { handleInspect } from "../../commands-inspect.js";
 import { handleLogs } from "../../commands-logs.js";
 import { handleDebug } from "../../commands-debug.js";
-import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleCleanupProjects, handleCleanupWorktrees, handleRecover, handleRebuild } from "../../commands-maintenance.js";
+import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleCleanupProjects, handleCleanupWorktrees, handleRecover, handleRebuild, handleSync } from "../../commands-maintenance.js";
 import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
 import { handleUndo } from "../../undo.js";
@@ -131,6 +131,10 @@ export async function handleOpsCommand(trimmed, ctx, pi) {
         await handleRebuild(ctx, projectRoot(), trimmed.replace(/^rebuild\s*/, "").trim());
         return true;
     }
+    if (trimmed === "sync" || trimmed.startsWith("sync ")) {
+        await handleSync(ctx, projectRoot(), trimmed.replace(/^sync\s*/, "").trim());
+        return true;
+    }
     if (trimmed === "closeout" || trimmed.startsWith("closeout ")) {
         const { handleCloseout } = await import("../../commands-closeout.js");
         await handleCloseout(trimmed.replace(/^closeout\s*/, "").trim(), ctx, projectRoot());
@@ -334,5 +338,225 @@ Examples:
         await handleWorktree(trimmed.replace(/^(worktree|wt)\s*/, "").trim(), ctx);
         return true;
     }
+    // Additional commands — ideation/exploration workflows (implemented, not aliased).
+    if (trimmed === "explore" || trimmed.startsWith("explore ")) {
+        const { handleExplore } = await import("../../commands-gsd-core.js");
+        await handleExplore(trimmed.replace(/^explore\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "spike" || trimmed.startsWith("spike ")) {
+        const { handleSpike } = await import("../../commands-gsd-core.js");
+        await handleSpike(trimmed.replace(/^spike\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "sketch" || trimmed.startsWith("sketch ")) {
+        const { handleSketch } = await import("../../commands-gsd-core.js");
+        await handleSketch(trimmed.replace(/^sketch\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // Additional commands — codebase intelligence workflows (implemented, not aliased).
+    if (trimmed === "map-codebase" || trimmed.startsWith("map-codebase ")) {
+        const { handleMapCodebase } = await import("../../commands-gsd-core.js");
+        await handleMapCodebase(trimmed.replace(/^map-codebase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "docs-update" || trimmed.startsWith("docs-update ")) {
+        const { handleDocsUpdate } = await import("../../commands-gsd-core.js");
+        await handleDocsUpdate(trimmed.replace(/^docs-update\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "graphify" || trimmed.startsWith("graphify ")) {
+        const { handleGraphify } = await import("../../commands-gsd-core.js");
+        await handleGraphify(trimmed.replace(/^graphify\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "stats") {
+        const { handleStats } = await import("../../commands-gsd-core.js");
+        await handleStats("", ctx, pi);
+        return true;
+    }
+    if (trimmed === "progress" || trimmed.startsWith("progress ")) {
+        const { handleProgress } = await import("../../commands-gsd-core.js");
+        await handleProgress(trimmed.replace(/^progress\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "health" || trimmed.startsWith("health ")) {
+        const { handleHealth } = await import("../../commands-gsd-core.js");
+        await handleHealth(trimmed.replace(/^health\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "surface" || trimmed.startsWith("surface ")) {
+        const { handleSurface } = await import("../../commands-gsd-core.js");
+        await handleSurface(trimmed.replace(/^surface\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // Additional commands — review / audit workflows (implemented, not aliased).
+    if (trimmed === "code-review" || trimmed.startsWith("code-review ")) {
+        const { handleCodeReview } = await import("../../commands-gsd-core.js");
+        await handleCodeReview(trimmed.replace(/^code-review\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "review" || trimmed.startsWith("review ")) {
+        const { handleReview } = await import("../../commands-gsd-core.js");
+        await handleReview(trimmed.replace(/^review\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "audit-milestone" || trimmed.startsWith("audit-milestone ")) {
+        const { handleAuditMilestone } = await import("../../commands-gsd-core.js");
+        await handleAuditMilestone(trimmed.replace(/^audit-milestone\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "audit-uat" || trimmed.startsWith("audit-uat ")) {
+        const { handleAuditUat } = await import("../../commands-gsd-core.js");
+        await handleAuditUat(trimmed.replace(/^audit-uat\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "audit-fix" || trimmed.startsWith("audit-fix ")) {
+        const { handleAuditFix } = await import("../../commands-gsd-core.js");
+        await handleAuditFix(trimmed.replace(/^audit-fix\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "ui-review" || trimmed.startsWith("ui-review ")) {
+        const { handleUiReview } = await import("../../commands-gsd-core.js");
+        await handleUiReview(trimmed.replace(/^ui-review\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "secure-phase" || trimmed.startsWith("secure-phase ")) {
+        const { handleSecurePhase } = await import("../../commands-gsd-core.js");
+        await handleSecurePhase(trimmed.replace(/^secure-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "validate-phase" || trimmed.startsWith("validate-phase ")) {
+        const { handleValidatePhase } = await import("../../commands-gsd-core.js");
+        await handleValidatePhase(trimmed.replace(/^validate-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "verify-work" || trimmed.startsWith("verify-work ")) {
+        const { handleVerifyWork } = await import("../../commands-gsd-core.js");
+        await handleVerifyWork(trimmed.replace(/^verify-work\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "plan-review-convergence" || trimmed.startsWith("plan-review-convergence ")) {
+        const { handlePlanReviewConvergence } = await import("../../commands-gsd-core.js");
+        await handlePlanReviewConvergence(trimmed.replace(/^plan-review-convergence\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // Additional commands — workflow phase commands (implemented, not aliased).
+    if (trimmed === "discuss-phase" || trimmed.startsWith("discuss-phase ")) {
+        const { handleDiscussPhase } = await import("../../commands-gsd-core.js");
+        await handleDiscussPhase(trimmed.replace(/^discuss-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "plan-phase" || trimmed.startsWith("plan-phase ")) {
+        const { handlePlanPhase } = await import("../../commands-gsd-core.js");
+        await handlePlanPhase(trimmed.replace(/^plan-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "execute-phase" || trimmed.startsWith("execute-phase ")) {
+        const { handleExecutePhase } = await import("../../commands-gsd-core.js");
+        await handleExecutePhase(trimmed.replace(/^execute-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "spec-phase" || trimmed.startsWith("spec-phase ")) {
+        const { handleSpecPhase } = await import("../../commands-gsd-core.js");
+        await handleSpecPhase(trimmed.replace(/^spec-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "mvp-phase" || trimmed.startsWith("mvp-phase ")) {
+        const { handleMvpPhase } = await import("../../commands-gsd-core.js");
+        await handleMvpPhase(trimmed.replace(/^mvp-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "ui-phase" || trimmed.startsWith("ui-phase ")) {
+        const { handleUiPhase } = await import("../../commands-gsd-core.js");
+        await handleUiPhase(trimmed.replace(/^ui-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "ai-integration-phase" || trimmed.startsWith("ai-integration-phase ")) {
+        const { handleAiIntegrationPhase } = await import("../../commands-gsd-core.js");
+        await handleAiIntegrationPhase(trimmed.replace(/^ai-integration-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "ultraplan-phase" || trimmed.startsWith("ultraplan-phase ")) {
+        const { handleUltraplanPhase } = await import("../../commands-gsd-core.js");
+        await handleUltraplanPhase(trimmed.replace(/^ultraplan-phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "autonomous" || trimmed.startsWith("autonomous ")) {
+        const { handleAutonomous } = await import("../../commands-gsd-core.js");
+        await handleAutonomous(trimmed.replace(/^autonomous\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "pause-work" || trimmed.startsWith("pause-work ")) {
+        const { handlePauseWork } = await import("../../commands-gsd-core.js");
+        await handlePauseWork(trimmed.replace(/^pause-work\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "resume-work" || trimmed.startsWith("resume-work ")) {
+        const { handleResumeWork } = await import("../../commands-gsd-core.js");
+        await handleResumeWork(trimmed.replace(/^resume-work\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // Additional commands — project management commands (implemented, not aliased).
+    if (trimmed === "manager" || trimmed.startsWith("manager ")) {
+        const { handleManager } = await import("../../commands-gsd-core.js");
+        await handleManager(trimmed.replace(/^manager\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "phase" || trimmed.startsWith("phase ")) {
+        const { handlePhase } = await import("../../commands-gsd-core.js");
+        await handlePhase(trimmed.replace(/^phase\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "thread" || trimmed.startsWith("thread ")) {
+        const { handleThread } = await import("../../commands-gsd-core.js");
+        await handleThread(trimmed.replace(/^thread\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "workstreams" || trimmed.startsWith("workstreams ")) {
+        const { handleWorkstreams } = await import("../../commands-gsd-core.js");
+        await handleWorkstreams(trimmed.replace(/^workstreams\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "workspace" || trimmed.startsWith("workspace ")) {
+        const { handleWorkspace } = await import("../../commands-gsd-core.js");
+        await handleWorkspace(trimmed.replace(/^workspace\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "milestone-summary" || trimmed.startsWith("milestone-summary ")) {
+        const { handleMilestoneSummary } = await import("../../commands-gsd-core.js");
+        await handleMilestoneSummary(trimmed.replace(/^milestone-summary\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "review-backlog" || trimmed.startsWith("review-backlog ")) {
+        const { handleReviewBacklog } = await import("../../commands-gsd-core.js");
+        await handleReviewBacklog(trimmed.replace(/^review-backlog\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "inbox" || trimmed.startsWith("inbox ")) {
+        const { handleInbox } = await import("../../commands-gsd-core.js");
+        await handleInbox(trimmed.replace(/^inbox\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "import" || trimmed.startsWith("import ")) {
+        const { handleImport } = await import("../../commands-gsd-core.js");
+        await handleImport(trimmed.replace(/^import\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "ingest-docs" || trimmed.startsWith("ingest-docs ")) {
+        const { handleIngestDocs } = await import("../../commands-gsd-core.js");
+        await handleIngestDocs(trimmed.replace(/^ingest-docs\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "profile-user" || trimmed.startsWith("profile-user ")) {
+        const { handleProfileUser } = await import("../../commands-gsd-core.js");
+        await handleProfileUser(trimmed.replace(/^profile-user\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "settings" || trimmed.startsWith("settings ")) {
+        const { handleSettings } = await import("../../commands-gsd-core.js");
+        await handleSettings(trimmed.replace(/^settings\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }

package/dist/resources/extensions/gsd/commands-cmux.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { saveFile } from "./files.js";
-import { getProjectGSDPreferencesPath, loadEffectiveGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { clearGSDPreferencesCache, getProjectGSDPreferencesPath, loadEffectiveGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 /**
  * Auto-enable cmux in project preferences when detected but never configured.
@@ -29,6 +29,7 @@ export function autoEnableCmuxPreferences() {
     if (preserved)
         body = preserved;
     writeFileSync(path, `---\n${frontmatter}---${body}`, "utf-8");
+    clearGSDPreferencesCache();
     return true;
 }
 function extractBodyAfterFrontmatter(content) {
@@ -56,6 +57,7 @@ async function writeProjectCmuxPreferences(ctx, updater) {
             body = preserved;
     }
     await saveFile(path, `---\n${frontmatter}---${body}`);
+    clearGSDPreferencesCache();
     await ctx.waitForIdle();
     await ctx.reload();
 }

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

@@ -8,6 +8,8 @@ import { formatPercent, formatTokenCount } from "./metrics.js";
 import { countTokensSync } from "./token-counter.js";
 import { writeContextChartHtml } from "./context-chart-html.js";
 import { openInBrowser } from "./export.js";
+import { truncateWithEllipsis } from "../shared/format-utils.js";
+const REDACTED_TOOL_ARGUMENT_KEYS = new Set(["content", "oldText", "newText"]);
 function resolveProvider(provider) {
     const normalized = (provider ?? "unknown").toLowerCase();
     if (normalized === "anthropic" || normalized === "claude-code")
@@ -167,6 +169,22 @@ export function parseSystemPromptSections(systemPrompt, provider) {
     }
     return sections;
 }
+function redactToolCallArguments(value) {
+    if (Array.isArray(value))
+        return value.map(redactToolCallArguments);
+    if (!value || typeof value !== "object")
+        return value;
+    const safe = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (REDACTED_TOOL_ARGUMENT_KEYS.has(key)) {
+            safe[key] = typeof child === "string" ? truncateWithEllipsis(child, 101) : "[redacted]";
+        }
+        else {
+            safe[key] = redactToolCallArguments(child);
+        }
+    }
+    return safe;
+}
 function messageToText(message) {
     const role = message.role;
     if (role === "assistant") {
@@ -183,7 +201,7 @@ function messageToText(message) {
                     parts.push(typed.thinking);
                 if (typed.type === "toolCall") {
                     parts.push(typed.name ?? "tool");
-                    parts.push(JSON.stringify(typed.arguments ?? {}));
+                    parts.push(JSON.stringify(redactToolCallArguments(typed.arguments ?? {})));
                 }
             }
         }