gsd-antigravity-kit 1.27.2 → 1.27.3

package/.agent/skills/gsd/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gsd
-version: 1.27.0
+version: 1.28.0
 description: "Antigravity GSD (Get Stuff Done) - A spec-driven hierarchical planning and execution system. Triggers on project planning, phase management, and GSD slash commands."
 ---
 
@@ -36,15 +36,20 @@ This skill should be used when:
 - `gsd:do`
 - `gsd:execute-phase`
 - `gsd:fast`
+- `gsd:forensics`
 - `gsd:gsd-tools`
 - `gsd:health`
 - `gsd:help`
 - `gsd:insert-phase`
 - `gsd:join-discord`
 - `gsd:list-phase-assumptions`
+- `gsd:list-workspaces`
+- `gsd:manager`
 - `gsd:map-codebase`
+- `gsd:milestone-summary`
 - `gsd:new-milestone`
 - `gsd:new-project`
+- `gsd:new-workspace`
 - `gsd:next`
 - `gsd:note`
 - `gsd:pause-work`
@@ -57,6 +62,7 @@ This skill should be used when:
 - `gsd:quick`
 - `gsd:reapply-patches`
 - `gsd:remove-phase`
+- `gsd:remove-workspace`
 - `gsd:research-phase`
 - `gsd:resume-work`
 - `gsd:review-backlog`
@@ -72,6 +78,7 @@ This skill should be used when:
 - `gsd:update`
 - `gsd:validate-phase`
 - `gsd:verify-work`
+- `gsd:workstreams`
 
 ## System Overview
 
@@ -99,15 +106,20 @@ The following slash commands are available in this skill. Use them to drive the
 - **[`gsd:do`](references/commands/do.md)**: Route freeform text to the right GSD command automatically
 - **[`gsd:execute-phase`](references/commands/execute-phase.md)**: Execute all plans in a phase with wave-based parallelization
 - **[`gsd:fast`](references/commands/fast.md)**: Execute a trivial task inline — no subagents, no planning overhead
+- **[`gsd:forensics`](references/commands/forensics.md)**: Post-mortem investigation for failed GSD workflows — analyzes git history, artifacts, and state to diagnose what went wrong
 - **[`gsd:gsd-tools`](references/commands/gsd-tools.md)**: Direct access to GSD internal CLI tools for atomic operations (state, roadmap, phase, config, etc.)
 - **[`gsd:health`](references/commands/health.md)**: Diagnose planning directory health and optionally repair issues
 - **[`gsd:help`](references/commands/help.md)**: Show available GSD commands and usage guide
 - **[`gsd:insert-phase`](references/commands/insert-phase.md)**: Insert urgent work as decimal phase (e.g., 72.1) between existing phases
 - **[`gsd:join-discord`](references/commands/join-discord.md)**: Join the GSD Discord community
 - **[`gsd:list-phase-assumptions`](references/commands/list-phase-assumptions.md)**: Surface Antigravity's assumptions about a phase approach before planning
+- **[`gsd:list-workspaces`](references/commands/list-workspaces.md)**: List active GSD workspaces and their status
+- **[`gsd:manager`](references/commands/manager.md)**: Interactive command center for managing multiple phases from one terminal
 - **[`gsd:map-codebase`](references/commands/map-codebase.md)**: Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents
+- **[`gsd:milestone-summary`](references/commands/milestone-summary.md)**: Generate a comprehensive project summary from milestone artifacts for team onboarding and review
 - **[`gsd:new-milestone`](references/commands/new-milestone.md)**: Start a new milestone cycle — update PROJECT.md and route to requirements
 - **[`gsd:new-project`](references/commands/new-project.md)**: Initialize a new project with deep context gathering and PROJECT.md
+- **[`gsd:new-workspace`](references/commands/new-workspace.md)**: Create an isolated workspace with repo copies and independent .planning/
 - **[`gsd:next`](references/commands/next.md)**: Automatically advance to the next logical step in the GSD workflow
 - **[`gsd:note`](references/commands/note.md)**: Zero-friction idea capture. Append, list, or promote notes to todos.
 - **[`gsd:pause-work`](references/commands/pause-work.md)**: Create context handoff when pausing work mid-phase
@@ -120,6 +132,7 @@ The following slash commands are available in this skill. Use them to drive the
 - **[`gsd:quick`](references/commands/quick.md)**: Execute a quick task with GSD guarantees (atomic commits, state tracking) but skip optional agents
 - **[`gsd:reapply-patches`](references/commands/reapply-patches.md)**: Reapply local modifications after a GSD update
 - **[`gsd:remove-phase`](references/commands/remove-phase.md)**: Remove a future phase from roadmap and renumber subsequent phases
+- **[`gsd:remove-workspace`](references/commands/remove-workspace.md)**: Remove a GSD workspace and clean up worktrees
 - **[`gsd:research-phase`](references/commands/research-phase.md)**: Research how to implement a phase (standalone - usually use /gsd:plan-phase instead)
 - **[`gsd:resume-work`](references/commands/resume-work.md)**: Resume work from previous session with full context restoration
 - **[`gsd:review-backlog`](references/commands/review-backlog.md)**: Review and promote backlog items to active milestone
@@ -135,6 +148,7 @@ The following slash commands are available in this skill. Use them to drive the
 - **[`gsd:update`](references/commands/update.md)**: Update GSD to latest version with changelog display
 - **[`gsd:validate-phase`](references/commands/validate-phase.md)**: Retroactively audit and fill Nyquist validation gaps for a completed phase
 - **[`gsd:verify-work`](references/commands/verify-work.md)**: Validate built features through conversational UAT
+- **[`gsd:workstreams`](references/commands/workstreams.md)**: Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
 
 ### 3. Directory Structure
 The skill uses a standardized directory structure for portability and organization:
@@ -169,4 +183,4 @@ General documentation on the GSD philosophy, usage patterns, and configuration.
 5.  **CLI Invocation**: `gsd-tools` is **NOT** a global command. Always invoke it with the full node path: `node .agent/skills/gsd/bin/gsd-tools.cjs <command> [args]`. Never run `gsd-tools` bare.
 
 ---
-*Generated by gsd-converter on 2026-03-21*
+*Generated by gsd-converter on 2026-03-22*

package/.agent/skills/gsd/assets/templates/config.json

@@ -6,7 +6,9 @@
     "plan_check": true,
     "verifier": true,
     "auto_advance": false,
-    "nyquist_validation": true
+    "nyquist_validation": true,
+    "discuss_mode": "discuss",
+    "research_before_questions": false
   },
   "planning": {
     "commit_docs": true,

package/.agent/skills/gsd/bin/gsd-tools.cjs

@@ -33,8 +33,9 @@ function showHelp(cmd, sub) {
 
 const fs = require('fs');
 const path = require('path');
+const core = require('./lib/core.cjs');
 const { parseIncludeFlag } = require('./lib/core.cjs');
-const { error, findProjectRoot } = require('./lib/core.cjs');
+const { error, findProjectRoot, getActiveWorkstream } = core;
 const state = require('./lib/state.cjs');
 const phase = require('./lib/phase.cjs');
 const roadmap = require('./lib/roadmap.cjs');
@@ -47,6 +48,47 @@ const init = require('./lib/init.cjs');
 const frontmatter = require('./lib/frontmatter.cjs');
 const profilePipeline = require('./lib/profile-pipeline.cjs');
 const profileOutput = require('./lib/profile-output.cjs');
+const workstream = require('./lib/workstream.cjs');
+
+// ─── Arg parsing helpers ──────────────────────────────────────────────────────
+
+/**
+ * Extract named --flag <value> pairs from an args array.
+ * Returns an object mapping flag names to their values (null if absent).
+ * Flags listed in `booleanFlags` are treated as boolean (no value consumed).
+ *
+ * parseNamedArgs(args, 'phase', 'plan')        → { phase: '3', plan: '1' }
+ * parseNamedArgs(args, [], ['amend', 'force'])  → { amend: true, force: false }
+ */
+function parseNamedArgs(args, valueFlags = [], booleanFlags = []) {
+  const result = {};
+  for (const flag of valueFlags) {
+  const idx = args.indexOf(`--${flag}`);
+  result[flag] = idx !== -1 && args[idx + 1] !== undefined && !args[idx + 1].startsWith('--')
+    ? args[idx + 1]
+    : null;
+  }
+  for (const flag of booleanFlags) {
+  result[flag] = args.includes(`--${flag}`);
+  }
+  return result;
+}
+
+/**
+ * Collect all tokens after --flag until the next --flag or end of args.
+ * Handles multi-word values like --name Foo Bar Version 1.
+ * Returns null if the flag is absent.
+ */
+function parseMultiwordArg(args, flag) {
+  const idx = args.indexOf(`--${flag}`);
+  if (idx === -1) return null;
+  const tokens = [];
+  for (let i = idx + 1; i < args.length; i++) {
+  if (args[i].startsWith('--')) break;
+  tokens.push(args[i]);
+  }
+  return tokens.length > 0 ? tokens.join(' ') : null;
+}
 
 // ─── CLI Router ───────────────────────────────────────────────────────────────
 
@@ -73,11 +115,42 @@ async function main() {
   error(`Invalid --cwd: ${cwd}`);
   }
 
-  // Resolve worktree root: in a linked worktree, .planning/ lives in the main worktree
+  // Resolve worktree root: in a linked worktree, .planning/ lives in the main worktree.
+  // However, in monorepo worktrees where the subdirectory itself owns .planning/,
+  // skip worktree resolution — the CWD is already the correct project root.
   const { resolveWorktreeRoot } = require('./lib/core.cjs');
+  if (!fs.existsSync(path.join(cwd, '.planning'))) {
   const worktreeRoot = resolveWorktreeRoot(cwd);
   if (worktreeRoot !== cwd) {
-  cwd = worktreeRoot;
+    cwd = worktreeRoot;
+  }
+  }
+
+  // Optional workstream override for parallel milestone work.
+  // Priority: --ws flag > GSD_WORKSTREAM env var > active-workstream file > null (flat mode)
+  const wsEqArg = args.find(arg => arg.startsWith('--ws='));
+  const wsIdx = args.indexOf('--ws');
+  let ws = null;
+  if (wsEqArg) {
+  ws = wsEqArg.slice('--ws='.length).trim();
+  if (!ws) error('Missing value for --ws');
+  args.splice(args.indexOf(wsEqArg), 1);
+  } else if (wsIdx !== -1) {
+  ws = args[wsIdx + 1];
+  if (!ws || ws.startsWith('--')) error('Missing value for --ws');
+  args.splice(wsIdx, 2);
+  } else if (process.env.GSD_WORKSTREAM) {
+  ws = process.env.GSD_WORKSTREAM.trim();
+  } else {
+  ws = getActiveWorkstream(cwd);
+  }
+  // Validate workstream name to prevent path traversal attacks.
+  if (ws && !/^[a-zA-Z0-9_-]+$/.test(ws)) {
+  error('Invalid workstream name: must be alphanumeric, hyphens, and underscores only');
+  }
+  // Set env var so all modules (planningDir, planningPaths) auto-resolve workstream paths
+  if (ws) {
+  process.env.GSD_WORKSTREAM = ws;
   }
 
   const rawIndex = args.indexOf('--raw');
@@ -96,10 +169,21 @@ async function main() {
   }
   if (rawIndex !== -1) args.splice(rawIndex, 1);
 
+  // --pick <name>: extract a single field from JSON output (replaces jq dependency).
+  // Supports dot-notation (e.g., --pick workflow.research) and bracket notation
+  // for arrays (e.g., --pick directories[-1]).
+  const pickIdx = args.indexOf('--pick');
+  let pickField = null;
+  if (pickIdx !== -1) {
+  pickField = args[pickIdx + 1];
+  if (!pickField || pickField.startsWith('--')) error('Missing value for --pick');
+  args.splice(pickIdx, 2);
+  }
+
   const command = args[0];
 
   if (!command) {
-  error('Usage: node .agent/skills/gsd/bin/gsd-tools.cjs <command> [args] [--raw] [--cwd <path>]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, config-new-project, init');
+  error('Usage: node .agent/skills/gsd/bin/gsd-tools.cjs <command> [args] [--raw] [--pick <field>] [--cwd <path>] [--ws <name>]\nCommands: state, resolve-model, find-phase, commit, verify-summary, verify, frontmatter, template, generate-slug, current-timestamp, list-todos, verify-path-exists, config-ensure-section, config-new-project, init, workstream');
   }
 
   // Multi-repo guard: resolve project root for commands that read/write .planning/.
@@ -113,6 +197,67 @@ async function main() {
   cwd = findProjectRoot(cwd);
   }
 
+  // When --pick is active, intercept stdout to extract the requested field.
+  if (pickField) {
+  const origWriteSync = fs.writeSync;
+  const chunks = [];
+  fs.writeSync = function (fd, data, ...rest) {
+    if (fd === 1) { chunks.push(String(data)); return; }
+    return origWriteSync.call(fs, fd, data, ...rest);
+  };
+  const cleanup = () => {
+    fs.writeSync = origWriteSync;
+    const captured = chunks.join('');
+    let jsonStr = captured;
+    if (jsonStr.startsWith('@file:')) {
+    jsonStr = fs.readFileSync(jsonStr.slice(6), 'utf-8');
+    }
+    try {
+    const obj = JSON.parse(jsonStr);
+    const value = extractField(obj, pickField);
+    const result = value === null || value === undefined ? '' : String(value);
+    origWriteSync.call(fs, 1, result);
+    } catch {
+    origWriteSync.call(fs, 1, captured);
+    }
+  };
+  try {
+    await runCommand(command, args, cwd, raw);
+    cleanup();
+  } catch (e) {
+    fs.writeSync = origWriteSync;
+    throw e;
+  }
+  return;
+  }
+
+  await runCommand(command, args, cwd, raw);
+}
+
+/**
+ * Extract a field from an object using dot-notation and bracket syntax.
+ * Supports: 'field', 'parent.child', 'arr[-1]', 'arr[0]'
+ */
+function extractField(obj, fieldPath) {
+  const parts = fieldPath.split('.');
+  let current = obj;
+  for (const part of parts) {
+  if (current === null || current === undefined) return undefined;
+  const bracketMatch = part.match(/^(.+?)\[(-?\d+)]$/);
+  if (bracketMatch) {
+    const key = bracketMatch[1];
+    const index = parseInt(bracketMatch[2], 10);
+    current = current[key];
+    if (!Array.isArray(current)) return undefined;
+    current = index < 0 ? current[current.length + index] : current[index];
+  } else {
+    current = current[part];
+  }
+  }
+  return current;
+}
+
+async function runCommand(command, args, cwd, raw) {
   switch (command) {
   case 'state': {
     const subcommand = args[1];
@@ -135,74 +280,27 @@ async function main() {
     } else if (subcommand === 'advance-plan') {
     state.cmdStateAdvancePlan(cwd, raw);
     } else if (subcommand === 'record-metric') {
-    const phaseIdx = args.indexOf('--phase');
-    const planIdx = args.indexOf('--plan');
-    const durationIdx = args.indexOf('--duration');
-    const tasksIdx = args.indexOf('--tasks');
-    const filesIdx = args.indexOf('--files');
-    state.cmdStateRecordMetric(cwd, {
-      phase: phaseIdx !== -1 ? args[phaseIdx + 1] : null,
-      plan: planIdx !== -1 ? args[planIdx + 1] : null,
-      duration: durationIdx !== -1 ? args[durationIdx + 1] : null,
-      tasks: tasksIdx !== -1 ? args[tasksIdx + 1] : null,
-      files: filesIdx !== -1 ? args[filesIdx + 1] : null,
-    }, raw);
+    const { phase: p, plan, duration, tasks, files } = parseNamedArgs(args, ['phase', 'plan', 'duration', 'tasks', 'files']);
+    state.cmdStateRecordMetric(cwd, { phase: p, plan, duration, tasks, files }, raw);
     } else if (subcommand === 'update-progress') {
     state.cmdStateUpdateProgress(cwd, raw);
     } else if (subcommand === 'add-decision') {
-    const phaseIdx = args.indexOf('--phase');
-    const summaryIdx = args.indexOf('--summary');
-    const summaryFileIdx = args.indexOf('--summary-file');
-    const rationaleIdx = args.indexOf('--rationale');
-    const rationaleFileIdx = args.indexOf('--rationale-file');
-    state.cmdStateAddDecision(cwd, {
-      phase: phaseIdx !== -1 ? args[phaseIdx + 1] : null,
-      summary: summaryIdx !== -1 ? args[summaryIdx + 1] : null,
-      summary_file: summaryFileIdx !== -1 ? args[summaryFileIdx + 1] : null,
-      rationale: rationaleIdx !== -1 ? args[rationaleIdx + 1] : '',
-      rationale_file: rationaleFileIdx !== -1 ? args[rationaleFileIdx + 1] : null,
-    }, raw);
+    const { phase: p, summary, 'summary-file': summary_file, rationale, 'rationale-file': rationale_file } = parseNamedArgs(args, ['phase', 'summary', 'summary-file', 'rationale', 'rationale-file']);
+    state.cmdStateAddDecision(cwd, { phase: p, summary, summary_file, rationale: rationale || '', rationale_file }, raw);
     } else if (subcommand === 'add-blocker') {
-    const textIdx = args.indexOf('--text');
-    const textFileIdx = args.indexOf('--text-file');
-    state.cmdStateAddBlocker(cwd, {
-      text: textIdx !== -1 ? args[textIdx + 1] : null,
-      text_file: textFileIdx !== -1 ? args[textFileIdx + 1] : null,
-    }, raw);
+    const { text, 'text-file': text_file } = parseNamedArgs(args, ['text', 'text-file']);
+    state.cmdStateAddBlocker(cwd, { text, text_file }, raw);
     } else if (subcommand === 'resolve-blocker') {
-    const textIdx = args.indexOf('--text');
-    state.cmdStateResolveBlocker(cwd, textIdx !== -1 ? args[textIdx + 1] : null, raw);
+    state.cmdStateResolveBlocker(cwd, parseNamedArgs(args, ['text']).text, raw);
     } else if (subcommand === 'record-session') {
-    const stoppedIdx = args.indexOf('--stopped-at');
-    const resumeIdx = args.indexOf('--resume-file');
-    state.cmdStateRecordSession(cwd, {
-      stopped_at: stoppedIdx !== -1 ? args[stoppedIdx + 1] : null,
-      resume_file: resumeIdx !== -1 ? args[resumeIdx + 1] : 'None',
-    }, raw);
+    const { 'stopped-at': stopped_at, 'resume-file': resume_file } = parseNamedArgs(args, ['stopped-at', 'resume-file']);
+    state.cmdStateRecordSession(cwd, { stopped_at, resume_file: resume_file || 'None' }, raw);
     } else if (subcommand === 'begin-phase') {
-    const phaseIdx = args.indexOf('--phase');
-    const nameIdx = args.indexOf('--name');
-    const plansIdx = args.indexOf('--plans');
-    state.cmdStateBeginPhase(
-      cwd,
-      phaseIdx !== -1 ? args[phaseIdx + 1] : null,
-      nameIdx !== -1 ? args[nameIdx + 1] : null,
-      plansIdx !== -1 ? parseInt(args[plansIdx + 1], 10) : null,
-      raw
-    );
+    const { phase: p, name, plans } = parseNamedArgs(args, ['phase', 'name', 'plans']);
+    state.cmdStateBeginPhase(cwd, p, name, plans !== null ? parseInt(plans, 10) : null, raw);
     } else if (subcommand === 'signal-waiting') {
-    const typeIdx = args.indexOf('--type');
-    const qIdx = args.indexOf('--question');
-    const optIdx = args.indexOf('--options');
-    const phaseIdx = args.indexOf('--phase');
-    state.cmdSignalWaiting(
-      cwd,
-      typeIdx !== -1 ? args[typeIdx + 1] : null,
-      qIdx !== -1 ? args[qIdx + 1] : null,
-      optIdx !== -1 ? args[optIdx + 1] : null,
-      phaseIdx !== -1 ? args[phaseIdx + 1] : null,
-      raw
-    );
+    const { type, question, options, phase: p } = parseNamedArgs(args, ['type', 'question', 'options', 'phase']);
+    state.cmdSignalWaiting(cwd, type, question, options, p, raw);
     } else if (subcommand === 'signal-resume') {
     state.cmdSignalResume(cwd, raw);
     } else {
@@ -258,24 +356,18 @@ async function main() {
     template.cmdTemplateSelect(cwd, args[2], raw);
     } else if (subcommand === 'fill') {
     const templateType = args[2];
-    const phaseIdx = args.indexOf('--phase');
-    const planIdx = args.indexOf('--plan');
-    const nameIdx = args.indexOf('--name');
-    const typeIdx = args.indexOf('--type');
-    const waveIdx = args.indexOf('--wave');
-    const fieldsIdx = args.indexOf('--fields');
-    template.cmdTemplateFill(cwd, templateType, {
-      phase: phaseIdx !== -1 ? args[phaseIdx + 1] : null,
-      plan: planIdx !== -1 ? args[planIdx + 1] : null,
-      name: nameIdx !== -1 ? args[nameIdx + 1] : null,
-      type: typeIdx !== -1 ? args[typeIdx + 1] : 'execute',
-      wave: waveIdx !== -1 ? args[waveIdx + 1] : '1',
-      fields: fieldsIdx !== -1 ? (() => {
+    const { phase, plan, name, type, wave, fields: fieldsRaw } = parseNamedArgs(args, ['phase', 'plan', 'name', 'type', 'wave', 'fields']);
+    let fields = {};
+    if (fieldsRaw) {
       const { safeJsonParse } = require('./lib/security.cjs');
-      const result = safeJsonParse(args[fieldsIdx + 1], { label: '--fields' });
+      const result = safeJsonParse(fieldsRaw, { label: '--fields' });
       if (!result.ok) error(result.error);
-      return result.value;
-      })() : {},
+      fields = result.value;
+    }
+    template.cmdTemplateFill(cwd, templateType, {
+      phase, plan, name, fields,
+      type: type || 'execute',
+      wave: wave || '1',
     }, raw);
     } else {
     error('Unknown template subcommand. Available: select, fill');
@@ -287,18 +379,14 @@ async function main() {
     const subcommand = args[1];
     const file = args[2];
     if (subcommand === 'get') {
-    const fieldIdx = args.indexOf('--field');
-    frontmatter.cmdFrontmatterGet(cwd, file, fieldIdx !== -1 ? args[fieldIdx + 1] : null, raw);
+    frontmatter.cmdFrontmatterGet(cwd, file, parseNamedArgs(args, ['field']).field, raw);
     } else if (subcommand === 'set') {
-    const fieldIdx = args.indexOf('--field');
-    const valueIdx = args.indexOf('--value');
-    frontmatter.cmdFrontmatterSet(cwd, file, fieldIdx !== -1 ? args[fieldIdx + 1] : null, valueIdx !== -1 ? args[valueIdx + 1] : undefined, raw);
+    const { field, value } = parseNamedArgs(args, ['field', 'value']);
+    frontmatter.cmdFrontmatterSet(cwd, file, field, value !== null ? value : undefined, raw);
     } else if (subcommand === 'merge') {
-    const dataIdx = args.indexOf('--data');
-    frontmatter.cmdFrontmatterMerge(cwd, file, dataIdx !== -1 ? args[dataIdx + 1] : null, raw);
+    frontmatter.cmdFrontmatterMerge(cwd, file, parseNamedArgs(args, ['data']).data, raw);
     } else if (subcommand === 'validate') {
-    const schemaIdx = args.indexOf('--schema');
-    frontmatter.cmdFrontmatterValidate(cwd, file, schemaIdx !== -1 ? args[schemaIdx + 1] : null, raw);
+    frontmatter.cmdFrontmatterValidate(cwd, file, parseNamedArgs(args, ['schema']).schema, raw);
     } else {
     error('Unknown frontmatter subcommand. Available: get, set, merge, validate');
     }
@@ -449,18 +537,8 @@ async function main() {
   case 'milestone': {
     const subcommand = args[1];
     if (subcommand === 'complete') {
-    const nameIndex = args.indexOf('--name');
+    const milestoneName = parseMultiwordArg(args, 'name');
     const archivePhases = args.includes('--archive-phases');
-    // Collect --name value (everything after --name until next flag or end)
-    let milestoneName = null;
-    if (nameIndex !== -1) {
-      const nameArgs = [];
-      for (let i = nameIndex + 1; i < args.length; i++) {
-      if (args[i].startsWith('--')) break;
-      nameArgs.push(args[i]);
-      }
-      milestoneName = nameArgs.join(' ') || null;
-    }
     milestone.cmdMilestoneComplete(cwd, args[2], { name: milestoneName, archivePhases }, raw);
     } else {
     error('Unknown milestone subcommand. Available: complete');
@@ -513,11 +591,9 @@ async function main() {
 
   case 'scaffold': {
     const scaffoldType = args[1];
-    const phaseIndex = args.indexOf('--phase');
-    const nameIndex = args.indexOf('--name');
     const scaffoldOptions = {
-    phase: phaseIndex !== -1 ? args[phaseIndex + 1] : null,
-    name: nameIndex !== -1 ? args.slice(nameIndex + 1).join(' ') : null,
+    phase: parseNamedArgs(args, ['phase']).phase,
+    name: parseMultiwordArg(args, 'name'),
     };
     commands.cmdScaffold(cwd, scaffoldType, scaffoldOptions, raw);
     break;
@@ -563,8 +639,20 @@ async function main() {
     case 'progress':
       init.cmdInitProgress(cwd, includes, raw);
       break;
+    case 'manager':
+      init.cmdInitManager(cwd, raw);
+      break;
+    case 'new-workspace':
+      init.cmdInitNewWorkspace(cwd, raw);
+      break;
+    case 'list-workspaces':
+      init.cmdInitListWorkspaces(cwd, raw);
+      break;
+    case 'remove-workspace':
+      init.cmdInitRemoveWorkspace(cwd, args[2], raw);
+      break;
     default:
-      error(`Unknown init workflow: ${workflow}\nAvailable: execute-phase, plan-phase, new-project, new-milestone, quick, resume, verify-work, phase-op, todos, milestone-op, map-codebase, progress`);
+      error(`Unknown init workflow: ${workflow}\nAvailable: execute-phase, plan-phase, new-project, new-milestone, quick, resume, verify-work, phase-op, todos, milestone-op, map-codebase, progress, manager, new-workspace, list-workspaces, remove-workspace`);
     }
     break;
   }
@@ -686,6 +774,33 @@ async function main() {
     break;
   }
 
+  case 'workstream': {
+    const subcommand = args[1];
+    if (subcommand === 'create') {
+    const migrateNameIdx = args.indexOf('--migrate-name');
+    const noMigrate = args.includes('--no-migrate');
+    workstream.cmdWorkstreamCreate(cwd, args[2], {
+      migrate: !noMigrate,
+      migrateName: migrateNameIdx !== -1 ? args[migrateNameIdx + 1] : null,
+    }, raw);
+    } else if (subcommand === 'list') {
+    workstream.cmdWorkstreamList(cwd, raw);
+    } else if (subcommand === 'status') {
+    workstream.cmdWorkstreamStatus(cwd, args[2], raw);
+    } else if (subcommand === 'complete') {
+    workstream.cmdWorkstreamComplete(cwd, args[2], {}, raw);
+    } else if (subcommand === 'set') {
+    workstream.cmdWorkstreamSet(cwd, args[2], raw);
+    } else if (subcommand === 'get') {
+    workstream.cmdWorkstreamGet(cwd, raw);
+    } else if (subcommand === 'progress') {
+    workstream.cmdWorkstreamProgress(cwd, raw);
+    } else {
+    error('Unknown workstream subcommand. Available: create, list, status, complete, set, get, progress');
+    }
+    break;
+  }
+
   default:
     error(`Unknown command: ${command}`);
   }

package/.agent/skills/gsd/bin/help-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.27.0",
+  "version": "1.28.0",
   "commands": {
     "add-backlog": {
       "description": "Add an idea to the backlog parking lot (999.x numbering)"
@@ -46,6 +46,9 @@
     "fast": {
       "description": "Execute a trivial task inline \u2014 no subagents, no planning overhead"
     },
+    "forensics": {
+      "description": "Post-mortem investigation for failed GSD workflows \u2014 analyzes git history, artifacts, and state to diagnose what went wrong"
+    },
     "health": {
       "description": "Diagnose planning directory health and optionally repair issues"
     },
@@ -61,15 +64,27 @@
     "list-phase-assumptions": {
       "description": "Surface Antigravity's assumptions about a phase approach before planning"
     },
+    "list-workspaces": {
+      "description": "List active GSD workspaces and their status"
+    },
+    "manager": {
+      "description": "Interactive command center for managing multiple phases from one terminal"
+    },
     "map-codebase": {
       "description": "Analyze codebase with parallel mapper agents to produce .planning/codebase/ documents"
     },
+    "milestone-summary": {
+      "description": "Generate a comprehensive project summary from milestone artifacts for team onboarding and review"
+    },
     "new-milestone": {
       "description": "Start a new milestone cycle \u2014 update PROJECT.md and route to requirements"
     },
     "new-project": {
       "description": "Initialize a new project with deep context gathering and PROJECT.md"
     },
+    "new-workspace": {
+      "description": "Create an isolated workspace with repo copies and independent .planning/"
+    },
     "next": {
       "description": "Automatically advance to the next logical step in the GSD workflow"
     },
@@ -110,6 +125,9 @@
     "remove-phase": {
       "description": "Remove a future phase from roadmap and renumber subsequent phases"
     },
+    "remove-workspace": {
+      "description": "Remove a GSD workspace and clean up worktrees"
+    },
     "research-phase": {
       "description": "Research how to implement a phase (standalone - usually use /gsd:plan-phase instead)"
     },
@@ -155,6 +173,9 @@
     "verify-work": {
       "description": "Validate built features through conversational UAT"
     },
+    "workstreams": {
+      "description": "Manage parallel workstreams \u2014 list, create, switch, status, progress, complete, and resume"
+    },
     "state": {
       "description": "Manage and query project state memory.",
       "subcommands": {

package/.agent/skills/gsd/bin/hooks/gsd-check-update.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// gsd-hook-version: 1.27.0
+// gsd-hook-version: 1.28.0
 // Check for GSD updates in background, write result to cache
 // Called by SessionStart hook - runs once per session
 
@@ -65,9 +65,10 @@ const child = spawn(process.execPath, ['-e', `
   } catch (e) {}
 
   // Check for stale hooks — compare hook version headers against installed VERSION
+  // Hooks live inside get-shit-done/hooks/, not configDir/hooks/
   let staleHooks = [];
   if (configDir) {
-    const hooksDir = path.join(configDir, 'hooks');
+    const hooksDir = path.join(configDir, 'get-shit-done', 'hooks');
     try {
       if (fs.existsSync(hooksDir)) {
         const hookFiles = fs.readdirSync(hooksDir).filter(f => f.startsWith('gsd-') && f.endsWith('.js'));

package/.agent/skills/gsd/bin/hooks/gsd-context-monitor.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// gsd-hook-version: 1.27.0
+// gsd-hook-version: 1.28.0
 // Context Monitor - PostToolUse/AfterTool hook (Gemini uses AfterTool)
 // Reads context metrics from the statusline bridge file and injects
 // warnings when context usage is high. This makes the AGENT aware of

package/.agent/skills/gsd/bin/hooks/gsd-prompt-guard.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// gsd-hook-version: 1.27.0
+// gsd-hook-version: 1.28.0
 // GSD Prompt Injection Guard — PreToolUse hook
 // Scans file content being written to .planning/ for prompt injection patterns.
 // Defense-in-depth: catches injected instructions before they enter agent context.

package/.agent/skills/gsd/bin/hooks/gsd-statusline.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// gsd-hook-version: 1.27.0
+// gsd-hook-version: 1.28.0
 // Antigravity Statusline - GSD Edition
 // Shows: model | current task | directory | context usage
 

package/.agent/skills/gsd/bin/hooks/gsd-workflow-guard.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// gsd-hook-version: 1.27.0
+// gsd-hook-version: 1.28.0
 // GSD Workflow Guard — PreToolUse hook
 // Detects when Antigravity attempts file edits outside a GSD workflow context
 // (no active /gsd: command or Task subagent) and injects an advisory warning.