@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/dist/resources/extensions/gsd/closeout-consistency-gate.js

@@ -1,10 +1,14 @@
 // Project/App: gsd-pi
 // File Purpose: Shared DB-backed guard for milestone closeout finalization.
-import { dirname } from "node:path";
-import { getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, insertAssessment, isDbAvailable, transaction, } from "./gsd-db.js";
 import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk, } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { closeQualityGatesFromEvidence } from "./quality-gate-closure.js";
+import { insertMilestoneValidationGates } from "./milestone-validation-gates.js";
+import { relMilestoneFile, resolveSliceFile } from "./paths.js";
+import { invalidateAllCaches } from "./cache.js";
 export const CLOSEOUT_CONSISTENCY_BLOCKED_REASON = "closeout-consistency-blocked";
 function blocked(reason, message) {
     return {
@@ -23,6 +27,80 @@ function artifactBasePathFromDb() {
         return undefined;
     return dirname(dirname(dbPath));
 }
+function allSlicesHaveCloseoutSummaryEvidence(milestoneId, artifactBasePath) {
+    const slices = getMilestoneSlices(milestoneId);
+    if (slices.length === 0)
+        return false;
+    return slices.every((slice) => {
+        if (!isClosedStatus(slice.status))
+            return false;
+        for (const task of getSliceTasks(milestoneId, slice.id)) {
+            if (!isClosedStatus(task.status))
+                return false;
+        }
+        const summaryPath = resolveSliceFile(artifactBasePath, milestoneId, slice.id, "SUMMARY");
+        return Boolean(summaryPath && existsSync(summaryPath));
+    });
+}
+function renderCloseoutPassThroughValidation(milestoneId) {
+    return [
+        "---",
+        "verdict: pass",
+        "skip_validation: true",
+        "skip_validation_reason: closeout-recovery",
+        "remediation_round: 0",
+        "---",
+        "",
+        "# Milestone Validation (skipped)",
+        "",
+        `Milestone validation was recorded during closeout for ${milestoneId} because all slices already had SUMMARY evidence and no milestone-validation assessment was present.`,
+        "",
+    ].join("\n");
+}
+function recordCloseoutPassThroughValidationIfReady(milestoneId, artifactBasePath) {
+    const basePath = artifactBasePath ?? artifactBasePathFromDb();
+    if (!basePath)
+        return false;
+    const existing = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    if (existing?.status === "pass")
+        return true;
+    if (existing)
+        return false;
+    if (!allSlicesHaveCloseoutSummaryEvidence(milestoneId, basePath))
+        return false;
+    const validationPath = join(basePath, relMilestoneFile(basePath, milestoneId, "VALIDATION"));
+    const content = renderCloseoutPassThroughValidation(milestoneId);
+    mkdirSync(dirname(validationPath), { recursive: true });
+    writeFileSync(validationPath, content, "utf-8");
+    try {
+        transaction(() => {
+            insertAssessment({
+                path: validationPath,
+                milestoneId,
+                sliceId: null,
+                taskId: null,
+                status: "pass",
+                scope: "milestone-validation",
+                fullContent: content,
+            });
+            const gateSliceId = getMilestoneSlices(milestoneId)[0]?.id;
+            if (gateSliceId) {
+                insertMilestoneValidationGates(milestoneId, gateSliceId, "pass", new Date().toISOString());
+            }
+        });
+    }
+    catch (err) {
+        try {
+            unlinkSync(validationPath);
+        }
+        catch {
+            // best effort cleanup
+        }
+        throw err;
+    }
+    invalidateAllCaches();
+    return true;
+}
 export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
     if (!isDbAvailable()) {
         return blocked("db-unavailable", `Closeout consistency blocked for ${milestoneId}: canonical DB is unavailable.`);
@@ -37,12 +115,22 @@ export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
     if (!isClosedStatus(milestone.status) && !options.allowOpenMilestone) {
         return blocked("milestone-open", `Closeout consistency blocked for ${milestoneId}: canonical DB milestone status is "${milestone.status}".`);
     }
-    const validation = milestone.status === "skipped"
+    let validation = milestone.status === "skipped"
         ? null
         : getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    if (milestone.status !== "skipped" &&
+        validation?.status !== "pass" &&
+        options.allowPassThroughValidation &&
+        recordCloseoutPassThroughValidationIfReady(milestoneId, options.artifactBasePath ?? artifactBasePathFromDb())) {
+        validation = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    }
     if (milestone.status !== "skipped") {
         if (validation?.status !== "pass") {
-            return blocked("validation-not-pass", `Closeout consistency blocked for ${milestoneId}: latest milestone validation is "${validation?.status ?? "absent"}".`);
+            const validationStatus = validation?.status ?? "absent";
+            const recovery = validationStatus === "absent"
+                ? ` Run \`/gsd validate-milestone ${milestoneId}\` to create the validation, or set \`phases.skip_milestone_validation: true\` in .gsd/PREFERENCES.md to skip it.`
+                : "";
+            return blocked("validation-not-pass", `Closeout consistency blocked for ${milestoneId}: latest milestone validation is "${validationStatus}".${recovery}`);
         }
     }
     const slices = getMilestoneSlices(milestoneId);

package/dist/resources/extensions/gsd/closeout-wizard.js

@@ -13,7 +13,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { findUnmergedCompletedMilestones, } from "./unmerged-milestone-guard.js";
 import { appendRequirementsBacklogToSummary } from "./requirements-backlog.js";
 import { nativeBranchList, nativeIsRepo } from "./native-git-bridge.js";
-import { allWorktreesDirs } from "./worktree-manager.js";
+import { allWorktreesDirs, isMilestoneWorktreeResidueCandidate, pruneEphemeralGhostWorktreeDirectories, } from "./worktree-manager.js";
 const MILESTONE_MERGE_CLOSEOUT_COMMANDS = [
     "/gsd status for overview",
     "/gsd visualize to inspect",
@@ -28,9 +28,13 @@ function listMilestoneWorktreeIds(basePath) {
         for (const entry of readdirSync(wtDir)) {
             if (!MILESTONE_ID_RE.test(entry))
                 continue;
+            const fullPath = join(wtDir, entry);
             try {
-                if (statSync(join(wtDir, entry)).isDirectory())
-                    ids.add(entry);
+                if (!statSync(fullPath).isDirectory())
+                    continue;
+                if (!isMilestoneWorktreeResidueCandidate(basePath, fullPath))
+                    continue;
+                ids.add(entry);
             }
             catch {
                 // skip unreadable entries
@@ -70,6 +74,7 @@ function isStrandedMilestoneId(milestoneId) {
 export function detectIdleMilestoneResidueHint(basePath) {
     if (!nativeIsRepo(basePath))
         return null;
+    pruneEphemeralGhostWorktreeDirectories(basePath);
     const gsdDir = join(basePath, ".gsd");
     const dbPath = join(gsdDir, "gsd.db");
     if (!existsSync(gsdDir) || !existsSync(dbPath)) {

package/dist/resources/extensions/gsd/codebase-generator.js

@@ -330,19 +330,16 @@ export function ensureCodebaseMapFresh(basePath, options, ensureOptions) {
     const ttlMs = ensureOptions?.ttlMs ?? DEFAULT_REFRESH_TTL_MS;
     const force = ensureOptions?.force === true;
     const now = Date.now();
-    // Enumerate files and compute fingerprint before the TTL check so that
-    // file changes are always detected, even within the TTL window.
-    const existing = readCodebaseMap(basePath);
-    const listed = enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
-    const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated);
-    // TTL short-circuit: only bypass regeneration when the fingerprint matches,
-    // confirming that no tracked files changed since the last check.
+    // TTL short-circuit: avoid spawning git on the per-turn freshness path.
     if (!force && ttlMs > 0) {
         const cached = freshnessCache.get(cacheKey);
-        if (cached && now - cached.checkedAt < ttlMs && cached.result.fingerprint === fingerprint) {
+        if (cached && now - cached.checkedAt < ttlMs) {
             return cached.result;
         }
     }
+    const existing = readCodebaseMap(basePath);
+    const listed = enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
+    const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated);
     const cacheAndReturn = (result) => {
         freshnessCache.set(cacheKey, { checkedAt: now, result });
         return result;

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/core.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
-import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
+import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.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 +10,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 +55,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 +159,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)
@@ -257,7 +286,10 @@ export async function handleSetup(args, ctx, pi) {
         return;
     }
     if (args === "model") {
-        await handleModel("", ctx, pi);
+        // Default model picker: persist settings.json default only — do not pin the
+        // session override that /gsd model uses, or PREFERENCES.md per-phase models
+        // are ignored for the rest of this session (#model-prefs-precedence).
+        await handleModel("", ctx, pi, { pinSession: false });
         return;
     }
     if (args === "keys") {
@@ -361,7 +393,7 @@ async function resolveRequestedModel(query, ctx) {
         return undefined;
     return selectModelByProvider(`Multiple models match "${query}"`, partialMatches, ctx, ctx.model);
 }
-async function handleModel(trimmedArgs, ctx, pi) {
+async function handleModel(trimmedArgs, ctx, pi, options) {
     const availableModels = ctx.modelRegistry.getAvailable();
     if (availableModels.length === 0) {
         ctx.ui.notify("No available models found. Check provider auth and model discovery.", "warning");
@@ -395,15 +427,18 @@ async function handleModel(trimmedArgs, ctx, pi) {
     }
     // /gsd model is an explicit per-session pin for GSD dispatches.
     // This is captured at auto bootstrap so it survives internal session
-    // switches during /gsd auto and /gsd next runs.
+    // switches during /gsd auto and /gsd next runs. /gsd setup model skips
+    // this pin so PREFERENCES.md per-phase models keep precedence.
+    const pinSession = options?.pinSession !== false;
     const sessionId = ctx.sessionManager?.getSessionId?.();
-    if (sessionId) {
+    if (pinSession && sessionId) {
         setSessionModelOverride(sessionId, {
             provider: targetModel.provider,
             id: targetModel.id,
         });
     }
-    ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}`, "info");
+    const pinNote = pinSession ? "" : " (default updated; per-phase prefs still apply in auto)";
+    ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}${pinNote}`, "info");
 }
 export async function handleCoreCommand(trimmed, ctx, pi) {
     if (trimmed === "help" || trimmed === "h" || trimmed === "?" || trimmed.startsWith("help ")) {
@@ -470,7 +505,16 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
     }
     if (trimmed === "show-config") {
         const { GSDConfigOverlay, formatConfigText } = await import("../../config-overlay.js");
-        const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDConfigOverlay(tui, theme, () => done(true)), {
+        const basePath = projectRoot();
+        const anchorProvider = resolveProfileAnchorProvider(ctx.model?.provider);
+        const disabledProviders = resolveDisabledModelProvidersFromPreferences();
+        const availableModelIds = modelIdsForProfileResolution(ctx.modelRegistry, anchorProvider, disabledProviders);
+        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,
             overlayOptions: {
                 width: "65%",
@@ -480,7 +524,7 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
             },
         });
         if (result === undefined) {
-            ctx.ui.notify(formatConfigText(), "info");
+            ctx.ui.notify(formatConfigText(configOptions), "info");
         }
         return true;
     }