gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

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

@@ -1,257 +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
-    "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/context-budget.js

@@ -1,187 +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";
-import { compressToTarget } from "./prompt-compressor.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;
-}
-/**
- * Smart context reduction: compress first, then truncate if still over budget.
- * Returns the content within budget with maximum information preservation.
- */
-export function reduceToFit(content, budgetChars) {
-    if (!content || content.length <= budgetChars) {
-        return { content, droppedSections: 0 };
-    }
-    // Step 1: Try compression
-    const compressed = compressToTarget(content, budgetChars);
-    if (compressed.compressedChars <= budgetChars) {
-        return { content: compressed.content, droppedSections: 0 };
-    }
-    // Step 2: Truncate the compressed content at section boundaries
-    return truncateAtSectionBoundary(compressed.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-store.js

@@ -1,165 +0,0 @@
-// GSD Context Store — Query Layer & Formatters
-//
-// Typed query functions for decisions and requirements from the DB views,
-// with optional filtering. Format functions produce prompt-injectable markdown.
-// All functions degrade gracefully: return empty results when DB unavailable, never throw.
-import { isDbAvailable, _getAdapter } from './gsd-db.js';
-/**
- * Query active (non-superseded) decisions with optional filters.
- * - milestoneId: filters where when_context LIKE '%milestoneId%'
- * - scope: filters where scope = :scope (exact match)
- *
- * Returns [] if DB is not available. Never throws.
- */
-export function queryDecisions(opts) {
-    if (!isDbAvailable())
-        return [];
-    const adapter = _getAdapter();
-    if (!adapter)
-        return [];
-    try {
-        const clauses = ['superseded_by IS NULL'];
-        const params = {};
-        if (opts?.milestoneId) {
-            clauses.push('when_context LIKE :milestone_pattern');
-            params[':milestone_pattern'] = `%${opts.milestoneId}%`;
-        }
-        if (opts?.scope) {
-            clauses.push('scope = :scope');
-            params[':scope'] = opts.scope;
-        }
-        const sql = `SELECT * FROM decisions WHERE ${clauses.join(' AND ')} ORDER BY seq`;
-        const rows = adapter.prepare(sql).all(params);
-        return rows.map(row => ({
-            seq: row['seq'],
-            id: row['id'],
-            when_context: row['when_context'],
-            scope: row['scope'],
-            decision: row['decision'],
-            choice: row['choice'],
-            rationale: row['rationale'],
-            revisable: row['revisable'],
-            superseded_by: null,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Query active (non-superseded) requirements with optional filters.
- * - sliceId: filters where primary_owner LIKE '%sliceId%' OR supporting_slices LIKE '%sliceId%'
- * - status: filters where status = :status (exact match)
- *
- * Returns [] if DB is not available. Never throws.
- */
-export function queryRequirements(opts) {
-    if (!isDbAvailable())
-        return [];
-    const adapter = _getAdapter();
-    if (!adapter)
-        return [];
-    try {
-        const clauses = ['superseded_by IS NULL'];
-        const params = {};
-        if (opts?.sliceId) {
-            clauses.push('(primary_owner LIKE :slice_pattern OR supporting_slices LIKE :slice_pattern)');
-            params[':slice_pattern'] = `%${opts.sliceId}%`;
-        }
-        if (opts?.status) {
-            clauses.push('status = :status');
-            params[':status'] = opts.status;
-        }
-        const sql = `SELECT * FROM requirements WHERE ${clauses.join(' AND ')} ORDER BY id`;
-        const rows = adapter.prepare(sql).all(params);
-        return rows.map(row => ({
-            id: row['id'],
-            class: row['class'],
-            status: row['status'],
-            description: row['description'],
-            why: row['why'],
-            source: row['source'],
-            primary_owner: row['primary_owner'],
-            supporting_slices: row['supporting_slices'],
-            validation: row['validation'],
-            notes: row['notes'],
-            full_content: row['full_content'],
-            superseded_by: null,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-// ─── Format Functions ──────────────────────────────────────────────────────
-/**
- * Format decisions as a markdown table matching DECISIONS.md format.
- * Returns empty string for empty input.
- */
-export function formatDecisionsForPrompt(decisions) {
-    if (decisions.length === 0)
-        return '';
-    const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? |';
-    const separator = '|---|------|-------|----------|--------|-----------|------------|';
-    const rows = decisions.map(d => `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} |`);
-    return [header, separator, ...rows].join('\n');
-}
-/**
- * Format requirements as structured H3 sections matching REQUIREMENTS.md format.
- * Returns empty string for empty input.
- */
-export function formatRequirementsForPrompt(requirements) {
-    if (requirements.length === 0)
-        return '';
-    return requirements.map(r => {
-        const lines = [
-            `### ${r.id}: ${r.description}`,
-            '',
-            `- **Class:** ${r.class}`,
-            `- **Status:** ${r.status}`,
-            `- **Why:** ${r.why}`,
-            `- **Source:** ${r.source}`,
-            `- **Primary Owner:** ${r.primary_owner}`,
-        ];
-        if (r.supporting_slices) {
-            lines.push(`- **Supporting Slices:** ${r.supporting_slices}`);
-        }
-        lines.push(`- **Validation:** ${r.validation}`);
-        if (r.notes) {
-            lines.push(`- **Notes:** ${r.notes}`);
-        }
-        return lines.join('\n');
-    }).join('\n\n');
-}
-// ─── Artifact Query Functions ──────────────────────────────────────────────
-/**
- * Query a hierarchy artifact by its relative path.
- * Returns the full_content string or null if not found/unavailable.
- * Never throws.
- */
-export function queryArtifact(path) {
-    if (!isDbAvailable())
-        return null;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return null;
-    try {
-        const row = adapter.prepare('SELECT full_content FROM artifacts WHERE path = :path').get({ ':path': path });
-        if (!row)
-            return null;
-        const content = row['full_content'];
-        return content || null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Query PROJECT.md content from the artifacts table.
- * PROJECT.md is stored with the relative path 'PROJECT.md' by the importer.
- * Returns the content string or null if not found/unavailable.
- * Never throws.
- */
-export function queryProject() {
-    return queryArtifact('PROJECT.md');
-}