gsd-pi 2.72.0-dev.3159350 → 2.72.0-dev.4f3264a

package/src/resources/extensions/gsd/auto/loop.ts

@@ -29,69 +29,6 @@ import {
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterMs, COOLDOWN_FALLBACK_WAIT_MS, MAX_COOLDOWN_RETRIES } from "./infra-errors.js";
 import { resolveEngine } from "../engine-resolver.js";
-import { logWarning } from "../workflow-logger.js";
-import { gsdRoot } from "../paths.js";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-
-// ── Stuck detection persistence (#3704) ──────────────────────────────────
-// Persist stuck detection state to disk so it survives session restarts.
-// Without this, restarting auto-mode resets all counters, allowing the
-// same blocked unit to burn a full retry budget each session.
-function stuckStatePath(basePath: string): string {
-  return join(gsdRoot(basePath), "runtime", "stuck-state.json");
-}
-
-function loadStuckState(basePath: string): { recentUnits: Array<{ key: string }>; stuckRecoveryAttempts: number } {
-  try {
-    const data = JSON.parse(readFileSync(stuckStatePath(basePath), "utf-8"));
-    return {
-      recentUnits: Array.isArray(data.recentUnits) ? data.recentUnits : [],
-      stuckRecoveryAttempts: typeof data.stuckRecoveryAttempts === "number" ? data.stuckRecoveryAttempts : 0,
-    };
-  } catch (err) {
-    debugLog("autoLoop", { phase: "load-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
-    return { recentUnits: [], stuckRecoveryAttempts: 0 };
-  }
-}
-
-function saveStuckState(basePath: string, state: LoopState): void {
-  try {
-    const filePath = stuckStatePath(basePath);
-    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
-    writeFileSync(filePath, JSON.stringify({
-      recentUnits: state.recentUnits.slice(-20), // keep last 20 entries
-      stuckRecoveryAttempts: state.stuckRecoveryAttempts,
-      updatedAt: new Date().toISOString(),
-    }) + "\n");
-  } catch (err) {
-    debugLog("autoLoop", { phase: "save-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-// ── Memory pressure monitoring (#3331) ──────────────────────────────────
-// Check heap usage every N iterations and trigger graceful shutdown before
-// the OS OOM killer sends SIGKILL. The threshold is 90% of the V8 heap
-// limit (--max-old-space-size or default ~1.5-4GB depending on platform).
-const MEMORY_CHECK_INTERVAL = 5; // check every 5 iterations
-const MEMORY_PRESSURE_THRESHOLD = 0.85; // 85% of heap limit
-
-function checkMemoryPressure(): { pressured: boolean; heapMB: number; limitMB: number; pct: number } {
-  const mem = process.memoryUsage();
-  // v8.getHeapStatistics() gives heap_size_limit but requires import
-  // Use a conservative estimate: RSS > 3GB is danger zone on most systems
-  const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
-  const rssMB = Math.round(mem.rss / 1024 / 1024);
-  // Try to get the actual V8 heap limit
-  let limitMB = 4096; // conservative default
-  try {
-    const v8 = require("node:v8");
-    const stats = v8.getHeapStatistics();
-    limitMB = Math.round(stats.heap_size_limit / 1024 / 1024);
-  } catch { limitMB = 4096; /* v8 stats unavailable — use conservative default */ }
-  const pct = heapMB / limitMB;
-  return { pressured: pct > MEMORY_PRESSURE_THRESHOLD, heapMB, limitMB, pct };
-}
 
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
@@ -109,13 +46,7 @@ export async function autoLoop(
 ): Promise<void> {
   debugLog("autoLoop", { phase: "enter" });
   let iteration = 0;
-  // Load persisted stuck state so counters survive session restarts (#3704)
-  const persisted = loadStuckState(s.basePath);
-  const loopState: LoopState = {
-    recentUnits: persisted.recentUnits,
-    stuckRecoveryAttempts: persisted.stuckRecoveryAttempts,
-    consecutiveFinalizeTimeouts: 0,
-  };
+  const loopState: LoopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
   let consecutiveErrors = 0;
   let consecutiveCooldowns = 0;
   const recentErrorMessages: string[] = [];
@@ -143,24 +74,6 @@ export async function autoLoop(
       break;
     }
 
-    // ── Memory pressure check (#3331) ──
-    // Graceful shutdown before OOM killer sends SIGKILL.
-    if (iteration % MEMORY_CHECK_INTERVAL === 0) {
-      const mem = checkMemoryPressure();
-      debugLog("autoLoop", { phase: "memory-check", ...mem });
-      if (mem.pressured) {
-        logWarning("dispatch", `Memory pressure: ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%) — stopping auto-mode to prevent OOM kill`);
-        await deps.stopAuto(
-          ctx,
-          pi,
-          `Memory pressure: heap at ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%). ` +
-          `Stopping gracefully to prevent OOM kill after ${iteration} iterations. ` +
-          `Resume with /gsd auto to continue from where you left off.`,
-        );
-        break;
-      }
-    }
-
     if (!s.cmdCtx) {
       debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
       break;
@@ -294,7 +207,6 @@ export async function autoLoop(
         consecutiveCooldowns = 0;
         recentErrorMessages.length = 0;
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
-        saveStuckState(s.basePath, loopState); // persist across session restarts (#3704)
         debugLog("autoLoop", { phase: "iteration-complete", iteration });
 
         if (reconcileResult.outcome === "milestone-complete") {

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

@@ -0,0 +1,72 @@
+/**
+ * Pre-dispatch observability checks for auto-mode units.
+ * Validates plan/summary file quality and builds repair instructions
+ * for the agent to fix gaps before proceeding with the unit.
+ */
+
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import {
+  validatePlanBoundary,
+  validateExecuteBoundary,
+  validateCompleteBoundary,
+  formatValidationIssues,
+} from "./observability-validator.js";
+import type { ValidationIssue } from "./observability-validator.js";
+import { parseUnitId } from "./unit-id.js";
+
+export async function collectObservabilityWarnings(
+  ctx: ExtensionContext,
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): Promise<ValidationIssue[]> {
+  // Hook units have custom artifacts — skip standard observability checks
+  if (unitType.startsWith("hook/")) return [];
+
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+
+  if (!mid || !sid) return [];
+
+  let issues = [] as Awaited<ReturnType<typeof validatePlanBoundary>>;
+
+  if (unitType === "plan-slice") {
+    issues = await validatePlanBoundary(basePath, mid, sid);
+  } else if (unitType === "execute-task" && tid) {
+    issues = await validateExecuteBoundary(basePath, mid, sid, tid);
+  } else if (unitType === "complete-slice") {
+    issues = await validateCompleteBoundary(basePath, mid, sid);
+  }
+
+  if (issues.length > 0) {
+    ctx.ui.notify(
+      `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
+      "warning",
+    );
+  }
+
+  return issues;
+}
+
+export function buildObservabilityRepairBlock(issues: ValidationIssue[]): string {
+  if (issues.length === 0) return "";
+  const items = issues.map(issue => {
+    const fileName = issue.file.split("/").pop() || issue.file;
+    let line = `- **${fileName}**: ${issue.message}`;
+    if (issue.suggestion) line += ` → ${issue.suggestion}`;
+    return line;
+  });
+  return [
+    "",
+    "---",
+    "",
+    "## Pre-flight: Observability gaps to fix FIRST",
+    "",
+    "The following issues were detected in plan/summary files for this unit.",
+    "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+    "",
+    ...items,
+    "",
+    "---",
+    "",
+  ].join("\n");
+}

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

@@ -25,7 +25,6 @@ import {
   buildTaskFileName,
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
-import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import {
@@ -368,12 +367,6 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       }
     });
 
-    // Keep the on-disk STATE.md aligned with the live derived state after
-    // ordinary unit completion, before any worktree state is synced back.
-    await runSafely("postUnit", "state-rebuild", async () => {
-      await rebuildState(s.basePath);
-    });
-
     // Sync worktree state back to project root (skipped for lightweight sidecars)
     if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
       await runSafely("postUnit", "worktree-sync", () => {

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

@@ -677,13 +677,9 @@ function cleanupAfterLoopExit(ctx: ExtensionContext): void {
     logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
   }
 
-  // A transient provider-error pause intentionally leaves the paused badge
-  // visible so the user still has a resumable auto-mode signal on screen.
-  if (!s.paused) {
-    ctx.ui.setStatus("gsd-auto", undefined);
-    ctx.ui.setWidget("gsd-progress", undefined);
-    ctx.ui.setFooter(undefined);
-  }
+  ctx.ui.setStatus("gsd-auto", undefined);
+  ctx.ui.setWidget("gsd-progress", undefined);
+  ctx.ui.setFooter(undefined);
 
   // Restore CWD out of worktree back to original project root
   if (s.originalBasePath) {
@@ -795,22 +791,7 @@ export async function stopAuto(
       debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
     }
 
-    // ── Step 5: Rebuild state while DB is still open (#3599) ──
-    // rebuildState() calls deriveState() which needs the DB for authoritative
-    // state. Previously this ran after closeDatabase(), forcing a filesystem
-    // fallback that could disagree with the DB-backed dispatch decisions —
-    // a split-brain where dispatch says "blocked" but STATE.md shows work.
-    if (s.basePath) {
-      try {
-        await rebuildState(s.basePath);
-      } catch (e) {
-        debugLog("stop-rebuild-state-failed", {
-          error: e instanceof Error ? e.message : String(e),
-        });
-      }
-    }
-
-    // ── Step 6: DB cleanup ──
+    // ── Step 5: DB cleanup ──
     if (isDbAvailable()) {
       try {
         const { closeDatabase } = await import("./gsd-db.js");
@@ -822,7 +803,7 @@ export async function stopAuto(
       }
     }
 
-    // ── Step 7: Restore basePath and chdir ──
+    // ── Step 6: Restore basePath and chdir ──
     try {
       if (s.originalBasePath) {
         s.basePath = s.originalBasePath;
@@ -837,7 +818,7 @@ export async function stopAuto(
       debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
     }
 
-    // ── Step 8: Ledger notification ──
+    // ── Step 7: Ledger notification ──
     try {
       const ledger = getLedger();
       if (ledger && ledger.units.length > 0) {
@@ -853,6 +834,17 @@ export async function stopAuto(
       debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
     }
 
+    // ── Step 8: Rebuild state ──
+    if (s.basePath) {
+      try {
+        await rebuildState(s.basePath);
+      } catch (e) {
+        debugLog("stop-rebuild-state-failed", {
+          error: e instanceof Error ? e.message : String(e),
+        });
+      }
+    }
+
     // ── Step 9: Cmux sidebar / event log ──
     try {
       clearCmuxSidebar(loadedPreferences);
@@ -1721,6 +1713,9 @@ export async function dispatchHookUnit(
   return true;
 }
 
+// Direct phase dispatch → auto-direct-dispatch.ts
+export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
+
 // Re-export recovery functions for external consumers
 export {
   buildLoopRemediationSteps,

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -181,10 +181,14 @@ export function registerHooks(pi: ExtensionAPI): void {
     // Only gate-shaped ask_user_questions calls should block execution.
     // The gate stays pending until the user selects the approval option.
     if (event.toolName === "ask_user_questions") {
-      const questions: any[] = (event.input as any)?.questions ?? [];
-      const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
-      if (typeof questionId === "string") {
-        setPendingGate(questionId);
+      const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+      const inDiscussion = milestoneId !== null || isQueuePhaseActive();
+      if (inDiscussion) {
+        const questions: any[] = (event.input as any)?.questions ?? [];
+        const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
+        if (typeof questionId === "string") {
+          setPendingGate(questionId);
+        }
       }
     }
 
@@ -282,6 +286,7 @@ export function registerHooks(pi: ExtensionAPI): void {
     if (event.toolName !== "ask_user_questions") return;
     const milestoneId = getDiscussionMilestoneId(process.cwd());
     const queueActive = isQueuePhaseActive();
+    if (!milestoneId && !queueActive) return;
 
     const details = event.details as any;
 
@@ -314,16 +319,13 @@ export function registerHooks(pi: ExtensionAPI): void {
         // Only unlock the gate if the user selected the first option (confirmation).
         // Cross-references against the question's defined options to reject free-form "Other" text.
         const answer = details.response?.answers?.[question.id];
-        const inferredMilestoneId = extractDepthVerificationMilestoneId(question.id) ?? milestoneId;
         if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
-          markDepthVerified(inferredMilestoneId);
-          clearPendingGate();
+          markDepthVerified(extractDepthVerificationMilestoneId(question.id) ?? milestoneId);
         }
         break;
       }
     }
 
-    if (!milestoneId && !queueActive) return;
     if (!milestoneId) return;
 
     const basePath = process.cwd();

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

@@ -78,10 +78,6 @@ export function parseDoctorArgs(args: string) {
   return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
 }
 
-export function isDoctorHealActionable(issue: { fixable: boolean; severity: string }): boolean {
-  return issue.fixable && issue.severity !== "info";
-}
-
 export async function handleDoctor(args: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<void> {
   const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
   const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -113,7 +109,7 @@ export async function handleDoctor(args: string, ctx: ExtensionCommandContext, p
       scope: effectiveScope,
       includeWarnings: true,
     });
-    const actionable = unresolved.filter(isDoctorHealActionable);
+    const actionable = unresolved.filter(issue => issue.severity === "error");
     if (actionable.length === 0) {
       ctx.ui.notify("Doctor heal found nothing actionable to hand off to the LLM.", "info");
       return;

package/src/resources/extensions/gsd/context-injector.ts

@@ -16,7 +16,7 @@
 import { readFileSync, existsSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import type { StepDefinition } from "./definition-loader.js";
-import { readFrozenDefinition } from "./definition-io.js";
+import { readFrozenDefinition } from "./custom-workflow-engine.js";
 
 /** Maximum characters per artifact to prevent context window blowout. */
 const MAX_CONTEXT_CHARS = 10_000;

package/src/resources/extensions/gsd/custom-workflow-engine.ts

@@ -22,6 +22,7 @@ import type {
 } from "./engine-types.js";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { parse } from "yaml";
 import {
   readGraph,
   writeGraph,
@@ -31,13 +32,16 @@ import {
   type WorkflowGraph,
 } from "./graph.js";
 import { injectContext } from "./context-injector.js";
-import type { StepDefinition } from "./definition-loader.js";
-import { readFrozenDefinition } from "./definition-io.js";
+import type { WorkflowDefinition, StepDefinition } from "./definition-loader.js";
 import { parseUnitId } from "./unit-id.js";
 import { withFileLock } from "./file-lock.js";
 
-// Re-export for downstream consumers
-export { readFrozenDefinition } from "./definition-io.js";
+/** Read and parse the frozen DEFINITION.yaml from a run directory. */
+export function readFrozenDefinition(runDir: string): WorkflowDefinition {
+  const defPath = join(runDir, "DEFINITION.yaml");
+  const raw = readFileSync(defPath, "utf-8");
+  return parse(raw, { schema: "core" }) as WorkflowDefinition;
+}
 
 export class CustomWorkflowEngine implements WorkflowEngine {
   readonly engineId = "custom";

package/src/resources/extensions/gsd/file-watcher.ts

@@ -0,0 +1,100 @@
+import type { FSWatcher } from "chokidar";
+import type { EventBus } from "@gsd/pi-coding-agent";
+import { relative } from "node:path";
+
+let watcher: FSWatcher | null = null;
+let pending = new Map<string, ReturnType<typeof setTimeout>>();
+
+const EVENT_MAP: Record<string, string> = {
+	"settings.json": "settings-changed",
+	"auth.json": "auth-changed",
+	"models.json": "models-changed",
+};
+
+const EXTENSIONS_DIR = "extensions";
+
+const IGNORED_PATTERNS = [
+	"**/sessions/**",
+	"**/*.tmp",
+	"**/*.swp",
+	"**/*~",
+	"**/.DS_Store",
+];
+
+const DEBOUNCE_MS = 300;
+
+/**
+ * Start watching `agentDir` (e.g. `~/.gsd/agent/`) for config changes.
+ * Emits events on the supplied EventBus when watched files are modified.
+ */
+export async function startFileWatcher(
+	agentDir: string,
+	eventBus: EventBus,
+): Promise<void> {
+	if (watcher) {
+		await watcher.close();
+	}
+
+	const { watch } = await import("chokidar");
+
+	pending = new Map<string, ReturnType<typeof setTimeout>>();
+
+	function debounceEmit(event: string): void {
+		const existing = pending.get(event);
+		if (existing) clearTimeout(existing);
+		pending.set(
+			event,
+			setTimeout(() => {
+				pending.delete(event);
+				eventBus.emit(event, { timestamp: Date.now() });
+			}, DEBOUNCE_MS),
+		);
+	}
+
+	function resolveEvent(filePath: string): string | null {
+		const rel = relative(agentDir, filePath);
+		if (rel.startsWith("..")) return null;
+
+		// Check direct file matches
+		for (const [file, event] of Object.entries(EVENT_MAP)) {
+			if (rel === file) return event;
+		}
+
+		// Check extensions directory
+		if (rel.startsWith(EXTENSIONS_DIR + "/") || rel === EXTENSIONS_DIR) {
+			return "extensions-changed";
+		}
+
+		return null;
+	}
+
+	watcher = watch(agentDir, {
+		ignoreInitial: true,
+		depth: 2,
+		ignored: IGNORED_PATTERNS,
+	});
+
+	for (const eventType of ["add", "change", "unlink"] as const) {
+		watcher.on(eventType, (filePath: string) => {
+			const event = resolveEvent(filePath);
+			if (event) debounceEmit(event);
+		});
+	}
+
+	// Wait for watcher to be ready
+	await new Promise<void>((resolve) => {
+		watcher!.on("ready", resolve);
+	});
+}
+
+/**
+ * Stop the file watcher and clean up resources.
+ */
+export async function stopFileWatcher(): Promise<void> {
+	for (const timer of pending.values()) clearTimeout(timer);
+	pending.clear();
+	if (watcher) {
+		await watcher.close();
+		watcher = null;
+	}
+}

package/src/resources/extensions/gsd/gsd-db.ts

@@ -163,29 +163,6 @@ function openRawDb(path: string): unknown {
 
 const SCHEMA_VERSION = 14;
 
-function indexExists(db: DbAdapter, name: string): boolean {
-  return !!db.prepare(
-    "SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?",
-  ).get(name);
-}
-
-function dedupeVerificationEvidenceRows(db: DbAdapter): void {
-  db.exec(`
-    DELETE FROM verification_evidence
-    WHERE rowid NOT IN (
-      SELECT MIN(rowid)
-      FROM verification_evidence
-      GROUP BY task_id, slice_id, milestone_id, command, verdict
-    )
-  `);
-}
-
-function ensureVerificationEvidenceDedupIndex(db: DbAdapter): void {
-  if (indexExists(db, "idx_verification_evidence_dedup")) return;
-  dedupeVerificationEvidenceRows(db);
-  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
-}
-
 function initSchema(db: DbAdapter, fileBacked: boolean): void {
   if (fileBacked) db.exec("PRAGMA journal_mode=WAL");
   if (fileBacked) db.exec("PRAGMA busy_timeout = 5000");
@@ -433,7 +410,7 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
     db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
     db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-    ensureVerificationEvidenceDedupIndex(db);
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
 
     // v14 index — slice dependency lookups
     db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
@@ -766,7 +743,7 @@ function migrateSchema(db: DbAdapter): void {
       db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
       db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
       db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-      ensureVerificationEvidenceDedupIndex(db);
+      db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
       db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
         ":version": 13,
         ":applied_at": new Date().toISOString(),
@@ -1565,30 +1542,6 @@ export interface TaskRow {
 }
 
 function rowToTask(row: Record<string, unknown>): TaskRow {
-  const parseTaskArray = (value: unknown): string[] => {
-    if (Array.isArray(value)) {
-      return value.filter((entry): entry is string => typeof entry === "string");
-    }
-    if (typeof value !== "string") return [];
-
-    const trimmed = value.trim();
-    if (!trimmed) return [];
-
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed)) {
-        return parsed.filter((entry): entry is string => typeof entry === "string");
-      }
-      if (typeof parsed === "string" && parsed.trim()) {
-        return [parsed.trim()];
-      }
-    } catch {
-      // Older/corrupt DB rows may contain raw comma-separated paths instead of JSON arrays.
-    }
-
-    return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
-  };
-
   return {
     milestone_id: row["milestone_id"] as string,
     slice_id: row["slice_id"] as string,
@@ -1608,10 +1561,10 @@ function rowToTask(row: Record<string, unknown>): TaskRow {
     full_summary_md: row["full_summary_md"] as string,
     description: (row["description"] as string) ?? "",
     estimate: (row["estimate"] as string) ?? "",
-    files: parseTaskArray(row["files"]),
+    files: JSON.parse((row["files"] as string) || "[]"),
     verify: (row["verify"] as string) ?? "",
-    inputs: parseTaskArray(row["inputs"]),
-    expected_output: parseTaskArray(row["expected_output"]),
+    inputs: JSON.parse((row["inputs"] as string) || "[]"),
+    expected_output: JSON.parse((row["expected_output"] as string) || "[]"),
     observability_impact: (row["observability_impact"] as string) ?? "",
     full_plan_md: (row["full_plan_md"] as string) ?? "",
     sequence: (row["sequence"] as number) ?? 0,

package/src/resources/extensions/gsd/key-manager.ts

@@ -49,8 +49,6 @@ export const PROVIDER_REGISTRY: ProviderInfo[] = [
   { id: "custom-openai",    label: "Custom (OpenAI-compat)",  category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
   { id: "cerebras",         label: "Cerebras",                category: "llm", envVar: "CEREBRAS_API_KEY" },
   { id: "azure-openai-responses", label: "Azure OpenAI",      category: "llm", envVar: "AZURE_OPENAI_API_KEY" },
-  { id: "alibaba-coding-plan", label: "Alibaba Coding Plan",  category: "llm", envVar: "ALIBABA_API_KEY",      dashboardUrl: "bailian.console.aliyun.com" },
-  { id: "alibaba-dashscope",   label: "Alibaba DashScope",    category: "llm", envVar: "DASHSCOPE_API_KEY",    dashboardUrl: "dashscope.console.aliyun.com" },
 
   // Tool Keys
   { id: "context7",  label: "Context7 Docs",     category: "tool", envVar: "CONTEXT7_API_KEY",  dashboardUrl: "context7.com/dashboard" },

package/src/resources/extensions/gsd/preferences-skills.ts

@@ -17,6 +17,7 @@ import type {
   SkillResolutionReport,
 } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 
 // Re-export types so existing consumers of ./preferences-skills.js keep working
 export type { GSDSkillRule, SkillDiscoveryMode, SkillResolution, SkillResolutionReport } from "./preferences-types.js";
@@ -142,5 +143,38 @@ export function resolveAllSkillReferences(preferences: GSDPreferences, cwd: stri
   return { resolutions, warnings };
 }
 
-// resolveSkillDiscoveryMode and resolveSkillStalenessDays moved to
-// preferences.ts to break circular dependency (they need loadEffectiveGSDPreferences).
+/**
+ * Format a skill reference for the system prompt.
+ * If resolved, shows the path so the agent knows exactly where to read.
+ * If unresolved, marks it clearly.
+ */
+export function formatSkillRef(ref: string, resolutions: Map<string, SkillResolution>): string {
+  const resolution = resolutions.get(ref);
+  if (!resolution || resolution.method === "unresolved") {
+    return `${ref} (⚠ not found — check skill name or path)`;
+  }
+  // For absolute paths where SKILL.md is just appended, don't clutter the output
+  if (resolution.method === "absolute-path" || resolution.method === "absolute-dir") {
+    return ref;
+  }
+  // For bare names resolved from skill directories, show the resolved path
+  return `${ref} → \`${resolution.resolvedPath}\``;
+}
+
+/**
+ * Resolve the skill discovery mode from effective preferences.
+ * Defaults to "suggest" -- skills are identified during research but not installed automatically.
+ */
+export function resolveSkillDiscoveryMode(): SkillDiscoveryMode {
+  const prefs = loadEffectiveGSDPreferences();
+  return prefs?.preferences.skill_discovery ?? "suggest";
+}
+
+/**
+ * Resolve the skill staleness threshold in days.
+ * Returns 0 if disabled, default 60 if not configured.
+ */
+export function resolveSkillStalenessDays(): number {
+  const prefs = loadEffectiveGSDPreferences();
+  return prefs?.preferences.skill_staleness_days ?? 60;
+}