gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -0,0 +1,133 @@
+/**
+ * Model selection and dynamic routing for auto-mode unit dispatch.
+ * Handles complexity-based routing, model resolution across providers,
+ * and fallback chains.
+ */
+import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
+import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { resolveModelForComplexity } from "./model-router.js";
+import { getLedger, getProjectTotals } from "./metrics.js";
+import { unitPhaseLabel } from "./auto-dashboard.js";
+/**
+ * Select and apply the appropriate model for a unit dispatch.
+ * Handles: per-unit-type model preferences, dynamic complexity routing,
+ * provider/model resolution, fallback chains, and start-model re-application.
+ *
+ * Returns routing metadata for metrics tracking.
+ */
+export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel) {
+    const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+    let routing = null;
+    if (modelConfig) {
+        const availableModels = ctx.modelRegistry.getAvailable();
+        // ─── Dynamic Model Routing ─────────────────────────────────────────
+        const routingConfig = resolveDynamicRoutingConfig();
+        let effectiveModelConfig = modelConfig;
+        let routingTierLabel = "";
+        if (routingConfig.enabled) {
+            let budgetPct;
+            if (routingConfig.budget_pressure !== false) {
+                const budgetCeiling = prefs?.budget_ceiling;
+                if (budgetCeiling !== undefined && budgetCeiling > 0) {
+                    const currentLedger = getLedger();
+                    const totalCost = currentLedger ? getProjectTotals(currentLedger.units).cost : 0;
+                    budgetPct = totalCost / budgetCeiling;
+                }
+            }
+            const isHook = unitType.startsWith("hook/");
+            const shouldClassify = !isHook || routingConfig.hooks !== false;
+            if (shouldClassify) {
+                const classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
+                const availableModelIds = availableModels.map(m => m.id);
+                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
+                if (routingResult.wasDowngraded) {
+                    effectiveModelConfig = {
+                        primary: routingResult.modelId,
+                        fallbacks: routingResult.fallbacks,
+                    };
+                    if (verbose) {
+                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
+                    }
+                }
+                routingTierLabel = ` [${tierLabel(classification.tier)}]`;
+                routing = { tier: classification.tier, modelDowngraded: routingResult.wasDowngraded };
+            }
+        }
+        const modelsToTry = [effectiveModelConfig.primary, ...effectiveModelConfig.fallbacks];
+        for (const modelId of modelsToTry) {
+            const model = resolveModelId(modelId, availableModels, ctx.model?.provider);
+            if (!model) {
+                if (verbose)
+                    ctx.ui.notify(`Model ${modelId} not found, trying fallback.`, "info");
+                continue;
+            }
+            // Warn if the ID is ambiguous across providers
+            if (!modelId.includes("/")) {
+                const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
+                if (providers.length > 1 && model.provider !== ctx.model?.provider) {
+                    ctx.ui.notify(`Model ID "${modelId}" exists in multiple providers (${providers.join(", ")}). ` +
+                        `Resolved to ${model.provider}. Use "provider/model" format for explicit targeting.`, "warning");
+                }
+            }
+            const ok = await pi.setModel(model, { persist: false });
+            if (ok) {
+                const fallbackNote = modelId === effectiveModelConfig.primary
+                    ? ""
+                    : ` (fallback from ${effectiveModelConfig.primary})`;
+                const phase = unitPhaseLabel(unitType);
+                ctx.ui.notify(`Model [${phase}]${routingTierLabel}: ${model.provider}/${model.id}${fallbackNote}`, "info");
+                break;
+            }
+            else {
+                const nextModel = modelsToTry[modelsToTry.indexOf(modelId) + 1];
+                if (nextModel) {
+                    if (verbose)
+                        ctx.ui.notify(`Failed to set model ${modelId}, trying ${nextModel}...`, "info");
+                }
+                else {
+                    ctx.ui.notify(`All preferred models unavailable for ${unitType}. Using default.`, "warning");
+                }
+            }
+        }
+    }
+    else if (autoModeStartModel) {
+        // No model preference for this unit type — re-apply the model captured
+        // at auto-mode start to prevent bleed from shared global settings.json (#650).
+        const availableModels = ctx.modelRegistry.getAvailable();
+        const startModel = availableModels.find(m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id);
+        if (startModel) {
+            const ok = await pi.setModel(startModel, { persist: false });
+            if (!ok) {
+                const byId = availableModels.find(m => m.id === autoModeStartModel.id);
+                if (byId)
+                    await pi.setModel(byId, { persist: false });
+            }
+        }
+    }
+    return { routing };
+}
+/**
+ * Resolve a model ID string to a model object from the available models list.
+ * Handles formats: "provider/model", "bare-id", "org/model-name" (OpenRouter).
+ */
+function resolveModelId(modelId, availableModels, currentProvider) {
+    const slashIdx = modelId.indexOf("/");
+    if (slashIdx !== -1) {
+        const maybeProvider = modelId.substring(0, slashIdx);
+        const id = modelId.substring(slashIdx + 1);
+        const knownProviders = new Set(availableModels.map(m => m.provider.toLowerCase()));
+        if (knownProviders.has(maybeProvider.toLowerCase())) {
+            const match = availableModels.find(m => m.provider.toLowerCase() === maybeProvider.toLowerCase()
+                && m.id.toLowerCase() === id.toLowerCase());
+            if (match)
+                return match;
+        }
+        // Try matching the full string as a model ID (OpenRouter-style)
+        const lower = modelId.toLowerCase();
+        return availableModels.find(m => m.id.toLowerCase() === lower
+            || `${m.provider}/${m.id}`.toLowerCase() === lower);
+    }
+    // Bare ID — prefer current provider, then first available
+    const exactProviderMatch = availableModels.find(m => m.id === modelId && m.provider === currentProvider);
+    return exactProviderMatch ?? availableModels.find(m => m.id === modelId);
+}

package/dist/resources/extensions/gsd/auto-observability.js

@@ -0,0 +1,56 @@
+/**
+ * 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 { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
+export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
+    // Hook units have custom artifacts — skip standard observability checks
+    if (unitType.startsWith("hook/"))
+        return [];
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    const tid = parts[2];
+    if (!mid || !sid)
+        return [];
+    let issues = [];
+    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) {
+    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/dist/resources/extensions/gsd/auto-post-unit.js

@@ -0,0 +1,385 @@
+/**
+ * Post-unit processing for handleAgentEnd — auto-commit, doctor run,
+ * state rebuild, worktree sync, DB dual-write, hooks, triage, and
+ * quick-task dispatch.
+ *
+ * Split into two functions called sequentially by handleAgentEnd with
+ * the verification gate between them:
+ *   1. postUnitPreVerification() — commit, doctor, state rebuild, worktree sync, artifact verification
+ *   2. postUnitPostVerification() — DB dual-write, hooks, triage, quick-tasks
+ *
+ * Extracted from handleAgentEnd() in auto.ts.
+ */
+import { deriveState } from "./state.js";
+import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
+import { loadPrompt } from "./prompt-loader.js";
+import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, } from "./paths.js";
+import { invalidateAllCaches } from "./cache.js";
+import { closeoutUnit } from "./auto-unit-closeout.js";
+import { autoCommitCurrentBranch, } from "./worktree.js";
+import { verifyExpectedArtifact, } from "./auto-recovery.js";
+import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
+import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.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";
+import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
+import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
+import { debugLog } from "./debug-logger.js";
+/** Throttle STATE.md rebuilds — at most once per 30 seconds */
+const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+/**
+ * Pre-verification processing: parallel worker signal check, cache invalidation,
+ * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
+ *
+ * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
+ */
+export async function postUnitPreVerification(pctx) {
+    const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
+    // ── Parallel worker signal check ──
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+    if (milestoneLock) {
+        const signal = consumeSignal(s.basePath, milestoneLock);
+        if (signal) {
+            if (signal.signal === "stop") {
+                await stopAuto(ctx, pi);
+                return "dispatched";
+            }
+            if (signal.signal === "pause") {
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
+        }
+    }
+    // Invalidate all caches
+    invalidateAllCaches();
+    // Small delay to let files settle
+    await new Promise(r => setTimeout(r, 500));
+    // Auto-commit
+    if (s.currentUnit) {
+        try {
+            let taskContext;
+            if (s.currentUnit.type === "execute-task") {
+                const parts = s.currentUnit.id.split("/");
+                const [mid, sid, tid] = parts;
+                if (mid && sid && tid) {
+                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
+                    if (summaryPath) {
+                        try {
+                            const summaryContent = await loadFile(summaryPath);
+                            if (summaryContent) {
+                                const summary = parseSummary(summaryContent);
+                                taskContext = {
+                                    taskId: `${sid}/${tid}`,
+                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                                    oneLiner: summary.oneLiner || undefined,
+                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                };
+                            }
+                        }
+                        catch {
+                            // Non-fatal
+                        }
+                    }
+                }
+            }
+            const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
+            if (commitMsg) {
+                ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+        // Doctor: fix mechanical bookkeeping
+        try {
+            const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
+            const doctorScope = scopeParts.join("/");
+            const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
+            const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
+            const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
+            if (report.fixesApplied.length > 0) {
+                ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
+            }
+            // Proactive health tracking
+            const summary = summarizeDoctorIssues(report.issues);
+            recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
+            // Check if we should escalate to LLM-assisted heal
+            if (summary.errors > 0) {
+                const unresolvedErrors = report.issues
+                    .filter(i => i.severity === "error" && !i.fixable)
+                    .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
+                const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
+                if (escalation.shouldEscalate) {
+                    ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
+                    try {
+                        const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
+                        const { dispatchDoctorHeal } = await import("./commands-handlers.js");
+                        const actionable = report.issues.filter(i => i.severity === "error");
+                        const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
+                        const structuredIssues = formatDoctorIssuesForPrompt(actionable);
+                        dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
+                    }
+                    catch {
+                        // Non-fatal
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+        // Throttled STATE.md rebuild
+        const now = Date.now();
+        if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+            try {
+                await rebuildState(s.basePath);
+                s.lastStateRebuildAt = now;
+                autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        // Prune dead bg-shell processes
+        try {
+            const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
+            pruneDeadProcesses();
+        }
+        catch {
+            // 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 {
+                await resolveAllOverrides(s.basePath);
+                resetRewriteCircuitBreaker();
+                ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        // Post-triage: execute actionable resolutions
+        if (s.currentUnit.type === "triage-captures") {
+            try {
+                const { executeTriageResolutions } = await import("./triage-resolution.js");
+                const state = await deriveState(s.basePath);
+                const mid = state.activeMilestone?.id;
+                const sid = state.activeSlice?.id;
+                if (mid && sid) {
+                    const triageResult = executeTriageResolutions(s.basePath, mid, sid);
+                    if (triageResult.injected > 0) {
+                        ctx.ui.notify(`Triage: injected ${triageResult.injected} task${triageResult.injected === 1 ? "" : "s"} into ${sid} plan.`, "info");
+                    }
+                    if (triageResult.replanned > 0) {
+                        ctx.ui.notify(`Triage: replan trigger written for ${sid} — next dispatch will enter replanning.`, "info");
+                    }
+                    if (triageResult.quickTasks.length > 0) {
+                        for (const qt of triageResult.quickTasks) {
+                            s.pendingQuickTasks.push(qt);
+                        }
+                        ctx.ui.notify(`Triage: ${triageResult.quickTasks.length} quick-task${triageResult.quickTasks.length === 1 ? "" : "s"} queued for execution.`, "info");
+                    }
+                    for (const action of triageResult.actions) {
+                        process.stderr.write(`gsd-triage: ${action}\n`);
+                    }
+                }
+            }
+            catch (err) {
+                process.stderr.write(`gsd-triage: resolution execution failed: ${err.message}\n`);
+            }
+        }
+        // Artifact verification
+        let triggerArtifactVerified = false;
+        if (!s.currentUnit.type.startsWith("hook/")) {
+            try {
+                triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                if (triggerArtifactVerified) {
+                    invalidateAllCaches();
+                }
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+        else {
+            // Hook unit completed — finalize its runtime record
+            try {
+                writeUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, {
+                    phase: "finalized",
+                    progressCount: 1,
+                    lastProgressKind: "hook-completed",
+                });
+                clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+    }
+    return "continue";
+}
+/**
+ * Post-verification processing: DB dual-write, post-unit hooks, triage
+ * capture dispatch, quick-task dispatch.
+ *
+ * Sidecar work (hooks, triage, quick-tasks) is enqueued on `s.sidecarQueue`
+ * for the main loop to drain via `runUnit()`.
+ *
+ * Returns:
+ * - "continue" — proceed to sidecar drain / normal dispatch
+ * - "step-wizard" — step mode, show wizard instead
+ * - "stopped" — stopAuto was called
+ */
+export async function postUnitPostVerification(pctx) {
+    const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
+    // ── DB dual-write ──
+    if (isDbAvailable()) {
+        try {
+            const { migrateFromMarkdown } = await import("./md-importer.js");
+            migrateFromMarkdown(s.basePath);
+        }
+        catch (err) {
+            process.stderr.write(`gsd-db: re-import failed: ${err.message}\n`);
+        }
+    }
+    // ── Post-unit hooks ──
+    if (s.currentUnit && !s.stepMode) {
+        const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+        if (hookUnit) {
+            if (s.currentUnit) {
+                await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
+            }
+            persistHookState(s.basePath);
+            s.sidecarQueue.push({
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                prompt: hookUnit.prompt,
+                model: hookUnit.model,
+            });
+            debugLog("postUnitPostVerification", {
+                phase: "sidecar-enqueue",
+                kind: "hook",
+                unitType: hookUnit.unitType,
+                unitId: hookUnit.unitId,
+                hookName: hookUnit.hookName,
+            });
+            return "continue";
+        }
+        // Check if a hook requested a retry of the trigger unit
+        if (isRetryPending()) {
+            const trigger = consumeRetryTrigger();
+            if (trigger) {
+                ctx.ui.notify(`Hook requested retry of ${trigger.unitType} ${trigger.unitId}.`, "info");
+                // Fall through to normal dispatch — deriveState will re-derive the unit
+            }
+        }
+    }
+    // ── Triage check ──
+    if (!s.stepMode &&
+        s.currentUnit &&
+        !s.currentUnit.type.startsWith("hook/") &&
+        s.currentUnit.type !== "triage-captures" &&
+        s.currentUnit.type !== "quick-task") {
+        try {
+            if (hasPendingCaptures(s.basePath)) {
+                const pending = loadPendingCaptures(s.basePath);
+                if (pending.length > 0) {
+                    const state = await deriveState(s.basePath);
+                    const mid = state.activeMilestone?.id;
+                    const sid = state.activeSlice?.id;
+                    if (mid && sid) {
+                        let currentPlan = "";
+                        let roadmapContext = "";
+                        const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
+                        if (planFile)
+                            currentPlan = (await loadFile(planFile)) ?? "";
+                        const roadmapFile = resolveMilestoneFile(s.basePath, mid, "ROADMAP");
+                        if (roadmapFile)
+                            roadmapContext = (await loadFile(roadmapFile)) ?? "";
+                        const capturesList = pending.map(c => `- **${c.id}**: "${c.text}" (captured: ${c.timestamp})`).join("\n");
+                        const prompt = loadPrompt("triage-captures", {
+                            pendingCaptures: capturesList,
+                            currentPlan: currentPlan || "(no active slice plan)",
+                            roadmapContext: roadmapContext || "(no active roadmap)",
+                        });
+                        if (s.currentUnit) {
+                            await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
+                        }
+                        const triageUnitId = `${mid}/${sid}/triage`;
+                        s.sidecarQueue.push({
+                            kind: "triage",
+                            unitType: "triage-captures",
+                            unitId: triageUnitId,
+                            prompt,
+                        });
+                        debugLog("postUnitPostVerification", {
+                            phase: "sidecar-enqueue",
+                            kind: "triage",
+                            unitId: triageUnitId,
+                            pendingCount: pending.length,
+                        });
+                        ctx.ui.notify(`Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`, "info");
+                        return "continue";
+                    }
+                }
+            }
+        }
+        catch {
+            // Triage check failure is non-fatal
+        }
+    }
+    // ── Quick-task dispatch ──
+    if (!s.stepMode &&
+        s.pendingQuickTasks.length > 0 &&
+        s.currentUnit &&
+        s.currentUnit.type !== "quick-task") {
+        try {
+            const capture = s.pendingQuickTasks.shift();
+            const { buildQuickTaskPrompt } = await import("./triage-resolution.js");
+            const { markCaptureExecuted } = await import("./captures.js");
+            const prompt = buildQuickTaskPrompt(capture);
+            if (s.currentUnit) {
+                await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
+            }
+            markCaptureExecuted(s.basePath, capture.id);
+            const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
+            s.sidecarQueue.push({
+                kind: "quick-task",
+                unitType: "quick-task",
+                unitId: qtUnitId,
+                prompt,
+                captureId: capture.id,
+            });
+            debugLog("postUnitPostVerification", {
+                phase: "sidecar-enqueue",
+                kind: "quick-task",
+                unitId: qtUnitId,
+                captureId: capture.id,
+            });
+            ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
+            return "continue";
+        }
+        catch {
+            // Non-fatal — proceed to normal dispatch
+        }
+    }
+    // Step mode → show wizard instead of dispatch
+    if (s.stepMode) {
+        return "step-wizard";
+    }
+    return "continue";
+}