gsd-pi 2.59.0-dev.023bd39 → 2.59.0-dev.d77b3dd

package/dist/resources/extensions/gsd/model-router.js

@@ -76,6 +76,65 @@ const MODEL_COST_PER_1K_INPUT = {
     "gemini-2.5-pro": 0.00125,
     "deepseek-chat": 0.00014,
 };
+export const MODEL_CAPABILITY_PROFILES = {
+    "claude-opus-4-6": { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
+    "claude-sonnet-4-6": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
+    "claude-haiku-4-5": { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+    "gpt-4o": { coding: 80, debugging: 75, research: 70, reasoning: 75, speed: 65, longContext: 70, instruction: 80 },
+    "gpt-4o-mini": { coding: 55, debugging: 45, research: 40, reasoning: 45, speed: 90, longContext: 45, instruction: 70 },
+    "gemini-2.5-pro": { coding: 75, debugging: 70, research: 85, reasoning: 75, speed: 55, longContext: 90, instruction: 75 },
+    "gemini-2.0-flash": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+    "deepseek-chat": { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
+    "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
+};
+const BASE_REQUIREMENTS = {
+    "execute-task": { coding: 0.9, instruction: 0.7, speed: 0.3 },
+    "research-milestone": { research: 0.9, longContext: 0.7, reasoning: 0.5 },
+    "research-slice": { research: 0.9, longContext: 0.7, reasoning: 0.5 },
+    "plan-milestone": { reasoning: 0.9, coding: 0.5 },
+    "plan-slice": { reasoning: 0.9, coding: 0.5 },
+    "replan-slice": { reasoning: 0.9, debugging: 0.6, coding: 0.5 },
+    "reassess-roadmap": { reasoning: 0.9, research: 0.5 },
+    "complete-slice": { instruction: 0.8, speed: 0.7 },
+    "run-uat": { instruction: 0.7, speed: 0.8 },
+    "discuss-milestone": { reasoning: 0.6, instruction: 0.7 },
+    "complete-milestone": { instruction: 0.8, reasoning: 0.5 },
+};
+/**
+ * Compute a task requirement vector from unit type and optional metadata.
+ */
+export function computeTaskRequirements(unitType, metadata) {
+    const base = { ...(BASE_REQUIREMENTS[unitType] ?? { reasoning: 0.5 }) };
+    if (unitType === "execute-task" && metadata) {
+        if (metadata.tags?.some(t => /^(docs?|readme|comment|config|typo|rename)$/i.test(t))) {
+            return { ...base, instruction: 0.9, coding: 0.3, speed: 0.7 };
+        }
+        if (metadata.complexityKeywords?.some(k => k === "concurrency" || k === "compatibility")) {
+            return { ...base, debugging: 0.9, reasoning: 0.8 };
+        }
+        if (metadata.complexityKeywords?.some(k => k === "migration" || k === "architecture")) {
+            return { ...base, reasoning: 0.9, coding: 0.8 };
+        }
+        if ((metadata.fileCount ?? 0) >= 6 || (metadata.estimatedLines ?? 0) >= 500) {
+            return { ...base, coding: 0.9, reasoning: 0.7 };
+        }
+    }
+    return base;
+}
+/**
+ * Score a model against a task requirement vector.
+ * Returns weighted average in range 0–100. Returns 50 for empty requirements.
+ */
+export function scoreModel(capabilities, requirements) {
+    let weightedSum = 0;
+    let weightSum = 0;
+    for (const [dim, weight] of Object.entries(requirements)) {
+        const capability = capabilities[dim] ?? 50;
+        weightedSum += weight * capability;
+        weightSum += weight;
+    }
+    return weightSum > 0 ? weightedSum / weightSum : 50;
+}
 // ─── Public API ──────────────────────────────────────────────────────────────
 /**
  * Resolve the model to use for a given complexity tier.
@@ -88,7 +147,7 @@ const MODEL_COST_PER_1K_INPUT = {
  * @param routingConfig   Dynamic routing configuration
  * @param availableModelIds  List of available model IDs (from registry)
  */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds) {
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, metadata) {
     // If no phase config or routing disabled, pass through
     if (!phaseConfig || !routingConfig.enabled) {
         return {
@@ -127,18 +186,31 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         };
     }
     // Find the best model for the requested tier
-    const targetModelId = findModelForTier(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
+    const useCapabilityScoring = routingConfig.capability_routing && unitType;
+    let targetModelId;
+    let capabilityScores;
+    let taskRequirements;
+    let selectionMethod = "tier-only";
+    if (useCapabilityScoring) {
+        const result = findModelForTierWithCapability(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false, unitType, metadata);
+        targetModelId = result.modelId;
+        capabilityScores = Object.keys(result.scores).length > 0 ? result.scores : undefined;
+        taskRequirements = Object.keys(result.requirements).length > 0 ? result.requirements : undefined;
+        selectionMethod = capabilityScores ? "capability-scored" : "tier-only";
+    }
+    else {
+        targetModelId = findModelForTier(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
+    }
     if (!targetModelId) {
-        // No suitable model found — use configured primary
         return {
             modelId: configuredPrimary,
             fallbacks: phaseConfig.fallbacks,
             tier: requestedTier,
             wasDowngraded: false,
             reason: `no ${requestedTier}-tier model available`,
+            selectionMethod,
         };
     }
-    // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
     const fallbacks = [
         ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
         configuredPrimary,
@@ -149,6 +221,9 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         tier: requestedTier,
         wasDowngraded: true,
         reason: classification.reason,
+        selectionMethod,
+        capabilityScores,
+        taskRequirements,
     };
 }
 /**
@@ -168,6 +243,7 @@ export function escalateTier(currentTier) {
 export function defaultRoutingConfig() {
     return {
         enabled: true,
+        capability_routing: false,
         escalate_on_failure: true,
         budget_pressure: true,
         cross_provider: true,
@@ -231,6 +307,49 @@ function findModelForTier(tier, config, availableModelIds, crossProvider) {
     });
     return candidates[0] ?? null;
 }
+function findModelForTierWithCapability(tier, config, availableModelIds, crossProvider, unitType, metadata) {
+    const explicitModel = config.tier_models?.[tier];
+    if (explicitModel) {
+        const match = availableModelIds.find(id => {
+            const bareAvail = id.includes("/") ? id.split("/").pop() : id;
+            const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop() : explicitModel;
+            return bareAvail === bareExplicit || id === explicitModel;
+        });
+        if (match)
+            return { modelId: match, scores: {}, requirements: {} };
+    }
+    const requirements = computeTaskRequirements(unitType, metadata);
+    const candidates = availableModelIds.filter(id => getModelTier(id) === tier);
+    if (candidates.length === 0)
+        return { modelId: null, scores: {}, requirements };
+    const scores = {};
+    for (const id of candidates) {
+        const bareId = id.includes("/") ? id.split("/").pop() : id;
+        const profile = getModelProfile(bareId);
+        scores[id] = scoreModel(profile, requirements);
+    }
+    candidates.sort((a, b) => {
+        const scoreDiff = scores[b] - scores[a];
+        if (Math.abs(scoreDiff) > 2)
+            return scoreDiff;
+        if (crossProvider) {
+            const costDiff = getModelCost(a) - getModelCost(b);
+            if (costDiff !== 0)
+                return costDiff;
+        }
+        return a.localeCompare(b);
+    });
+    return { modelId: candidates[0], scores, requirements };
+}
+function getModelProfile(bareId) {
+    if (MODEL_CAPABILITY_PROFILES[bareId])
+        return MODEL_CAPABILITY_PROFILES[bareId];
+    for (const [knownId, profile] of Object.entries(MODEL_CAPABILITY_PROFILES)) {
+        if (bareId.includes(knownId) || knownId.includes(bareId))
+            return profile;
+    }
+    return { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
+}
 function getModelCost(modelId) {
     const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
     if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {

package/dist/resources/extensions/gsd/phase-anchor.js

@@ -0,0 +1,56 @@
+/**
+ * Phase handoff anchors — compact structured summaries written between
+ * GSD auto-mode phases so downstream agents inherit decisions, blockers,
+ * and intent without re-inferring from scratch.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+function anchorsDir(basePath, milestoneId) {
+    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+}
+function anchorPath(basePath, milestoneId, phase) {
+    return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
+}
+export function writePhaseAnchor(basePath, milestoneId, anchor) {
+    const dir = anchorsDir(basePath, milestoneId);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(anchorPath(basePath, milestoneId, anchor.phase), JSON.stringify(anchor, null, 2), "utf-8");
+}
+export function readPhaseAnchor(basePath, milestoneId, phase) {
+    const path = anchorPath(basePath, milestoneId, phase);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function formatAnchorForPrompt(anchor) {
+    const lines = [
+        `## Handoff from ${anchor.phase}`,
+        "",
+        `**Intent:** ${anchor.intent}`,
+    ];
+    if (anchor.decisions.length > 0) {
+        lines.push("", "**Decisions:**");
+        for (const d of anchor.decisions)
+            lines.push(`- ${d}`);
+    }
+    if (anchor.blockers.length > 0) {
+        lines.push("", "**Blockers:**");
+        for (const b of anchor.blockers)
+            lines.push(`- ${b}`);
+    }
+    if (anchor.nextSteps.length > 0) {
+        lines.push("", "**Next steps:**");
+        for (const s of anchor.nextSteps)
+            lines.push(`- ${s}`);
+    }
+    lines.push("", "---");
+    return lines.join("\n");
+}

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

@@ -71,6 +71,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "forensics_dedup",
     "show_token_cost",
     "stale_commit_threshold_minutes",
+    "context_management",
     "experimental",
 ]);
 /** Canonical list of all dispatch unit types. */

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

@@ -425,6 +425,12 @@ export function validatePreferences(preferences) {
                 else
                     errors.push("dynamic_routing.hooks must be a boolean");
             }
+            if (dr.capability_routing !== undefined) {
+                if (typeof dr.capability_routing === "boolean")
+                    validDr.capability_routing = dr.capability_routing;
+                else
+                    errors.push("dynamic_routing.capability_routing must be a boolean");
+            }
             if (dr.tier_models !== undefined) {
                 if (typeof dr.tier_models === "object" && dr.tier_models !== null) {
                     const tm = dr.tier_models;
@@ -452,6 +458,46 @@ export function validatePreferences(preferences) {
             errors.push("dynamic_routing must be an object");
         }
     }
+    // ─── Context Management ──────────────────────────────────────────────
+    if (preferences.context_management !== undefined) {
+        if (typeof preferences.context_management === "object" && preferences.context_management !== null) {
+            const cm = preferences.context_management;
+            const validCm = {};
+            if (cm.observation_masking !== undefined) {
+                if (typeof cm.observation_masking === "boolean")
+                    validCm.observation_masking = cm.observation_masking;
+                else
+                    errors.push("context_management.observation_masking must be a boolean");
+            }
+            if (cm.observation_mask_turns !== undefined) {
+                const turns = cm.observation_mask_turns;
+                if (typeof turns === "number" && turns >= 1 && turns <= 50)
+                    validCm.observation_mask_turns = turns;
+                else
+                    errors.push("context_management.observation_mask_turns must be a number between 1 and 50");
+            }
+            if (cm.compaction_threshold_percent !== undefined) {
+                const pct = cm.compaction_threshold_percent;
+                if (typeof pct === "number" && pct >= 0.5 && pct <= 0.95)
+                    validCm.compaction_threshold_percent = pct;
+                else
+                    errors.push("context_management.compaction_threshold_percent must be a number between 0.5 and 0.95");
+            }
+            if (cm.tool_result_max_chars !== undefined) {
+                const chars = cm.tool_result_max_chars;
+                if (typeof chars === "number" && chars >= 200 && chars <= 10000)
+                    validCm.tool_result_max_chars = chars;
+                else
+                    errors.push("context_management.tool_result_max_chars must be a number between 200 and 10000");
+            }
+            if (Object.keys(validCm).length > 0) {
+                validated.context_management = validCm;
+            }
+        }
+        else {
+            errors.push("context_management must be an object");
+        }
+    }
     // ─── Parallel Config ────────────────────────────────────────────────────
     if (preferences.parallel && typeof preferences.parallel === "object") {
         const p = preferences.parallel;

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -12,6 +12,8 @@ A researcher explored the codebase and a planner decomposed the work — you are
 
 {{runtimeContext}}
 
+{{phaseAnchorSection}}
+
 {{resumeSection}}
 
 {{carryForwardSection}}

package/dist/resources/extensions/gsd/prompts/rethink.md

@@ -45,6 +45,13 @@ reason: "<reason>"
 ### Unpark a milestone
 Remove the `{ID}-PARKED.md` file from the milestone directory to reactivate it.
 
+### Skip a slice
+Mark a slice as skipped so auto-mode advances past it without executing. Use the `gsd_skip_slice` tool:
+```
+gsd_skip_slice({ milestone_id: "M003", slice_id: "S02", reason: "Descoped — feature moved to M005" })
+```
+Skipped slices are treated as closed by the state machine (like "complete" but distinct). Use when a slice is no longer needed or has been superseded. The slice data is preserved for reference.
+
 ### Discard a milestone
 **Permanently** delete a milestone directory and prune it from QUEUE-ORDER.json. **Always confirm with the user before discarding.** Warn explicitly if the milestone has completed work.
 

package/dist/resources/extensions/gsd/prompts/triage-captures.md

@@ -20,6 +20,8 @@ The user captured thoughts during execution using `/gsd capture`. Your job is to
 
 For each capture, classify it as one of:
 
+- **stop**: User directive to halt auto-mode immediately. Use when the user says "stop", "halt", "abort", "don't continue", "pause", or otherwise wants execution to cease. Auto-mode will pause after the current unit completes. Examples: "stop running", "halt execution", "don't continue".
+- **backtrack**: User directive to abandon the current milestone and return to a previous one. The user believes earlier milestones missed critical features or need rework. Include the target milestone ID (e.g., M003) in the Resolution field. Auto-mode will pause and write a regression marker. Examples: "restart from M003", "go back to milestone 3", "M004 and M005 failed, restart from M003".
 - **quick-task**: Small, self-contained, no downstream impact. Can be done in minutes without modifying the plan. Examples: fix a typo, add a missing import, tweak a config value.
 - **inject**: Belongs in the current slice but wasn't planned. Needs a new task added to the slice plan. Examples: add error handling to a module being built, add a missing test case for current work.
 - **defer**: Belongs in a future slice or milestone. Not urgent for current work. Examples: performance optimization, feature that depends on unbuilt infrastructure, nice-to-have enhancement.
@@ -28,10 +30,12 @@ For each capture, classify it as one of:
 
 ## Decision Guidelines
 
+- **ALWAYS classify as stop** when the user explicitly says "stop", "halt", "abort", or "don't continue". Never shoe-horn a stop directive into "replan" or "note".
+- **ALWAYS classify as backtrack** when the user references returning to a previous milestone, restarting from an earlier point, or abandoning current milestone work. Include the target milestone ID in the Resolution field (e.g., "Backtrack to M003").
 - Prefer **quick-task** when the work is clearly small and self-contained.
 - Prefer **inject** over **replan** when only a new task is needed, not rewriting existing ones.
 - Prefer **defer** over **inject** when the work doesn't belong in the current slice's scope.
-- Use **replan** only when remaining incomplete tasks need to change — not just for adding work.
+- Use **replan** only when remaining incomplete tasks in the *current slice* need to change — not for cross-milestone issues.
 - Use **note** for observations that don't require action.
 - When unsure between quick-task and inject, consider: will this take more than 10 minutes? If yes, inject.
 
@@ -46,6 +50,7 @@ For each capture, classify it as one of:
    - If applicable, which files would be affected
    
    For captures classified as **note** or **defer**, auto-confirm without asking — these are low-impact.
+   For captures classified as **stop** or **backtrack**, auto-confirm without asking — these are urgent user directives that must be honored immediately.
    For captures classified as **quick-task**, **inject**, or **replan**, ask the user to confirm or choose a different classification.
 
 3. **Update** `.gsd/CAPTURES.md` — for each capture, update its section with the confirmed classification:

package/dist/resources/extensions/gsd/rethink.js

@@ -81,8 +81,11 @@ function buildRethinkData(basePath, milestoneIds, state, queueOrder) {
         if (dbAvailable && status !== "complete") {
             const slices = getMilestoneSlices(mid);
             if (slices.length > 0) {
-                const done = slices.filter(s => s.status === "complete").length;
-                sliceInfo = `${done}/${slices.length} complete`;
+                const done = slices.filter(s => s.status === "complete" || s.status === "done").length;
+                const skipped = slices.filter(s => s.status === "skipped").length;
+                sliceInfo = skipped > 0
+                    ? `${done}/${slices.length} complete, ${skipped} skipped`
+                    : `${done}/${slices.length} complete`;
             }
         }
         // Add parked reason if applicable

package/dist/resources/extensions/gsd/state.js

@@ -223,7 +223,7 @@ function extractContextTitle(content, fallback) {
  * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
  */
 function isStatusDone(status) {
-    return status === 'complete' || status === 'done';
+    return status === 'complete' || status === 'done' || status === 'skipped';
 }
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.

package/dist/resources/extensions/gsd/status-guards.js

@@ -1,12 +1,13 @@
 /**
  * Status predicates for GSD state-machine guards.
  *
- * The DB stores status as free-form strings. Two values indicate
- * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * The DB stores status as free-form strings. Three values indicate
+ * "closed": "complete" (canonical), "done" (legacy / alias), and
+ * "skipped" (user-directed skip via rethink or backtrack).
  * Every inline `status === "complete" || status === "done"` should
  * use isClosedStatus() instead.
  */
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status) {
-    return status === "complete" || status === "done";
+    return status === "complete" || status === "done" || status === "skipped";
 }

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -9,7 +9,7 @@
  *
  * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
@@ -99,6 +99,116 @@ export function executeReplan(basePath, mid, sid, capture) {
         return false;
     }
 }
+// ─── Backtrack (Milestone Regression) ────────────────────────────────────────
+/**
+ * Execute a backtrack directive — user wants to abandon current milestone
+ * and return to a previous one (milestone regression).
+ *
+ * Writes a BACKTRACK-TRIGGER.md marker at `.gsd/BACKTRACK-TRIGGER.md` with
+ * the target milestone, reason, and timestamp. The state machine (deriveState)
+ * detects this and transitions the project to the target milestone, resetting
+ * its slices to allow re-planning.
+ *
+ * Returns the extracted target milestone ID, or null if extraction failed.
+ */
+export function executeBacktrack(basePath, currentMilestoneId, capture) {
+    try {
+        // Extract target milestone from capture text or resolution
+        const targetMatch = (capture.resolution ?? capture.text)
+            .match(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/);
+        const targetMilestoneId = targetMatch?.[1] ?? null;
+        const ts = new Date().toISOString();
+        const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+        const content = [
+            `# Backtrack Trigger`,
+            ``,
+            `**Source:** Capture ${capture.id}`,
+            `**Capture:** ${capture.text}`,
+            `**Rationale:** ${capture.rationale ?? "User-initiated milestone backtrack"}`,
+            `**From:** ${currentMilestoneId}`,
+            `**Target:** ${targetMilestoneId ?? "(user to specify)"}`,
+            `**Triggered:** ${ts}`,
+            ``,
+            `Auto-mode was paused by this backtrack directive. The user directed`,
+            `that the current milestone (${currentMilestoneId}) be abandoned and work`,
+            `should return to ${targetMilestoneId ?? "a previous milestone"}.`,
+            ``,
+            `## Recovery Steps`,
+            ``,
+            `1. Review what went wrong in ${currentMilestoneId}`,
+            `2. Identify missing features/requirements from the target milestone`,
+            `3. Resume auto-mode — the state machine will re-enter discussion for the target`,
+        ].join("\n");
+        writeFileSync(triggerPath, content, "utf-8");
+        // If we have a valid target, also reset that milestone's completion status
+        // so deriveState() will re-enter it as the active milestone.
+        if (targetMilestoneId) {
+            try {
+                const targetDir = join(milestonesDir(basePath), targetMilestoneId);
+                if (existsSync(targetDir)) {
+                    // Write a regression marker so the state machine knows this milestone
+                    // needs re-discussion, not just re-execution
+                    const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
+                    writeFileSync(regressionPath, [
+                        `# Milestone Regression`,
+                        ``,
+                        `**From:** ${currentMilestoneId}`,
+                        `**Reason:** ${capture.text}`,
+                        `**Triggered:** ${ts}`,
+                        ``,
+                        `This milestone is being revisited because downstream milestone`,
+                        `${currentMilestoneId} failed or missed critical features that should`,
+                        `have been part of this milestone's scope.`,
+                        ``,
+                        `The discuss phase should re-evaluate requirements and identify gaps.`,
+                    ].join("\n"), "utf-8");
+                }
+            }
+            catch { /* best-effort */ }
+        }
+        return targetMilestoneId;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the backtrack trigger file if it exists.
+ * Returns the parsed target milestone and metadata, or null.
+ */
+export function readBacktrackTrigger(basePath) {
+    const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+    if (!existsSync(triggerPath))
+        return null;
+    try {
+        const content = readFileSync(triggerPath, "utf-8");
+        const target = content.match(/\*\*Target:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+        const from = content.match(/\*\*From:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+        const capture = content.match(/\*\*Capture:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+        const triggeredAt = content.match(/\*\*Triggered:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+        return {
+            target: target === "(user to specify)" ? null : target,
+            from,
+            capture,
+            triggeredAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove the backtrack trigger after it has been processed.
+ */
+export function clearBacktrackTrigger(basePath) {
+    const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+    try {
+        if (existsSync(triggerPath)) {
+            unlinkSync(triggerPath);
+        }
+    }
+    catch { /* best-effort */ }
+}
 // ─── File Overlap Detection ───────────────────────────────────────────────────
 /**
  * Detect file overlap between a capture's affected files and planned tasks.
@@ -240,6 +350,8 @@ export function executeTriageResolutions(basePath, mid, sid) {
         replanned: 0,
         deferredMilestones: 0,
         quickTasks: [],
+        stopped: 0,
+        backtracks: [],
         actions: [],
     };
     const actionable = loadActionableCaptures(basePath, mid || undefined);
@@ -318,5 +430,20 @@ export function executeTriageResolutions(basePath, mid, sid) {
             }
         }
     }
+    // Count stop/backtrack captures — these are handled by the pre-dispatch guard
+    // in runGuards(), not here. We just report them for logging purposes.
+    const allCaptures = loadAllCaptures(basePath);
+    for (const cap of allCaptures) {
+        if (cap.status !== "resolved" || cap.executed)
+            continue;
+        if (cap.classification === "stop") {
+            result.stopped++;
+            result.actions.push(`Stop directive from ${cap.id}: "${cap.text}" — will pause on next dispatch`);
+        }
+        else if (cap.classification === "backtrack") {
+            result.backtracks.push(cap);
+            result.actions.push(`Backtrack directive from ${cap.id}: "${cap.text}" — will trigger milestone regression on next dispatch`);
+        }
+    }
     return result;
 }

package/dist/resources/extensions/gsd/triage-ui.js

@@ -33,9 +33,17 @@ const CLASSIFICATION_LABELS = {
         label: "Note",
         description: "Informational only — no action needed.",
     },
+    "stop": {
+        label: "Stop",
+        description: "Halt auto-mode immediately — user directive to cease execution.",
+    },
+    "backtrack": {
+        label: "Backtrack",
+        description: "Abandon current milestone and return to a previous one.",
+    },
 };
 const ALL_CLASSIFICATIONS = [
-    "quick-task", "inject", "defer", "replan", "note",
+    "quick-task", "inject", "defer", "replan", "note", "stop", "backtrack",
 ];
 // ─── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -57,8 +65,9 @@ export async function showTriageConfirmation(ctx, triageResults, captures, baseP
         const capture = captureMap.get(result.captureId);
         if (!capture)
             continue;
-        // Auto-confirm note and defer — low-impact, no plan modification
-        if (result.classification === "note" || result.classification === "defer") {
+        // Auto-confirm note, defer, stop, and backtrack — low-impact or urgent directives
+        if (result.classification === "note" || result.classification === "defer"
+            || result.classification === "stop" || result.classification === "backtrack") {
             const resolution = result.classification === "note"
                 ? "acknowledged as note"
                 : `deferred${result.targetSlice ? ` to ${result.targetSlice}` : ""}`;

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-QlWL-8CXgQpzV3ehkNMzh
+t_cBZAENjaOJIRST3dw08

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -1,46 +1,46 @@
 {
-  "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
+  "/_not-found/page": "/_not-found",
   "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/dev-mode/route": "/api/dev-mode",
-  "/api/browse-directories/route": "/api/browse-directories",
   "/api/doctor/route": "/api/doctor",
+  "/api/captures/route": "/api/captures",
   "/api/cleanup/route": "/api/cleanup",
-  "/api/export-data/route": "/api/export-data",
-  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/browse-directories/route": "/api/browse-directories",
   "/api/forensics/route": "/api/forensics",
-  "/api/captures/route": "/api/captures",
-  "/api/history/route": "/api/history",
+  "/api/export-data/route": "/api/export-data",
   "/api/git/route": "/api/git",
   "/api/hooks/route": "/api/hooks",
+  "/api/history/route": "/api/history",
+  "/api/knowledge/route": "/api/knowledge",
   "/api/inspect/route": "/api/inspect",
   "/api/experimental/route": "/api/experimental",
-  "/api/knowledge/route": "/api/knowledge",
   "/api/live-state/route": "/api/live-state",
-  "/api/recovery/route": "/api/recovery",
-  "/api/onboarding/route": "/api/onboarding",
+  "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
   "/api/preferences/route": "/api/preferences",
+  "/api/recovery/route": "/api/recovery",
   "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
-  "/api/session/manage/route": "/api/session/manage",
+  "/api/onboarding/route": "/api/onboarding",
+  "/api/session/events/route": "/api/session/events",
   "/api/settings-data/route": "/api/settings-data",
   "/api/shutdown/route": "/api/shutdown",
-  "/api/session/events/route": "/api/session/events",
-  "/api/steer/route": "/api/steer",
   "/api/skill-health/route": "/api/skill-health",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/terminal/input/route": "/api/terminal/input",
   "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/resize/route": "/api/terminal/resize",
+  "/api/steer/route": "/api/steer",
   "/api/terminal/stream/route": "/api/terminal/stream",
   "/api/remote-questions/route": "/api/remote-questions",
-  "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/visualizer/route": "/api/visualizer",
+  "/api/undo/route": "/api/undo",
+  "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/update/route": "/api/update",
   "/api/files/route": "/api/files",
-  "/api/undo/route": "/api/undo",
   "/page": "/"
 }