gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.9bafd68

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -0,0 +1,111 @@
+/**
+ * GSD Milestone Actions — Park, Unpark, and Discard operations.
+ *
+ * Park: Creates a PARKED.md marker file. deriveState() skips parked milestones
+ * when finding the active milestone, but keeps them in the registry.
+ *
+ * Unpark: Removes the PARKED.md marker. The milestone resumes normal state
+ * derivation (active/pending depending on position and dependencies).
+ *
+ * Discard: Permanently removes the milestone directory. Also prunes
+ * QUEUE-ORDER.json if the discarded milestone was in it.
+ */
+import { existsSync, rmSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
+import { invalidateAllCaches } from "./cache.js";
+import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
+// ─── Park ──────────────────────────────────────────────────────────────────
+/**
+ * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
+ * Parked milestones are skipped during active-milestone discovery but stay on disk.
+ * Returns true if successfully parked, false if milestone not found or already parked.
+ */
+export function parkMilestone(basePath, milestoneId, reason) {
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (!mDir || !existsSync(mDir))
+        return false;
+    // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
+    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+    if (summaryFile)
+        return false;
+    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
+    if (existsSync(parkedPath))
+        return false; // already parked
+    const content = [
+        "---",
+        `parked_at: ${new Date().toISOString()}`,
+        `reason: "${reason.replace(/"/g, '\\"')}"`,
+        "---",
+        "",
+        `# ${milestoneId} — Parked`,
+        "",
+        `> ${reason}`,
+        "",
+    ].join("\n");
+    writeFileSync(parkedPath, content, "utf-8");
+    invalidateAllCaches();
+    return true;
+}
+// ─── Unpark ────────────────────────────────────────────────────────────────
+/**
+ * Unpark a milestone — removes the PARKED.md marker file.
+ * Returns true if successfully unparked, false if milestone not found or not parked.
+ */
+export function unparkMilestone(basePath, milestoneId) {
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (!mDir || !existsSync(mDir))
+        return false;
+    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
+    if (!existsSync(parkedPath))
+        return false; // not parked
+    unlinkSync(parkedPath);
+    invalidateAllCaches();
+    return true;
+}
+// ─── Discard ───────────────────────────────────────────────────────────────
+/**
+ * Discard a milestone — permanently removes the milestone directory and
+ * prunes it from QUEUE-ORDER.json if present.
+ * Returns true if successfully discarded, false if milestone not found.
+ */
+export function discardMilestone(basePath, milestoneId) {
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (!mDir || !existsSync(mDir))
+        return false;
+    rmSync(mDir, { recursive: true, force: true });
+    // Prune from queue order if present
+    const order = loadQueueOrder(basePath);
+    if (order && order.includes(milestoneId)) {
+        saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
+    }
+    invalidateAllCaches();
+    return true;
+}
+// ─── Query ─────────────────────────────────────────────────────────────────
+/**
+ * Check whether a milestone is parked (PARKED.md exists).
+ */
+export function isParked(basePath, milestoneId) {
+    return !!resolveMilestoneFile(basePath, milestoneId, "PARKED");
+}
+/**
+ * Read the park reason from PARKED.md frontmatter.
+ * Returns null if the milestone is not parked or the reason can't be extracted.
+ */
+export function getParkedReason(basePath, milestoneId) {
+    const parkedFile = resolveMilestoneFile(basePath, milestoneId, "PARKED");
+    if (!parkedFile)
+        return null;
+    try {
+        const content = readFileSync(parkedFile, "utf-8");
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match)
+            return null;
+        const reasonMatch = match[1].match(/reason:\s*"([^"]*?)"/);
+        return reasonMatch ? reasonMatch[1] : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/{milestone-ids.ts → milestone-ids.js}

@@ -4,93 +4,80 @@
  *
  * Consumed by 15+ modules across the GSD extension. Zero side-effects.
  */
-
 import { randomInt } from "node:crypto";
 import { readdirSync, existsSync } from "node:fs";
 import { milestonesDir } from "./paths.js";
 import { loadQueueOrder, sortByQueueOrder } from "./queue-order.js";
 import { getErrorMessage } from "./error-utils.js";
-
 // ─── Regex ──────────────────────────────────────────────────────────────────
-
 /** Matches both classic `M001` and unique `M001-abc123` formats (anchored). */
 export const MILESTONE_ID_RE = /^M\d{3}(?:-[a-z0-9]{6})?$/;
-
 // ─── Parsing & Extraction ───────────────────────────────────────────────────
-
 /** Extract the trailing sequential number from a milestone ID. Returns 0 for non-matches. */
-export function extractMilestoneSeq(id: string): number {
-  const m = id.match(/^M(\d{3})(?:-[a-z0-9]{6})?$/);
-  return m ? parseInt(m[1], 10) : 0;
+export function extractMilestoneSeq(id) {
+    const m = id.match(/^M(\d{3})(?:-[a-z0-9]{6})?$/);
+    return m ? parseInt(m[1], 10) : 0;
 }
-
 /** Structured parse of a milestone ID into optional suffix and sequence number. */
-export function parseMilestoneId(id: string): { suffix?: string; num: number } {
-  const m = id.match(/^M(\d{3})(?:-([a-z0-9]{6}))?$/);
-  if (!m) return { num: 0 };
-  return {
-    ...(m[2] ? { suffix: m[2] } : {}),
-    num: parseInt(m[1], 10),
-  };
+export function parseMilestoneId(id) {
+    const m = id.match(/^M(\d{3})(?:-([a-z0-9]{6}))?$/);
+    if (!m)
+        return { num: 0 };
+    return {
+        ...(m[2] ? { suffix: m[2] } : {}),
+        num: parseInt(m[1], 10),
+    };
 }
-
 // ─── Sorting ────────────────────────────────────────────────────────────────
-
 /** Comparator for sorting milestone IDs by sequential number. */
-export function milestoneIdSort(a: string, b: string): number {
-  return extractMilestoneSeq(a) - extractMilestoneSeq(b);
+export function milestoneIdSort(a, b) {
+    return extractMilestoneSeq(a) - extractMilestoneSeq(b);
 }
-
 // ─── Generation ─────────────────────────────────────────────────────────────
-
 /** Generate a 6-char lowercase `[a-z0-9]` suffix using crypto.randomInt(). */
-export function generateMilestoneSuffix(): string {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < 6; i++) {
-    result += chars[randomInt(36)];
-  }
-  return result;
+export function generateMilestoneSuffix() {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < 6; i++) {
+        result += chars[randomInt(36)];
+    }
+    return result;
 }
-
 /** Return the highest numeric suffix among milestone IDs (0 when the list is empty or has no numeric IDs). */
-export function maxMilestoneNum(milestoneIds: string[]): number {
-  return milestoneIds.reduce((max, id) => {
-    const num = extractMilestoneSeq(id);
-    return num > max ? num : max;
-  }, 0);
+export function maxMilestoneNum(milestoneIds) {
+    return milestoneIds.reduce((max, id) => {
+        const num = extractMilestoneSeq(id);
+        return num > max ? num : max;
+    }, 0);
 }
-
 /** Derive the next milestone ID from existing IDs using max-based approach to avoid collisions after deletions. */
-export function nextMilestoneId(milestoneIds: string[], uniqueEnabled?: boolean): string {
-  const seq = String(maxMilestoneNum(milestoneIds) + 1).padStart(3, "0");
-  if (uniqueEnabled) {
-    return `M${seq}-${generateMilestoneSuffix()}`;
-  }
-  return `M${seq}`;
+export function nextMilestoneId(milestoneIds, uniqueEnabled) {
+    const seq = String(maxMilestoneNum(milestoneIds) + 1).padStart(3, "0");
+    if (uniqueEnabled) {
+        return `M${seq}-${generateMilestoneSuffix()}`;
+    }
+    return `M${seq}`;
 }
-
 // ─── Discovery ──────────────────────────────────────────────────────────────
-
 /** Scan the milestones directory and return IDs sorted by queue order (or numeric fallback). */
-export function findMilestoneIds(basePath: string): string[] {
-  const dir = milestonesDir(basePath);
-  try {
-    const ids = readdirSync(dir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => {
-        const match = d.name.match(/^(M\d+(?:-[a-z0-9]{6})?)/);
-        return match ? match[1] : d.name;
-      });
-
-    // Apply custom queue order if available, else fall back to numeric sort
-    const customOrder = loadQueueOrder(basePath);
-    return sortByQueueOrder(ids, customOrder);
-  } catch (err) {
-    // Log why milestone scanning failed — silent [] here causes infinite loops (#456)
-    if (existsSync(dir)) {
-      console.error(`[gsd] findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
+export function findMilestoneIds(basePath) {
+    const dir = milestonesDir(basePath);
+    try {
+        const ids = readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => {
+            const match = d.name.match(/^(M\d+(?:-[a-z0-9]{6})?)/);
+            return match ? match[1] : d.name;
+        });
+        // Apply custom queue order if available, else fall back to numeric sort
+        const customOrder = loadQueueOrder(basePath);
+        return sortByQueueOrder(ids, customOrder);
+    }
+    catch (err) {
+        // Log why milestone scanning failed — silent [] here causes infinite loops (#456)
+        if (existsSync(dir)) {
+            console.error(`[gsd] findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
+        }
+        return [];
     }
-    return [];
-  }
 }

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -0,0 +1,48 @@
+// GSD Extension — Model Cost Table
+// Static cost reference for known models, used by the dynamic router
+// for cross-provider cost comparison.
+//
+// Costs are approximate per-1K-token rates in USD (input tokens).
+// Updated with GSD releases. Users can override via preferences.
+/**
+ * Bundled cost table for known models.
+ * Updated periodically with GSD releases.
+ */
+export const BUNDLED_COST_TABLE = [
+    // Anthropic
+    { id: "claude-opus-4-6", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
+    { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+    { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
+    { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+    { id: "claude-3-5-sonnet-latest", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+    { id: "claude-3-5-haiku-latest", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
+    { id: "claude-3-opus-latest", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
+    // OpenAI
+    { id: "gpt-4o", inputPer1k: 0.0025, outputPer1k: 0.01, updatedAt: "2025-03-15" },
+    { id: "gpt-4o-mini", inputPer1k: 0.00015, outputPer1k: 0.0006, updatedAt: "2025-03-15" },
+    { id: "o1", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
+    { id: "o3", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
+    { id: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, updatedAt: "2025-03-15" },
+    // Google
+    { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
+    { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
+    { id: "gemini-2.5-pro", inputPer1k: 0.00125, outputPer1k: 0.005, updatedAt: "2025-03-15" },
+    // DeepSeek
+    { id: "deepseek-chat", inputPer1k: 0.00014, outputPer1k: 0.00028, updatedAt: "2025-03-15" },
+];
+/**
+ * Lookup cost for a model ID. Returns undefined if not found.
+ */
+export function lookupModelCost(modelId) {
+    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    return BUNDLED_COST_TABLE.find(e => e.id === bareId)
+        ?? BUNDLED_COST_TABLE.find(e => bareId.includes(e.id) || e.id.includes(bareId));
+}
+/**
+ * Compare two models by input cost. Returns negative if a is cheaper.
+ */
+export function compareModelCost(modelIdA, modelIdB) {
+    const costA = lookupModelCost(modelIdA)?.inputPer1k ?? 999;
+    const costB = lookupModelCost(modelIdB)?.inputPer1k ?? 999;
+    return costA - costB;
+}

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

@@ -0,0 +1,187 @@
+// GSD Extension — Dynamic Model Router
+// Maps complexity tiers to models, enforcing downgrade-only semantics.
+// The user's configured model is always the ceiling.
+import { tierOrdinal } from "./complexity-classifier.js";
+// ─── Known Model Tiers ───────────────────────────────────────────────────────
+// Maps known model IDs to their capability tier. Used when tier_models is not
+// explicitly configured to pick the best available model for each tier.
+const MODEL_CAPABILITY_TIER = {
+    // Light-tier models (cheapest)
+    "claude-haiku-4-5": "light",
+    "claude-3-5-haiku-latest": "light",
+    "claude-3-haiku-20240307": "light",
+    "gpt-4o-mini": "light",
+    "gemini-2.0-flash": "light",
+    "gemini-flash-2.0": "light",
+    // Standard-tier models
+    "claude-sonnet-4-6": "standard",
+    "claude-sonnet-4-5-20250514": "standard",
+    "claude-3-5-sonnet-latest": "standard",
+    "gpt-4o": "standard",
+    "gemini-2.5-pro": "standard",
+    "deepseek-chat": "standard",
+    // Heavy-tier models (most capable)
+    "claude-opus-4-6": "heavy",
+    "claude-3-opus-latest": "heavy",
+    "gpt-4-turbo": "heavy",
+    "o1": "heavy",
+    "o3": "heavy",
+};
+// ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
+// Used for cross-provider cost comparison when multiple providers offer
+// the same capability tier.
+const MODEL_COST_PER_1K_INPUT = {
+    "claude-haiku-4-5": 0.0008,
+    "claude-3-5-haiku-latest": 0.0008,
+    "claude-sonnet-4-6": 0.003,
+    "claude-sonnet-4-5-20250514": 0.003,
+    "claude-opus-4-6": 0.015,
+    "gpt-4o-mini": 0.00015,
+    "gpt-4o": 0.0025,
+    "gemini-2.0-flash": 0.0001,
+    "gemini-2.5-pro": 0.00125,
+    "deepseek-chat": 0.00014,
+};
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Resolve the model to use for a given complexity tier.
+ *
+ * Downgrade-only: the returned model is always equal to or cheaper than
+ * the user's configured primary model. Never upgrades beyond configuration.
+ *
+ * @param classification  The complexity classification result
+ * @param phaseConfig     The user's configured model for this phase (ceiling)
+ * @param routingConfig   Dynamic routing configuration
+ * @param availableModelIds  List of available model IDs (from registry)
+ */
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds) {
+    // If no phase config or routing disabled, pass through
+    if (!phaseConfig || !routingConfig.enabled) {
+        return {
+            modelId: phaseConfig?.primary ?? "",
+            fallbacks: phaseConfig?.fallbacks ?? [],
+            tier: classification.tier,
+            wasDowngraded: false,
+            reason: "dynamic routing disabled or no phase config",
+        };
+    }
+    const configuredPrimary = phaseConfig.primary;
+    const configuredTier = getModelTier(configuredPrimary);
+    const requestedTier = classification.tier;
+    // Downgrade-only: if requested tier >= configured tier, no change
+    if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
+        return {
+            modelId: configuredPrimary,
+            fallbacks: phaseConfig.fallbacks,
+            tier: requestedTier,
+            wasDowngraded: false,
+            reason: `tier ${requestedTier} >= configured ${configuredTier}`,
+        };
+    }
+    // Find the best model for the requested tier
+    const 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`,
+        };
+    }
+    // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
+    const fallbacks = [
+        ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
+        configuredPrimary,
+    ].filter(f => f !== targetModelId);
+    return {
+        modelId: targetModelId,
+        fallbacks,
+        tier: requestedTier,
+        wasDowngraded: true,
+        reason: classification.reason,
+    };
+}
+/**
+ * Escalate to the next tier after a failure.
+ * Returns the new tier, or null if already at heavy (max).
+ */
+export function escalateTier(currentTier) {
+    switch (currentTier) {
+        case "light": return "standard";
+        case "standard": return "heavy";
+        case "heavy": return null;
+    }
+}
+/**
+ * Get the default routing config (all features enabled).
+ */
+export function defaultRoutingConfig() {
+    return {
+        enabled: false,
+        escalate_on_failure: true,
+        budget_pressure: true,
+        cross_provider: true,
+        hooks: true,
+    };
+}
+// ─── Internal ────────────────────────────────────────────────────────────────
+function getModelTier(modelId) {
+    // Strip provider prefix if present
+    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    // Check exact match first
+    if (MODEL_CAPABILITY_TIER[bareId])
+        return MODEL_CAPABILITY_TIER[bareId];
+    // Check if any known model ID is a prefix/suffix match
+    for (const [knownId, tier] of Object.entries(MODEL_CAPABILITY_TIER)) {
+        if (bareId.includes(knownId) || knownId.includes(bareId))
+            return tier;
+    }
+    // Unknown models are assumed heavy (safest assumption)
+    return "heavy";
+}
+function findModelForTier(tier, config, availableModelIds, crossProvider) {
+    // 1. Check explicit tier_models config
+    const explicitModel = config.tier_models?.[tier];
+    if (explicitModel && availableModelIds.includes(explicitModel)) {
+        return explicitModel;
+    }
+    // Also check with provider prefix stripped
+    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;
+        });
+        if (match)
+            return match;
+    }
+    // 2. Auto-detect: find the cheapest available model in the requested tier
+    const candidates = availableModelIds
+        .filter(id => {
+        const modelTier = getModelTier(id);
+        return modelTier === tier;
+    })
+        .sort((a, b) => {
+        if (!crossProvider)
+            return 0;
+        const costA = getModelCost(a);
+        const costB = getModelCost(b);
+        return costA - costB;
+    });
+    return candidates[0] ?? null;
+}
+function getModelCost(modelId) {
+    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
+        return MODEL_COST_PER_1K_INPUT[bareId];
+    }
+    // Check partial matches
+    for (const [knownId, cost] of Object.entries(MODEL_COST_PER_1K_INPUT)) {
+        if (bareId.includes(knownId) || knownId.includes(bareId))
+            return cost;
+    }
+    // Unknown cost — assume expensive to avoid routing to unknown cheap models
+    return 999;
+}