gsd-pi 2.64.0-dev.9c14bd0 → 2.64.0-dev.b3ee078

package/dist/headless.js

@@ -184,7 +184,9 @@ async function runHeadlessOnce(options, restartCount) {
     // per-unit timeout via auto-supervisor. Disable the overall timeout unless the
     // user explicitly set --timeout.
     const isAutoMode = options.command === 'auto';
-    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next';
+    // discuss and plan are multi-turn: they involve multiple question rounds,
+    // codebase scanning, and artifact writing before the workflow completes (#3547).
+    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next' || options.command === 'discuss' || options.command === 'plan';
     if (isAutoMode && options.timeout === 300_000) {
         options.timeout = 0;
     }

package/dist/resources/extensions/bg-shell/bg-shell-lifecycle.js

@@ -3,7 +3,7 @@
  * context injection, process discovery, footer widget, and periodic maintenance.
  */
 import { truncateToWidth, visibleWidth, } from "@gsd/pi-tui";
-import { processes, pendingAlerts, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
+import { processes, pendingAlerts, pushAlert, cleanupAll, cleanupSessionProcesses, persistManifest, loadManifest, pruneDeadProcesses, } from "./process-manager.js";
 import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 export function registerBgShellLifecycle(pi, state) {
@@ -15,17 +15,32 @@ export function registerBgShellLifecycle(pi, state) {
             state.latestCtx = { ...state.latestCtx, cwd: syncedCwd };
         }
     }
-    // Clean up on session shutdown
-    pi.on("session_shutdown", async () => {
-        cleanupAll();
-    });
     // Register signal handlers to clean up bg processes on unexpected exit (fixes #428)
     const signalCleanup = () => {
         cleanupAll();
+        // Also kill bash-tool spawned children that bg-shell doesn't track
+        try {
+            const { listDescendants } = require("@gsd/native");
+            const descendants = listDescendants(process.pid);
+            for (const childPid of descendants) {
+                try {
+                    process.kill(childPid, "SIGKILL");
+                }
+                catch { }
+            }
+        }
+        catch { }
     };
     process.on("SIGTERM", signalCleanup);
     process.on("SIGINT", signalCleanup);
     process.on("beforeExit", signalCleanup);
+    // Clean up on session shutdown — remove signal handlers to prevent accumulation
+    pi.on("session_shutdown", async () => {
+        process.off("SIGTERM", signalCleanup);
+        process.off("SIGINT", signalCleanup);
+        process.off("beforeExit", signalCleanup);
+        cleanupAll();
+    });
     // ── Compaction Awareness: Survive Context Resets ───────────────
     /** Build a compact state summary of all alive processes for context re-injection */
     function buildProcessStateAlert(reason) {
@@ -39,7 +54,7 @@ export function registerBgShellLifecycle(pi, state) {
             const groupInfo = p.group ? ` [${p.group}]` : "";
             return `  - id:${p.id} "${p.label}" [${p.processType}] status:${p.status} uptime:${formatUptime(Date.now() - p.startedAt)}${portInfo}${urlInfo}${errInfo}${groupInfo}`;
         }).join("\n");
-        pendingAlerts.push(`${reason} ${alive.length} background process(es) are still running:\n${processSummaries}\nUse bg_shell digest/output/kill with these IDs.`);
+        pushAlert(null, `${reason} ${alive.length} background process(es) are still running:\n${processSummaries}\nUse bg_shell digest/output/kill with these IDs.`);
     }
     // After compaction, the LLM loses all memory of running processes.
     // Queue a detailed alert so the next before_agent_start injects full state.
@@ -108,7 +123,7 @@ export function registerBgShellLifecycle(pi, state) {
             }
             if (surviving.length > 0) {
                 const summary = surviving.map(s => `  - ${s.id}: ${s.label} (pid ${s.pid}, type: ${s.processType}${s.group ? `, group: ${s.group}` : ""})`).join("\n");
-                pendingAlerts.push(`${surviving.length} background process(es) from previous session still running:\n${summary}\n  Note: These processes are outside bg_shell's control. Kill them manually if needed.`);
+                pushAlert(null, `${surviving.length} background process(es) from previous session still running:\n${summary}\n  Note: These processes are outside bg_shell's control. Kill them manually if needed.`);
             }
         }
     });

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -16,6 +16,7 @@ import { startPortProbing, transitionToReady } from "./readiness-detector.js";
 export const processes = new Map();
 /** Pending alerts to inject into the next agent context */
 export let pendingAlerts = [];
+const MAX_PENDING_ALERTS = 50;
 /** Replace the pendingAlerts array (used by the extension entry point) */
 export function setPendingAlerts(alerts) {
     pendingAlerts = alerts;
@@ -41,7 +42,11 @@ export function addEvent(bg, event) {
     }
 }
 export function pushAlert(bg, message) {
-    pendingAlerts.push(`[bg:${bg.id} ${bg.label}] ${message}`);
+    const prefix = bg ? `[bg:${bg.id} ${bg.label}] ` : "";
+    pendingAlerts.push(`${prefix}${message}`);
+    if (pendingAlerts.length > MAX_PENDING_ALERTS) {
+        pendingAlerts.splice(0, pendingAlerts.length - MAX_PENDING_ALERTS);
+    }
 }
 export function getInfo(p) {
     return {

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

@@ -768,31 +768,42 @@ export function registerDbTools(pi) {
                 return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
             };
             const coerced = { ...params };
-            coerced.filesModified = (params.filesModified ?? []).map((f) => {
+            // Coerce simple string-array fields: LLMs sometimes pass a plain string
+            // instead of a single-element array (#3585).
+            const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
+            coerced.provides = wrapArray(params.provides);
+            coerced.keyFiles = wrapArray(params.keyFiles);
+            coerced.keyDecisions = wrapArray(params.keyDecisions);
+            coerced.patternsEstablished = wrapArray(params.patternsEstablished);
+            coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
+            coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
+            coerced.drillDownPaths = wrapArray(params.drillDownPaths);
+            coerced.affects = wrapArray(params.affects);
+            coerced.filesModified = wrapArray(params.filesModified).map((f) => {
                 if (typeof f !== "string")
                     return f;
                 const [path, description] = splitPair(f);
                 return { path, description };
             });
-            coerced.requires = (params.requires ?? []).map((r) => {
+            coerced.requires = wrapArray(params.requires).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [slice, provides] = splitPair(r);
                 return { slice, provides };
             });
-            coerced.requirementsAdvanced = (params.requirementsAdvanced ?? []).map((r) => {
+            coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, how] = splitPair(r);
                 return { id, how };
             });
-            coerced.requirementsValidated = (params.requirementsValidated ?? []).map((r) => {
+            coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, proof] = splitPair(r);
                 return { id, proof };
             });
-            coerced.requirementsInvalidated = (params.requirementsInvalidated ?? []).map((r) => {
+            coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, what] = splitPair(r);
@@ -851,14 +862,14 @@ export function registerDbTools(pi) {
             deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
             knownLimitations: Type.Optional(Type.String({ description: "Known limitations or gaps, or 'None.'" })),
             followUps: Type.Optional(Type.String({ description: "Follow-up work discovered during execution, or 'None.'" })),
-            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified" })),
-            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key decisions made during this slice" })),
-            patternsEstablished: Type.Optional(Type.Array(Type.String(), { description: "Patterns established by this slice" })),
-            observabilitySurfaces: Type.Optional(Type.Array(Type.String(), { description: "Observability surfaces added" })),
-            provides: Type.Optional(Type.Array(Type.String(), { description: "What this slice provides to downstream slices" })),
-            requirementsSurfaced: Type.Optional(Type.Array(Type.String(), { description: "New requirements surfaced" })),
-            drillDownPaths: Type.Optional(Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" })),
-            affects: Type.Optional(Type.Array(Type.String(), { description: "Downstream slices affected" })),
+            keyFiles: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key decisions made during this slice" })),
+            patternsEstablished: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Patterns established by this slice" })),
+            observabilitySurfaces: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Observability surfaces added" })),
+            provides: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "What this slice provides to downstream slices" })),
+            requirementsSurfaced: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "New requirements surfaced" })),
+            drillDownPaths: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Paths to task summaries for drill-down" })),
+            affects: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Downstream slices affected" })),
             requirementsAdvanced: Type.Optional(Type.Array(Type.Union([
                 Type.Object({
                     id: Type.String({ description: "Requirement ID" }),

package/dist/resources/extensions/gsd/bootstrap/notify-interceptor.js

@@ -0,0 +1,28 @@
+// GSD Extension — Notify Interceptor
+// Wraps ctx.ui.notify() in-place to persist every notification through the
+// notification store. Uses a WeakSet to prevent double-wrapping and handle
+// UI context replacement on /reload gracefully.
+import { appendNotification } from "../notification-store.js";
+// Track which ui context objects have been wrapped to prevent double-install.
+// WeakSet allows GC to collect replaced uiContext instances after /reload.
+const _wrappedContexts = new WeakSet();
+/**
+ * Install the notify interceptor on a context's UI object.
+ * Mutates ctx.ui.notify in place — the original is called after persistence.
+ * Safe to call multiple times; no-ops if already installed on the same ui object.
+ */
+export function installNotifyInterceptor(ctx) {
+    if (_wrappedContexts.has(ctx.ui))
+        return;
+    const originalNotify = ctx.ui.notify.bind(ctx.ui);
+    ctx.ui.notify = (message, type) => {
+        try {
+            appendNotification(message, (type ?? "info"), "notify");
+        }
+        catch {
+            // Non-fatal — never let persistence break the UI
+        }
+        originalNotify(message, type);
+    };
+    _wrappedContexts.add(ctx.ui);
+}

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -18,6 +18,9 @@ import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult } from "../safety/evidence-collector.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
 import { logWarning as safetyLogWarning } from "../workflow-logger.js";
+import { installNotifyInterceptor } from "./notify-interceptor.js";
+import { initNotificationStore } from "../notification-store.js";
+import { initNotificationWidget } from "../notification-widget.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -27,6 +30,9 @@ async function syncServiceTierStatus(ctx) {
 }
 export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
+        initNotificationWidget(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -63,6 +69,8 @@ export function registerHooks(pi) {
         loadToolApiKeys();
     });
     pi.on("session_switch", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { GSDNotificationOverlay } from "../notification-overlay.js";
 import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
@@ -23,6 +24,21 @@ export function registerShortcuts(pi) {
             });
         },
     });
+    pi.registerShortcut(Key.ctrlAlt("n"), {
+        description: shortcutDesc("Open notification history", "/gsd notifications"),
+        handler: async (ctx) => {
+            await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()), {
+                overlay: true,
+                overlayOptions: {
+                    width: "80%",
+                    minWidth: 60,
+                    maxHeight: "88%",
+                    anchor: "center",
+                    backdrop: true,
+                },
+            });
+        },
+    });
     pi.registerShortcut(Key.ctrlAlt("p"), {
         description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
         handler: async (ctx) => {

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -229,6 +229,12 @@ function buildWorktreeContextBlock() {
     }
     return "";
 }
+/**
+ * Low-entropy resume intent patterns — short phrases a user types to
+ * continue work after a pause, rate limit, or context reset (#3615).
+ * Tested against the trimmed, lowercased prompt with trailing punctuation stripped.
+ */
+const RESUME_INTENT_PATTERNS = /^(continue|resume|ok|go|go ahead|proceed|keep going|carry on|next|yes|yeah|yep|sure|do it|let's go|pick up where you left off)$/;
 async function buildGuidedExecuteContextInjection(prompt, basePath) {
     const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (executeMatch) {
@@ -243,6 +249,20 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
             return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, state.activeTask.id, state.activeTask.title);
         }
     }
+    // Fallback: low-entropy resume prompt (e.g., "continue", "ok", "go ahead")
+    // during an active executing task — inject task context so the agent
+    // doesn't rebuild from scratch (#3615).
+    // Intent-gated: only fire for short, resume-like prompts to avoid hijacking
+    // control/help/diagnostic prompts with unrelated execution context.
+    // Phase-gated: only fire during "executing" to avoid misrouting during
+    // replanning, gate evaluation, or other non-execution phases.
+    const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+    if (RESUME_INTENT_PATTERNS.test(trimmed)) {
+        const state = await deriveState(basePath);
+        if (state.phase === "executing" && state.activeTask && state.activeMilestone && state.activeSlice) {
+            return buildTaskExecutionContextInjection(basePath, state.activeMilestone.id, state.activeSlice.id, state.activeTask.id, state.activeTask.title);
+        }
+    }
     return null;
 }
 async function buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, taskId, taskTitle) {

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -36,6 +36,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "hooks", desc: "Show configured post-unit and pre-dispatch hooks" },
     { cmd: "run-hook", desc: "Manually trigger a specific hook" },
     { cmd: "skill-health", desc: "Skill lifecycle dashboard" },
+    { cmd: "notifications", desc: "View, filter, and clear persistent notification history" },
     { cmd: "doctor", desc: "Runtime health checks with auto-fix" },
     { cmd: "logs", desc: "Browse activity logs, debug logs, and metrics" },
     { cmd: "forensics", desc: "Examine execution logs" },
@@ -97,6 +98,11 @@ const NESTED_COMPLETIONS = {
         { cmd: "keys", desc: "Manage API keys" },
         { cmd: "prefs", desc: "Configure global preferences" },
     ],
+    notifications: [
+        { cmd: "clear", desc: "Clear all notifications" },
+        { cmd: "tail", desc: "Show last N notifications (default: 20)" },
+        { cmd: "filter", desc: "Filter by severity (error|warning|info|success)" },
+    ],
     logs: [
         { cmd: "debug", desc: "List or view debug log files" },
         { cmd: "tail", desc: "Show last N activity log summaries" },

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

@@ -25,6 +25,7 @@ export function showHelp(ctx) {
         "  /gsd queue          Show queued/dispatched units and execution order",
         "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
         "  /gsd changelog      Show categorized release notes  [version]",
+        "  /gsd notifications  View persistent notification history  [clear|tail|filter]  (Ctrl+Alt+N)",
         "",
         "COURSE CORRECTION",
         "  /gsd steer <desc>   Apply user override to active work",

package/dist/resources/extensions/gsd/commands/handlers/notifications-handler.js

@@ -0,0 +1,104 @@
+// GSD Extension — /gsd notifications Command Handler
+// View, filter, and clear the persistent notification history.
+import { readNotifications, clearNotifications, getUnreadCount, suppressPersistence, unsuppressPersistence, } from "../../notification-store.js";
+import { GSDNotificationOverlay } from "../../notification-overlay.js";
+function severityIcon(severity) {
+    switch (severity) {
+        case "error": return "✗";
+        case "warning": return "⚠";
+        case "success": return "✓";
+        case "info":
+        default: return "●";
+    }
+}
+function formatTimestamp(ts) {
+    try {
+        const d = new Date(ts);
+        return d.toLocaleString("en-US", { hour12: false, month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+    }
+    catch {
+        return ts.slice(0, 19);
+    }
+}
+export async function handleNotificationsCommand(args, ctx, pi) {
+    // /gsd notifications clear
+    if (args === "clear") {
+        clearNotifications();
+        // Suppress persistence so the confirmation toast doesn't re-populate the store
+        suppressPersistence();
+        try {
+            ctx.ui.notify("All notifications cleared.", "success");
+        }
+        finally {
+            unsuppressPersistence();
+        }
+        return true;
+    }
+    // /gsd notifications tail [N]
+    if (args === "tail" || args.startsWith("tail ")) {
+        const countStr = args.replace(/^tail\s*/, "").trim();
+        const count = countStr ? parseInt(countStr, 10) : 20;
+        const n = isNaN(count) || count < 1 ? 20 : Math.min(count, 100);
+        const entries = readNotifications().slice(0, n);
+        if (entries.length === 0) {
+            ctx.ui.notify("No notifications.", "info");
+            return true;
+        }
+        const lines = entries.map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        ctx.ui.notify(`Last ${entries.length} notification(s):\n${lines.join("\n")}`, "info");
+        return true;
+    }
+    // /gsd notifications filter <severity>
+    if (args.startsWith("filter ")) {
+        const severity = args.replace(/^filter\s+/, "").trim().toLowerCase();
+        if (!["error", "warning", "info", "success"].includes(severity)) {
+            ctx.ui.notify("Usage: /gsd notifications filter <error|warning|info|success>", "warning");
+            return true;
+        }
+        const entries = readNotifications().filter((e) => e.severity === severity);
+        if (entries.length === 0) {
+            ctx.ui.notify(`No ${severity} notifications.`, "info");
+            return true;
+        }
+        const lines = entries.slice(0, 20).map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        const suffix = entries.length > 20 ? `\n... and ${entries.length - 20} more` : "";
+        ctx.ui.notify(`${severity} notifications (${entries.length}):\n${lines.join("\n")}${suffix}`, "info");
+        return true;
+    }
+    // /gsd notifications (no args) — open overlay in TUI, or print summary
+    if (args === "" || args === "status") {
+        // Try overlay first (TUI mode)
+        if (ctx.hasUI) {
+            try {
+                await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()), {
+                    overlay: true,
+                    overlayOptions: {
+                        width: "80%",
+                        minWidth: 60,
+                        maxHeight: "88%",
+                        anchor: "center",
+                        backdrop: true,
+                    },
+                });
+                return true;
+            }
+            catch {
+                // Fall through to text output if overlay fails
+            }
+        }
+        // Text fallback (RPC/headless mode)
+        const unread = getUnreadCount();
+        const entries = readNotifications().slice(0, 10);
+        if (entries.length === 0) {
+            ctx.ui.notify("No notifications.", "info");
+            return true;
+        }
+        const lines = entries.map((e) => `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`);
+        const header = unread > 0 ? `${unread} unread — ` : "";
+        ctx.ui.notify(`${header}Recent notifications:\n${lines.join("\n")}`, "info");
+        return true;
+    }
+    // Unknown subcommand
+    ctx.ui.notify("Usage: /gsd notifications [clear|tail [N]|filter <severity>]", "warning");
+    return true;
+}

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

@@ -175,6 +175,11 @@ Examples:
         await dispatchDirectPhase(ctx, pi, phase, projectRoot());
         return true;
     }
+    if (trimmed === "notifications" || trimmed.startsWith("notifications ")) {
+        const { handleNotificationsCommand } = await import("./notifications-handler.js");
+        await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "inspect") {
         await handleInspect(ctx);
         return true;