gsd-pi 2.73.1 → 2.74.0-dev.0306a2e

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -2,9 +2,10 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
-import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
+import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
+import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
@@ -12,6 +13,7 @@ import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
+import { logWarning } from "../workflow-logger.js";
 
 export { writeCrashLog } from "./crash-log.js";
 
@@ -58,12 +60,17 @@ function installEpipeGuard(): void {
 }
 
 export function registerGsdExtension(pi: ExtensionAPI): void {
-  registerGSDCommand(pi);
+  // Note: registerGSDCommand is called by index.ts before this function,
+  // so we intentionally skip it here to avoid double-registration.
   registerWorktreeCommand(pi);
   registerExitCommand(pi);
 
   installEpipeGuard();
 
+  // Ecosystem handlers captured by the GSDExtensionAPI wrapper for the
+  // GSD-owned `before_agent_start` dispatch step (#3338).
+  const ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[] = [];
+
   pi.registerCommand("kill", {
     description: "Exit GSD immediately (no cleanup)",
     handler: async (_args: string, _ctx: ExtensionCommandContext) => {
@@ -71,10 +78,33 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
     },
   });
 
-  registerDynamicTools(pi);
-  registerDbTools(pi);
-  registerJournalTools(pi);
-  registerQueryTools(pi);
-  registerShortcuts(pi);
-  registerHooks(pi);
+  // Wrap non-critical registrations individually so one failure
+  // doesn't prevent the others from loading.
+  const nonCriticalRegistrations: Array<[string, () => void]> = [
+    ["dynamic-tools", () => registerDynamicTools(pi)],
+    ["db-tools", () => registerDbTools(pi)],
+    ["journal-tools", () => registerJournalTools(pi)],
+    ["query-tools", () => registerQueryTools(pi)],
+    ["shortcuts", () => registerShortcuts(pi)],
+    ["hooks", () => registerHooks(pi, ecosystemHandlers)],
+    ["ecosystem", () => {
+      void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
+        logWarning(
+          "ecosystem",
+          `loader failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      });
+    }],
+  ];
+
+  for (const [name, register] of nonCriticalRegistrations) {
+    try {
+      register();
+    } catch (err) {
+      logWarning(
+        "bootstrap",
+        `Failed to register ${name}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
 }

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -3,6 +3,10 @@ import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
 
+import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
+import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
+import { getEcosystemReadyPromise } from "../ecosystem/loader.js";
+
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
@@ -35,7 +39,10 @@ async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
   ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
 
-export function registerHooks(pi: ExtensionAPI): void {
+export function registerHooks(
+  pi: ExtensionAPI,
+  ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[],
+): void {
   pi.on("session_start", async (_event, ctx) => {
     initNotificationStore(process.cwd());
     installNotifyInterceptor(ctx);
@@ -93,7 +100,50 @@ export function registerHooks(pi: ExtensionAPI): void {
   });
 
   pi.on("before_agent_start", async (event, ctx: ExtensionContext) => {
-    return buildBeforeAgentStartResult(event, ctx);
+    // Wait for ecosystem loader to finish (no-op after first turn).
+    await getEcosystemReadyPromise();
+
+    // GSD's own context injection (existing behavior — unchanged).
+    const gsdResult = await buildBeforeAgentStartResult(event, ctx);
+
+    // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
+    // deriveState has its own ~100ms cache so this is cheap on repeat calls.
+    try {
+      const state = await deriveState(process.cwd());
+      updateSnapshot(state);
+    } catch {
+      updateSnapshot(null);
+    }
+
+    // Chain ecosystem handlers using pi's runner.ts chaining protocol:
+    // each handler sees the systemPrompt mutated by prior handlers.
+    let currentSystemPrompt = gsdResult?.systemPrompt ?? event.systemPrompt;
+    // `any` because pi's BeforeAgentStartEventResult.message uses an internal
+    // CustomMessage type that's not re-exported (see ecosystem/gsd-extension-api.ts).
+    let lastMessage: any = gsdResult?.message;
+
+    for (const handler of ecosystemHandlers) {
+      try {
+        const r = await handler(
+          { ...event, systemPrompt: currentSystemPrompt },
+          ctx,
+        );
+        if (r?.systemPrompt !== undefined) currentSystemPrompt = r.systemPrompt;
+        if (r?.message) lastMessage = r.message;
+      } catch (err) {
+        safetyLogWarning(
+          "ecosystem",
+          `before_agent_start handler failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
+    // Compose result. Return undefined if nothing changed (preserves runner contract).
+    if (currentSystemPrompt === event.systemPrompt && !lastMessage) return undefined;
+    return {
+      systemPrompt: currentSystemPrompt !== event.systemPrompt ? currentSystemPrompt : undefined,
+      message: lastMessage,
+    };
   });
 
   pi.on("agent_end", async (event, ctx: ExtensionContext) => {

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -15,7 +15,7 @@ export interface GsdCommandDefinition {
 type CompletionMap = Record<string, readonly GsdCommandDefinition[]>;
 
 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|model|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";
+  "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|model|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|ship|do|session-report|backlog|pr-branch|add-tests";
 
 export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -74,6 +74,12 @@ export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
   { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
   { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
+  { cmd: "ship", desc: "Create PR from milestone artifacts and open for review" },
+  { cmd: "do", desc: "Route freeform text to the right GSD command" },
+  { cmd: "session-report", desc: "Session cost, tokens, and work summary" },
+  { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
+  { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
+  { cmd: "add-tests", desc: "Generate tests for completed slices" },
 ];
 
 const NESTED_COMPLETIONS: CompletionMap = {
@@ -244,6 +250,25 @@ const NESTED_COMPLETIONS: CompletionMap = {
     { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
     { cmd: "help", desc: "Show usage and available subcommands" },
   ],
+  ship: [
+    { cmd: "--dry-run", desc: "Preview PR without creating" },
+    { cmd: "--draft", desc: "Open as draft PR" },
+    { cmd: "--base", desc: "Override target branch (default: main)" },
+    { cmd: "--force", desc: "Ship even with pending tasks" },
+  ],
+  "session-report": [
+    { cmd: "--json", desc: "Machine-readable JSON output" },
+    { cmd: "--save", desc: "Save report to .gsd/reports/" },
+  ],
+  backlog: [
+    { cmd: "add", desc: "Add item to backlog" },
+    { cmd: "promote", desc: "Promote backlog item to active slice" },
+    { cmd: "remove", desc: "Remove backlog item" },
+  ],
+  "pr-branch": [
+    { cmd: "--dry-run", desc: "Preview what would be filtered" },
+    { cmd: "--name", desc: "Custom branch name" },
+  ],
 };
 
 function filterOptions(

package/src/resources/extensions/gsd/commands/handlers/ops.ts

@@ -11,6 +11,9 @@ import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
 import { handleUndo } from "../../undo.js";
 import { handleRemote } from "../../../remote-questions/mod.js";
+import { handleShip } from "../../commands-ship.js";
+import { handleSessionReport } from "../../commands-session-report.js";
+import { handlePrBranch } from "../../commands-pr-branch.js";
 import { projectRoot } from "../context.js";
 
 export async function handleOpsCommand(trimmed: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<boolean> {
@@ -216,5 +219,27 @@ Examples:
     await handleCodebase(trimmed.replace(/^codebase\s*/, "").trim(), ctx, pi);
     return true;
   }
+  if (trimmed === "ship" || trimmed.startsWith("ship ")) {
+    await handleShip(trimmed.replace(/^ship\s*/, "").trim(), ctx, pi);
+    return true;
+  }
+  if (trimmed === "session-report" || trimmed.startsWith("session-report ")) {
+    await handleSessionReport(trimmed.replace(/^session-report\s*/, "").trim(), ctx);
+    return true;
+  }
+  if (trimmed === "pr-branch" || trimmed.startsWith("pr-branch ")) {
+    await handlePrBranch(trimmed.replace(/^pr-branch\s*/, "").trim(), ctx);
+    return true;
+  }
+  if (trimmed === "add-tests" || trimmed.startsWith("add-tests ")) {
+    const { handleAddTests } = await import("../../commands-add-tests.js");
+    await handleAddTests(trimmed.replace(/^add-tests\s*/, "").trim(), ctx, pi);
+    return true;
+  }
+  if (trimmed === "extract-learnings" || trimmed.startsWith("extract-learnings ")) {
+    const { handleExtractLearnings } = await import("../../commands-extract-learnings.js");
+    await handleExtractLearnings(trimmed.replace(/^extract-learnings\s*/, "").trim(), ctx, pi);
+    return true;
+  }
   return false;
 }

package/src/resources/extensions/gsd/commands/handlers/workflow.ts

@@ -38,6 +38,67 @@ const WORKFLOW_USAGE = [
   "  resume            — Resume paused custom workflow auto-mode",
 ].join("\n");
 
+function splitWorkflowRunArgs(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | null = null;
+  let escapeNext = false;
+
+  for (const ch of input) {
+    if (escapeNext) {
+      current += ch;
+      escapeNext = false;
+      continue;
+    }
+
+    if (ch === "\\") {
+      escapeNext = true;
+      continue;
+    }
+
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (escapeNext) current += "\\";
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+export function parseWorkflowRunArgs(args: string): { defName: string; overrides: Record<string, string> } {
+  const parts = splitWorkflowRunArgs(args);
+  const defName = parts[0] ?? "";
+  const overrides: Record<string, string> = {};
+  for (let i = 1; i < parts.length; i++) {
+    const eqIdx = parts[i].indexOf("=");
+    if (eqIdx > 0) {
+      overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
+    }
+  }
+  return { defName, overrides };
+}
+
 async function handleCustomWorkflow(
   sub: string,
   ctx: ExtensionCommandContext,
@@ -62,15 +123,7 @@ async function handleCustomWorkflow(
       ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
       return true;
     }
-    const parts = args.split(/\s+/);
-    const defName = parts[0];
-    const overrides: Record<string, string> = {};
-    for (let i = 1; i < parts.length; i++) {
-      const eqIdx = parts[i].indexOf("=");
-      if (eqIdx > 0) {
-        overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
-      }
-    }
+    const { defName, overrides } = parseWorkflowRunArgs(args);
     try {
       const base = projectRoot();
       const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
@@ -168,6 +221,18 @@ async function handleCustomWorkflow(
 }
 
 export async function handleWorkflowCommand(trimmed: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<boolean> {
+  // ── /gsd do — natural language routing (must be early to route to other commands) ──
+  if (trimmed === "do" || trimmed.startsWith("do ")) {
+    const { handleDo } = await import("../../commands-do.js");
+    await handleDo(trimmed.replace(/^do\s*/, "").trim(), ctx, pi);
+    return true;
+  }
+  // ── Backlog management ──
+  if (trimmed === "backlog" || trimmed.startsWith("backlog ")) {
+    const { handleBacklog } = await import("../../commands-backlog.js");
+    await handleBacklog(trimmed.replace(/^backlog\s*/, "").trim(), ctx, pi);
+    return true;
+  }
   // ── Custom workflow commands (`/gsd workflow ...`) ──
   if (trimmed === "workflow" || trimmed.startsWith("workflow ")) {
     const sub = trimmed.slice("workflow".length).trim();

package/src/resources/extensions/gsd/commands-add-tests.ts

@@ -0,0 +1,137 @@
+/**
+ * GSD Command — /gsd add-tests
+ *
+ * Generates tests for a completed slice by dispatching an LLM prompt
+ * with implementation context (summaries, changed files, test patterns).
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { deriveState } from "./state.js";
+import { gsdRoot, resolveSliceFile } from "./paths.js";
+import { loadPrompt } from "./prompt-loader.js";
+
+function findLastCompletedSlice(basePath: string, milestoneId: string): string | null {
+  // Scan disk for slices that have a SUMMARY.md (indicating completion)
+  const slicesDir = join(gsdRoot(basePath), "milestones", milestoneId, "slices");
+  if (!existsSync(slicesDir)) return null;
+
+  try {
+    const entries = readdirSync(slicesDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+      .sort((a, b) => b.name.localeCompare(a.name)); // reverse order — latest first
+
+    for (const entry of entries) {
+      const summaryPath = join(slicesDir, entry.name, `${entry.name}-SUMMARY.md`);
+      if (existsSync(summaryPath)) return entry.name;
+    }
+  } catch {
+    // non-fatal
+  }
+  return null;
+}
+
+function readSliceSummary(basePath: string, milestoneId: string, sliceId: string): { title: string; content: string } {
+  const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+  if (summaryPath && existsSync(summaryPath)) {
+    const content = readFileSync(summaryPath, "utf-8");
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    return { title: titleMatch?.[1] ?? sliceId, content };
+  }
+  return { title: sliceId, content: "(no summary available)" };
+}
+
+function detectTestPatterns(basePath: string): string {
+  const patterns: string[] = [];
+
+  // Check for common test configs
+  const checks = [
+    { file: "jest.config.ts", name: "Jest" },
+    { file: "jest.config.js", name: "Jest" },
+    { file: "vitest.config.ts", name: "Vitest" },
+    { file: "vitest.config.js", name: "Vitest" },
+    { file: ".mocharc.yml", name: "Mocha" },
+  ];
+
+  for (const check of checks) {
+    if (existsSync(join(basePath, check.file))) {
+      patterns.push(`Framework: ${check.name} (${check.file})`);
+    }
+  }
+
+  // Look for existing test files to infer patterns
+  const testDirs = ["tests", "test", "src/__tests__", "__tests__"];
+  for (const dir of testDirs) {
+    const fullDir = join(basePath, dir);
+    if (existsSync(fullDir)) {
+      try {
+        const files = readdirSync(fullDir).filter((f) => f.endsWith(".test.ts") || f.endsWith(".spec.ts") || f.endsWith(".test.js"));
+        if (files.length > 0) {
+          patterns.push(`Test directory: ${dir}/ (${files.length} test files)`);
+          // Read first test file for patterns
+          const samplePath = join(fullDir, files[0]);
+          const sample = readFileSync(samplePath, "utf-8").slice(0, 500);
+          patterns.push(`Sample pattern from ${files[0]}:\n${sample}`);
+          break;
+        }
+      } catch {
+        // non-fatal
+      }
+    }
+  }
+
+  return patterns.length > 0 ? patterns.join("\n") : "No test framework detected. Use Node.js built-in test runner.";
+}
+
+export async function handleAddTests(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const basePath = process.cwd();
+  const state = await deriveState(basePath);
+
+  if (!state.activeMilestone) {
+    ctx.ui.notify("No active milestone.", "warning");
+    return;
+  }
+
+  const milestoneId = state.activeMilestone.id;
+
+  // Determine target
+  const targetId = args.trim() || findLastCompletedSlice(basePath, milestoneId);
+  if (!targetId) {
+    ctx.ui.notify(
+      "No completed slices found. Specify a slice ID: /gsd add-tests S03",
+      "warning",
+    );
+    return;
+  }
+
+  // Gather context
+  const summary = readSliceSummary(basePath, milestoneId, targetId);
+  const testPatterns = detectTestPatterns(basePath);
+
+  ctx.ui.notify(`Generating tests for ${targetId}: "${summary.title}"...`, "info");
+
+  try {
+    const prompt = loadPrompt("add-tests", {
+      sliceId: targetId,
+      sliceTitle: summary.title,
+      sliceSummary: summary.content,
+      existingTestPatterns: testPatterns,
+      workingDirectory: basePath,
+    });
+
+    pi.sendMessage(
+      { customType: "gsd-add-tests", content: prompt, display: false },
+      { triggerTurn: true },
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.ui.notify(`Failed to dispatch test generation: ${msg}`, "error");
+  }
+}

package/src/resources/extensions/gsd/commands-backlog.ts

@@ -0,0 +1,182 @@
+/**
+ * GSD Command — /gsd backlog
+ *
+ * Structured backlog management with 999.x numbering.
+ * Items stored in .gsd/BACKLOG.md as markdown checklist.
+ * Items can be promoted to active slices via add-slice.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+import { gsdRoot } from "./paths.js";
+
+interface BacklogItem {
+  id: string;
+  title: string;
+  done: boolean;
+  note: string;
+}
+
+function backlogPath(basePath: string): string {
+  return join(gsdRoot(basePath), "BACKLOG.md");
+}
+
+function parseBacklog(basePath: string): BacklogItem[] {
+  const filePath = backlogPath(basePath);
+  if (!existsSync(filePath)) return [];
+
+  const content = readFileSync(filePath, "utf-8");
+  const items: BacklogItem[] = [];
+
+  for (const line of content.split("\n")) {
+    const match = line.match(/^- \[([ x])\] (999\.\d+) — (.+?)(?:\s*\((.+)\))?$/);
+    if (match) {
+      items.push({
+        id: match[2],
+        title: match[3].trim(),
+        done: match[1] === "x",
+        note: match[4] ?? "",
+      });
+    }
+  }
+
+  return items;
+}
+
+function writeBacklog(basePath: string, items: BacklogItem[]): void {
+  const filePath = backlogPath(basePath);
+  mkdirSync(dirname(filePath), { recursive: true });
+  const lines = ["# Backlog\n"];
+  for (const item of items) {
+    const check = item.done ? "x" : " ";
+    const note = item.note ? ` (${item.note})` : "";
+    lines.push(`- [${check}] ${item.id} — ${item.title}${note}`);
+  }
+  lines.push(""); // trailing newline
+  writeFileSync(filePath, lines.join("\n"), "utf-8");
+}
+
+function nextBacklogId(items: BacklogItem[]): string {
+  let maxNum = 0;
+  for (const item of items) {
+    const match = item.id.match(/^999\.(\d+)$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNum) maxNum = num;
+    }
+  }
+  return `999.${maxNum + 1}`;
+}
+
+async function listBacklog(basePath: string, ctx: ExtensionCommandContext): Promise<void> {
+  const items = parseBacklog(basePath);
+  if (items.length === 0) {
+    ctx.ui.notify("Backlog is empty. Add items with /gsd backlog add <title>", "info");
+    return;
+  }
+
+  const lines = ["Backlog:\n"];
+  for (const item of items) {
+    const status = item.done ? "✓" : "○";
+    const note = item.note ? ` (${item.note})` : "";
+    lines.push(`  ${status} ${item.id} — ${item.title}${note}`);
+  }
+  const pending = items.filter((i) => !i.done).length;
+  lines.push(`\n${pending} pending, ${items.length - pending} promoted/done`);
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function addBacklogItem(basePath: string, title: string, ctx: ExtensionCommandContext): Promise<void> {
+  if (!title) {
+    ctx.ui.notify("Usage: /gsd backlog add <title>", "warning");
+    return;
+  }
+
+  const items = parseBacklog(basePath);
+  const id = nextBacklogId(items);
+  const date = new Date().toISOString().slice(0, 10);
+
+  items.push({ id, title: title.replace(/^['"]|['"]$/g, ""), done: false, note: `added ${date}` });
+  writeBacklog(basePath, items);
+
+  ctx.ui.notify(`Added ${id}: "${title}"`, "success");
+}
+
+async function promoteBacklogItem(
+  basePath: string,
+  itemId: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  if (!itemId) {
+    ctx.ui.notify("Usage: /gsd backlog promote <id>\nExample: /gsd backlog promote 999.1", "warning");
+    return;
+  }
+
+  const items = parseBacklog(basePath);
+  const item = items.find((i) => i.id === itemId);
+
+  if (!item) {
+    ctx.ui.notify(`Backlog item ${itemId} not found.`, "warning");
+    return;
+  }
+
+  if (item.done) {
+    ctx.ui.notify(`${itemId} is already promoted/done.`, "info");
+    return;
+  }
+
+  // Promote — currently requires single-writer engine (not yet available)
+  // Mark as promoted in backlog for now; slice creation will be available with the engine.
+  item.done = true;
+  item.note = `promoted ${new Date().toISOString().slice(0, 10)}`;
+  writeBacklog(basePath, items);
+  ctx.ui.notify(`Promoted ${itemId}: "${item.title}" — add it to the roadmap manually or wait for engine slice commands.`, "info");
+}
+
+async function removeBacklogItem(basePath: string, itemId: string, ctx: ExtensionCommandContext): Promise<void> {
+  if (!itemId) {
+    ctx.ui.notify("Usage: /gsd backlog remove <id>", "warning");
+    return;
+  }
+
+  const items = parseBacklog(basePath);
+  const idx = items.findIndex((i) => i.id === itemId);
+
+  if (idx === -1) {
+    ctx.ui.notify(`Backlog item ${itemId} not found.`, "warning");
+    return;
+  }
+
+  const removed = items.splice(idx, 1)[0];
+  writeBacklog(basePath, items);
+  ctx.ui.notify(`Removed ${removed.id}: "${removed.title}"`, "success");
+}
+
+export async function handleBacklog(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const basePath = process.cwd();
+  const parts = args.trim().split(/\s+/);
+  const sub = parts[0] ?? "";
+  const rest = parts.slice(1).join(" ");
+
+  switch (sub) {
+    case "":
+      return listBacklog(basePath, ctx);
+    case "add":
+      return addBacklogItem(basePath, rest, ctx);
+    case "promote":
+      return promoteBacklogItem(basePath, rest.trim(), ctx, pi);
+    case "remove":
+      return removeBacklogItem(basePath, rest.trim(), ctx);
+    default:
+      // Treat as implicit add
+      return addBacklogItem(basePath, args, ctx);
+  }
+}