lsd-pi 1.0.0 → 1.1.1

package/dist/resources/extensions/gsd/complexity-classifier.js

@@ -1,259 +0,0 @@
-// GSD Extension — Complexity Classifier
-// Classifies unit complexity for dynamic model routing.
-// Pure heuristics + adaptive learning — no LLM calls. Sub-millisecond classification.
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { getAdaptiveTierAdjustment } from "./routing-history.js";
-import { parseUnitId } from "./unit-id.js";
-// ─── Unit Type → Default Tier Mapping ────────────────────────────────────────
-const UNIT_TYPE_TIERS = {
-    // Tier 1 — Light: structured summaries, completion, UAT
-    "complete-slice": "light",
-    "run-uat": "light",
-    // Tier 2 — Standard: research, routine planning, discussion
-    "discuss-milestone": "standard",
-    "discuss-slice": "standard",
-    "research-milestone": "standard",
-    "research-slice": "standard",
-    "plan-milestone": "standard",
-    "plan-slice": "standard",
-    // Tier 3 — Heavy: execution, replanning (requires deep reasoning)
-    "execute-task": "standard", // default standard, upgraded by metadata
-    "replan-slice": "heavy",
-    "reassess-roadmap": "heavy",
-};
-// ─── Public API ──────────────────────────────────────────────────────────────
-/**
- * Classify unit complexity to determine which model tier to use.
- *
- * @param unitType    The type of unit being dispatched
- * @param unitId      The unit ID (e.g. "M001/S01/T01")
- * @param basePath    Project base path (for reading task plans)
- * @param budgetPct   Current budget usage as fraction (0.0-1.0+), or undefined if no budget
- * @param metadata    Optional pre-parsed task metadata
- */
-export function classifyUnitComplexity(unitType, unitId, basePath, budgetPct, metadata) {
-    // Hook units default to light
-    if (unitType.startsWith("hook/")) {
-        const result = { tier: "light", reason: "hook unit", downgraded: false };
-        return applyBudgetPressure(result, budgetPct);
-    }
-    // Start with the default tier for this unit type
-    let tier = UNIT_TYPE_TIERS[unitType] ?? "standard";
-    let reason = `unit type: ${unitType}`;
-    // For execute-task, analyze task metadata for complexity signals
-    if (unitType === "execute-task") {
-        const taskAnalysis = analyzeTaskComplexity(unitId, basePath, metadata);
-        tier = taskAnalysis.tier;
-        reason = taskAnalysis.reason;
-    }
-    // For plan-slice, check if the slice has many tasks (complex planning)
-    if (unitType === "plan-slice" || unitType === "plan-milestone") {
-        const planAnalysis = analyzePlanComplexity(unitId, basePath);
-        if (planAnalysis) {
-            tier = planAnalysis.tier;
-            reason = planAnalysis.reason;
-        }
-    }
-    // Adaptive learning: check if history suggests bumping the tier
-    const tags = metadata?.tags ?? extractTaskMetadata(unitId, basePath).tags;
-    const adaptiveAdjustment = getAdaptiveTierAdjustment(unitType, tier, tags);
-    if (adaptiveAdjustment && tierOrdinal(adaptiveAdjustment) > tierOrdinal(tier)) {
-        reason = `${reason} (adaptive: high failure rate at ${tier})`;
-        tier = adaptiveAdjustment;
-    }
-    const result = { tier, reason, downgraded: false };
-    return applyBudgetPressure(result, budgetPct);
-}
-/**
- * Get a short label for the tier (for dashboard display).
- */
-export function tierLabel(tier) {
-    switch (tier) {
-        case "light": return "L";
-        case "standard": return "S";
-        case "heavy": return "H";
-    }
-}
-/**
- * Get the tier ordering value (for comparison).
- */
-export function tierOrdinal(tier) {
-    switch (tier) {
-        case "light": return 0;
-        case "standard": return 1;
-        case "heavy": return 2;
-    }
-}
-function analyzeTaskComplexity(unitId, basePath, metadata) {
-    // Try to read task plan for complexity signals
-    const meta = metadata ?? extractTaskMetadata(unitId, basePath);
-    // Heavy signals
-    if (meta.dependencyCount && meta.dependencyCount >= 3) {
-        return { tier: "heavy", reason: `${meta.dependencyCount} dependencies` };
-    }
-    if (meta.fileCount && meta.fileCount >= 6) {
-        return { tier: "heavy", reason: `${meta.fileCount} files to modify` };
-    }
-    if (meta.estimatedLines && meta.estimatedLines >= 500) {
-        return { tier: "heavy", reason: `~${meta.estimatedLines} lines estimated` };
-    }
-    // Heavy signals from complexity keywords (Phase 4)
-    if (meta.complexityKeywords && meta.complexityKeywords.length >= 2) {
-        return { tier: "heavy", reason: `complex: ${meta.complexityKeywords.join(", ")}` };
-    }
-    if (meta.codeBlockCount && meta.codeBlockCount >= 5) {
-        return { tier: "heavy", reason: `${meta.codeBlockCount} code blocks in plan` };
-    }
-    // Standard signals from single complexity keyword
-    if (meta.complexityKeywords && meta.complexityKeywords.length === 1) {
-        return { tier: "standard", reason: `${meta.complexityKeywords[0]} task` };
-    }
-    // Light signals (simple tasks)
-    if (meta.tags?.some(t => /^(docs?|readme|comment|config|typo|rename)$/i.test(t))) {
-        return { tier: "light", reason: `simple task: ${meta.tags.join(", ")}` };
-    }
-    if (meta.fileCount !== undefined && meta.fileCount <= 1 && !meta.isNewFile) {
-        return { tier: "light", reason: "single file modification" };
-    }
-    // Standard by default
-    return { tier: "standard", reason: "standard execution task" };
-}
-function analyzePlanComplexity(unitId, basePath) {
-    // Check if this is a milestone-level plan (more complex) vs single slice
-    const { milestone: mid, slice: sid } = parseUnitId(unitId);
-    if (!sid) {
-        // Milestone-level planning is always at least standard
-        return { tier: "standard", reason: "milestone-level planning" };
-    }
-    // For slice planning, try to read the context/research to gauge complexity
-    // If research exists and is large, bump to heavy
-    const researchPath = join(gsdRoot(basePath), mid, "slices", sid, "RESEARCH.md");
-    try {
-        if (existsSync(researchPath)) {
-            const content = readFileSync(researchPath, "utf-8");
-            const lineCount = content.split("\n").length;
-            if (lineCount > 200) {
-                return { tier: "heavy", reason: `complex slice: ${lineCount}-line research` };
-            }
-        }
-    }
-    catch {
-        // Non-fatal
-    }
-    return null; // Use default tier
-}
-/**
- * Extract task metadata from the task plan file on disk.
- */
-function extractTaskMetadata(unitId, basePath) {
-    const meta = {};
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-    if (!mid || !sid || !tid)
-        return meta;
-    const taskPlanPath = join(gsdRoot(basePath), mid, "slices", sid, "tasks", `${tid}-PLAN.md`);
-    try {
-        if (!existsSync(taskPlanPath))
-            return meta;
-        const content = readFileSync(taskPlanPath, "utf-8");
-        const lines = content.split("\n");
-        // Count files mentioned in "Files:" or "- Files:" lines
-        const fileLines = lines.filter(l => /^\s*-?\s*files?\s*:/i.test(l));
-        if (fileLines.length > 0) {
-            // Count comma-separated or bullet-pointed files
-            const allFiles = new Set();
-            for (const line of fileLines) {
-                const filesStr = line.replace(/^\s*-?\s*files?\s*:\s*/i, "");
-                const files = filesStr.split(/[,;]/).map(f => f.trim()).filter(Boolean);
-                files.forEach(f => allFiles.add(f));
-            }
-            meta.fileCount = allFiles.size;
-        }
-        // Check for "new file" or "create" keywords
-        meta.isNewFile = lines.some(l => /\b(create|new file|scaffold|bootstrap)\b/i.test(l));
-        // Look for tags/labels in frontmatter or content
-        const tags = [];
-        if (content.match(/\b(refactor|migration|architect)/i))
-            tags.push("refactor");
-        if (content.match(/\b(test|spec|coverage)\b/i))
-            tags.push("test");
-        if (content.match(/\b(doc|readme|comment|jsdoc)\b/i))
-            tags.push("docs");
-        if (content.match(/\b(config|env|setting)\b/i))
-            tags.push("config");
-        if (content.match(/\b(rename|typo|spelling)\b/i))
-            tags.push("rename");
-        meta.tags = tags;
-        // Try to extract estimated lines from content
-        const estimateMatch = content.match(/~?\s*(\d+)\s*lines?\b/i);
-        if (estimateMatch) {
-            meta.estimatedLines = parseInt(estimateMatch[1], 10);
-        }
-        // Phase 4: Deeper introspection signals
-        // Count fenced code blocks (```) — more code blocks = more complex implementation
-        const codeBlockMatches = content.match(/^```/gm);
-        meta.codeBlockCount = codeBlockMatches ? Math.floor(codeBlockMatches.length / 2) : 0;
-        // Detect complexity keywords that suggest harder tasks
-        const complexityKeywords = [];
-        if (content.match(/\b(migration|migrate|schema change)\b/i))
-            complexityKeywords.push("migration");
-        if (content.match(/\b(architect|design pattern|system design)\b/i))
-            complexityKeywords.push("architecture");
-        if (content.match(/\b(security|auth|encrypt|credential|vulnerability)\b/i))
-            complexityKeywords.push("security");
-        if (content.match(/\b(performance|optimize|cache|index)\b/i))
-            complexityKeywords.push("performance");
-        if (content.match(/\b(concurrent|parallel|race condition|mutex|lock)\b/i))
-            complexityKeywords.push("concurrency");
-        if (content.match(/\b(backward.?compat|breaking change|deprecat)\b/i))
-            complexityKeywords.push("compatibility");
-        meta.complexityKeywords = complexityKeywords;
-    }
-    catch {
-        // Non-fatal — metadata extraction is best-effort
-    }
-    return meta;
-}
-// ─── Budget Pressure ─────────────────────────────────────────────────────────
-/**
- * Apply budget pressure to a classification result.
- * As budget usage increases, more aggressively downgrade tiers.
- *
- * - <50%:   Normal classification (no change)
- * - 50-75%: Tier 2 → Tier 1 where possible
- * - 75-90%: Only heavy tasks keep configured model
- * - >90%:   Everything except replan-slice gets cheapest model
- */
-function applyBudgetPressure(result, budgetPct) {
-    if (budgetPct === undefined || budgetPct < 0.5)
-        return result;
-    const original = result.tier;
-    if (budgetPct >= 0.9) {
-        // >90%: almost everything goes to light
-        if (result.tier !== "heavy") {
-            result.tier = "light";
-        }
-        else {
-            // Even heavy gets downgraded to standard
-            result.tier = "standard";
-        }
-    }
-    else if (budgetPct >= 0.75) {
-        // 75-90%: only heavy stays, everything else goes to light
-        if (result.tier === "standard") {
-            result.tier = "light";
-        }
-    }
-    else {
-        // 50-75%: standard → light
-        if (result.tier === "standard") {
-            result.tier = "light";
-        }
-    }
-    if (result.tier !== original) {
-        result.downgraded = true;
-        result.reason = `${result.reason} (budget pressure: ${Math.round(budgetPct * 100)}%)`;
-    }
-    return result;
-}

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

@@ -1,15 +0,0 @@
-/**
- * GSD Extension — Shared Constants
- *
- * Centralized timeout and cache-size constants used across the GSD extension.
- */
-// ─── Timeouts ─────────────────────────────────────────────────────────────────
-/** Default timeout for verification-gate commands (ms). */
-export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
-/** Default timeout for the dynamic bash tool (seconds). */
-export const DEFAULT_BASH_TIMEOUT_SECS = 120;
-// ─── Cache Sizes ──────────────────────────────────────────────────────────────
-/** Max directory-listing cache entries before eviction (#611). */
-export const DIR_CACHE_MAX = 200;
-/** Max parse-cache entries before eviction. */
-export const CACHE_MAX = 50;

package/dist/resources/extensions/gsd/context-budget.js

@@ -1,179 +0,0 @@
-/**
- * Context budget engine — proportional allocation, section-boundary truncation,
- * and executor context window resolution.
- *
- * All functions are pure or near-pure (dependency-injected). No global state, no I/O.
- * Budget ratios are module-level constants for easy tuning.
- *
- * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
- */
-import { getCharsPerToken } from "./token-counter.js";
-// ─── Budget ratio constants ──────────────────────────────────────────────────
-// Percentages of total context window allocated to each budget category.
-// These are applied after tokens→chars conversion.
-/** Proportion of context window for dependency/prior-task summaries */
-const SUMMARY_RATIO = 0.15;
-/** Proportion of context window for inline context (plans, decisions, code) */
-const INLINE_CONTEXT_RATIO = 0.40;
-/** Proportion of context window for verification sections in prompts */
-const VERIFICATION_RATIO = 0.10;
-/** Approximate chars-per-token conversion factor */
-const CHARS_PER_TOKEN = 4;
-/** Default context window when none can be resolved (D002) */
-const DEFAULT_CONTEXT_WINDOW = 200_000;
-/** Percentage of context consumed before suggesting a continue-here checkpoint */
-const CONTINUE_THRESHOLD_PERCENT = 70;
-// ─── Task count bounds ───────────────────────────────────────────────────────
-// Task count range scales with context window. Smaller windows get fewer tasks
-// to avoid overloading the executor.
-const TASK_COUNT_MIN = 2;
-/** Task count ceiling tiers: [contextWindowThreshold, maxTasks] */
-const TASK_COUNT_TIERS = [
-    [500_000, 8], // 500K+ tokens → up to 8 tasks
-    [200_000, 6], // 200K+ tokens → up to 6 tasks
-    [128_000, 5], // 128K+ tokens → up to 5 tasks
-    [0, 3], // anything smaller → up to 3 tasks
-];
-// ─── Public API ──────────────────────────────────────────────────────────────
-/**
- * Compute proportional budget allocations from a context window size (in tokens).
- *
- * Returns deterministic output for any given input. Invalid inputs (≤ 0)
- * silently default to 200K (D002).
- */
-export function computeBudgets(contextWindow, provider) {
-    const effectiveWindow = contextWindow > 0 ? contextWindow : DEFAULT_CONTEXT_WINDOW;
-    const charsPerToken = provider ? getCharsPerToken(provider) : CHARS_PER_TOKEN;
-    const totalChars = effectiveWindow * charsPerToken;
-    return {
-        summaryBudgetChars: Math.floor(totalChars * SUMMARY_RATIO),
-        inlineContextBudgetChars: Math.floor(totalChars * INLINE_CONTEXT_RATIO),
-        verificationBudgetChars: Math.floor(totalChars * VERIFICATION_RATIO),
-        continueThresholdPercent: CONTINUE_THRESHOLD_PERCENT,
-        taskCountRange: {
-            min: TASK_COUNT_MIN,
-            max: resolveTaskCountMax(effectiveWindow),
-        },
-    };
-}
-/**
- * Truncate content at markdown section boundaries to fit within a character budget.
- *
- * Splits on `### ` headings and `---` dividers. Keeps whole sections that fit.
- * Appends `[...truncated N sections]` when content is dropped.
- * Returns content unchanged when it fits within budget.
- *
- * @see D003 — section-boundary truncation is mandatory; mid-section cuts are unacceptable.
- */
-export function truncateAtSectionBoundary(content, budgetChars) {
-    if (!content || content.length <= budgetChars) {
-        return { content, droppedSections: 0 };
-    }
-    // Split on section markers: ### headings or --- dividers (on their own line)
-    const sections = splitIntoSections(content);
-    if (sections.length <= 1) {
-        // No section markers — keep as much as fits from the start
-        const truncated = content.slice(0, budgetChars);
-        return { content: truncated + "\n\n[...truncated 1 sections]", droppedSections: 1 };
-    }
-    // Greedily keep sections that fit
-    let usedChars = 0;
-    let keptCount = 0;
-    for (const section of sections) {
-        const sectionLen = section.length;
-        if (usedChars + sectionLen > budgetChars && keptCount > 0) {
-            break;
-        }
-        // Always keep at least the first section (even if it exceeds budget)
-        usedChars += sectionLen;
-        keptCount++;
-        if (usedChars >= budgetChars)
-            break;
-    }
-    const droppedCount = sections.length - keptCount;
-    if (droppedCount === 0) {
-        return { content, droppedSections: 0 };
-    }
-    const kept = sections.slice(0, keptCount).join("");
-    return {
-        content: kept.trimEnd() + `\n\n[...truncated ${droppedCount} sections]`,
-        droppedSections: droppedCount,
-    };
-}
-/**
- * Resolve the executor model's context window size using a fallback chain:
- *
- * 1. Look up the configured executor model ID in preferences → find in registry → return contextWindow
- * 2. Fall back to sessionContextWindow if provided
- * 3. Fall back to 200K default (D002)
- *
- * Supports "provider/model" format in preferences for explicit provider targeting.
- */
-export function resolveExecutorContextWindow(registry, preferences, sessionContextWindow) {
-    // Step 1: Try configured executor model
-    if (preferences?.models?.execution && registry) {
-        const executionConfig = preferences.models.execution;
-        const modelId = typeof executionConfig === "string"
-            ? executionConfig
-            : executionConfig.model;
-        if (modelId) {
-            const model = findModelById(registry, modelId);
-            if (model && model.contextWindow > 0) {
-                return model.contextWindow;
-            }
-        }
-    }
-    // Step 2: Fall back to session context window
-    if (sessionContextWindow && sessionContextWindow > 0) {
-        return sessionContextWindow;
-    }
-    // Step 3: Fall back to default (D002)
-    return DEFAULT_CONTEXT_WINDOW;
-}
-/**
- * Reduce content to fit within budget using section-boundary truncation.
- */
-export function reduceToFit(content, budgetChars) {
-    if (!content || content.length <= budgetChars) {
-        return { content, droppedSections: 0 };
-    }
-    return truncateAtSectionBoundary(content, budgetChars);
-}
-// ─── Internal helpers ────────────────────────────────────────────────────────
-/**
- * Resolve task count ceiling from context window size.
- * Larger windows support more tasks per slice.
- */
-function resolveTaskCountMax(contextWindow) {
-    for (const [threshold, max] of TASK_COUNT_TIERS) {
-        if (contextWindow >= threshold)
-            return max;
-    }
-    return 3; // fallback — unreachable given tiers include 0
-}
-/**
- * Split content into sections at `### ` headings or `---` dividers.
- * Each section includes its leading marker.
- */
-function splitIntoSections(content) {
-    // Match section boundaries: ### heading or --- divider at start of line
-    const pattern = /^(?=### |\-{3,}\s*$)/m;
-    const parts = content.split(pattern).filter(p => p.length > 0);
-    return parts;
-}
-/**
- * Find a model in the registry by ID string.
- * Supports "provider/model" format for explicit provider targeting,
- * or bare model ID (first match wins).
- */
-function findModelById(registry, modelId) {
-    const allModels = registry.getAll();
-    const slashIdx = modelId.indexOf("/");
-    if (slashIdx !== -1) {
-        const provider = modelId.substring(0, slashIdx).toLowerCase();
-        const id = modelId.substring(slashIdx + 1).toLowerCase();
-        return allModels.find(m => m.provider.toLowerCase() === provider && m.id.toLowerCase() === id);
-    }
-    // Bare ID — first match
-    return allModels.find(m => m.id === modelId);
-}

package/dist/resources/extensions/gsd/context-injector.js

@@ -1,74 +0,0 @@
-/**
- * context-injector.ts — Inject prior step artifacts as context into step prompts.
- *
- * Reads the frozen DEFINITION.yaml from a run directory, finds the current step's
- * `contextFrom` references, locates each referenced step's `produces` artifacts
- * on disk, reads their content (truncated to 10k chars), and prepends formatted
- * context blocks to the step prompt.
- *
- * Observability:
- * - Truncation is logged via console.warn when it occurs, preventing silent overflow.
- * - Missing artifact files are skipped silently (the step may not have produced them yet).
- * - Unknown step IDs in contextFrom produce a console.warn for diagnosis.
- * - The frozen DEFINITION.yaml on disk is the single source of truth for contextFrom config.
- */
-import { readFileSync, existsSync } from "node:fs";
-import { resolve, sep } from "node:path";
-import { readFrozenDefinition } from "./custom-workflow-engine.js";
-/** Maximum characters per artifact to prevent context window blowout. */
-const MAX_CONTEXT_CHARS = 10_000;
-/**
- * Inject context from prior step artifacts into a step's prompt.
- *
- * Reads the frozen DEFINITION.yaml from `runDir`, finds the step matching
- * `stepId`, and for each step ID in its `contextFrom` array, looks up that
- * step's `produces` paths, reads them from disk (relative to `runDir`),
- * truncates to MAX_CONTEXT_CHARS, and prepends as labeled context blocks.
- *
- * @param runDir — absolute path to the workflow run directory
- * @param stepId — the step ID whose prompt to enrich
- * @param prompt — the original step prompt
- * @returns The prompt with context blocks prepended, or unchanged if no context applies
- * @throws Error if DEFINITION.yaml is missing or unreadable
- */
-export function injectContext(runDir, stepId, prompt) {
-    const def = readFrozenDefinition(runDir);
-    const step = def.steps.find((s) => s.id === stepId);
-    if (!step || !step.contextFrom || step.contextFrom.length === 0) {
-        return prompt;
-    }
-    const contextBlocks = [];
-    for (const refStepId of step.contextFrom) {
-        const refStep = def.steps.find((s) => s.id === refStepId);
-        if (!refStep) {
-            console.warn(`context-injector: step "${stepId}" references unknown step "${refStepId}" in contextFrom — skipping`);
-            continue;
-        }
-        if (!refStep.produces || refStep.produces.length === 0) {
-            continue;
-        }
-        for (const relPath of refStep.produces) {
-            const absPath = resolve(runDir, relPath);
-            // Path traversal guard: ensure resolved path stays within runDir
-            if (!absPath.startsWith(resolve(runDir) + sep) && absPath !== resolve(runDir)) {
-                console.warn(`context-injector: artifact path "${relPath}" resolves outside runDir — skipping`);
-                continue;
-            }
-            if (!existsSync(absPath)) {
-                // Artifact not yet produced or optional — skip silently
-                continue;
-            }
-            let content = readFileSync(absPath, "utf-8");
-            if (content.length > MAX_CONTEXT_CHARS) {
-                console.warn(`context-injector: truncating artifact "${relPath}" from step "${refStepId}" ` +
-                    `(${content.length} chars → ${MAX_CONTEXT_CHARS} chars)`);
-                content = content.slice(0, MAX_CONTEXT_CHARS) + "\n...[truncated]";
-            }
-            contextBlocks.push(`--- Context from step "${refStepId}" (file: ${relPath}) ---\n${content}\n---`);
-        }
-    }
-    if (contextBlocks.length === 0) {
-        return prompt;
-    }
-    return contextBlocks.join("\n\n") + "\n\n" + prompt;
-}