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

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -54,14 +54,11 @@ export function createAwaitTool(getManager) {
                     };
                 }
             }
-            // Suppress follow-up notifications for all watched jobs upfront.
-            // suppressFollowUp() cancels the pending delivery timer (if any), which
-            // handles both the within-turn case (job completes while we await) and
-            // the cross-turn case (job already completed before await_job was called).
-            // Previously this only set j.awaited = true, which missed the cross-turn
-            // case because the queueMicrotask had already fired (#3787).
+            // Mark all watched jobs as awaited upfront so the onJobComplete
+            // callback (which fires synchronously in the promise .then()) knows
+            // to suppress the follow-up message.
             for (const j of watched)
-                manager.suppressFollowUp(j.id);
+                j.awaited = true;
             // If all watched jobs are already done, return immediately
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -118,38 +118,13 @@ export class AsyncJobManager {
         }
     }
     // ── Private ────────────────────────────────────────────────────────────
-    /**
-     * Suppress follow-up notification for a job — cancels any pending delivery
-     * timer and marks the job as awaited. Safe to call at any time, including
-     * before or after the job completes (#3787).
-     */
-    suppressFollowUp(id) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        job.awaited = true;
-        if (job.deliveryTimer !== undefined) {
-            clearTimeout(job.deliveryTimer);
-            job.deliveryTimer = undefined;
-        }
-    }
     deliverResult(job) {
         if (!this.onJobComplete)
             return;
-        // Use setTimeout(0) instead of queueMicrotask so the handle is cancellable.
-        // suppressFollowUp() can clear this timer even when await_job is called in
-        // a later LLM turn (after the job already completed). queueMicrotask ran
-        // immediately and could not be cancelled (#2762, #3787).
+        // Defer delivery by one microtask so await_job's .then() chain runs first
+        // and can set job.awaited = true before onJobComplete checks it (#2762).
         const cb = this.onJobComplete;
-        job.deliveryTimer = setTimeout(() => {
-            job.deliveryTimer = undefined;
-            if (!job.awaited)
-                cb(job);
-        }, 0);
-        // Allow process to exit even if timer is pending
-        if (typeof job.deliveryTimer === "object" && "unref" in job.deliveryTimer) {
-            job.deliveryTimer.unref();
-        }
+        queueMicrotask(() => cb(job));
     }
     scheduleEviction(id) {
         const existing = this.evictionTimers.get(id);

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -405,25 +405,32 @@ export function makeAbortedMessage(model, lastTextContent) {
 /**
  * Resolve the Claude Code permission mode for the current run.
  *
- * GSD subagents run underneath a host Claude Code session the user has
- * already consented to, and their work (edits, shell inspection, MCP calls)
- * spans the full workflow toolset. Defaulting the inner SDK to
- * `bypassPermissions` avoids per-tool approval prompts that offer no
- * meaningful safety beyond what the host session and the subagent prompts
- * already enforce. `GSD_CLAUDE_CODE_PERMISSION_MODE` lets security-conscious
- * users opt into a stricter mode (`acceptEdits`, `default`, `plan`).
+ * - Auto-mode / headless runs bypass permissions so tool calls don't block
+ *   on prompts the user isn't watching.
+ * - Interactive runs default to `acceptEdits` so file/bash writes still
+ *   land quickly but the SDK retains a permission gate.
+ * - `GSD_CLAUDE_CODE_PERMISSION_MODE` forces a specific mode when set.
  *
- * Tradeoff: bypass means a prompt-injection payload read from an untrusted
- * file could trigger tool calls without a second gate. Accepted for GSD
- * because the workflow is explicit user intent and the alternative
- * (#4099) is continuous approval fatigue that blocks real work.
+ * Cross-extension coupling is kept minimal by dynamically importing
+ * `isAutoActive` and falling back to the bypass default if the import
+ * fails (e.g. in unit tests that load stream-adapter in isolation).
  */
 export async function resolveClaudePermissionMode(env = process.env) {
     const override = env.GSD_CLAUDE_CODE_PERMISSION_MODE?.trim();
     if (override === "bypassPermissions" || override === "acceptEdits" || override === "default" || override === "plan") {
         return override;
     }
-    return "bypassPermissions";
+    try {
+        const autoMod = (await import("../gsd/auto.js"));
+        if (typeof autoMod.isAutoActive === "function" && autoMod.isAutoActive()) {
+            return "bypassPermissions";
+        }
+        return "acceptEdits";
+    }
+    catch {
+        // auto.ts unavailable (tests, non-GSD contexts) — stay permissive.
+        return "bypassPermissions";
+    }
 }
 /**
  * Build the options object passed to the Claude Agent SDK's `query()` call.
@@ -440,21 +447,13 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
     const mcpServers = buildWorkflowMcpServers();
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     const disallowedTools = ["AskUserQuestion"];
-    // Pre-authorize the safe built-ins and every registered workflow MCP
-    // server's tools. `acceptEdits` mode (the interactive default) only
-    // auto-approves file edits — Read/Glob/Grep, basic shell inspection, and
-    // every `mcp__gsd-workflow__*` call still surface as "This command
-    // requires approval" and block GSD actions (#4099).
-    const allowedTools = [
-        "Read",
-        "Write",
-        "Edit",
-        "Glob",
-        "Grep",
-        "Bash(ls:*)",
-        "Bash(pwd)",
-        ...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
-    ];
+    // Pre-authorize every registered workflow MCP server's tools. Without this,
+    // `acceptEdits` mode (the interactive default) auto-approves built-in
+    // Edit/Write/Bash but still gates MCP calls like `mcp__gsd-workflow__*`,
+    // surfacing "This command requires approval" on every GSD action (#4099).
+    const allowedTools = mcpServers
+        ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`)
+        : [];
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,

package/dist/resources/extensions/gsd/auto/loop.js

@@ -13,69 +13,6 @@ import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } fr
 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) {
-    return join(gsdRoot(basePath), "runtime", "stuck-state.json");
-}
-function loadStuckState(basePath) {
-    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, state) {
-    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() {
-    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 →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -87,13 +24,7 @@ function checkMemoryPressure() {
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
     let iteration = 0;
-    // Load persisted stuck state so counters survive session restarts (#3704)
-    const persisted = loadStuckState(s.basePath);
-    const loopState = {
-        recentUnits: persisted.recentUnits,
-        stuckRecoveryAttempts: persisted.stuckRecoveryAttempts,
-        consecutiveFinalizeTimeouts: 0,
-    };
+    const loopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
     let consecutiveErrors = 0;
     let consecutiveCooldowns = 0;
     const recentErrorMessages = [];
@@ -113,19 +44,6 @@ export async function autoLoop(ctx, pi, s, deps) {
             await deps.stopAuto(ctx, pi, `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`);
             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;
@@ -244,7 +162,6 @@ export async function autoLoop(ctx, pi, s, deps) {
                 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") {
                     await deps.stopAuto(ctx, pi, "Workflow complete");

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

@@ -16,7 +16,6 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
-import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
@@ -289,11 +288,6 @@ export async function postUnitPreVerification(pctx, opts) {
                 debugLog("postUnit", { phase: "browser-teardown", status: "closed" });
             }
         });
-        // 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/dist/resources/extensions/gsd/auto.js

@@ -425,13 +425,9 @@ function cleanupAfterLoopExit(ctx) {
         /* best-effort — mirror stopAuto cleanup */
         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) {
         s.basePath = s.originalBasePath;
@@ -533,22 +529,7 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             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");
@@ -560,7 +541,7 @@ export async function stopAuto(ctx, pi, reason) {
                 });
             }
         }
-        // ── Step 7: Restore basePath and chdir ──
+        // ── Step 6: Restore basePath and chdir ──
         try {
             if (s.originalBasePath) {
                 s.basePath = s.originalBasePath;
@@ -576,7 +557,7 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             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) {
@@ -590,6 +571,17 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             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);
@@ -1302,6 +1294,8 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     pi.sendMessage({ customType: "gsd-auto", content: hookPrompt, display: true }, { triggerTurn: true });
     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, } from "./auto-recovery.js";
 export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -172,10 +172,14 @@ export function registerHooks(pi) {
         // 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 = event.input?.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 = event.input?.questions ?? [];
+                const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
+                if (typeof questionId === "string") {
+                    setPendingGate(questionId);
+                }
             }
         }
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
@@ -257,6 +261,8 @@ export function registerHooks(pi) {
             return;
         const milestoneId = getDiscussionMilestoneId(process.cwd());
         const queueActive = isQueuePhaseActive();
+        if (!milestoneId && !queueActive)
+            return;
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -287,16 +293,12 @@ export function registerHooks(pi) {
                 // 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/dist/resources/extensions/gsd/commands-handlers.js

@@ -61,9 +61,6 @@ export function parseDoctorArgs(args) {
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
     return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
 }
-export function isDoctorHealActionable(issue) {
-    return issue.fixable && issue.severity !== "info";
-}
 export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -91,7 +88,7 @@ export async function handleDoctor(args, ctx, pi) {
             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/dist/resources/extensions/gsd/context-injector.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
-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/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,13 +13,17 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
-import { readFrozenDefinition } from "./definition-io.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) {
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const raw = readFileSync(defPath, "utf-8");
+    return parse(raw, { schema: "core" });
+}
 export class CustomWorkflowEngine {
     engineId = "custom";
     runDir;

package/dist/resources/extensions/gsd/gsd-db.js

@@ -121,25 +121,6 @@ function openRawDb(path) {
     return new Database(path);
 }
 const SCHEMA_VERSION = 14;
-function indexExists(db, name) {
-    return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
-}
-function dedupeVerificationEvidenceRows(db) {
-    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) {
-    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, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -377,7 +358,7 @@ function initSchema(db, fileBacked) {
         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)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
@@ -687,7 +668,7 @@ function migrateSchema(db) {
             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(),
@@ -1353,29 +1334,6 @@ export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
     currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
 }
 function rowToTask(row) {
-    const parseTaskArray = (value) => {
-        if (Array.isArray(value)) {
-            return value.filter((entry) => 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) => 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"],
         slice_id: row["slice_id"],
@@ -1395,10 +1353,10 @@ function rowToTask(row) {
         full_summary_md: row["full_summary_md"],
         description: row["description"] ?? "",
         estimate: row["estimate"] ?? "",
-        files: parseTaskArray(row["files"]),
+        files: JSON.parse(row["files"] || "[]"),
         verify: row["verify"] ?? "",
-        inputs: parseTaskArray(row["inputs"]),
-        expected_output: parseTaskArray(row["expected_output"]),
+        inputs: JSON.parse(row["inputs"] || "[]"),
+        expected_output: JSON.parse(row["expected_output"] || "[]"),
         observability_impact: row["observability_impact"] ?? "",
         full_plan_md: row["full_plan_md"] ?? "",
         sequence: row["sequence"] ?? 0,

package/dist/resources/extensions/gsd/key-manager.js

@@ -26,8 +26,6 @@ export const PROVIDER_REGISTRY = [
     { 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" },
     { id: "jina", label: "Jina Page Extract", category: "tool", envVar: "JINA_API_KEY", dashboardUrl: "jina.ai/api" },

package/dist/resources/extensions/gsd/preferences-skills.js

@@ -9,6 +9,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { statSync } from "node:fs";
 import { validatePreferences } from "./preferences-validation.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
  * Known skill directories, in priority order.
  * Searches both the skills.sh ecosystem directory (~/.agents/skills/) and
@@ -129,5 +130,36 @@ export function resolveAllSkillReferences(preferences, cwd) {
     }
     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, resolutions) {
+    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() {
+    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() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.skill_staleness_days ?? 60;
+}

package/dist/resources/extensions/gsd/preferences-types.js

@@ -92,18 +92,3 @@ export const KNOWN_UNIT_TYPES = [
     "discuss-milestone", "discuss-slice", "worktree-merge",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
-/**
- * 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, resolutions) {
-    const resolution = resolutions.get(ref);
-    if (!resolution || resolution.method === "unresolved") {
-        return `${ref} (⚠ not found — check skill name or path)`;
-    }
-    if (resolution.method === "absolute-path" || resolution.method === "absolute-dir") {
-        return ref;
-    }
-    return `${ref} → \`${resolution.resolvedPath}\``;
-}