gsd-pi 2.29.0-dev.77f06e2 → 2.29.0-dev.f08b4fe

package/dist/extension-registry.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Extension Registry — manages manifest reading, registry persistence, and enable/disable state.
+ *
+ * Extensions without manifests always load (backwards compatible).
+ * A fresh install has an empty registry — all extensions enabled by default.
+ * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
+ */
+export interface ExtensionManifest {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    tier: "core" | "bundled" | "community";
+    requires: {
+        platform: string;
+    };
+    provides?: {
+        tools?: string[];
+        commands?: string[];
+        hooks?: string[];
+        shortcuts?: string[];
+    };
+    dependencies?: {
+        extensions?: string[];
+        runtime?: string[];
+    };
+}
+export interface ExtensionRegistryEntry {
+    id: string;
+    enabled: boolean;
+    source: "bundled" | "user" | "project";
+    disabledAt?: string;
+    disabledReason?: string;
+}
+export interface ExtensionRegistry {
+    version: 1;
+    entries: Record<string, ExtensionRegistryEntry>;
+}
+export declare function getRegistryPath(): string;
+export declare function loadRegistry(): ExtensionRegistry;
+export declare function saveRegistry(registry: ExtensionRegistry): void;
+/** Returns true if the extension is enabled (missing entries default to enabled). */
+export declare function isExtensionEnabled(registry: ExtensionRegistry, id: string): boolean;
+export declare function enableExtension(registry: ExtensionRegistry, id: string): void;
+/**
+ * Disable an extension. Returns an error string if the extension is core (cannot disable),
+ * or null on success.
+ */
+export declare function disableExtension(registry: ExtensionRegistry, id: string, manifest: ExtensionManifest | null, reason?: string): string | null;
+/** Read extension-manifest.json from a directory. Returns null if missing or invalid. */
+export declare function readManifest(extensionDir: string): ExtensionManifest | null;
+/**
+ * Given an entry path (e.g. `.../extensions/browser-tools/index.ts`),
+ * resolve the parent directory and read its manifest.
+ */
+export declare function readManifestFromEntryPath(entryPath: string): ExtensionManifest | null;
+/** Scan all subdirectories of extensionsDir for manifests. Returns a Map<id, manifest>. */
+export declare function discoverAllManifests(extensionsDir: string): Map<string, ExtensionManifest>;
+/**
+ * Auto-populate registry entries for newly discovered extensions.
+ * Extensions already in the registry are left untouched.
+ */
+export declare function ensureRegistryEntries(extensionsDir: string): void;

package/dist/extension-registry.js

@@ -0,0 +1,166 @@
+/**
+ * Extension Registry — manages manifest reading, registry persistence, and enable/disable state.
+ *
+ * Extensions without manifests always load (backwards compatible).
+ * A fresh install has an empty registry — all extensions enabled by default.
+ * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+// ─── Validation ─────────────────────────────────────────────────────────────
+function isRegistry(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const obj = data;
+    return obj.version === 1 && typeof obj.entries === "object" && obj.entries !== null;
+}
+function isManifest(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const obj = data;
+    return (typeof obj.id === "string" &&
+        typeof obj.name === "string" &&
+        typeof obj.version === "string" &&
+        typeof obj.tier === "string");
+}
+// ─── Registry Path ──────────────────────────────────────────────────────────
+export function getRegistryPath() {
+    return join(homedir(), ".gsd", "extensions", "registry.json");
+}
+// ─── Registry I/O ───────────────────────────────────────────────────────────
+function defaultRegistry() {
+    return { version: 1, entries: {} };
+}
+export function loadRegistry() {
+    const filePath = getRegistryPath();
+    try {
+        if (!existsSync(filePath))
+            return defaultRegistry();
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return isRegistry(parsed) ? parsed : defaultRegistry();
+    }
+    catch {
+        return defaultRegistry();
+    }
+}
+export function saveRegistry(registry) {
+    const filePath = getRegistryPath();
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        const tmp = filePath + ".tmp";
+        writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+        renameSync(tmp, filePath);
+    }
+    catch {
+        // Non-fatal — don't let persistence failures break operation
+    }
+}
+// ─── Query ──────────────────────────────────────────────────────────────────
+/** Returns true if the extension is enabled (missing entries default to enabled). */
+export function isExtensionEnabled(registry, id) {
+    const entry = registry.entries[id];
+    if (!entry)
+        return true;
+    return entry.enabled;
+}
+// ─── Mutations ──────────────────────────────────────────────────────────────
+export function enableExtension(registry, id) {
+    const entry = registry.entries[id];
+    if (entry) {
+        entry.enabled = true;
+        delete entry.disabledAt;
+        delete entry.disabledReason;
+    }
+    else {
+        registry.entries[id] = { id, enabled: true, source: "bundled" };
+    }
+}
+/**
+ * Disable an extension. Returns an error string if the extension is core (cannot disable),
+ * or null on success.
+ */
+export function disableExtension(registry, id, manifest, reason) {
+    if (manifest?.tier === "core") {
+        return `Cannot disable "${id}" — it is a core extension.`;
+    }
+    const entry = registry.entries[id];
+    if (entry) {
+        entry.enabled = false;
+        entry.disabledAt = new Date().toISOString();
+        entry.disabledReason = reason;
+    }
+    else {
+        registry.entries[id] = {
+            id,
+            enabled: false,
+            source: "bundled",
+            disabledAt: new Date().toISOString(),
+            disabledReason: reason,
+        };
+    }
+    return null;
+}
+// ─── Manifest Reading ───────────────────────────────────────────────────────
+/** Read extension-manifest.json from a directory. Returns null if missing or invalid. */
+export function readManifest(extensionDir) {
+    const manifestPath = join(extensionDir, "extension-manifest.json");
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        return isManifest(raw) ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Given an entry path (e.g. `.../extensions/browser-tools/index.ts`),
+ * resolve the parent directory and read its manifest.
+ */
+export function readManifestFromEntryPath(entryPath) {
+    const dir = dirname(entryPath);
+    return readManifest(dir);
+}
+// ─── Discovery ──────────────────────────────────────────────────────────────
+/** Scan all subdirectories of extensionsDir for manifests. Returns a Map<id, manifest>. */
+export function discoverAllManifests(extensionsDir) {
+    const manifests = new Map();
+    if (!existsSync(extensionsDir))
+        return manifests;
+    for (const entry of readdirSync(extensionsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const manifest = readManifest(join(extensionsDir, entry.name));
+        if (manifest) {
+            manifests.set(manifest.id, manifest);
+        }
+    }
+    return manifests;
+}
+/**
+ * Auto-populate registry entries for newly discovered extensions.
+ * Extensions already in the registry are left untouched.
+ */
+export function ensureRegistryEntries(extensionsDir) {
+    const manifests = discoverAllManifests(extensionsDir);
+    if (manifests.size === 0)
+        return;
+    const registry = loadRegistry();
+    let changed = false;
+    for (const [id, manifest] of manifests) {
+        if (!registry.entries[id]) {
+            registry.entries[id] = {
+                id,
+                enabled: true,
+                source: "bundled",
+            };
+            changed = true;
+        }
+    }
+    if (changed) {
+        saveRegistry(registry);
+    }
+}

package/dist/headless.js

@@ -128,6 +128,10 @@ async function runHeadlessOnce(options, restartCount) {
     let interrupted = false;
     const startTime = Date.now();
     const isNewMilestone = options.command === 'new-milestone';
+    // new-milestone involves codebase investigation + artifact writing — needs more time
+    if (isNewMilestone && options.timeout === 300_000) {
+        options.timeout = 600_000; // 10 minutes
+    }
     // Supervised mode cannot share stdin with --context -
     if (options.supervised && options.context === '-') {
         process.stderr.write('[headless] Error: --supervised cannot be used with --context - (both require stdin)\n');

package/dist/loader.js

@@ -29,6 +29,7 @@ if (firstArg === '--help' || firstArg === '-h') {
 import { agentDir, appRoot } from './app-paths.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
+import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled } from './extension-registry.js';
 import { renderLogo } from './logo.js';
 // pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
 // theme assets (dist/modes/interactive/theme/) without a src/ directory.
@@ -86,7 +87,15 @@ process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
 // where initResources() will sync them.
 const bundledExtDir = join(resourcesDir, 'extensions');
 const agentExtDir = join(agentDir, 'extensions');
-const discoveredExtensionPaths = discoverExtensionEntryPaths(bundledExtDir).map((entryPath) => join(agentExtDir, relative(bundledExtDir, entryPath)));
+const registry = loadRegistry();
+const discoveredExtensionPaths = discoverExtensionEntryPaths(bundledExtDir)
+    .map((entryPath) => join(agentExtDir, relative(bundledExtDir, entryPath)))
+    .filter((entryPath) => {
+    const manifest = readManifestFromEntryPath(entryPath);
+    if (!manifest)
+        return true; // no manifest = always load
+    return isExtensionEnabled(registry, manifest.id);
+});
 process.env.GSD_BUNDLED_EXTENSION_PATHS = serializeBundledExtensionPaths(discoveredExtensionPaths);
 // Respect HTTP_PROXY / HTTPS_PROXY / NO_PROXY env vars for all outbound requests.
 // pi-coding-agent's cli.ts sets this, but GSD bypasses that entry point — so we

package/dist/resource-loader.js

@@ -6,6 +6,7 @@ import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';
+import { loadRegistry, readManifestFromEntryPath, isExtensionEnabled, ensureRegistryEntries } from './extension-registry.js';
 // Resolve resources directory — prefer dist/resources/ (stable, set at build time)
 // over src/resources/ (live working tree, changes with git branch).
 //
@@ -218,6 +219,7 @@ export function initResources(agentDir) {
     // overwrite them (covers extensions, agents, and skills in one walk).
     makeTreeWritable(agentDir);
     writeManagedResourceManifest(agentDir);
+    ensureRegistryEntries(join(agentDir, 'extensions'));
 }
 /**
  * Constructs a DefaultResourceLoader that loads extensions from both
@@ -234,10 +236,18 @@ function getBundledExtensionKeys() {
     return _bundledExtensionKeys;
 }
 export function buildResourceLoader(agentDir) {
+    const registry = loadRegistry();
     const piAgentDir = join(homedir(), '.pi', 'agent');
     const piExtensionsDir = join(piAgentDir, 'extensions');
     const bundledKeys = getBundledExtensionKeys();
-    const piExtensionPaths = discoverExtensionEntryPaths(piExtensionsDir).filter((entryPath) => !bundledKeys.has(getExtensionKey(entryPath, piExtensionsDir)));
+    const piExtensionPaths = discoverExtensionEntryPaths(piExtensionsDir)
+        .filter((entryPath) => !bundledKeys.has(getExtensionKey(entryPath, piExtensionsDir)))
+        .filter((entryPath) => {
+        const manifest = readManifestFromEntryPath(entryPath);
+        if (!manifest)
+            return true;
+        return isExtensionEnabled(registry, manifest.id);
+    });
     return new DefaultResourceLoader({
         agentDir,
         additionalExtensionPaths: piExtensionPaths,

package/dist/resources/extensions/async-jobs/extension-manifest.json

@@ -0,0 +1,13 @@
+{
+  "id": "async-jobs",
+  "name": "Async Jobs",
+  "version": "1.0.0",
+  "description": "Run bash commands in the background with job tracking and cancellation",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["async_bash", "await_job", "cancel_job"],
+    "commands": ["jobs"],
+    "hooks": ["session_start"]
+  }
+}

package/dist/resources/extensions/bg-shell/extension-manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "bg-shell",
+  "name": "Background Shell",
+  "version": "1.0.0",
+  "description": "Run and manage background shell processes with interactive monitoring",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["bg_shell"],
+    "commands": ["bg"],
+    "hooks": ["session_shutdown"],
+    "shortcuts": ["Ctrl+Alt+B"]
+  }
+}

package/dist/resources/extensions/browser-tools/extension-manifest.json

@@ -0,0 +1,37 @@
+{
+  "id": "browser-tools",
+  "name": "Browser Tools",
+  "version": "1.0.0",
+  "description": "Playwright-based web automation, screenshots, and analysis",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": [
+      "browser_navigate", "browser_go_back", "browser_go_forward", "browser_reload",
+      "browser_click", "browser_drag", "browser_type", "browser_upload_file",
+      "browser_scroll", "browser_hover", "browser_key_press", "browser_select_option",
+      "browser_set_checked", "browser_screenshot", "browser_wait_for",
+      "browser_get_console_logs", "browser_get_network_logs", "browser_get_dialog_logs",
+      "browser_evaluate", "browser_get_accessibility_tree", "browser_find",
+      "browser_get_page_source", "browser_close",
+      "browser_trace_start", "browser_trace_stop", "browser_export_har",
+      "browser_timeline", "browser_session_summary", "browser_debug_bundle",
+      "browser_assert", "browser_diff", "browser_batch",
+      "browser_snapshot_refs", "browser_get_ref", "browser_click_ref",
+      "browser_hover_ref", "browser_fill_ref",
+      "browser_list_pages", "browser_switch_page", "browser_close_page",
+      "browser_list_frames", "browser_select_frame",
+      "browser_analyze_form", "browser_fill_form",
+      "browser_find_best", "browser_act",
+      "browser_save_pdf", "browser_save_state", "browser_restore_state",
+      "browser_mock_route", "browser_block_urls", "browser_clear_routes",
+      "browser_emulate_device", "browser_extract",
+      "browser_visual_diff", "browser_zoom_region",
+      "browser_generate_test", "browser_action_cache", "browser_check_injection"
+    ],
+    "hooks": ["session_shutdown"]
+  },
+  "dependencies": {
+    "runtime": ["playwright"]
+  }
+}

package/dist/resources/extensions/context7/extension-manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "context7",
+  "name": "Context7",
+  "version": "1.0.0",
+  "description": "Fetch up-to-date library documentation and code examples from Context7",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["resolve_library", "get_library_docs"],
+    "hooks": ["session_start"]
+  }
+}

package/dist/resources/extensions/google-search/extension-manifest.json

@@ -0,0 +1,12 @@
+{
+  "id": "google-search",
+  "name": "Google Search",
+  "version": "1.0.0",
+  "description": "Web search via Google with AI-synthesized answers and source citations",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["google_search"],
+    "hooks": ["session_start"]
+  }
+}

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -11,6 +11,7 @@ import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals, formatCost, formatTokenCount, formatTierSavings } from "./metrics.js";
+import { getHealthTrend, getConsecutiveErrorUnits } from "./doctor-proactive.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -649,6 +650,31 @@ export function updateProgressWidget(
  * Build a compact string-array representation of the progress widget.
  * Used as a fallback when the factory-based widget cannot render (RPC mode).
  */
+// ─── Model Health Indicator ───────────────────────────────────────────────────
+
+/**
+ * Compute a traffic-light health indicator from observable signals.
+ * 🟢 progressing well — no errors, trend stable/improving
+ * 🟡 struggling — some errors or degrading trend
+ * 🔴 stuck — consecutive errors, likely needs attention
+ */
+export function getModelHealthIndicator(): { emoji: string; label: string } {
+  const trend = getHealthTrend();
+  const consecutiveErrors = getConsecutiveErrorUnits();
+
+  if (consecutiveErrors >= 3) {
+    return { emoji: "🔴", label: "stuck" };
+  }
+  if (consecutiveErrors >= 1 || trend === "degrading") {
+    return { emoji: "🟡", label: "struggling" };
+  }
+  if (trend === "improving") {
+    return { emoji: "🟢", label: "progressing well" };
+  }
+  // stable or unknown
+  return { emoji: "🟢", label: "progressing" };
+}
+
 function buildProgressTextLines(
   verb: string,
   phaseLabel: string,
@@ -697,6 +723,11 @@ function buildProgressTextLines(
   }
 
   if (next) lines.push(`  Next: ${next}`);
+
+  // Model health indicator
+  const health = getModelHealthIndicator();
+  lines.push(`  Health: ${health.emoji} ${health.label}`);
+
   lines.push(`  ${widgetPwd}`);
 
   return lines;

package/dist/resources/extensions/gsd/auto-dispatch.ts

@@ -12,7 +12,7 @@
 import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
-import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
+import { loadFile, extractUatType, loadActiveOverrides, parseRoadmap } from "./files.js";
 import {
   resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile,
   relSliceFile, buildMilestoneFileName,
@@ -123,11 +123,40 @@ const DISPATCH_RULES: DispatchRule[] = [
       };
     },
   },
+  {
+    name: "uat-verdict-gate (non-PASS blocks progression)",
+    match: async ({ mid, basePath, prefs }) => {
+      // Only applies when UAT dispatch is enabled
+      if (!prefs?.uat_dispatch) return null;
+
+      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+      if (!roadmapContent) return null;
+
+      const roadmap = parseRoadmap(roadmapContent);
+      for (const slice of roadmap.slices.filter(s => s.done)) {
+        const resultFile = resolveSliceFile(basePath, mid, slice.id, "UAT-RESULT");
+        if (!resultFile) continue;
+        const content = await loadFile(resultFile);
+        if (!content) continue;
+        const verdictMatch = content.match(/verdict:\s*([\w-]+)/i);
+        const verdict = verdictMatch?.[1]?.toLowerCase();
+        if (verdict && verdict !== "pass" && verdict !== "passed") {
+          return {
+            action: "stop" as const,
+            reason: `UAT verdict for ${slice.id} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
+            level: "warning" as const,
+          };
+        }
+      }
+      return null;
+    },
+  },
   {
     name: "reassess-roadmap (post-completion)",
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      // Phase skip: skip reassess when preference or profile says so
-      if (prefs?.phases?.skip_reassess) return null;
+      // Reassess is opt-in: only fire when explicitly enabled
+      if (!prefs?.phases?.reassess_after_slice) return null;
       const needsReassess = await checkNeedsReassessment(basePath, mid, state);
       if (!needsReassess) return null;
       return {

package/dist/resources/extensions/gsd/auto-post-unit.ts

@@ -37,7 +37,6 @@ import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences } from "./pref
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
-import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
 import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
 import { isDbAvailable } from "./gsd-db.js";
 import { consumeSignal } from "./session-status-io.js";
@@ -213,15 +212,6 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
       // Non-fatal
     }
 
-    // Sync worktree state back to project root
-    if (s.originalBasePath && s.originalBasePath !== s.basePath) {
-      try {
-        syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
-      } catch {
-        // Non-fatal
-      }
-    }
-
     // Rewrite-docs completion
     if (s.currentUnit.type === "rewrite-docs") {
       try {
@@ -331,6 +321,45 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
     }
   }
 
+  // ── Mechanical completion (ADR-003) ──
+  // After task execution, attempt mechanical slice and milestone completion
+  // instead of dispatching LLM sessions for complete-slice / validate-milestone.
+  if (s.currentUnit?.type === "execute-task" && !s.stepMode) {
+    try {
+      const [mid, sid] = s.currentUnit.id.split("/");
+      if (mid && sid) {
+        const state = await deriveState(s.basePath);
+        if (state.phase === "summarizing" && state.activeSlice?.id === sid) {
+          const { mechanicalSliceCompletion } = await import("./mechanical-completion.js");
+          const ok = await mechanicalSliceCompletion(s.basePath, mid, sid);
+          if (ok) {
+            invalidateAllCaches();
+            autoCommitCurrentBranch(s.basePath, "mechanical-completion", `${mid}/${sid}`);
+            ctx.ui.notify(`Mechanical completion: ${sid} summary + roadmap updated.`, "info");
+
+            // Re-derive state — check if milestone is now ready for validation
+            invalidateAllCaches();
+            const postSliceState = await deriveState(s.basePath);
+            if (postSliceState.phase === "validating-milestone" || postSliceState.phase === "completing-milestone") {
+              const { aggregateMilestoneVerification, generateMilestoneSummary } = await import("./mechanical-completion.js");
+              const validation = await aggregateMilestoneVerification(s.basePath, mid);
+              if (validation.verdict !== "failed") {
+                await generateMilestoneSummary(s.basePath, mid);
+                invalidateAllCaches();
+                autoCommitCurrentBranch(s.basePath, "mechanical-milestone-completion", mid);
+                ctx.ui.notify(`Mechanical completion: ${mid} validation + summary written.`, "info");
+              }
+            }
+          }
+          // If !ok, summarizing phase persists → dispatch rule fires as LLM fallback
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`gsd-mechanical: completion failed: ${(err as Error).message}\n`);
+      // Non-fatal — fall through to normal dispatch
+    }
+  }
+
   // ── Post-unit hooks ──
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);