@snipcodeit/mgw 0.2.2 → 0.4.0

package/dist/lib/index.cjs

@@ -1,12 +1,150 @@
 'use strict';
 
-var index$1 = require('../index-BiwU0uWA.cjs');
+var index$1 = require('../index-B-_JvYpz.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;
+var hasRequiredPipeline;
+
+function requirePipeline () {
+	if (hasRequiredPipeline) return pipeline;
+	hasRequiredPipeline = 1;
+	const STAGES = {
+	  NEW: "new",
+	  TRIAGED: "triaged",
+	  NEEDS_INFO: "needs-info",
+	  NEEDS_SECURITY_REVIEW: "needs-security-review",
+	  DISCUSSING: "discussing",
+	  APPROVED: "approved",
+	  PLANNING: "planning",
+	  DIAGNOSING: "diagnosing",
+	  EXECUTING: "executing",
+	  VERIFYING: "verifying",
+	  PR_CREATED: "pr-created",
+	  DONE: "done",
+	  FAILED: "failed",
+	  BLOCKED: "blocked"
+	};
+	const STAGE_SET = new Set(Object.values(STAGES));
+	const VALID_TRANSITIONS = {
+	  [STAGES.NEW]: [STAGES.TRIAGED],
+	  [STAGES.TRIAGED]: [STAGES.NEEDS_INFO, STAGES.NEEDS_SECURITY_REVIEW, STAGES.DISCUSSING, STAGES.APPROVED, STAGES.PLANNING, STAGES.DIAGNOSING],
+	  [STAGES.NEEDS_INFO]: [STAGES.TRIAGED],
+	  [STAGES.NEEDS_SECURITY_REVIEW]: [STAGES.TRIAGED, STAGES.APPROVED],
+	  [STAGES.DISCUSSING]: [STAGES.TRIAGED, STAGES.APPROVED],
+	  [STAGES.APPROVED]: [STAGES.PLANNING],
+	  [STAGES.PLANNING]: [STAGES.EXECUTING],
+	  [STAGES.DIAGNOSING]: [STAGES.PLANNING],
+	  [STAGES.EXECUTING]: [STAGES.VERIFYING],
+	  [STAGES.VERIFYING]: [STAGES.PR_CREATED, STAGES.EXECUTING],
+	  [STAGES.PR_CREATED]: [STAGES.DONE],
+	  [STAGES.DONE]: [],
+	  [STAGES.FAILED]: [STAGES.NEW, STAGES.TRIAGED, STAGES.PLANNING, STAGES.EXECUTING],
+	  [STAGES.BLOCKED]: [STAGES.NEW, STAGES.TRIAGED, STAGES.PLANNING, STAGES.EXECUTING]
+	};
+	for (const stage of Object.keys(VALID_TRANSITIONS)) {
+	  if (stage !== STAGES.DONE && stage !== STAGES.FAILED && stage !== STAGES.BLOCKED) {
+	    VALID_TRANSITIONS[stage].push(STAGES.FAILED, STAGES.BLOCKED);
+	  }
+	}
+	const STAGE_ICONS = {
+	  [STAGES.NEW]: "\u25CB",
+	  [STAGES.TRIAGED]: "\u25C7",
+	  [STAGES.NEEDS_INFO]: "?",
+	  [STAGES.NEEDS_SECURITY_REVIEW]: "\u2691",
+	  [STAGES.DISCUSSING]: "\u{1F4AC}",
+	  [STAGES.APPROVED]: "\u2714",
+	  [STAGES.PLANNING]: "\u25C6",
+	  [STAGES.DIAGNOSING]: "\u{1F50D}",
+	  [STAGES.EXECUTING]: "\u25C6",
+	  [STAGES.VERIFYING]: "\u25C6",
+	  [STAGES.PR_CREATED]: "\u2713",
+	  [STAGES.DONE]: "\u2713",
+	  [STAGES.FAILED]: "\u2717",
+	  [STAGES.BLOCKED]: "\u2298"
+	};
+	const STAGE_LABELS = {
+	  [STAGES.NEW]: "New",
+	  [STAGES.TRIAGED]: "Triaged",
+	  [STAGES.NEEDS_INFO]: "Needs Info",
+	  [STAGES.NEEDS_SECURITY_REVIEW]: "Needs Security Review",
+	  [STAGES.DISCUSSING]: "Discussing",
+	  [STAGES.APPROVED]: "Approved",
+	  [STAGES.PLANNING]: "Planning",
+	  [STAGES.DIAGNOSING]: "Diagnosing",
+	  [STAGES.EXECUTING]: "Executing",
+	  [STAGES.VERIFYING]: "Verifying",
+	  [STAGES.PR_CREATED]: "PR Created",
+	  [STAGES.DONE]: "Done",
+	  [STAGES.FAILED]: "Failed",
+	  [STAGES.BLOCKED]: "Blocked"
+	};
+	function isValidStage(stage) {
+	  return STAGE_SET.has(stage);
+	}
+	function isValidTransition(from, to) {
+	  if (!isValidStage(from) || !isValidStage(to)) return false;
+	  const allowed = VALID_TRANSITIONS[from];
+	  return Array.isArray(allowed) && allowed.includes(to);
+	}
+	const _hooks = [];
+	function onTransition(fn) {
+	  _hooks.push(fn);
+	  return () => {
+	    const idx = _hooks.indexOf(fn);
+	    if (idx !== -1) _hooks.splice(idx, 1);
+	  };
+	}
+	function transitionStage(issueState, newStage, context) {
+	  const currentStage = issueState && issueState.pipeline_stage || STAGES.NEW;
+	  if (!isValidStage(newStage)) {
+	    throw new Error(`Invalid target stage: "${newStage}"`);
+	  }
+	  if (currentStage === newStage) {
+	    throw new Error(`Already at stage "${newStage}" \u2014 self-transitions are not allowed`);
+	  }
+	  if (!isValidTransition(currentStage, newStage)) {
+	    throw new Error(
+	      `Invalid transition: "${currentStage}" \u2192 "${newStage}". Allowed targets: [${(VALID_TRANSITIONS[currentStage] || []).join(", ")}]`
+	    );
+	  }
+	  const newState = Object.assign({}, issueState, {
+	    pipeline_stage: newStage,
+	    last_transition: (/* @__PURE__ */ new Date()).toISOString(),
+	    previous_stage: currentStage
+	  });
+	  const ctx = context || {};
+	  for (const hook of _hooks) {
+	    try {
+	      hook(currentStage, newStage, ctx);
+	    } catch (err) {
+	      process.stderr.write(`[pipeline] hook error: ${err.message}
+`);
+	    }
+	  }
+	  return newState;
+	}
+	function clearHooks() {
+	  _hooks.length = 0;
+	}
+	pipeline = {
+	  STAGES,
+	  VALID_TRANSITIONS,
+	  STAGE_ICONS,
+	  STAGE_LABELS,
+	  isValidStage,
+	  isValidTransition,
+	  transitionStage,
+	  onTransition,
+	  clearHooks
+	};
+	return pipeline;
+}
+
 var gsdAdapter;
 var hasRequiredGsdAdapter;
 
@@ -15,24 +153,55 @@ 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;
 	function invokeGsdTool(command, args) {
 	  const toolPath = getGsdToolsPath();
 	  const argsStr = Array.isArray(args) ? args.map((a) => JSON.stringify(String(a))).join(" ") : "";
@@ -41,13 +210,21 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  try {
 	    raw = execSync(cmd, {
 	      encoding: "utf-8",
-	      stdio: ["pipe", "pipe", "pipe"]
+	      stdio: ["pipe", "pipe", "pipe"],
+	      timeout: GSD_TIMEOUT_MS
 	    }).trim();
 	  } catch (err) {
+	    if (err.killed) {
+	      throw new TimeoutError(
+	        `GSD tool timed out after ${GSD_TIMEOUT_MS / 1e3}s: ${command}`,
+	        { timeoutMs: GSD_TIMEOUT_MS, operation: `gsd-tools ${command}` }
+	      );
+	    }
 	    const stderr = err.stderr ? err.stderr.trim() : "";
-	    throw new Error(
+	    throw new GsdToolError(
 	      `GSD tool command failed: ${command}
-` + (stderr ? `stderr: ${stderr}` : `exit code: ${err.status}`)
+` + (stderr ? `stderr: ${stderr}` : `exit code: ${err.status}`),
+	      { command, cause: err }
 	    );
 	  }
 	  if (!raw) return null;
@@ -89,13 +266,13 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  if (/gsd-route:diagnose|needs-diagnosis/.test(labelStr)) {
 	    return "diagnose";
 	  }
-	  if (stage === "diagnosing") {
+	  if (stage === STAGES.DIAGNOSING) {
 	    return "diagnose";
 	  }
-	  if (stage === "executing") {
+	  if (stage === STAGES.EXECUTING) {
 	    return "execute-only";
 	  }
-	  if (stage === "verifying") {
+	  if (stage === STAGES.VERIFYING) {
 	    return "verify-only";
 	  }
 	  if (projectState && projectState.milestones) ;
@@ -140,6 +317,7 @@ Ensure the get-shit-done framework is installed at ~/.claude/get-shit-done/`
 	  return { activeMilestone, currentPhase, planCount };
 	}
 	gsdAdapter = {
+	  resolveGsdRoot,
 	  getGsdToolsPath,
 	  invokeGsdTool,
 	  getTimestamp,
@@ -171,7 +349,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",
@@ -344,15 +522,15 @@ Checked: ` + path.join(__dirname, "..", "templates") + "\nChecked: " + path.join
 		    const nextMatch = nextSectionMatch.exec(content);
 		    const sectionEnd = nextMatch ? nextMatch.index : content.length;
 		    const sectionText = content.slice(sectionStart, sectionEnd);
-		    const goalMatch = sectionText.match(/\*\*Goal[:\*]*\*?\*?[:\s]+([^\n]+)/);
+		    const goalMatch = sectionText.match(/\*\*Goal[:*]*\*?\*?[:\s]+([^\n]+)/);
 		    const goal = goalMatch ? goalMatch[1].trim().replace(/\*+$/, "") : "";
-		    const reqMatch = sectionText.match(/\*\*Requirements?[:\*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
+		    const reqMatch = sectionText.match(/\*\*Requirements?[:*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
 		    let requirements = [];
 		    if (reqMatch) {
 		      const reqText = reqMatch[1].trim();
 		      requirements = reqText.split(/[,\n]+/).map((r) => r.trim().replace(/^[-*\s]+/, "").trim()).filter((r) => r.length > 0);
 		    }
-		    const scMatch = sectionText.match(/\*\*Success Criteria[:\*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
+		    const scMatch = sectionText.match(/\*\*Success Criteria[:*]*\*?\*?[:\s]+([\s\S]*?)(?=\n\*\*|\n###|$)/);
 		    let success_criteria = [];
 		    if (scMatch) {
 		      const scText = scMatch[1];
@@ -477,122 +655,19 @@ function requireTemplates () {
 	return templates;
 }
 
-var retry;
-var hasRequiredRetry;
+var claude;
+var hasRequiredClaude;
 
-function requireRetry () {
-	if (hasRequiredRetry) return retry;
-	hasRequiredRetry = 1;
-	const MAX_RETRIES = 3;
-	const BACKOFF_BASE_MS = 5e3;
-	const BACKOFF_MAX_MS = 3e5;
-	const TRANSIENT_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-	const TRANSIENT_MESSAGE_PATTERNS = [
-	  "network timeout",
-	  "econnreset",
-	  "econnrefused",
-	  "etimedout",
-	  "socket hang up",
-	  "worktree lock",
-	  "model overload",
-	  "rate limit",
-	  "too many requests",
-	  "service unavailable",
-	  "bad gateway",
-	  "gateway timeout"
-	];
-	const NEEDS_INFO_MESSAGE_PATTERNS = [
-	  "ambiguous",
-	  "missing required field",
-	  "contradictory requirements",
-	  "issue body"
-	];
-	function classifyFailure(error) {
-	  if (!error || typeof error !== "object") {
-	    return { class: "permanent", reason: "no error object provided" };
-	  }
-	  const status = error.status;
-	  const message = (error.message || "").toLowerCase();
-	  const code = (error.code || "").toLowerCase();
-	  if (typeof status === "number") {
-	    if (status === 429) {
-	      return { class: "transient", reason: "rate limit (HTTP 429)" };
-	    }
-	    if (TRANSIENT_STATUS_CODES.has(status)) {
-	      return { class: "transient", reason: `server error (HTTP ${status})` };
-	    }
-	    if (status === 403) {
-	      return { class: "permanent", reason: "forbidden (HTTP 403 \u2014 non-rate-limit)" };
-	    }
-	    if (status >= 400 && status < 500) {
-	      return { class: "permanent", reason: `client error (HTTP ${status})` };
-	    }
-	  }
-	  if (code) {
-	    const networkCodes = /* @__PURE__ */ new Set([
-	      "econnreset",
-	      "econnrefused",
-	      "etimedout",
-	      "enotfound",
-	      "epipe"
-	    ]);
-	    if (networkCodes.has(code)) {
-	      return { class: "transient", reason: `network error (${code.toUpperCase()})` };
-	    }
-	    if (code === "enoent") {
-	      return { class: "permanent", reason: "file not found (ENOENT) \u2014 GSD tools may be missing" };
-	    }
-	  }
-	  for (const pattern of TRANSIENT_MESSAGE_PATTERNS) {
-	    if (message.includes(pattern)) {
-	      return { class: "transient", reason: `transient condition detected: "${pattern}"` };
-	    }
-	  }
-	  for (const pattern of NEEDS_INFO_MESSAGE_PATTERNS) {
-	    if (message.includes(pattern)) {
-	      return { class: "needs-info", reason: `issue requires clarification: "${pattern}"` };
-	    }
-	  }
-	  return {
-	    class: "permanent",
-	    reason: "unknown error \u2014 classified as permanent to prevent runaway retries"
-	  };
-	}
-	function canRetry(issueState) {
-	  if (!issueState || typeof issueState !== "object") return false;
-	  if (issueState.dead_letter === true) return false;
-	  const count = typeof issueState.retry_count === "number" ? issueState.retry_count : 0;
-	  return count < MAX_RETRIES;
-	}
-	function incrementRetry(issueState) {
-	  const current = typeof issueState.retry_count === "number" ? issueState.retry_count : 0;
-	  return Object.assign({}, issueState, { retry_count: current + 1 });
-	}
-	function resetRetryState(issueState) {
-	  return Object.assign({}, issueState, {
-	    retry_count: 0,
-	    last_failure_class: null,
-	    dead_letter: false
-	  });
-	}
-	function getBackoffMs(retryCount) {
-	  const count = Math.max(0, Math.floor(retryCount));
-	  const base = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * Math.pow(2, count));
-	  return Math.floor(Math.random() * (base + 1));
-	}
-	retry = {
-	  // Constants
-	  MAX_RETRIES,
-	  BACKOFF_BASE_MS,
-	  BACKOFF_MAX_MS,
-	  // Core functions
-	  classifyFailure,
-	  canRetry,
-	  incrementRetry,
-	  resetRetryState,
-	  getBackoffMs
+function requireClaude () {
+	if (hasRequiredClaude) return claude;
+	hasRequiredClaude = 1;
+	const provider = index$1.requireProviderClaude();
+	claude = {
+	  assertClaudeAvailable: provider.assertAvailable,
+	  invokeClaude: provider.invoke,
+	  getCommandsDir: provider.getCommandsDir
 	};
-	return retry;
+	return claude;
 }
 
 var progress;
@@ -601,7 +676,8 @@ var hasRequiredProgress;
 function requireProgress () {
 	if (hasRequiredProgress) return progress;
 	hasRequiredProgress = 1;
-	const { IS_TTY, IS_CI, USE_COLOR } = index$1.requireOutput();
+	const { USE_COLOR } = index$1.requireOutput();
+	const { STAGES } = requirePipeline();
 	const SUPPORTS_COLOR = USE_COLOR;
 	const C = {
 	  reset: "\x1B[0m",
@@ -646,16 +722,16 @@ function requireProgress () {
 	}
 	function stageIcon(stage) {
 	  switch (stage) {
-	    case "done":
-	    case "pr-created":
+	    case STAGES.DONE:
+	    case STAGES.PR_CREATED:
 	      return { icon: "\u2713", colored: col(C.green, "\u2713") };
-	    case "executing":
-	    case "planning":
-	    case "verifying":
+	    case STAGES.EXECUTING:
+	    case STAGES.PLANNING:
+	    case STAGES.VERIFYING:
 	      return { icon: "\u25C6", colored: col(C.blue, "\u25C6") };
-	    case "failed":
+	    case STAGES.FAILED:
 	      return { icon: "\u2717", colored: col(C.red, "\u2717") };
-	    case "blocked":
+	    case STAGES.BLOCKED:
 	      return { icon: "\u2298", colored: col(C.yellow, "\u2298") };
 	    default:
 	      return { icon: "\u25CB", colored: col(C.dim, "\u25CB") };
@@ -673,8 +749,8 @@ ${header}
 `);
 	  if (issues && issues.length > 0) {
 	    const parts = issues.map(({ number, pipeline_stage }) => {
-	      const s = number === currentIssue && pipeline_stage !== "done" ? "executing" : pipeline_stage || "new";
-	      const { colored, icon } = stageIcon(s);
+	      const s = number === currentIssue && pipeline_stage !== STAGES.DONE ? STAGES.EXECUTING : pipeline_stage || STAGES.NEW;
+	      const { colored } = stageIcon(s);
 	      const numStr = SUPPORTS_COLOR ? `${C.dim}#${number}${C.reset}` : `#${number}`;
 	      return `${numStr}${colored}`;
 	    });
@@ -692,25 +768,448 @@ ${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;
 
 function requireLib () {
 	if (hasRequiredLib) return lib;
 	hasRequiredLib = 1;
-	lib = {
+	const _exports = {
 	  ...index$1.requireState(),
 	  ...index$1.requireGithub(),
 	  ...requireGsd(),
 	  ...requireGsdAdapter(),
 	  ...requireTemplates(),
 	  ...index$1.requireOutput(),
-	  ...index$1.requireClaude(),
-	  ...requireRetry(),
+	  ...requireClaude(),
+	  ...index$1.requireProviderManager(),
+	  ...index$1.requireRetry(),
 	  ...index$1.requireSpinner(),
 	  ...requireProgress(),
-	  ...index$1.requireTui()
+	  ...requirePipeline(),
+	  ...index$1.requireErrors(),
+	  ...index$1.requireLogger(),
+	  ...requireIssueContext()
 	};
+	Object.defineProperty(_exports, "createIssuesBrowser", {
+	  configurable: true,
+	  enumerable: true,
+	  get() {
+	    const value = index$1.requireTui().createIssuesBrowser;
+	    Object.defineProperty(_exports, "createIssuesBrowser", { value, enumerable: true });
+	    return value;
+	  }
+	});
+	lib = _exports;
 	return lib;
 }
 
@@ -718,4 +1217,3 @@ var libExports = requireLib();
 var index = /*@__PURE__*/index$1.getDefaultExportFromCjs(libExports);
 
 module.exports = index;
-0&&(module.exports={getMgwDir,getActiveDir,getCompletedDir,loadProjectState,writeProjectState,loadActiveIssue,mergeProjectState,migrateProjectState,resolveActiveMilestoneIndex,getRepo,getIssue,listIssues,getMilestone,getRateLimit,closeMilestone,createRelease,getProjectNodeId,findExistingBoard,getProjectFields,createProject,addItemToProject,postMilestoneStartAnnouncement,getGsdToolsPath,invokeGsdTool,getTimestamp,generateSlug,resolveModel,historyDigest,roadmapAnalyze,selectGsdRoute,getGsdState,validate,getSchema,VALID_GSD_ROUTES,IS_TTY,IS_CI,USE_COLOR,COLORS,colorize,statusLine,log,error,verbose,debug,formatJson,assertClaudeAvailable,invokeClaude,getCommandsDir,MAX_RETRIES,BACKOFF_BASE_MS,BACKOFF_MAX_MS,classifyFailure,canRetry,incrementRetry,resetRetryState,getBackoffMs,createSpinner,withSpinner,SUPPORTS_SPINNER,renderProgressBar,printMilestoneProgress,stageIcon,SUPPORTS_COLOR,createIssuesBrowser});