gsd-pi 2.31.2-dev.2453512 → 2.31.2-dev.392f611

package/dist/resources/extensions/gsd/visualizer-data.ts

@@ -18,6 +18,9 @@ import {
 } from './metrics.js';
 import { loadAllCaptures, countPendingCaptures } from './captures.js';
 import { loadEffectiveGSDPreferences } from './preferences.js';
+import { runProviderChecks, type ProviderCheckResult } from './doctor-providers.js';
+import { generateSkillHealthReport } from './skill-health.js';
+import { runEnvironmentChecks, type EnvironmentCheckResult } from './doctor-environment.js';
 
 import type { Phase } from './types.js';
 import type { CaptureEntry } from './captures.js';
@@ -142,6 +145,22 @@ export interface CapturesInfo {
   totalCount: number;
 }
 
+export interface ProviderStatusSummary {
+  name: string;
+  label: string;
+  category: string;
+  ok: boolean;
+  required: boolean;
+  message: string;
+}
+
+export interface SkillSummaryInfo {
+  total: number;
+  warningCount: number;
+  criticalCount: number;
+  topIssue: string | null;
+}
+
 export interface HealthInfo {
   budgetCeiling: number | undefined;
   tokenProfile: string;
@@ -152,6 +171,9 @@ export interface HealthInfo {
   toolCalls: number;
   assistantMessages: number;
   userMessages: number;
+  providers: ProviderStatusSummary[];
+  skillSummary: SkillSummaryInfo;
+  environmentIssues: import("./doctor-environment.js").EnvironmentCheckResult[];
 }
 
 export interface VisualizerData {
@@ -538,7 +560,7 @@ function loadKnowledge(basePath: string): KnowledgeInfo {
 
 // ─── Health Loader ────────────────────────────────────────────────────────────
 
-function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthInfo {
+function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null, basePath: string): HealthInfo {
   const prefs = loadEffectiveGSDPreferences();
   const budgetCeiling = prefs?.preferences?.budget_ceiling;
   const tokenProfile = prefs?.preferences?.token_profile ?? 'standard';
@@ -553,6 +575,39 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthI
   const tierBreakdown = aggregateByTier(units);
   const tierSavingsLine = formatTierSavings(units);
 
+  // Provider checks — fast (auth.json + env vars only, no network)
+  let providers: ProviderStatusSummary[] = [];
+  try {
+    providers = runProviderChecks().map((r: ProviderCheckResult) => ({
+      name: r.name,
+      label: r.label,
+      category: r.category,
+      ok: r.status === "ok" || r.status === "unconfigured",
+      required: r.required,
+      message: r.message,
+    }));
+  } catch { /* non-fatal */ }
+
+  // Skill health summary
+  let skillSummary: SkillSummaryInfo = { total: 0, warningCount: 0, criticalCount: 0, topIssue: null };
+  try {
+    const report = generateSkillHealthReport(basePath);
+    const warnings = report.suggestions.filter(s => s.severity === "warning");
+    const criticals = report.suggestions.filter(s => s.severity === "critical");
+    skillSummary = {
+      total: report.skills.length,
+      warningCount: warnings.length,
+      criticalCount: criticals.length,
+      topIssue: report.suggestions[0]?.message ?? null,
+    };
+  } catch { /* non-fatal */ }
+
+  // Environment issues (from doctor-environment.ts, #1221)
+  let environmentIssues: EnvironmentCheckResult[] = [];
+  try {
+    environmentIssues = runEnvironmentChecks(basePath).filter(r => r.status !== "ok");
+  } catch { /* non-fatal */ }
+
   return {
     budgetCeiling,
     tokenProfile,
@@ -563,6 +618,9 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthI
     toolCalls: totals?.toolCalls ?? 0,
     assistantMessages: totals?.assistantMessages ?? 0,
     userMessages: totals?.userMessages ?? 0,
+    providers,
+    skillSummary,
+    environmentIssues,
   };
 }
 
@@ -780,7 +838,7 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     totalCount: allCaptures.length,
   };
 
-  const health = loadHealth(units, totals);
+  const health = loadHealth(units, totals, basePath);
   const stats = buildVisualizerStats(milestones, changelog.entries);
   const discussion = loadDiscussionState(basePath, milestones);
 

package/dist/resources/extensions/gsd/visualizer-views.ts

@@ -1113,5 +1113,59 @@ export function renderHealthView(
   lines.push(`  Tool calls: ${th.fg("text", String(health.toolCalls))}`);
   lines.push(`  Messages: ${th.fg("text", String(health.assistantMessages))} sent / ${th.fg("text", String(health.userMessages))} received`);
 
+  // Environment section — issues only (from doctor-environment.ts, #1221)
+  if (health.environmentIssues?.length > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Environment")));
+    lines.push("");
+    for (const r of health.environmentIssues) {
+      const icon = r.status === "error" ? th.fg("error", "✗") : th.fg("warning", "⚠");
+      lines.push(`  ${icon} ${th.fg("text", r.message)}`);
+      if (r.detail) lines.push(`    ${th.fg("dim", r.detail)}`);
+    }
+  }
+
+  // Providers section
+  if (health.providers?.length > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Providers")));
+    lines.push("");
+    const categoryOrder = ["llm", "remote", "search", "tool"];
+    const categoryLabels: Record<string, string> = { llm: "LLM", remote: "Notifications", search: "Search", tool: "Tools" };
+    const grouped = new Map<string, typeof health.providers>();
+    for (const p of health.providers) {
+      const cat = p.category;
+      if (!grouped.has(cat)) grouped.set(cat, []);
+      grouped.get(cat)!.push(p);
+    }
+    for (const cat of categoryOrder) {
+      const items = grouped.get(cat);
+      if (!items || items.length === 0) continue;
+      lines.push(`  ${th.fg("dim", categoryLabels[cat] ?? cat)}`);
+      for (const p of items) {
+        const icon = p.ok ? th.fg("success", "✓") : th.fg("error", "✗");
+        const msg = p.ok ? th.fg("dim", p.message) : th.fg("text", p.message);
+        lines.push(`    ${icon} ${msg}`);
+      }
+    }
+  }
+
+  // Skills section
+  if (health.skillSummary?.total > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Skills")));
+    lines.push("");
+    const { total, warningCount, criticalCount, topIssue } = health.skillSummary;
+    const issueColor = criticalCount > 0 ? "error" : warningCount > 0 ? "warning" : "success";
+    const issueTag = criticalCount > 0
+      ? `${criticalCount} critical`
+      : warningCount > 0
+        ? `${warningCount} warning${warningCount > 1 ? "s" : ""}`
+        : "all healthy";
+    lines.push(`  ${th.fg("text", String(total))} skills tracked  ·  ${th.fg(issueColor, issueTag)}`);
+    if (topIssue) lines.push(`  ${th.fg("warning", "⚠")} ${th.fg("dim", topIssue)}`);
+    lines.push(`  ${th.fg("dim", "→ /gsd skill-health for full report")}`);
+  }
+
   return lines;
 }

package/dist/worktree-cli.d.ts

@@ -12,7 +12,43 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
+interface ExtensionModules {
+    createWorktree: (basePath: string, name: string) => {
+        path: string;
+        branch: string;
+    };
+    listWorktrees: (basePath: string) => Array<{
+        name: string;
+        path: string;
+        branch: string;
+    }>;
+    removeWorktree: (basePath: string, name: string, opts?: {
+        deleteBranch?: boolean;
+    }) => void;
+    mergeWorktreeToMain: (basePath: string, name: string, commitMessage: string) => void;
+    diffWorktreeAll: (basePath: string, name: string) => {
+        added: any[];
+        modified: any[];
+        removed: any[];
+    };
+    diffWorktreeNumstat: (basePath: string, name: string) => Array<{
+        added: number;
+        removed: number;
+    }>;
+    worktreeBranchName: (name: string) => string;
+    worktreePath: (basePath: string, name: string) => string;
+    runWorktreePostCreateHook: (basePath: string, wtPath: string) => string | null;
+    nativeHasChanges: (path: string) => boolean;
+    nativeDetectMainBranch: (basePath: string) => string;
+    nativeCommitCountBetween: (basePath: string, from: string, to: string) => number;
+    inferCommitType: (name: string) => string;
+    autoCommitCurrentBranch: (wtPath: string, reason: string, name: string) => void;
+}
 interface WorktreeStatus {
     name: string;
     path: string;
@@ -24,11 +60,11 @@ interface WorktreeStatus {
     uncommitted: boolean;
     commits: number;
 }
-declare function getWorktreeStatus(basePath: string, name: string, wtPath: string): WorktreeStatus;
-declare function handleList(basePath: string): void;
+declare function getWorktreeStatus(ext: ExtensionModules, basePath: string, name: string, wtPath: string): WorktreeStatus;
+declare function handleList(basePath: string): Promise<void>;
 declare function handleMerge(basePath: string, args: string[]): Promise<void>;
-declare function handleClean(basePath: string): void;
-declare function handleRemove(basePath: string, args: string[]): void;
-declare function handleStatusBanner(basePath: string): void;
-declare function handleWorktreeFlag(worktreeFlag: boolean | string): void;
+declare function handleClean(basePath: string): Promise<void>;
+declare function handleRemove(basePath: string, args: string[]): Promise<void>;
+declare function handleStatusBanner(basePath: string): Promise<void>;
+declare function handleWorktreeFlag(worktreeFlag: boolean | string): Promise<void>;
 export { handleList, handleMerge, handleClean, handleRemove, handleStatusBanner, handleWorktreeFlag, getWorktreeStatus, };

package/dist/worktree-cli.js

@@ -12,18 +12,53 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
 import chalk from 'chalk';
-import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, worktreeBranchName, } from './resources/extensions/gsd/worktree-manager.js';
-import { runWorktreePostCreateHook } from './resources/extensions/gsd/auto-worktree.js';
+import { createJiti } from '@mariozechner/jiti';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { generateWorktreeName } from './worktree-name-gen.js';
-import { nativeHasChanges, nativeDetectMainBranch, nativeCommitCountBetween, } from './resources/extensions/gsd/native-git-bridge.js';
-import { inferCommitType } from './resources/extensions/gsd/git-service.js';
 import { existsSync } from 'node:fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+// Lazily-loaded extension modules (loaded once on first use via jiti)
+let _ext = null;
+async function loadExtensionModules() {
+    if (_ext)
+        return _ext;
+    const [wtMgr, autoWt, gitBridge, gitSvc, wt] = await Promise.all([
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree-manager.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/auto-worktree.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/native-git-bridge.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/git-service.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree.ts'), {}),
+    ]);
+    _ext = {
+        createWorktree: wtMgr.createWorktree,
+        listWorktrees: wtMgr.listWorktrees,
+        removeWorktree: wtMgr.removeWorktree,
+        mergeWorktreeToMain: wtMgr.mergeWorktreeToMain,
+        diffWorktreeAll: wtMgr.diffWorktreeAll,
+        diffWorktreeNumstat: wtMgr.diffWorktreeNumstat,
+        worktreeBranchName: wtMgr.worktreeBranchName,
+        worktreePath: wtMgr.worktreePath,
+        runWorktreePostCreateHook: autoWt.runWorktreePostCreateHook,
+        nativeHasChanges: gitBridge.nativeHasChanges,
+        nativeDetectMainBranch: gitBridge.nativeDetectMainBranch,
+        nativeCommitCountBetween: gitBridge.nativeCommitCountBetween,
+        inferCommitType: gitSvc.inferCommitType,
+        autoCommitCurrentBranch: wt.autoCommitCurrentBranch,
+    };
+    return _ext;
+}
 // ─── Status Helpers ─────────────────────────────────────────────────────────
-function getWorktreeStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getWorktreeStatus(ext, basePath, name, wtPath) {
+    const diff = ext.diffWorktreeAll(basePath, name);
+    const numstat = ext.diffWorktreeNumstat(basePath, name);
     const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -33,19 +68,19 @@ function getWorktreeStatus(basePath, name, wtPath) {
     }
     let uncommitted = false;
     try {
-        uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+        uncommitted = existsSync(wtPath) && ext.nativeHasChanges(wtPath);
     }
     catch { /* */ }
     let commits = 0;
     try {
-        const mainBranch = nativeDetectMainBranch(basePath);
-        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
+        const mainBranch = ext.nativeDetectMainBranch(basePath);
+        commits = ext.nativeCommitCountBetween(basePath, mainBranch, ext.worktreeBranchName(name));
     }
     catch { /* */ }
     return {
         name,
         path: wtPath,
-        branch: worktreeBranchName(name),
+        branch: ext.worktreeBranchName(name),
         exists: existsSync(wtPath),
         filesChanged,
         linesAdded,
@@ -71,65 +106,66 @@ function formatStatus(s) {
     return lines.join('\n');
 }
 // ─── Subcommand: list ───────────────────────────────────────────────────────
-function handleList(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleList(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees. Create one with: gsd -w <name>\n'));
         return;
     }
     process.stderr.write(chalk.bold('\nWorktrees\n\n'));
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         process.stderr.write(formatStatus(status) + '\n\n');
     }
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
 async function handleMerge(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         // If only one worktree exists, merge it
-        const worktrees = listWorktrees(basePath);
+        const worktrees = ext.listWorktrees(basePath);
         if (worktrees.length === 1) {
-            await doMerge(basePath, worktrees[0].name);
+            await doMerge(ext, basePath, worktrees[0].name);
             return;
         }
         process.stderr.write(chalk.red('Usage: gsd worktree merge <name>\n'));
         process.stderr.write(chalk.dim('Run gsd worktree list to see worktrees.\n'));
         process.exit(1);
     }
-    await doMerge(basePath, name);
+    await doMerge(ext, basePath, name);
 }
-async function doMerge(basePath, name) {
-    const worktrees = listWorktrees(basePath);
+async function doMerge(ext, basePath, name) {
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged === 0 && !status.uncommitted) {
         process.stderr.write(chalk.dim(`Worktree "${name}" has no changes to merge.\n`));
         // Clean up empty worktree
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`Removed empty worktree ${chalk.bold(name)}.\n`));
         return;
     }
     // Auto-commit dirty work before merge
     if (status.uncommitted) {
         try {
-            const { autoCommitCurrentBranch } = await import('./resources/extensions/gsd/worktree.js');
-            autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
+            ext.autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
             process.stderr.write(chalk.dim('  Auto-committed dirty work before merge.\n'));
         }
         catch { /* best-effort */ }
     }
-    const commitType = inferCommitType(name);
+    const commitType = ext.inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
-    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(nativeDetectMainBranch(basePath))}\n`);
+    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(ext.nativeDetectMainBranch(basePath))}\n`);
     process.stderr.write(chalk.dim(`  ${status.filesChanged} files, ${chalk.green(`+${status.linesAdded}`)} ${chalk.red(`-${status.linesRemoved}`)}\n\n`));
     try {
-        mergeWorktreeToMain(basePath, name, commitMessage);
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.mergeWorktreeToMain(basePath, name, commitMessage);
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`✓ Merged and cleaned up ${chalk.bold(name)}\n`));
         process.stderr.write(chalk.dim(`  commit: ${commitMessage}\n`));
     }
@@ -141,18 +177,19 @@ async function doMerge(basePath, name) {
     }
 }
 // ─── Subcommand: clean ──────────────────────────────────────────────────────
-function handleClean(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleClean(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees to clean.\n'));
         return;
     }
     let cleaned = 0;
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         if (status.filesChanged === 0 && !status.uncommitted) {
             try {
-                removeWorktree(basePath, wt.name, { deleteBranch: true });
+                ext.removeWorktree(basePath, wt.name, { deleteBranch: true });
                 process.stderr.write(chalk.green(`  ✓ Removed ${chalk.bold(wt.name)} (clean)\n`));
                 cleaned++;
             }
@@ -167,19 +204,20 @@ function handleClean(basePath) {
     process.stderr.write(chalk.dim(`\nCleaned ${cleaned} worktree${cleaned === 1 ? '' : 's'}.\n`));
 }
 // ─── Subcommand: remove ─────────────────────────────────────────────────────
-function handleRemove(basePath, args) {
+async function handleRemove(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         process.stderr.write(chalk.red('Usage: gsd worktree remove <name>\n'));
         process.exit(1);
     }
-    const worktrees = listWorktrees(basePath);
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged > 0 || status.uncommitted) {
         process.stderr.write(chalk.yellow(`⚠ Worktree "${name}" has unmerged changes (${status.filesChanged} files).\n`));
         process.stderr.write(chalk.yellow('  Use --force to remove anyway, or merge first: gsd worktree merge ' + name + '\n'));
@@ -187,17 +225,18 @@ function handleRemove(basePath, args) {
             process.exit(1);
         }
     }
-    removeWorktree(basePath, name, { deleteBranch: true });
+    ext.removeWorktree(basePath, name, { deleteBranch: true });
     process.stderr.write(chalk.green(`✓ Removed worktree ${chalk.bold(name)}\n`));
 }
 // ─── Subcommand: status (default when no args) ─────────────────────────────
-function handleStatusBanner(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleStatusBanner(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0)
         return;
     const withChanges = worktrees.filter(wt => {
         try {
-            const diff = diffWorktreeAll(basePath, wt.name);
+            const diff = ext.diffWorktreeAll(basePath, wt.name);
             return diff.added.length + diff.modified.length + diff.removed.length > 0;
         }
         catch {
@@ -214,14 +253,15 @@ function handleStatusBanner(basePath) {
         chalk.dim('Resume: gsd -w <name>  |  Merge: gsd worktree merge <name>  |  List: gsd worktree list\n\n'));
 }
 // ─── -w flag: create/resume worktree for interactive session ────────────────
-function handleWorktreeFlag(worktreeFlag) {
+async function handleWorktreeFlag(worktreeFlag) {
+    const ext = await loadExtensionModules();
     const basePath = process.cwd();
     // gsd -w (no name) — resume most recent worktree with changes, or create new
     if (worktreeFlag === true) {
-        const existing = listWorktrees(basePath);
+        const existing = ext.listWorktrees(basePath);
         const withChanges = existing.filter(wt => {
             try {
-                const diff = diffWorktreeAll(basePath, wt.name);
+                const diff = ext.diffWorktreeAll(basePath, wt.name);
                 return diff.added.length + diff.modified.length + diff.removed.length > 0;
             }
             catch {
@@ -243,7 +283,7 @@ function handleWorktreeFlag(worktreeFlag) {
             // Multiple active worktrees — show them and ask user to pick
             process.stderr.write(chalk.yellow(`${withChanges.length} worktrees have unmerged changes:\n\n`));
             for (const wt of withChanges) {
-                const status = getWorktreeStatus(basePath, wt.name, wt.path);
+                const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
                 process.stderr.write(formatStatus(status) + '\n\n');
             }
             process.stderr.write(chalk.dim('Specify which one: gsd -w <name>\n'));
@@ -251,12 +291,12 @@ function handleWorktreeFlag(worktreeFlag) {
         }
         // No active worktrees — create a new one
         const name = generateWorktreeName();
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
         return;
     }
     // gsd -w <name> — create or resume named worktree
     const name = worktreeFlag;
-    const existing = listWorktrees(basePath);
+    const existing = ext.listWorktrees(basePath);
     const found = existing.find(wt => wt.name === name);
     if (found) {
         process.chdir(found.path);
@@ -267,13 +307,13 @@ function handleWorktreeFlag(worktreeFlag) {
         process.stderr.write(chalk.dim(`  branch ${found.branch}\n\n`));
     }
     else {
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
     }
 }
-function createAndEnter(basePath, name) {
+async function createAndEnter(ext, basePath, name) {
     try {
-        const info = createWorktree(basePath, name);
-        const hookError = runWorktreePostCreateHook(basePath, info.path);
+        const info = ext.createWorktree(basePath, name);
+        const hookError = ext.runWorktreePostCreateHook(basePath, info.path);
         if (hookError) {
             process.stderr.write(chalk.yellow(`[gsd] ${hookError}\n`));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.31.2-dev.2453512",
+  "version": "2.31.2-dev.392f611",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/src/resources/extensions/gsd/auto-start.ts

@@ -131,9 +131,11 @@ export async function bootstrapAutoSession(
   // Initialize GitServiceImpl
   s.gitService = createGitService(s.basePath);
 
-  // Check for crash from previous session (use both old and new lock data)
+  // Check for crash from previous session (use both old and new lock data).
+  // Skip if the lock PID matches this process — acquireSessionLock() writes
+  // to the same auto.lock file before this check, so we'd always false-positive.
   const crashLock = readCrashLock(base);
-  if (crashLock) {
+  if (crashLock && crashLock.pid !== process.pid) {
     // We already hold the session lock, so no concurrent session is running.
     // The crash lock is from a dead process — recover context from it.
     const recoveredMid = crashLock.unitId.split("/")[0];

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

@@ -44,6 +44,8 @@ import { handleConfig } from "./commands-config.js";
 import { handleInspect } from "./commands-inspect.js";
 import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleDryRun } from "./commands-maintenance.js";
 import { handleDoctor, handleSteer, handleCapture, handleTriage, handleKnowledge, handleRunHook, handleUpdate, handleSkillHealth } from "./commands-handlers.js";
+import { computeProgressScore, formatProgressLine } from "./progress-score.js";
+import { runEnvironmentChecks } from "./doctor-environment.js";
 import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
 
@@ -1068,6 +1070,11 @@ async function handleSetup(args: string, ctx: ExtensionCommandContext): Promise<
 function formatTextStatus(state: GSDState): string {
   const lines: string[] = ["GSD Status\n"];
 
+  // Progress score — traffic light (#1221)
+  const progressScore = computeProgressScore();
+  lines.push(formatProgressLine(progressScore));
+  lines.push("");
+
   // Phase
   lines.push(`Phase: ${state.phase}`);
 
@@ -1114,5 +1121,17 @@ function formatTextStatus(state: GSDState): string {
     }
   }
 
+  // Environment health (#1221)
+  const envResults = runEnvironmentChecks(projectRoot());
+  const envIssues = envResults.filter(r => r.status !== "ok");
+  if (envIssues.length > 0) {
+    lines.push("");
+    lines.push("Environment:");
+    for (const r of envIssues) {
+      const icon = r.status === "error" ? "✗" : "⚠";
+      lines.push(`  ${icon} ${r.message}`);
+    }
+  }
+
   return lines.join("\n");
 }

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -23,6 +23,8 @@ import { getActiveWorktreeName } from "./worktree-command.js";
 import { getWorkerBatches, hasActiveWorkers, type WorkerEntry } from "../subagent/worker-registry.js";
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
+import { computeProgressScore, formatProgressLine } from "./progress-score.js";
+import { runEnvironmentChecks, type EnvironmentCheckResult } from "./doctor-environment.js";
 
 function unitLabel(type: string): string {
   switch (type) {
@@ -310,6 +312,15 @@ export class GSDDashboardOverlay {
       elapsedParts = th.fg("dim", `since ${this.dashData.remoteSession!.startedAt.replace("T", " ").slice(0, 19)}`);
     }
     lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsedParts, contentWidth)));
+
+    // Progress score — traffic light indicator (#1221)
+    if (this.dashData.active || this.dashData.paused) {
+      const progressScore = computeProgressScore();
+      const progressIcon = progressScore.level === "green" ? th.fg("success", "●")
+        : progressScore.level === "yellow" ? th.fg("warning", "●")
+          : th.fg("error", "●");
+      lines.push(row(`${progressIcon} ${th.fg("text", progressScore.summary)}`));
+    }
     lines.push(blank());
 
     if (this.dashData.currentUnit) {
@@ -579,6 +590,23 @@ export class GSDDashboardOverlay {
       }
     }
 
+    // Environment health section (#1221) — only show issues
+    const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());
+    const envIssues = envResults.filter(r => r.status !== "ok");
+    if (envIssues.length > 0) {
+      lines.push(blank());
+      lines.push(hr());
+      lines.push(row(th.fg("text", th.bold("Environment"))));
+      lines.push(blank());
+      for (const r of envIssues) {
+        const icon = r.status === "error" ? th.fg("error", "✗") : th.fg("warning", "⚠");
+        lines.push(row(`  ${icon} ${th.fg("text", r.message)}`));
+        if (r.detail) {
+          lines.push(row(th.fg("dim", `     ${r.detail}`)));
+        }
+      }
+    }
+
     lines.push(blank());
     lines.push(hr());
     lines.push(centered(th.fg("dim", "↑↓ scroll · g/G top/end · esc close")));