@undeemed/get-shit-done-codex 1.6.12 → 1.20.3

package/get-shit-done/workflows/verify-work.md

@@ -1,13 +1,13 @@
 <purpose>
 Validate built features through conversational testing with persistent state. Creates UAT.md that tracks test progress, survives /clear, and feeds gaps into /gsd:plan-phase --gaps.
 
-User tests, Claude records. One test at a time. Plain text responses.
+User tests, Codex records. One test at a time. Plain text responses.
 </purpose>
 
 <philosophy>
 **Show expected, ask if reality matches.**
 
-Claude presents what SHOULD happen. User confirms or describes what's different.
+Codex presents what SHOULD happen. User confirms or describes what's different.
 - "yes" / "y" / "next" / empty → pass
 - Anything else → logged as issue, severity inferred
 
@@ -15,11 +15,21 @@ No Pass/Fail buttons. No severity questions. Just: "Here's what should happen. D
 </philosophy>
 
 <template>
-@~/.claude/get-shit-done/templates/UAT.md
+@~/.codex/get-shit-done/templates/UAT.md
 </template>
 
 <process>
 
+<step name="initialize" priority="first">
+If $ARGUMENTS contains a phase number, load context:
+
+```bash
+INIT=$(node ~/.codex/get-shit-done/bin/gsd-tools.cjs init verify-work "${PHASE_ARG}")
+```
+
+Parse JSON for: `planner_model`, `checker_model`, `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `has_verification`.
+</step>
+
 <step name="check_active_session">
 **First: Check for active UAT sessions**
 
@@ -70,15 +80,10 @@ Continue to `create_uat_file`.
 <step name="find_summaries">
 **Find what to test:**
 
-Parse $ARGUMENTS as phase number (e.g., "4") or plan number (e.g., "04-02").
+Use `phase_dir` from init (or run init if not already done).
 
 ```bash
-# Find phase directory (match both zero-padded and unpadded)
-PADDED_PHASE=$(printf "%02d" ${PHASE_ARG} 2>/dev/null || echo "${PHASE_ARG}")
-PHASE_DIR=$(ls -d .planning/phases/${PADDED_PHASE}-* .planning/phases/${PHASE_ARG}-* 2>/dev/null | head -1)
-
-# Find SUMMARY files
-ls "$PHASE_DIR"/*-SUMMARY.md 2>/dev/null
+ls "$phase_dir"/*-SUMMARY.md 2>/dev/null
 ```
 
 Read each SUMMARY.md to extract testable deliverables.
@@ -159,7 +164,7 @@ skipped: 0
 [none yet]
 ```
 
-Write to `.planning/phases/XX-name/{phase}-UAT.md`
+Write to `.planning/phases/XX-name/{phase_num}-UAT.md`
 
 Proceed to `present_test`.
 </step>
@@ -287,8 +292,7 @@ Clear Current Test section:
 
 Commit the UAT file:
 ```bash
-git add ".planning/phases/XX-name/{phase}-UAT.md"
-git commit -m "test({phase}): complete UAT - {passed} passed, {issues} issues"
+node ~/.codex/get-shit-done/bin/gsd-tools.cjs commit "test({phase_num}): complete UAT - {passed} passed, {issues} issues" --files ".planning/phases/XX-name/{phase_num}-UAT.md"
 ```
 
 Present summary:
@@ -330,7 +334,7 @@ Spawning parallel debug agents to investigate each issue.
 ```
 
 - Load diagnose-issues workflow
-- Follow @~/.claude/get-shit-done/workflows/diagnose-issues.md
+- Follow @~/.codex/get-shit-done/workflows/diagnose-issues.md
 - Spawn parallel debug agents for each issue
 - Collect root causes
 - Update UAT.md with root causes
@@ -362,7 +366,7 @@ Task(
 **Mode:** gap_closure
 
 **UAT with diagnoses:**
-@.planning/phases/{phase_dir}/{phase}-UAT.md
+@.planning/phases/{phase_dir}/{phase_num}-UAT.md
 
 **Project State:**
 @.planning/STATE.md
@@ -378,6 +382,7 @@ Plans must be executable prompts.
 </downstream_consumer>
 """,
   subagent_type="gsd-planner",
+  model="{planner_model}",
   description="Plan gap fixes for Phase {phase}"
 )
 ```
@@ -423,6 +428,7 @@ Return one of:
 </expected_output>
 """,
   subagent_type="gsd-plan-checker",
+  model="{checker_model}",
   description="Verify Phase {phase} fix plans"
 )
 ```
@@ -463,6 +469,7 @@ Do NOT replan from scratch unless issues are fundamental.
 </instructions>
 """,
   subagent_type="gsd-planner",
+  model="{planner_model}",
   description="Revise Phase {phase} plans"
 )
 ```

package/hooks/dist/gsd-check-update.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// Check for GSD updates in background, write result to cache
+// Called by SessionStart hook - runs once per session
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const homeDir = os.homedir();
+const cwd = process.cwd();
+const cacheDir = path.join(homeDir, '.codex', 'cache');
+const cacheFile = path.join(cacheDir, 'gsd-update-check.json');
+
+// VERSION file locations (check project first, then global)
+const projectVersionFile = path.join(cwd, 'get-shit-done', 'VERSION');
+const globalVersionFile = path.join(homeDir, '.codex', 'get-shit-done', 'VERSION');
+
+// Ensure cache directory exists
+if (!fs.existsSync(cacheDir)) {
+  fs.mkdirSync(cacheDir, { recursive: true });
+}
+
+// Run check in background (spawn background process, windowsHide prevents console flash)
+const child = spawn(process.execPath, ['-e', `
+  const fs = require('fs');
+  const { execSync } = require('child_process');
+
+  const cacheFile = ${JSON.stringify(cacheFile)};
+  const projectVersionFile = ${JSON.stringify(projectVersionFile)};
+  const globalVersionFile = ${JSON.stringify(globalVersionFile)};
+
+  // Check project directory first (local install), then global
+  let installed = '0.0.0';
+  const readInstalledVersion = (versionFilePath) => {
+    const raw = fs.readFileSync(versionFilePath, 'utf8');
+    return (raw.split(/\\r?\\n/)[0] || '').trim() || '0.0.0';
+  };
+  try {
+    if (fs.existsSync(projectVersionFile)) {
+      installed = readInstalledVersion(projectVersionFile);
+    } else if (fs.existsSync(globalVersionFile)) {
+      installed = readInstalledVersion(globalVersionFile);
+    }
+  } catch (e) {}
+
+  let latest = null;
+  try {
+    latest = execSync('npm view @undeemed/get-shit-done-codex version', { encoding: 'utf8', timeout: 10000, windowsHide: true }).trim();
+  } catch (e) {}
+
+  const result = {
+    update_available: latest && installed !== latest,
+    installed,
+    latest: latest || 'unknown',
+    checked: Math.floor(Date.now() / 1000)
+  };
+
+  fs.writeFileSync(cacheFile, JSON.stringify(result));
+`], {
+  stdio: 'ignore',
+  windowsHide: true,
+  detached: true  // Required on Windows for proper process detachment
+});
+
+child.unref();

package/hooks/dist/gsd-statusline.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Codex Statusline - GSD Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Codex';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to 80% limit)
+    // Scale context to show 100% at the effective limit.
+    let ctx = '';
+    if (remaining != null) {
+      const rem = Math.round(remaining);
+      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+      // Scale: 80% real usage = 100% displayed
+      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on scaled usage (thresholds adjusted for new scale)
+      if (used < 63) {        // ~50% real
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 81) { // ~65% real
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 95) { // ~76% real
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const todosDir = path.join(homeDir, '.codex', 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {
+        // Silently fail on file system errors - don't break statusline
+      }
+    }
+
+    // GSD update available?
+    let gsdUpdate = '';
+    const cacheFile = path.join(homeDir, '.codex', 'cache', 'gsd-update-check.json');
+    if (fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        if (cache.update_available) {
+          gsdUpdate = '\x1b[33m⬆ /prompts:gsd-update\x1b[0m │ ';
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@undeemed/get-shit-done-codex",
-  "version": "1.6.12",
-  "description": "A meta-prompting, context engineering and spec-driven development system for OpenAI Codex CLI. Fork of get-shit-done by TÂCHES, adapted for Codex CLI by undeemed.",
+  "version": "1.20.3",
+  "description": "A meta-prompting, context engineering and spec-driven development system for OpenAI Codex (CLI and Desktop). Fork of get-shit-done by TÂCHES, adapted for Codex by undeemed.",
   "bin": {
     "get-shit-done-codex": "bin/install.js"
   },
@@ -12,6 +12,9 @@
     "bin",
     "commands",
     "get-shit-done",
+    "agents",
+    "hooks/dist",
+    "scripts",
     "AGENTS.md"
   ],
   "keywords": [
@@ -33,7 +36,20 @@
     "type": "git",
     "url": "git+https://github.com/undeemed/get-shit-done-codex.git"
   },
+  "homepage": "https://github.com/undeemed/get-shit-done-codex",
+  "bugs": {
+    "url": "https://github.com/undeemed/get-shit-done-codex/issues"
+  },
   "engines": {
     "node": ">=16.7.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "esbuild": "^0.24.0"
+  },
+  "scripts": {
+    "build:hooks": "node scripts/build-hooks.js",
+    "prepublishOnly": "npm run build:hooks",
+    "test": "node --test get-shit-done/bin/gsd-tools.test.cjs"
   }
-}
+}

package/scripts/build-hooks.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Copy GSD hooks to dist for installation.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HOOKS_DIR = path.join(__dirname, '..', 'hooks');
+const DIST_DIR = path.join(HOOKS_DIR, 'dist');
+
+// Hooks to copy (pure Node.js, no bundling needed)
+const HOOKS_TO_COPY = [
+  'gsd-check-update.js',
+  'gsd-statusline.js'
+];
+
+function build() {
+  // Ensure dist directory exists
+  if (!fs.existsSync(DIST_DIR)) {
+    fs.mkdirSync(DIST_DIR, { recursive: true });
+  }
+
+  // Copy hooks to dist
+  for (const hook of HOOKS_TO_COPY) {
+    const src = path.join(HOOKS_DIR, hook);
+    const dest = path.join(DIST_DIR, hook);
+
+    if (!fs.existsSync(src)) {
+      console.warn(`Warning: ${hook} not found, skipping`);
+      continue;
+    }
+
+    console.log(`Copying ${hook}...`);
+    fs.copyFileSync(src, dest);
+    console.log(`  → ${dest}`);
+  }
+
+  console.log('\nBuild complete.');
+}
+
+build();

package/commands/gsd/whats-new.md

@@ -1,124 +0,0 @@
----
-name: gsd:whats-new
-description: See what's new in GSD since your installed version
----
-
-<objective>
-Display changes between installed version and latest available version.
-
-Shows version comparison, changelog entries for missed versions, and update instructions.
-</objective>
-
-<process>
-
-<step name="get_installed_version">
-Read installed version from VERSION file:
-
-```bash
-cat ~/.claude/get-shit-done/VERSION 2>/dev/null
-```
-
-**If VERSION file missing:**
-```
-## GSD What's New
-
-**Installed version:** Unknown
-
-Your installation doesn't include version tracking.
-
-**To fix:** `npx get-shit-done-cc --global`
-
-This will reinstall with version tracking enabled.
-```
-
-STOP here if no VERSION file.
-</step>
-
-<step name="fetch_remote_changelog">
-Fetch latest CHANGELOG.md from GitHub:
-
-Use WebFetch tool with:
-- URL: `https://raw.githubusercontent.com/glittercowboy/get-shit-done/main/CHANGELOG.md`
-- Prompt: "Extract all version entries with their dates and changes. Return in Keep-a-Changelog format."
-
-**If fetch fails:**
-Fall back to local changelog:
-```bash
-cat ~/.claude/get-shit-done/CHANGELOG.md 2>/dev/null
-```
-
-Note to user: "Couldn't check for updates (offline or GitHub unavailable). Showing local changelog."
-</step>
-
-<step name="parse_versions">
-From the remote (or local) changelog:
-
-1. **Extract latest version** - First `## [X.Y.Z]` line after `## [Unreleased]`
-2. **Compare with installed** - From VERSION file
-3. **Extract entries between** - All version sections from latest down to (but not including) installed
-
-**Version comparison:**
-- If installed == latest: "You're on the latest version"
-- If installed < latest: Show changes since installed version
-- If installed > latest: "You're ahead of latest release (development version?)"
-</step>
-
-<step name="display_output">
-Format output clearly:
-
-**If up to date:**
-```
-## GSD What's New
-
-**Installed:** 1.4.26
-**Latest:** 1.4.26
-
-You're on the latest version.
-
-[View full changelog](https://github.com/glittercowboy/get-shit-done/blob/main/CHANGELOG.md)
-```
-
-**If updates available:**
-```
-## GSD What's New
-
-**Installed:** 1.4.23
-**Latest:** 1.4.26
-
----
-
-### Changes since your version:
-
-## [1.4.26] - 2026-01-20
-
-### Added
-- Feature X
-- Feature Y
-
-### Changed
-- **BREAKING:** Changed Z behavior
-
-## [1.4.25] - 2026-01-18
-
-### Fixed
-- Bug in feature A
-
----
-
-[View full changelog](https://github.com/glittercowboy/get-shit-done/blob/main/CHANGELOG.md)
-
-**To update:** `npx get-shit-done-cc --global`
-```
-
-**Breaking changes:** Surface prominently with **BREAKING:** prefix in the output.
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] Installed version read from VERSION file
-- [ ] Remote changelog fetched (or graceful fallback to local)
-- [ ] Version comparison displayed clearly
-- [ ] Changes since installed version shown (if any)
-- [ ] Update instructions provided when behind
-</success_criteria>