get-shit-done-cc 1.5.21 → 1.5.23

package/agents/gsd-phase-researcher.md

@@ -23,6 +23,18 @@ Your job: Answer "What do I need to know to PLAN this phase well?" Produce a sin
 - Return structured result to orchestrator
 </role>
 
+<upstream_input>
+**CONTEXT.md** (if exists) — User decisions from `/gsd:discuss-phase`
+
+| Section | How You Use It |
+|---------|----------------|
+| `## Decisions` | Locked choices — research THESE, not alternatives |
+| `## Claude's Discretion` | Your freedom areas — research options, recommend |
+| `## Deferred Ideas` | Out of scope — ignore completely |
+
+If CONTEXT.md exists, it constrains your research scope. Don't explore alternatives to locked decisions.
+</upstream_input>
+
 <downstream_consumer>
 Your RESEARCH.md is consumed by `gsd-planner` which uses specific sections:
 
@@ -420,7 +432,7 @@ Things that couldn't be fully resolved:
 
 <execution_flow>
 
-## Step 1: Receive Research Scope
+## Step 1: Receive Research Scope and Load Context
 
 Orchestrator provides:
 - Phase number and name
@@ -429,6 +441,25 @@ Orchestrator provides:
 - Prior decisions/constraints
 - Output file path
 
+**Load phase context if exists:**
+
+```bash
+PHASE_DIR=$(ls -d .planning/phases/${PHASE}-* 2>/dev/null | head -1)
+ls "${PHASE_DIR}/${PHASE}-CONTEXT.md" 2>/dev/null
+```
+
+**If CONTEXT.md exists, read it:**
+
+The CONTEXT.md contains user decisions from `/gsd:discuss-phase` that MUST guide your research:
+- **Decisions** — locked choices that constrain what you research
+- **Claude's Discretion** — areas where you have freedom
+- **Deferred Ideas** — out of scope, ignore these
+
+**Use CONTEXT.md to focus research:**
+- If user decided "use library X" → research X deeply, don't explore alternatives
+- If user decided "simple UI, no animations" → don't research animation libraries
+- If marked as Claude's discretion → research options and recommend
+
 Parse and confirm understanding before proceeding.
 
 ## Step 2: Identify Research Domains
@@ -484,12 +515,14 @@ Run through verification protocol checklist:
 
 Use the output format template. Populate all sections with verified findings.
 
-Write to: `.planning/phases/{phase_dir}/{phase}-RESEARCH.md`
+Write to: `${PHASE_DIR}/${PHASE}-RESEARCH.md`
+
+Where `PHASE_DIR` is the full path (e.g., `.planning/phases/01-foundation`)
 
 ## Step 6: Commit Research
 
 ```bash
-git add .planning/phases/${PHASE_DIR}/${PHASE}-RESEARCH.md
+git add "${PHASE_DIR}/${PHASE}-RESEARCH.md"
 git commit -m "docs(${PHASE}): research phase domain
 
 Phase ${PHASE}: ${PHASE_NAME}
@@ -522,7 +555,7 @@ When research finishes successfully:
 
 ### File Created
 
-`.planning/phases/{phase_dir}/{phase}-RESEARCH.md`
+`${PHASE_DIR}/${PHASE}-RESEARCH.md`
 
 ### Confidence Assessment
 

package/agents/gsd-planner.md

@@ -1156,11 +1156,38 @@ Write to `.planning/phases/XX-name/{phase}-{NN}-PLAN.md` (e.g., `01-02-PLAN.md`
 Include frontmatter (phase, plan, type, wave, depends_on, files_modified, autonomous, must_haves).
 </step>
 
+<step name="update_roadmap">
+Update ROADMAP.md to finalize phase placeholders created by add-phase or insert-phase.
+
+1. Read `.planning/ROADMAP.md`
+2. Find the phase entry (`### Phase {N}:`)
+3. Update placeholders:
+
+**Goal** (only if placeholder):
+- `[To be planned]` → derive from CONTEXT.md > RESEARCH.md > phase description
+- `[Urgent work - to be planned]` → derive from same sources
+- If Goal already has real content → leave it alone
+
+**Plans** (always update):
+- `**Plans:** 0 plans` → `**Plans:** {N} plans`
+- `**Plans:** (created by /gsd:plan-phase)` → `**Plans:** {N} plans`
+
+**Plan list** (always update):
+- Replace `Plans:\n- [ ] TBD ...` with actual plan checkboxes:
+  ```
+  Plans:
+  - [ ] {phase}-01-PLAN.md — {brief objective}
+  - [ ] {phase}-02-PLAN.md — {brief objective}
+  ```
+
+4. Write updated ROADMAP.md
+</step>
+
 <step name="git_commit">
-Commit phase plan(s):
+Commit phase plan(s) and updated roadmap:
 
 ```bash
-git add .planning/phases/${PHASE}-*/${PHASE}-*-PLAN.md
+git add .planning/phases/${PHASE}-*/${PHASE}-*-PLAN.md .planning/ROADMAP.md
 git commit -m "docs(${PHASE}): create phase plan
 
 Phase ${PHASE}: ${PHASE_NAME}
@@ -1264,7 +1291,7 @@ Execute: `/gsd:execute-phase {phase}`
 
 ### Files Updated
 
-- .planning/phases/{phase_dir}/{plan}-PLAN.md
+- .planning/phases/{phase_dir}/{phase}-{plan}-PLAN.md
 
 {If any issues NOT addressed:}
 

package/agents/gsd-roadmapper.md

@@ -505,13 +505,17 @@ If gaps found, include in draft for user decision.
 
 **Write files first, then return.** This ensures artifacts persist even if context is lost.
 
-1. **Create phase directories:**
+1. **Create phase directories (zero-padded):**
    ```bash
-   mkdir -p .planning/phases/01-{name}
-   mkdir -p .planning/phases/02-{name}
-   # etc.
+   # Always zero-pad phase numbers: 01, 02, ... 09, 10, 11
+   for i in 1 2 3; do
+     PADDED=$(printf "%02d" $i)
+     mkdir -p ".planning/phases/${PADDED}-{phase-name}"
+   done
    ```
 
+   Examples: `01-foundation`, `02-core-features`, `10-polish`
+
 2. **Write ROADMAP.md** using output format
 
 3. **Write STATE.md** using output format
@@ -546,9 +550,9 @@ When files are written and returning to orchestrator:
 **Files written:**
 - .planning/ROADMAP.md
 - .planning/STATE.md
-- .planning/phases/01-{name}/
-- .planning/phases/02-{name}/
-...
+- .planning/phases/01-{phase-name}/
+- .planning/phases/02-{phase-name}/
+- ... (all phases zero-padded)
 
 **Updated:**
 - .planning/REQUIREMENTS.md (traceability section)

package/bin/install.js

@@ -55,6 +55,8 @@ function parseConfigDirArg() {
 const explicitConfigDir = parseConfigDirArg();
 const hasHelp = args.includes('--help') || args.includes('-h');
 const forceStatusline = args.includes('--force-statusline');
+const forceNotify = args.includes('--force-notify');
+const noNotify = args.includes('--no-notify');
 
 console.log(banner);
 
@@ -68,6 +70,8 @@ if (hasHelp) {
     ${cyan}-c, --config-dir <path>${reset}   Specify custom Claude config directory
     ${cyan}-h, --help${reset}                Show this help message
     ${cyan}--force-statusline${reset}        Replace existing statusline config
+    ${cyan}--force-notify${reset}            Replace existing notification hook
+    ${cyan}--no-notify${reset}               Skip notification hook installation
 
   ${yellow}Examples:${reset}
     ${dim}# Install to default ~/.claude directory${reset}
@@ -225,29 +229,81 @@ function install(isGlobal) {
     console.log(`  ${green}✓${reset} Installed hooks`);
   }
 
-  // Configure statusline in settings.json
+  // Configure statusline and hooks in settings.json
   const settingsPath = path.join(claudeDir, 'settings.json');
   const settings = readSettings(settingsPath);
   const statuslineCommand = isGlobal
     ? '$HOME/.claude/hooks/statusline.sh'
     : '.claude/hooks/statusline.sh';
+  const updateCheckCommand = isGlobal
+    ? '$HOME/.claude/hooks/gsd-check-update.sh'
+    : '.claude/hooks/gsd-check-update.sh';
+  const notifyCommand = isGlobal
+    ? '$HOME/.claude/hooks/gsd-notify.sh'
+    : '.claude/hooks/gsd-notify.sh';
+
+  // Configure SessionStart hook for update checking
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.SessionStart) {
+    settings.hooks.SessionStart = [];
+  }
 
-  return { settingsPath, settings, statuslineCommand };
+  // Check if GSD update hook already exists
+  const hasGsdUpdateHook = settings.hooks.SessionStart.some(entry =>
+    entry.hooks && entry.hooks.some(h => h.command && h.command.includes('gsd-check-update'))
+  );
+
+  if (!hasGsdUpdateHook) {
+    settings.hooks.SessionStart.push({
+      hooks: [
+        {
+          type: 'command',
+          command: updateCheckCommand
+        }
+      ]
+    });
+    console.log(`  ${green}✓${reset} Configured update check hook`);
+  }
+
+  return { settingsPath, settings, statuslineCommand, notifyCommand };
 }
 
 /**
- * Apply statusline config and print completion message
+ * Apply statusline and notification config, then print completion message
  */
-function finishInstall(settingsPath, settings, statuslineCommand, shouldInstall) {
-  if (shouldInstall) {
+function finishInstall(settingsPath, settings, statuslineCommand, notifyCommand, shouldInstallStatusline, shouldInstallNotify) {
+  if (shouldInstallStatusline) {
     settings.statusLine = {
       type: 'command',
       command: statuslineCommand
     };
-    writeSettings(settingsPath, settings);
     console.log(`  ${green}✓${reset} Configured statusline`);
   }
 
+  if (shouldInstallNotify) {
+    if (!settings.hooks.Stop) {
+      settings.hooks.Stop = [];
+    }
+    // Remove any existing GSD notify hook first
+    settings.hooks.Stop = settings.hooks.Stop.filter(entry =>
+      !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('gsd-notify')))
+    );
+    settings.hooks.Stop.push({
+      hooks: [
+        {
+          type: 'command',
+          command: notifyCommand
+        }
+      ]
+    });
+    console.log(`  ${green}✓${reset} Configured completion notifications`);
+  }
+
+  // Always write settings (hooks were already configured in install())
+  writeSettings(settingsPath, settings);
+
   console.log(`
   ${green}Done!${reset} Launch Claude Code and run ${cyan}/gsd:help${reset}.
 `);
@@ -256,7 +312,7 @@ function finishInstall(settingsPath, settings, statuslineCommand, shouldInstall)
 /**
  * Handle statusline configuration with optional prompt
  */
-function handleStatusline(settingsPath, settings, statuslineCommand, isInteractive, callback) {
+function handleStatusline(settings, isInteractive, callback) {
   const hasExisting = settings.statusLine != null;
 
   // No existing statusline - just install it
@@ -309,6 +365,66 @@ function handleStatusline(settingsPath, settings, statuslineCommand, isInteracti
   });
 }
 
+/**
+ * Handle notification hook configuration with optional prompt
+ */
+function handleNotifications(settings, isInteractive, callback) {
+  // Check if --no-notify flag was passed
+  if (noNotify) {
+    callback(false);
+    return;
+  }
+
+  // Check if GSD notify hook already exists
+  const hasExisting = settings.hooks?.Stop?.some(entry =>
+    entry.hooks && entry.hooks.some(h => h.command && h.command.includes('gsd-notify'))
+  );
+
+  // No existing - just install it
+  if (!hasExisting) {
+    callback(true);
+    return;
+  }
+
+  // Has existing and --force-notify flag
+  if (forceNotify) {
+    callback(true);
+    return;
+  }
+
+  // Has existing, non-interactive mode - skip
+  if (!isInteractive) {
+    console.log(`  ${yellow}⚠${reset} Skipping notifications (already configured)`);
+    console.log(`    Use ${cyan}--force-notify${reset} to replace\n`);
+    callback(false);
+    return;
+  }
+
+  // Has existing, interactive mode - prompt user
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log(`
+  ${yellow}⚠${reset} Existing notification hook detected
+
+  GSD includes completion notifications that alert you when:
+    • A phase completes planning or execution
+    • Claude stops and needs your input
+    • Works on Mac, Linux, and Windows
+
+  ${cyan}1${reset}) Keep existing
+  ${cyan}2${reset}) Replace with GSD notifications
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    callback(choice === '2');
+  });
+}
+
 /**
  * Prompt for install location
  */
@@ -332,10 +448,12 @@ function promptLocation() {
     rl.close();
     const choice = answer.trim() || '1';
     const isGlobal = choice !== '2';
-    const { settingsPath, settings, statuslineCommand } = install(isGlobal);
-    // Interactive mode - prompt for statusline if needed
-    handleStatusline(settingsPath, settings, statuslineCommand, true, (shouldInstall) => {
-      finishInstall(settingsPath, settings, statuslineCommand, shouldInstall);
+    const { settingsPath, settings, statuslineCommand, notifyCommand } = install(isGlobal);
+    // Interactive mode - prompt for optional features
+    handleStatusline(settings, true, (shouldInstallStatusline) => {
+      handleNotifications(settings, true, (shouldInstallNotify) => {
+        finishInstall(settingsPath, settings, statuslineCommand, notifyCommand, shouldInstallStatusline, shouldInstallNotify);
+      });
     });
   });
 }
@@ -348,16 +466,20 @@ if (hasGlobal && hasLocal) {
   console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
   process.exit(1);
 } else if (hasGlobal) {
-  const { settingsPath, settings, statuslineCommand } = install(true);
-  // Non-interactive - skip prompt, respect --force-statusline
-  handleStatusline(settingsPath, settings, statuslineCommand, false, (shouldInstall) => {
-    finishInstall(settingsPath, settings, statuslineCommand, shouldInstall);
+  const { settingsPath, settings, statuslineCommand, notifyCommand } = install(true);
+  // Non-interactive - respect flags
+  handleStatusline(settings, false, (shouldInstallStatusline) => {
+    handleNotifications(settings, false, (shouldInstallNotify) => {
+      finishInstall(settingsPath, settings, statuslineCommand, notifyCommand, shouldInstallStatusline, shouldInstallNotify);
+    });
   });
 } else if (hasLocal) {
-  const { settingsPath, settings, statuslineCommand } = install(false);
-  // Non-interactive - skip prompt, respect --force-statusline
-  handleStatusline(settingsPath, settings, statuslineCommand, false, (shouldInstall) => {
-    finishInstall(settingsPath, settings, statuslineCommand, shouldInstall);
+  const { settingsPath, settings, statuslineCommand, notifyCommand } = install(false);
+  // Non-interactive - respect flags
+  handleStatusline(settings, false, (shouldInstallStatusline) => {
+    handleNotifications(settings, false, (shouldInstallNotify) => {
+      finishInstall(settingsPath, settings, statuslineCommand, notifyCommand, shouldInstallStatusline, shouldInstallNotify);
+    });
   });
 } else {
   promptLocation();

package/commands/gsd/create-roadmap.md

@@ -119,7 +119,6 @@ Roadmap created:
 
 **Also available:**
 - `/gsd:discuss-phase 1` — gather context first
-- `/gsd:research-phase 1` — investigate unknowns
 - Review roadmap
 
 ---

package/commands/gsd/plan-phase.md

@@ -81,10 +81,11 @@ grep -A5 "Phase ${PHASE}:" .planning/ROADMAP.md 2>/dev/null
 ```bash
 PHASE_DIR=$(ls -d .planning/phases/${PHASE}-* 2>/dev/null | head -1)
 if [ -z "$PHASE_DIR" ]; then
-  # Create phase directory from roadmap name
+  # Create phase directory from roadmap name with zero-padded phase number
   PHASE_NAME=$(grep "Phase ${PHASE}:" .planning/ROADMAP.md | sed 's/.*Phase [0-9]*: //' | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
-  mkdir -p ".planning/phases/${PHASE}-${PHASE_NAME}"
-  PHASE_DIR=".planning/phases/${PHASE}-${PHASE_NAME}"
+  PADDED_PHASE=$(printf "%02d" ${PHASE})
+  mkdir -p ".planning/phases/${PADDED_PHASE}-${PHASE_NAME}"
+  PHASE_DIR=".planning/phases/${PADDED_PHASE}-${PHASE_NAME}"
 fi
 ```
 

package/commands/gsd/progress.md

@@ -201,7 +201,6 @@ Check if `{phase}-CONTEXT.md` exists in phase directory.
 
 **Also available:**
 - `/gsd:discuss-phase {phase}` — gather context first
-- `/gsd:research-phase {phase}` — investigate unknowns
 - `/gsd:list-phase-assumptions {phase}` — see Claude's assumptions
 
 ---
@@ -276,7 +275,6 @@ Read ROADMAP.md to get the next phase's name and goal.
 **Also available:**
 - `/gsd:verify-work {Z}` — user acceptance test before continuing
 - `/gsd:discuss-phase {Z+1}` — gather context first
-- `/gsd:research-phase {Z+1}` — investigate unknowns
 
 ---
 ```

package/commands/gsd/update.md

@@ -85,6 +85,12 @@ npx get-shit-done-cc --global
 ```
 
 Capture output. If install fails, show error and STOP.
+
+Clear the update cache so statusline indicator disappears:
+
+```bash
+rm -f ~/.claude/cache/gsd-update-check.json
+```
 </step>
 
 <step name="fetch_changelog">

package/get-shit-done/workflows/create-roadmap.md

@@ -585,7 +585,6 @@ Project initialized:
 
 **Also available:**
 - `/gsd:discuss-phase 1` — gather context first
-- `/gsd:research-phase 1` — investigate unknowns
 - Review roadmap
 
 ---

package/get-shit-done/workflows/discuss-phase.md

@@ -229,7 +229,9 @@ Track deferred ideas internally.
 <step name="write_context">
 Create CONTEXT.md capturing decisions made.
 
-**File location:** `.planning/phases/${PHASE}-${SLUG}/${PHASE}-CONTEXT.md`
+**File location:** `.planning/phases/${PADDED_PHASE}-${SLUG}/${PADDED_PHASE}-CONTEXT.md`
+
+Zero-pad the phase number: `PADDED_PHASE=$(printf "%02d" ${PHASE})`
 
 Create phase directory if it doesn't exist. Use roadmap phase name for slug (lowercase, hyphens).
 
@@ -294,7 +296,7 @@ Write file.
 Present summary and next steps:
 
 ```
-Created: .planning/phases/${PHASE}-${SLUG}/${PHASE}-CONTEXT.md
+Created: .planning/phases/${PADDED_PHASE}-${SLUG}/${PADDED_PHASE}-CONTEXT.md
 
 ## Decisions Captured
 
@@ -321,7 +323,7 @@ Created: .planning/phases/${PHASE}-${SLUG}/${PHASE}-CONTEXT.md
 ---
 
 **Also available:**
-- `/gsd:research-phase ${PHASE}` — investigate unknowns first
+- `/gsd:plan-phase ${PHASE} --skip-research` — plan without research
 - Review/edit CONTEXT.md before continuing
 
 ---

package/get-shit-done/workflows/execute-plan.md

@@ -1771,7 +1771,6 @@ All {Y} plans finished.
 **Also available:**
 - `/gsd:verify-work {Z}` — manual acceptance testing before continuing
 - `/gsd:discuss-phase {Z+1}` — gather context first
-- `/gsd:research-phase {Z+1}` — investigate unknowns
 - Review phase accomplishments before continuing
 
 ---

package/hooks/gsd-check-update.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Check for GSD updates in background, write result to cache
+# Called by SessionStart hook - runs once per session
+
+CACHE_FILE="$HOME/.claude/cache/gsd-update-check.json"
+mkdir -p "$HOME/.claude/cache"
+
+# Run check in background (non-blocking)
+(
+  installed=$(cat "$HOME/.claude/get-shit-done/VERSION" 2>/dev/null || echo "0.0.0")
+  latest=$(npm view get-shit-done-cc version 2>/dev/null)
+
+  if [[ -n "$latest" && "$installed" != "$latest" ]]; then
+    echo "{\"update_available\":true,\"installed\":\"$installed\",\"latest\":\"$latest\",\"checked\":$(date +%s)}" > "$CACHE_FILE"
+  else
+    echo "{\"update_available\":false,\"installed\":\"$installed\",\"latest\":\"${latest:-unknown}\",\"checked\":$(date +%s)}" > "$CACHE_FILE"
+  fi
+) &
+
+exit 0

package/hooks/gsd-notify.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# GSD Completion Notification Hook
+# Cross-platform alert when Claude stops (task complete, needs input, etc.)
+
+input=$(cat)
+session_id=$(echo "$input" | jq -r '.session_id // empty')
+cwd=$(echo "$input" | jq -r '.cwd // empty')
+transcript_path=$(echo "$input" | jq -r '.transcript_path // empty')
+
+# Extract project name
+project="Claude Code"
+if [[ -n "$cwd" ]]; then
+  project=$(basename "$cwd")
+fi
+
+# Try to get context from GSD state file
+message=""
+state_file="$cwd/.planning/STATE.md"
+if [[ -f "$state_file" ]]; then
+  phase=$(grep -m1 "^current_phase:" "$state_file" 2>/dev/null | sed 's/^current_phase: *//')
+  status=$(grep -m1 "^status:" "$state_file" 2>/dev/null | sed 's/^status: *//')
+  if [[ -n "$phase" && -n "$status" ]]; then
+    message="Phase $phase: $status"
+  fi
+fi
+
+# Fallback: check todo list for current/completed task
+if [[ -z "$message" && -n "$session_id" ]]; then
+  todo_file=$(ls -t "$HOME/.claude/todos/${session_id}"*.json 2>/dev/null | head -1)
+  if [[ -f "$todo_file" ]]; then
+    # Get most recently completed task, or in-progress task
+    completed=$(jq -r '[.[] | select(.status=="completed")] | last | .content // empty' "$todo_file" 2>/dev/null)
+    if [[ -n "$completed" ]]; then
+      message="Completed: $completed"
+    else
+      in_progress=$(jq -r '.[] | select(.status=="in_progress") | .content' "$todo_file" 2>/dev/null | head -1)
+      if [[ -n "$in_progress" ]]; then
+        message="Paused: $in_progress"
+      fi
+    fi
+  fi
+fi
+
+# Fallback: generic message
+if [[ -z "$message" ]]; then
+  message="Ready for input"
+fi
+
+# Send notification based on OS
+case "$(uname -s)" in
+  Darwin)
+    osascript -e "display alert \"GSD: $project\" message \"$message\" as informational" &>/dev/null &
+    ;;
+  Linux)
+    if command -v notify-send &>/dev/null; then
+      notify-send "GSD: $project" "$message" --urgency=normal
+    elif command -v zenity &>/dev/null; then
+      zenity --info --title="GSD: $project" --text="$message" &
+    fi
+    ;;
+  MINGW*|CYGWIN*|MSYS*)
+    # Windows via PowerShell
+    if command -v powershell.exe &>/dev/null; then
+      powershell.exe -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('$message', 'GSD: $project', 'OK', 'Information')" &>/dev/null &
+    fi
+    ;;
+esac
+
+exit 0

package/hooks/statusline.sh

@@ -40,10 +40,19 @@ if [[ -f "$todo" ]]; then
     task=$(jq -r '.[] | select(.status=="in_progress") | .activeForm' "$todo" 2>/dev/null | head -1)
 fi
 
+# GSD update available?
+gsd_update=""
+if [[ -f "$HOME/.claude/cache/gsd-update-check.json" ]]; then
+    update_available=$(jq -r '.update_available' "$HOME/.claude/cache/gsd-update-check.json" 2>/dev/null)
+    if [[ "$update_available" == "true" ]]; then
+        gsd_update=$'\033[33m⬆ /gsd:update\033[0m │ '
+    fi
+fi
+
 # Output
 dirname=$(basename "$dir")
 if [[ -n "$task" ]]; then
-    printf '\033[2m%s\033[0m │ \033[1m%s\033[0m │ \033[2m%s\033[0m%s' "$model" "$task" "$dirname" "$ctx"
+    printf '%s\033[2m%s\033[0m │ \033[1m%s\033[0m │ \033[2m%s\033[0m%s' "$gsd_update" "$model" "$task" "$dirname" "$ctx"
 else
-    printf '\033[2m%s\033[0m │ \033[2m%s\033[0m%s' "$model" "$dirname" "$ctx"
+    printf '%s\033[2m%s\033[0m │ \033[2m%s\033[0m%s' "$gsd_update" "$model" "$dirname" "$ctx"
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-shit-done-cc",
-  "version": "1.5.21",
+  "version": "1.5.23",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "get-shit-done-cc": "bin/install.js"