@snipcodeit/mgw 0.3.0 → 0.6.0

package/dist/lib/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var index$1 = require('../index-s7v-ifd0.cjs');
+var index$1 = require('../index-CHrVAIMY.cjs');
 var require$$0 = require('child_process');
 var require$$1 = require('path');
-var require$$2 = require('os');
-var require$$0$1 = require('fs');
+var require$$3 = require('os');
+var require$$2 = require('fs');
 require('events');
 
 var pipeline;
@@ -145,6 +145,500 @@ function requirePipeline () {
 	return pipeline;
 }
 
+var agentErrors;
+var hasRequiredAgentErrors;
+
+function requireAgentErrors () {
+	if (hasRequiredAgentErrors) return agentErrors;
+	hasRequiredAgentErrors = 1;
+	const { MgwError } = index$1.requireErrors();
+	const SEVERITY_LEVELS = Object.freeze({
+	  critical: { name: "critical", weight: 4, description: "Agent produced dangerous or misleading results" },
+	  high: { name: "high", weight: 3, description: "Agent failed to produce usable output" },
+	  medium: { name: "medium", weight: 2, description: "Agent partially succeeded but gaps remain" },
+	  low: { name: "low", weight: 1, description: "Minor issue, likely recoverable automatically" }
+	});
+	const AGENT_FAILURE_TYPES = Object.freeze({
+	  timeout: Object.freeze({
+	    code: "AGENT_ERR_TIMEOUT",
+	    name: "timeout",
+	    severity: "high",
+	    description: "Agent exceeded turn limit or wall-clock timeout without completing its task",
+	    recovery: "Retry with reduced scope \u2014 split the task into smaller sub-tasks or increase the turn budget",
+	    retryable: true
+	  }),
+	  "malformed-output": Object.freeze({
+	    code: "AGENT_ERR_MALFORMED_OUTPUT",
+	    name: "malformed-output",
+	    severity: "high",
+	    description: "Agent returned output that cannot be parsed or does not match the expected format",
+	    recovery: "Retry with explicit format instructions \u2014 add structured output examples to the prompt",
+	    retryable: true
+	  }),
+	  "partial-completion": Object.freeze({
+	    code: "AGENT_ERR_PARTIAL_COMPLETION",
+	    name: "partial-completion",
+	    severity: "medium",
+	    description: "Agent completed some but not all assigned tasks \u2014 partial artifacts exist",
+	    recovery: "Spawn a continuation agent for the remaining tasks using the partial output as context",
+	    retryable: true
+	  }),
+	  hallucination: Object.freeze({
+	    code: "AGENT_ERR_HALLUCINATION",
+	    name: "hallucination",
+	    severity: "critical",
+	    description: "Agent claimed success but required artifacts are missing or do not match expectations",
+	    recovery: "Reject all results and retry with a verification-first approach \u2014 require artifact proof before completion",
+	    retryable: false
+	  }),
+	  "permission-denied": Object.freeze({
+	    code: "AGENT_ERR_PERMISSION_DENIED",
+	    name: "permission-denied",
+	    severity: "high",
+	    description: "Agent was blocked by a pre-commit hook, sandbox restriction, or file permission",
+	    recovery: "Escalate to human operator \u2014 review sandbox configuration and hook settings",
+	    retryable: false
+	  })
+	});
+	const _codeToType = /* @__PURE__ */ new Map();
+	for (const [key, def] of Object.entries(AGENT_FAILURE_TYPES)) {
+	  _codeToType.set(def.code, { key, ...def });
+	}
+	class AgentFailureError extends MgwError {
+	  /**
+	   * @param {string} message - Human-readable error description
+	   * @param {object} [opts]
+	   * @param {string} [opts.agentType]   - GSD agent type (gsd-planner, gsd-executor, etc.)
+	   * @param {string} [opts.failureType] - Failure type key from AGENT_FAILURE_TYPES
+	   * @param {string[]} [opts.artifacts] - List of expected artifacts that are missing/malformed
+	   * @param {string} [opts.stage]       - Pipeline stage where failure occurred
+	   * @param {number} [opts.issueNumber] - Related GitHub issue number
+	   * @param {Error}  [opts.cause]       - Original error
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    const failureDef = o.failureType ? AGENT_FAILURE_TYPES[o.failureType] : null;
+	    const code = failureDef ? failureDef.code : "AGENT_ERR_UNKNOWN";
+	    super(message, { code, stage: o.stage, issueNumber: o.issueNumber, cause: o.cause });
+	    this.name = "AgentFailureError";
+	    this.agentType = o.agentType || null;
+	    this.failureType = o.failureType || null;
+	    this.artifacts = Array.isArray(o.artifacts) ? o.artifacts : [];
+	  }
+	  /**
+	   * Get the full failure type definition for this error.
+	   * @returns {object|null}
+	   */
+	  getFailureDefinition() {
+	    if (!this.failureType) return null;
+	    return AGENT_FAILURE_TYPES[this.failureType] || null;
+	  }
+	  /**
+	   * Get the severity level for this error.
+	   * @returns {string|null}
+	   */
+	  getSeverity() {
+	    const def = this.getFailureDefinition();
+	    return def ? def.severity : null;
+	  }
+	  /**
+	   * Check whether this failure type is safe to auto-retry.
+	   * @returns {boolean}
+	   */
+	  isRetryable() {
+	    const def = this.getFailureDefinition();
+	    return def ? def.retryable : false;
+	  }
+	}
+	const CLASSIFICATION_PATTERNS = [
+	  // Timeout patterns
+	  { pattern: "turn limit", type: "timeout" },
+	  { pattern: "max turns", type: "timeout" },
+	  { pattern: "context window exhausted", type: "timeout" },
+	  { pattern: "exceeded.*timeout", type: "timeout" },
+	  { pattern: "agent timed out", type: "timeout" },
+	  { pattern: "wall.?clock.*exceeded", type: "timeout" },
+	  // Malformed output patterns
+	  { pattern: "unparseable", type: "malformed-output" },
+	  { pattern: "invalid json", type: "malformed-output" },
+	  { pattern: "parse error", type: "malformed-output" },
+	  { pattern: "unexpected token", type: "malformed-output" },
+	  { pattern: "malformed output", type: "malformed-output" },
+	  { pattern: "missing required field", type: "malformed-output" },
+	  { pattern: "output format", type: "malformed-output" },
+	  { pattern: "expected.*format", type: "malformed-output" },
+	  // Partial completion patterns
+	  { pattern: "partial completion", type: "partial-completion" },
+	  { pattern: "incomplete.*tasks", type: "partial-completion" },
+	  { pattern: "completed.*of.*tasks", type: "partial-completion" },
+	  { pattern: "remaining tasks", type: "partial-completion" },
+	  { pattern: "some tasks failed", type: "partial-completion" },
+	  // Hallucination patterns (check before generic patterns)
+	  { pattern: "artifacts? missing", type: "hallucination" },
+	  { pattern: "claimed success.*missing", type: "hallucination" },
+	  { pattern: "file.*not found.*after", type: "hallucination" },
+	  { pattern: "verification failed.*not exist", type: "hallucination" },
+	  { pattern: "hallucination", type: "hallucination" },
+	  { pattern: "phantom", type: "hallucination" },
+	  // Permission denied patterns
+	  { pattern: "permission denied", type: "permission-denied" },
+	  { pattern: "access denied", type: "permission-denied" },
+	  { pattern: "hook.*failed", type: "permission-denied" },
+	  { pattern: "pre.?commit.*rejected", type: "permission-denied" },
+	  { pattern: "sandbox.*blocked", type: "permission-denied" },
+	  { pattern: "sandbox.*violation", type: "permission-denied" },
+	  { pattern: "eacces", type: "permission-denied" }
+	];
+	function classifyAgentFailure(error, context) {
+	  if (!error || typeof error !== "object") return null;
+	  const message = (error.message || "").toLowerCase();
+	  const code = (error.code || "").toLowerCase();
+	  const ctx = context || {};
+	  if (ctx.expectedArtifacts && ctx.actualArtifacts) {
+	    const expected = new Set(ctx.expectedArtifacts);
+	    const actual = new Set(ctx.actualArtifacts);
+	    const missing = [...expected].filter((a) => !actual.has(a));
+	    if (missing.length > 0 && ctx.tasksCompleted > 0) {
+	      const def = AGENT_FAILURE_TYPES.hallucination;
+	      return { type: "hallucination", code: def.code, severity: def.severity, confidence: "high" };
+	    }
+	  }
+	  if (typeof ctx.tasksTotal === "number" && typeof ctx.tasksCompleted === "number") {
+	    if (ctx.tasksCompleted > 0 && ctx.tasksCompleted < ctx.tasksTotal) {
+	      const def = AGENT_FAILURE_TYPES["partial-completion"];
+	      return { type: "partial-completion", code: def.code, severity: def.severity, confidence: "high" };
+	    }
+	  }
+	  if (code === "eacces" || code === "eperm") {
+	    const def = AGENT_FAILURE_TYPES["permission-denied"];
+	    return { type: "permission-denied", code: def.code, severity: def.severity, confidence: "high" };
+	  }
+	  for (const { pattern, type } of CLASSIFICATION_PATTERNS) {
+	    const regex = new RegExp(pattern, "i");
+	    if (regex.test(message)) {
+	      const def = AGENT_FAILURE_TYPES[type];
+	      return { type, code: def.code, severity: def.severity, confidence: "medium" };
+	    }
+	  }
+	  return null;
+	}
+	function getRecoveryAction(failureType) {
+	  const def = AGENT_FAILURE_TYPES[failureType];
+	  if (!def) return null;
+	  return {
+	    action: def.recovery,
+	    retryable: def.retryable,
+	    severity: def.severity
+	  };
+	}
+	function isRetryable(failureType) {
+	  const def = AGENT_FAILURE_TYPES[failureType];
+	  return def ? def.retryable : false;
+	}
+	function compareSeverity(a, b) {
+	  const weightA = (SEVERITY_LEVELS[a] || { weight: 0 }).weight;
+	  const weightB = (SEVERITY_LEVELS[b] || { weight: 0 }).weight;
+	  return weightA - weightB;
+	}
+	function getFailureByCode(errorCode) {
+	  return _codeToType.get(errorCode) || null;
+	}
+	agentErrors = {
+	  // Constants
+	  AGENT_FAILURE_TYPES,
+	  SEVERITY_LEVELS,
+	  // Error class
+	  AgentFailureError,
+	  // Classification
+	  classifyAgentFailure,
+	  // Recovery
+	  getRecoveryAction,
+	  isRetryable,
+	  // Utilities
+	  compareSeverity,
+	  getFailureByCode
+	};
+	return agentErrors;
+}
+
+var modelFallback;
+var hasRequiredModelFallback;
+
+function requireModelFallback () {
+	if (hasRequiredModelFallback) return modelFallback;
+	hasRequiredModelFallback = 1;
+	const fs = require$$2;
+	const path = require$$1;
+	const { MgwError } = index$1.requireErrors();
+	let classifyAgentFailure = null;
+	let _AGENT_FAILURE_TYPES = null;
+	try {
+	  const agentErrors = requireAgentErrors();
+	  classifyAgentFailure = agentErrors.classifyAgentFailure;
+	  _AGENT_FAILURE_TYPES = agentErrors.AGENT_FAILURE_TYPES;
+	} catch (_) {
+	}
+	let classifyFailure = null;
+	try {
+	  const retry = index$1.requireRetry();
+	  classifyFailure = retry.classifyFailure;
+	} catch (_) {
+	}
+	const DEFAULT_FALLBACK_CHAINS = Object.freeze({
+	  "gsd-planner": Object.freeze(["inherit", "sonnet", "haiku"]),
+	  "gsd-executor": Object.freeze(["sonnet", "haiku"]),
+	  "gsd-verifier": Object.freeze(["sonnet", "haiku"]),
+	  "gsd-plan-checker": Object.freeze(["sonnet", "haiku"]),
+	  "general-purpose": Object.freeze(["sonnet", "haiku"])
+	});
+	const NON_FALLBACK_FAILURE_TYPES = /* @__PURE__ */ new Set([
+	  "hallucination",
+	  // Unsafe — different model might hallucinate differently
+	  "permission-denied"
+	  // Environment issue — model change won't help
+	]);
+	class ModelFallbackError extends MgwError {
+	  /**
+	   * @param {string} message
+	   * @param {object} [opts]
+	   * @param {string} [opts.failureType]      - Last classified failure type
+	   * @param {string} [opts.agentType]        - GSD agent type
+	   * @param {string[]} [opts.modelsAttempted] - Models that were tried
+	   * @param {number} [opts.fallback_attempts] - Number of fallback attempts made
+	   * @param {Error}  [opts.cause]            - Last error from final model attempt
+	   * @param {string} [opts.stage]            - Pipeline stage
+	   * @param {number} [opts.issueNumber]      - Related GitHub issue number
+	   */
+	  constructor(message, opts) {
+	    const o = opts || {};
+	    super(message, {
+	      code: "MODEL_FALLBACK_EXHAUSTED",
+	      stage: o.stage,
+	      issueNumber: o.issueNumber,
+	      cause: o.cause
+	    });
+	    this.name = "ModelFallbackError";
+	    this.failureType = o.failureType || null;
+	    this.agentType = o.agentType || null;
+	    this.modelsAttempted = Array.isArray(o.modelsAttempted) ? o.modelsAttempted : [];
+	    this.fallback_attempts = typeof o.fallback_attempts === "number" ? o.fallback_attempts : 0;
+	  }
+	}
+	class ModelFallbackEngine {
+	  /**
+	   * @param {object} [opts]
+	   * @param {boolean} [opts.enabled]        - Master enable/disable switch (overrides config)
+	   * @param {object} [opts.chains]          - Per-agent-type chain overrides
+	   *   Format: { 'gsd-planner': ['inherit', 'sonnet'] }
+	   * @param {string} [opts.configPath]      - Path to .mgw/config.json (default: auto-detect)
+	   */
+	  constructor(opts) {
+	    const o = opts || {};
+	    const fileConfig = ModelFallbackEngine.loadConfig(o.configPath || null);
+	    if (typeof o.enabled === "boolean") {
+	      this._enabled = o.enabled;
+	    } else if (typeof fileConfig.enabled === "boolean") {
+	      this._enabled = fileConfig.enabled;
+	    } else {
+	      this._enabled = false;
+	    }
+	    this._chains = Object.assign(
+	      {},
+	      DEFAULT_FALLBACK_CHAINS,
+	      fileConfig.chains || {},
+	      o.chains || {}
+	    );
+	  }
+	  // -------------------------------------------------------------------------
+	  // Public API
+	  // -------------------------------------------------------------------------
+	  /**
+	   * Check whether model fallback is enabled.
+	   * @returns {boolean}
+	   */
+	  get enabled() {
+	    return this._enabled;
+	  }
+	  /**
+	   * Resolve the ordered fallback chain for an agent type.
+	   *
+	   * If model_fallback is disabled, returns an array with only the primary
+	   * model (no fallback — preserves backward-compatible behavior).
+	   *
+	   * @param {string} agentType - GSD agent type (e.g. 'gsd-planner')
+	   * @returns {string[]} Ordered model chain (first = primary, rest = fallbacks)
+	   */
+	  resolveFallbackChain(agentType) {
+	    const chain = this._chains[agentType] || this._chains["general-purpose"] || ["sonnet"];
+	    if (!this._enabled) {
+	      return [chain[0]];
+	    }
+	    return [...chain];
+	  }
+	  /**
+	   * Execute an async function with model-tier fallback.
+	   *
+	   * Takes a function that receives a model name and attempts execution
+	   * with each model in the fallback chain until one succeeds or the
+	   * chain is exhausted.
+	   *
+	   * @param {(modelName: string) => Promise<*>} fn - Async function that accepts model name
+	   * @param {object} [opts]
+	   * @param {string} [opts.agentType]    - GSD agent type for chain lookup
+	   * @param {function} [opts.onFallback] - Callback on fallback: (fromModel, toModel, attempt, error) => void
+	   * @param {AbortSignal} [opts.signal]  - AbortSignal to cancel fallback attempts
+	   * @returns {Promise<{ result: *, model: string, fallback_attempts: number, total_models_tried: number }>}
+	   * @throws {ModelFallbackError} If all models in chain are exhausted
+	   * @throws {Error} Original error if failure type is non-fallback-eligible
+	   */
+	  async executeWithFallback(fn, opts) {
+	    const o = opts || {};
+	    const agentType = o.agentType || "general-purpose";
+	    const onFallback = typeof o.onFallback === "function" ? o.onFallback : null;
+	    const signal = o.signal || null;
+	    const chain = this.resolveFallbackChain(agentType);
+	    const modelsAttempted = [];
+	    let lastError = null;
+	    let fallbackAttempts = 0;
+	    for (let i = 0; i < chain.length; i++) {
+	      const model = chain[i];
+	      if (signal && signal.aborted) {
+	        throw lastError || new MgwError("Fallback aborted by signal", { code: "FALLBACK_ABORTED" });
+	      }
+	      modelsAttempted.push(model);
+	      try {
+	        const result = await fn(model);
+	        return {
+	          result,
+	          model,
+	          fallback_attempts: fallbackAttempts,
+	          total_models_tried: modelsAttempted.length
+	        };
+	      } catch (err) {
+	        lastError = err;
+	        const failureType = this._classifyForFallback(err, agentType);
+	        if (NON_FALLBACK_FAILURE_TYPES.has(failureType)) {
+	          throw err;
+	        }
+	        if (i < chain.length - 1) {
+	          fallbackAttempts++;
+	          if (onFallback) {
+	            try {
+	              onFallback(model, chain[i + 1], fallbackAttempts, err);
+	            } catch (_) {
+	            }
+	          }
+	        }
+	      }
+	    }
+	    throw new ModelFallbackError(
+	      `Model fallback exhausted for ${agentType}: tried ${modelsAttempted.join(", ")}`,
+	      {
+	        failureType: this._classifyForFallback(lastError, agentType),
+	        agentType,
+	        modelsAttempted,
+	        fallback_attempts: fallbackAttempts,
+	        cause: lastError
+	      }
+	    );
+	  }
+	  // -------------------------------------------------------------------------
+	  // Internal: error classification for fallback decisions
+	  // -------------------------------------------------------------------------
+	  /**
+	   * Classify an error to determine if model fallback should be attempted.
+	   *
+	   * Uses agent-errors.cjs classification first (if available), then falls
+	   * back to generic retry.cjs classification.
+	   *
+	   * @param {Error} err       - The error to classify
+	   * @param {string} [agentType] - GSD agent type for context
+	   * @returns {string} Failure type key (e.g. 'timeout', 'permanent', 'transient')
+	   * @private
+	   */
+	  _classifyForFallback(err, agentType) {
+	    if (classifyAgentFailure) {
+	      const agentResult = classifyAgentFailure(err, { agentType });
+	      if (agentResult && agentResult.type) {
+	        return agentResult.type;
+	      }
+	    }
+	    if (classifyFailure) {
+	      const genericResult = classifyFailure(err);
+	      if (genericResult && genericResult.class) {
+	        if (genericResult.class === "transient") return "timeout";
+	        if (genericResult.class === "needs-info") return "needs-info";
+	        return "permanent";
+	      }
+	    }
+	    return "permanent";
+	  }
+	  // -------------------------------------------------------------------------
+	  // Static: config loading
+	  // -------------------------------------------------------------------------
+	  /**
+	   * Load model fallback configuration from .mgw/config.json.
+	   *
+	   * Looks for a `retry` section with `model_fallback` and `fallback_chains`:
+	   * ```json
+	   * {
+	   *   "retry": {
+	   *     "model_fallback": true,
+	   *     "fallback_chains": {
+	   *       "gsd-planner": ["inherit", "sonnet"],
+	   *       "gsd-executor": ["sonnet", "haiku"]
+	   *     }
+	   *   }
+	   * }
+	   * ```
+	   *
+	   * @param {string} [configPath] - Explicit path to config.json. If null,
+	   *   searches for .mgw/config.json relative to cwd.
+	   * @returns {{ enabled?: boolean, chains?: object }}
+	   */
+	  static loadConfig(configPath) {
+	    const empty = {};
+	    try {
+	      const cfgPath = configPath || path.join(process.cwd(), ".mgw", "config.json");
+	      if (!fs.existsSync(cfgPath)) return empty;
+	      const raw = fs.readFileSync(cfgPath, "utf-8");
+	      const config = JSON.parse(raw);
+	      if (!config || typeof config !== "object") return empty;
+	      const retry = config.retry;
+	      if (!retry || typeof retry !== "object") return empty;
+	      const result = {};
+	      if (typeof retry.model_fallback === "boolean") {
+	        result.enabled = retry.model_fallback;
+	      }
+	      if (retry.fallback_chains && typeof retry.fallback_chains === "object") {
+	        const chains = {};
+	        for (const [agentType, chain] of Object.entries(retry.fallback_chains)) {
+	          if (Array.isArray(chain) && chain.every((m) => typeof m === "string")) {
+	            chains[agentType] = chain;
+	          }
+	        }
+	        if (Object.keys(chains).length > 0) {
+	          result.chains = chains;
+	        }
+	      }
+	      return result;
+	    } catch (_) {
+	      return empty;
+	    }
+	  }
+	}
+	modelFallback = {
+	  // Constants
+	  DEFAULT_FALLBACK_CHAINS,
+	  NON_FALLBACK_FAILURE_TYPES,
+	  // Error class
+	  ModelFallbackError,
+	  // Engine
+	  ModelFallbackEngine
+	};
+	return modelFallback;
+}
+
 var gsdAdapter;
 var hasRequiredGsdAdapter;
 
@@ -153,24 +647,52 @@ function requireGsdAdapter () {
 	hasRequiredGsdAdapter = 1;
 	const { execSync } = require$$0;
 	const path = require$$1;
-	const os = require$$2;
-	const fs = require$$0$1;
+	const os = require$$3;
+	const fs = require$$2;
 	const { TimeoutError, GsdToolError } = index$1.requireErrors();
 	const { STAGES } = requirePipeline();
+	function resolveGsdRoot() {
+	  if (process.env.GSD_TOOLS_PATH) {
+	    return process.env.GSD_TOOLS_PATH;
+	  }
+	  const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	  if (fs.existsSync(configPath)) {
+	    try {
+	      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	      if (config.gsd_path) {
+	        return config.gsd_path;
+	      }
+	    } catch {
+	    }
+	  }
+	  return path.join(os.homedir(), ".claude", "get-shit-done");
+	}
 	function getGsdToolsPath() {
-	  const standard = path.join(
-	    os.homedir(),
-	    ".claude",
-	    "get-shit-done",
-	    "bin",
-	    "gsd-tools.cjs"
-	  );
-	  if (fs.existsSync(standard)) {
-	    return standard;
+	  const root = resolveGsdRoot();
+	  const toolPath = path.join(root, "bin", "gsd-tools.cjs");
+	  if (fs.existsSync(toolPath)) {
+	    return toolPath;
+	  }
+	  const checked = [];
+	  if (process.env.GSD_TOOLS_PATH) {
+	    checked.push(`  GSD_TOOLS_PATH: ${path.join(process.env.GSD_TOOLS_PATH, "bin", "gsd-tools.cjs")}`);
 	  }
+	  const configPath = path.join(process.cwd(), ".mgw", "config.json");
+	  if (fs.existsSync(configPath)) {
+	    try {
+	      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+	      if (config.gsd_path) {
+	        checked.push(`  .mgw/config.json gsd_path: ${path.join(config.gsd_path, "bin", "gsd-tools.cjs")}`);
+	      }
+	    } catch {
+	    }
+	  }
+	  const defaultPath = path.join(os.homedir(), ".claude", "get-shit-done", "bin", "gsd-tools.cjs");
+	  checked.push(`  default: ${defaultPath}`);
 	  throw new Error(
-	    `GSD tools not found at ${standard}.
-Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
+	    `GSD tools not found. Checked:
+${checked.join("\n")}
+Set GSD_TOOLS_PATH or add gsd_path to .mgw/config.json`
 	  );
 	}
 	const GSD_TIMEOUT_MS = 15e3;
@@ -288,7 +810,34 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  }
 	  return { activeMilestone, currentPhase, planCount };
 	}
+	let ModelFallbackEngine = null;
+	try {
+	  const modelFallback = requireModelFallback();
+	  ModelFallbackEngine = modelFallback.ModelFallbackEngine;
+	} catch (_) {
+	}
+	let _fallbackEngineSingleton = null;
+	function getModelFallbackEngine() {
+	  if (!ModelFallbackEngine) return null;
+	  if (!_fallbackEngineSingleton) {
+	    _fallbackEngineSingleton = new ModelFallbackEngine();
+	  }
+	  return _fallbackEngineSingleton;
+	}
+	function resolveFallbackChain(agentType) {
+	  const engine = getModelFallbackEngine();
+	  if (engine && engine.enabled) {
+	    return engine.resolveFallbackChain(agentType);
+	  }
+	  try {
+	    const primary = resolveModel(agentType);
+	    return [primary];
+	  } catch (_) {
+	    return ["sonnet"];
+	  }
+	}
 	gsdAdapter = {
+	  resolveGsdRoot,
 	  getGsdToolsPath,
 	  invokeGsdTool,
 	  getTimestamp,
@@ -297,7 +846,9 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  historyDigest,
 	  roadmapAnalyze,
 	  selectGsdRoute,
-	  getGsdState
+	  getGsdState,
+	  getModelFallbackEngine,
+	  resolveFallbackChain
 	};
 	return gsdAdapter;
 }
@@ -320,7 +871,7 @@ function requireTemplateLoader () {
 	if (hasRequiredTemplateLoader) return templateLoader.exports;
 	hasRequiredTemplateLoader = 1;
 	(function (module) {
-		const fs = require$$0$1;
+		const fs = require$$2;
 		const path = require$$1;
 		const VALID_GSD_ROUTES = [
 		  "quick",
@@ -626,6 +1177,21 @@ function requireTemplates () {
 	return templates;
 }
 
+var claude;
+var hasRequiredClaude;
+
+function requireClaude () {
+	if (hasRequiredClaude) return claude;
+	hasRequiredClaude = 1;
+	const provider = index$1.requireProviderClaude();
+	claude = {
+	  assertClaudeAvailable: provider.assertAvailable,
+	  invokeClaude: provider.invoke,
+	  getCommandsDir: provider.getCommandsDir
+	};
+	return claude;
+}
+
 var progress;
 var hasRequiredProgress;
 
@@ -724,6 +1290,415 @@ ${header}
 	return progress;
 }
 
+var issueContext;
+var hasRequiredIssueContext;
+
+function requireIssueContext () {
+	if (hasRequiredIssueContext) return issueContext;
+	hasRequiredIssueContext = 1;
+	const { execSync } = require$$0;
+	const fs = require$$2;
+	const path = require$$1;
+	const GH_TIMEOUT_MS = 3e4;
+	const BUDGET = {
+	  vision: 2e3,
+	  priorSummary: 500,
+	  maxPriorSummaries: 5,
+	  currentPlan: 4e3,
+	  milestone: 1e3
+	};
+	const CACHE_TTL_MINUTES = 30;
+	function run(cmd) {
+	  return execSync(cmd, {
+	    encoding: "utf-8",
+	    stdio: ["pipe", "pipe", "pipe"],
+	    timeout: GH_TIMEOUT_MS
+	  }).trim();
+	}
+	function getMgwDir() {
+	  return path.join(process.cwd(), ".mgw");
+	}
+	function getCacheDir() {
+	  const dir = path.join(getMgwDir(), "context-cache");
+	  fs.mkdirSync(dir, { recursive: true });
+	  return dir;
+	}
+	function truncate(str, maxLen) {
+	  if (!str || str.length <= maxLen) return str || "";
+	  return str.slice(0, maxLen) + "...";
+	}
+	function parseMetadata(commentBody) {
+	  const result = { type: null, phase: null, milestone: null, timestamp: null };
+	  if (!commentBody) return result;
+	  const match = commentBody.match(/<!--\s*(mgw:[^\n]*?)-->/);
+	  if (!match) return result;
+	  const header = match[1];
+	  const typeMatch = header.match(/mgw:type=(\S+)/);
+	  const phaseMatch = header.match(/mgw:phase=(\S+)/);
+	  const milestoneMatch = header.match(/mgw:milestone=(\S+)/);
+	  const timestampMatch = header.match(/mgw:timestamp=(\S+)/);
+	  if (typeMatch) result.type = typeMatch[1];
+	  if (phaseMatch) result.phase = parseInt(phaseMatch[1], 10);
+	  if (milestoneMatch) result.milestone = parseInt(milestoneMatch[1], 10);
+	  if (timestampMatch) result.timestamp = timestampMatch[1];
+	  return result;
+	}
+	function formatWithMetadata(content, meta) {
+	  const m = meta || {};
+	  const ts = m.timestamp || (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+	  const parts = [];
+	  if (m.type) parts.push(`mgw:type=${m.type}`);
+	  if (m.phase != null) parts.push(`mgw:phase=${m.phase}`);
+	  if (m.milestone != null) parts.push(`mgw:milestone=${m.milestone}`);
+	  parts.push(`mgw:timestamp=${ts}`);
+	  const header = `<!-- ${parts.join(" ")} -->`;
+	  return `${header}
+${content}`;
+	}
+	async function postPlanningComment(issueNumber, type, content, meta) {
+	  const formatted = formatWithMetadata(content, { ...meta, type });
+	  const tmpFile = path.join(require$$3.tmpdir(), `mgw-comment-${Date.now()}.md`);
+	  try {
+	    fs.writeFileSync(tmpFile, formatted, "utf-8");
+	    run(`gh issue comment ${issueNumber} --body-file ${JSON.stringify(tmpFile)}`);
+	  } finally {
+	    try {
+	      fs.unlinkSync(tmpFile);
+	    } catch (_) {
+	    }
+	  }
+	}
+	async function findPlanningComments(issueNumber, type) {
+	  const raw = run(
+	    `gh issue view ${issueNumber} --json comments --jq '.comments'`
+	  );
+	  const comments = JSON.parse(raw);
+	  const results = [];
+	  for (const c of comments) {
+	    const meta = parseMetadata(c.body);
+	    if (meta.type === type) {
+	      results.push({
+	        body: c.body,
+	        meta,
+	        createdAt: c.createdAt || ""
+	      });
+	    }
+	  }
+	  return results;
+	}
+	async function findLatestComment(issueNumber, type) {
+	  const comments = await findPlanningComments(issueNumber, type);
+	  if (comments.length === 0) return null;
+	  comments.sort((a, b) => {
+	    const tsA = a.meta.timestamp || a.createdAt || "";
+	    const tsB = b.meta.timestamp || b.createdAt || "";
+	    return tsA.localeCompare(tsB);
+	  });
+	  return comments[comments.length - 1];
+	}
+	async function assembleMilestoneContext(milestoneNum) {
+	  const cached = readCache(milestoneNum);
+	  if (cached) return Object.values(cached.summaries);
+	  const raw = run(
+	    `gh issue list --milestone ${JSON.stringify(String(milestoneNum))} --state closed --json number,title --limit 100`
+	  );
+	  const issues = JSON.parse(raw);
+	  const summaries = [];
+	  for (const issue of issues) {
+	    try {
+	      const comment = await findLatestComment(issue.number, "summary");
+	      if (comment) {
+	        const bodyWithoutHeader = comment.body.replace(/<!--[\s\S]*?-->\n?/, "").trim();
+	        summaries.push({
+	          issueNumber: issue.number,
+	          title: issue.title,
+	          summary: truncate(bodyWithoutHeader, BUDGET.priorSummary)
+	        });
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  writeCache(milestoneNum, summaries);
+	  return summaries;
+	}
+	async function assembleIssueContext(issueNumber) {
+	  const raw = run(
+	    `gh issue view ${issueNumber} --json number,title,body,milestone,labels,state`
+	  );
+	  const issue = JSON.parse(raw);
+	  let milestoneContext = [];
+	  if (issue.milestone && issue.milestone.number) {
+	    try {
+	      milestoneContext = await assembleMilestoneContext(issue.milestone.number);
+	    } catch (_) {
+	    }
+	  }
+	  let planComment = null;
+	  let summaryComment = null;
+	  try {
+	    planComment = await findLatestComment(issueNumber, "plan");
+	  } catch (_) {
+	  }
+	  try {
+	    summaryComment = await findLatestComment(issueNumber, "summary");
+	  } catch (_) {
+	  }
+	  return { issue, milestoneContext, planComment, summaryComment };
+	}
+	async function fetchProjectVision() {
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (fs.existsSync(projectJsonPath)) {
+	      const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	      const projectNumber = project.project && project.project.project_board && project.project.project_board.number || "";
+	      if (projectNumber) {
+	        const owner = run("gh repo view --json owner -q .owner.login");
+	        const readme = run(
+	          `gh project view ${projectNumber} --owner ${owner} --json readme -q .readme`
+	        );
+	        if (readme && readme.length > 10) {
+	          const visionMatch = readme.match(/##\s*Vision\s*\n([\s\S]*?)(?=\n##\s|\n$|$)/);
+	          if (visionMatch && visionMatch[1].trim()) {
+	            return visionMatch[1].trim();
+	          }
+	          const lines = readme.split("\n");
+	          const bodyLines = lines.filter((l) => !l.startsWith("# "));
+	          const body = bodyLines.join("\n").trim();
+	          if (body) return body;
+	        }
+	      }
+	    }
+	  } catch (_) {
+	  }
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (fs.existsSync(projectJsonPath)) {
+	      const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	      const description = project.project && project.project.description || "";
+	      if (description) return description;
+	      const projectName = project.project && project.project.name || "";
+	      if (projectName) return `Project: ${projectName}`;
+	    }
+	  } catch (_) {
+	  }
+	  try {
+	    const visionBriefPath = path.join(getMgwDir(), "vision-brief.json");
+	    if (fs.existsSync(visionBriefPath)) {
+	      const brief = JSON.parse(fs.readFileSync(visionBriefPath, "utf-8"));
+	      return brief.vision_summary || brief.description || "";
+	    }
+	  } catch (_) {
+	  }
+	  return "";
+	}
+	async function buildGSDPromptContext(opts) {
+	  const o = opts || {};
+	  const sections = [];
+	  if (o.includeVision) {
+	    try {
+	      const vision = await fetchProjectVision();
+	      if (vision) {
+	        sections.push(`<vision>
+${truncate(vision, BUDGET.vision)}
+</vision>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (o.milestone) {
+	    try {
+	      const milestoneRaw = run(
+	        `gh api repos/$(gh repo view --json nameWithOwner -q .nameWithOwner)/milestones/${o.milestone} --jq '{title: .title, description: .description}'`
+	      );
+	      const milestoneData = JSON.parse(milestoneRaw);
+	      const milestoneInfo = truncate(
+	        `${milestoneData.title}
+${milestoneData.description || ""}`,
+	        BUDGET.milestone
+	      );
+	      sections.push(`<milestone>
+${milestoneInfo}
+</milestone>`);
+	    } catch (_) {
+	    }
+	  }
+	  if (o.includePriorSummaries && o.milestone) {
+	    try {
+	      const summaries = await assembleMilestoneContext(o.milestone);
+	      const prior = summaries.filter((s) => o.issueNumber == null || s.issueNumber !== o.issueNumber).slice(-BUDGET.maxPriorSummaries);
+	      if (prior.length > 0) {
+	        const priorText = prior.map((s) => `### Issue #${s.issueNumber}: ${s.title}
+${s.summary}`).join("\n\n");
+	        sections.push(`<prior_phases>
+${priorText}
+</prior_phases>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (o.includeCurrentPlan && o.issueNumber) {
+	    try {
+	      const planComment = await findLatestComment(o.issueNumber, "plan");
+	      if (planComment) {
+	        const planBody = planComment.body.replace(/<!--[\s\S]*?-->\n?/, "").trim();
+	        sections.push(`<current_phase>
+${truncate(planBody, BUDGET.currentPlan)}
+</current_phase>`);
+	      }
+	    } catch (_) {
+	    }
+	  }
+	  if (sections.length === 0) return "";
+	  return `<mgw_context>
+
+${sections.join("\n\n")}
+
+</mgw_context>`;
+	}
+	async function safeContext(opts) {
+	  try {
+	    return await buildGSDPromptContext(opts);
+	  } catch (_) {
+	    return "";
+	  }
+	}
+	function readCache(milestoneNum) {
+	  try {
+	    const cachePath = path.join(getCacheDir(), `milestone-${milestoneNum}.json`);
+	    if (!fs.existsSync(cachePath)) return null;
+	    const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+	    const cachedAt = new Date(data.cached_at);
+	    const now = /* @__PURE__ */ new Date();
+	    const ageMinutes = (now - cachedAt) / (1e3 * 60);
+	    if (ageMinutes > (data.ttl_minutes || CACHE_TTL_MINUTES)) return null;
+	    return data;
+	  } catch (_) {
+	    return null;
+	  }
+	}
+	function writeCache(milestoneNum, summaries) {
+	  try {
+	    const cachePath = path.join(getCacheDir(), `milestone-${milestoneNum}.json`);
+	    const summaryMap = {};
+	    for (const s of summaries) {
+	      summaryMap[String(s.issueNumber)] = s;
+	    }
+	    const data = {
+	      milestone: Number(milestoneNum),
+	      cached_at: (/* @__PURE__ */ new Date()).toISOString(),
+	      ttl_minutes: CACHE_TTL_MINUTES,
+	      summaries: summaryMap
+	    };
+	    fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+	  } catch (_) {
+	  }
+	}
+	async function rebuildContextCache() {
+	  const cacheDir = getCacheDir();
+	  try {
+	    const files = fs.readdirSync(cacheDir);
+	    for (const f of files) {
+	      if (f.startsWith("milestone-") && f.endsWith(".json")) {
+	        fs.unlinkSync(path.join(cacheDir, f));
+	      }
+	    }
+	  } catch (_) {
+	  }
+	  let milestones;
+	  try {
+	    const repo = run("gh repo view --json nameWithOwner -q .nameWithOwner");
+	    const raw = run(`gh api repos/${repo}/milestones?state=all --jq '.[].number'`);
+	    milestones = raw.split("\n").filter(Boolean).map(Number);
+	  } catch (_) {
+	    milestones = [];
+	  }
+	  let totalIssues = 0;
+	  for (const num of milestones) {
+	    try {
+	      const summaries = await assembleMilestoneContext(num);
+	      totalIssues += summaries.length;
+	    } catch (_) {
+	    }
+	  }
+	  return { issueCount: totalIssues, milestoneCount: milestones.length };
+	}
+	async function updateProjectReadme() {
+	  try {
+	    const projectJsonPath = path.join(getMgwDir(), "project.json");
+	    if (!fs.existsSync(projectJsonPath)) return false;
+	    const project = JSON.parse(fs.readFileSync(projectJsonPath, "utf-8"));
+	    const board = project.project && project.project.project_board || {};
+	    const projectNumber = board.number;
+	    if (!projectNumber) return false;
+	    const owner = run("gh repo view --json owner -q .owner.login");
+	    const projectName = project.project && project.project.name || "";
+	    let visionSummary = "";
+	    try {
+	      const visionBriefPath = path.join(getMgwDir(), "vision-brief.json");
+	      if (fs.existsSync(visionBriefPath)) {
+	        const brief = JSON.parse(fs.readFileSync(visionBriefPath, "utf-8"));
+	        visionSummary = (brief.vision_summary || brief.description || "").slice(0, 500);
+	      }
+	    } catch (_) {
+	    }
+	    if (!visionSummary) {
+	      visionSummary = project.project && project.project.description || "Project initialized via MGW.";
+	    }
+	    const milestones = project.milestones || [];
+	    const tableLines = ["| # | Milestone | Issues | Status |", "|---|-----------|--------|--------|"];
+	    for (let i = 0; i < milestones.length; i++) {
+	      const m = milestones[i];
+	      const name = m.name || m.title || "Unnamed";
+	      const count = (m.issues || []).length;
+	      const doneCount = (m.issues || []).filter((iss) => iss.pipeline_stage === "done").length;
+	      const state = m.gsd_state || "planned";
+	      const progress = count > 0 ? ` (${doneCount}/${count})` : "";
+	      const stateLabel = state.charAt(0).toUpperCase() + state.slice(1);
+	      tableLines.push(`| ${i + 1} | ${name} | ${count}${progress} | ${stateLabel} |`);
+	    }
+	    const boardUrl = board.url || "";
+	    const readmeBody = `# ${projectName}
+
+## Vision
+${visionSummary}
+
+## Milestones
+${tableLines.join("\n")}
+
+## Links
+- [Board](${boardUrl})`;
+	    const tmpFile = path.join(require("os").tmpdir(), `mgw-readme-${Date.now()}.md`);
+	    try {
+	      fs.writeFileSync(tmpFile, readmeBody, "utf-8");
+	      run(`gh project edit ${projectNumber} --owner ${owner} --readme "$(cat ${JSON.stringify(tmpFile)})"`);
+	    } finally {
+	      try {
+	        fs.unlinkSync(tmpFile);
+	      } catch (_) {
+	      }
+	    }
+	    return true;
+	  } catch (_) {
+	    return false;
+	  }
+	}
+	issueContext = {
+	  parseMetadata,
+	  formatWithMetadata,
+	  postPlanningComment,
+	  findPlanningComments,
+	  findLatestComment,
+	  assembleMilestoneContext,
+	  assembleIssueContext,
+	  buildGSDPromptContext,
+	  safeContext,
+	  rebuildContextCache,
+	  fetchProjectVision,
+	  updateProjectReadme
+	};
+	return issueContext;
+}
+
 var lib;
 var hasRequiredLib;
 
@@ -737,13 +1712,15 @@ function requireLib () {
 	  ...requireGsdAdapter(),
 	  ...requireTemplates(),
 	  ...index$1.requireOutput(),
-	  ...index$1.requireClaude(),
+	  ...requireClaude(),
+	  ...index$1.requireProviderManager(),
 	  ...index$1.requireRetry(),
 	  ...index$1.requireSpinner(),
 	  ...requireProgress(),
 	  ...requirePipeline(),
 	  ...index$1.requireErrors(),
-	  ...index$1.requireLogger()
+	  ...index$1.requireLogger(),
+	  ...requireIssueContext()
 	};
 	Object.defineProperty(_exports, "createIssuesBrowser", {
 	  configurable: true,