@10kdevs/matha 0.1.0

package/dist/commands/after.js

@@ -0,0 +1,334 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { readJsonOrNull } from '../storage/reader.js';
+import { writeAtomic, appendToArray } from '../storage/writer.js';
+import { recordDecision, recordDangerZone } from '../brain/hippocampus.js';
+import { checkSchemaVersion, getSchemaMessage } from '../utils/schema-version.js';
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function generateSessionId(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    const randomHex = Array.from({ length: 4 })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join('');
+    return `${year}${month}${day}-${hours}${minutes}${seconds}-${randomHex}`;
+}
+async function findMostRecentPredictionFile(predictionsDir) {
+    try {
+        const files = await fs.readdir(predictionsDir);
+        if (files.length === 0)
+            return null;
+        // Sort filenames descending to get most recent
+        const sorted = files
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.replace('.json', ''))
+            .sort()
+            .reverse();
+        return sorted.length > 0 ? sorted[0] : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getLinkedSessionBrief(mathaDir, sessionId) {
+    try {
+        const briefPath = path.join(mathaDir, `sessions/${sessionId}.brief`);
+        return await readJsonOrNull(briefPath);
+    }
+    catch {
+        return null;
+    }
+}
+async function runAfter(projectRoot = process.cwd(), deps) {
+    const ask = deps?.ask ?? defaultAsk;
+    const log = deps?.log ?? console.log;
+    const now = deps?.now ?? (() => new Date());
+    const mathaDir = path.join(projectRoot, '.matha');
+    const configPath = path.join(mathaDir, 'config.json');
+    // GUARD: Check if .matha/config.json exists
+    const configExists = await pathExists(configPath);
+    if (!configExists) {
+        const message = 'MATHA is not initialised. Run `matha init` first.';
+        log(message);
+        return { exitCode: 1, message };
+    }
+    // SCHEMA VERSION CHECK
+    const schemaResult = await checkSchemaVersion(mathaDir);
+    const schemaMsg = getSchemaMessage(schemaResult);
+    if (schemaMsg)
+        log(schemaMsg);
+    if (schemaResult.status === 'newer') {
+        return { exitCode: 1, message: schemaMsg };
+    }
+    const timestamp = now().toISOString();
+    const predictionsDir = path.join(mathaDir, 'dopamine/predictions');
+    // Find most recent prediction file
+    const linkedSessionId = await findMostRecentPredictionFile(predictionsDir);
+    const sessionId = linkedSessionId ?? generateSessionId(now());
+    if (linkedSessionId) {
+        log(`\nLinking to session: ${linkedSessionId}\n`);
+    }
+    // Get scope and contract from linked session brief if available
+    const brief = await getLinkedSessionBrief(mathaDir, sessionId);
+    let scope = brief?.scope ?? 'unknown';
+    const assertions = brief?.contract && Array.isArray(brief.contract) ? brief.contract : [];
+    // PROMPT 01 — DISCOVERY: What assumption broke?
+    const assumptionInput = await ask('What assumption broke or needed correction? (press enter to skip)');
+    const assumption = assumptionInput.trim() || null;
+    // PROMPT 02 — CORRECTION: Only show if assumption provided
+    let correction = null;
+    if (assumption) {
+        const correctionInput = await ask('What was the correction? What is the right understanding?');
+        correction = correctionInput.trim() || null;
+    }
+    // PROMPT 03 — DANGER ZONE
+    const dangerPatternInput = await ask('Should this be recorded as a danger zone for future sessions?\n' +
+        'Describe the pattern to watch for, or press enter to skip.');
+    const dangerPattern = dangerPatternInput.trim() || null;
+    // PROMPT 04 — CONTRACT RESULT
+    let contractResult = 'none';
+    const failedAssertions = [];
+    if (assertions.length > 0) {
+        log(`\nCONTRACT VALIDATION — ${assertions.length} assertion(s) to check:\n`);
+        let passCount = 0;
+        let failCount = 0;
+        let skipCount = 0;
+        for (let i = 0; i < assertions.length; i++) {
+            const assertionText = assertions[i];
+            log(`  [${i + 1}/${assertions.length}] ${assertionText}`);
+            let valid = false;
+            while (!valid) {
+                let answer = await ask('  Did this pass? (y/n/skip)');
+                answer = answer.trim().toLowerCase();
+                if (answer === 'y' || answer === 'yes' || answer === 'pass') {
+                    passCount++;
+                    valid = true;
+                }
+                else if (answer === 'n' || answer === 'no' || answer === 'fail') {
+                    failCount++;
+                    failedAssertions.push(assertionText);
+                    valid = true;
+                }
+                else if (answer === 'skip' || answer === 's') {
+                    skipCount++;
+                    valid = true;
+                }
+                else {
+                    log('  Please answer y, n, or skip.');
+                }
+            }
+        }
+        if (failCount > 0) {
+            contractResult = 'violated';
+        }
+        else if (passCount === 0 && skipCount > 0) {
+            contractResult = 'none';
+        }
+        else if (passCount > 0 && skipCount > 0) {
+            contractResult = 'partial';
+        }
+        else if (passCount > 0) {
+            contractResult = 'passed';
+        }
+        else {
+            contractResult = 'none';
+        }
+        const marks = { passed: 'PASSED ✓', violated: 'VIOLATED ✗', partial: 'PARTIAL ~', none: 'NONE –' };
+        log(`\nContract result: ${marks[contractResult]}`);
+    }
+    else {
+        log('\nDid the behaviour contract pass?');
+        log('  1. Yes — all assertions passed');
+        log('  2. Partial — some assertions passed');
+        log('  3. No — contract was violated');
+        log('  4. No contract was written');
+        log('');
+        const contractChoice = await ask('Did the behaviour contract pass? (1-4):');
+        const contractResultMap = {
+            '1': 'passed',
+            '2': 'partial',
+            '3': 'violated',
+            '4': 'none',
+        };
+        contractResult = contractResultMap[contractChoice] || 'none';
+    }
+    // PROMPT 05 — ACTUALS: Files changed
+    const filesInput = await ask('Approximately how many files were changed in this session?');
+    const filesChanged = parseInt(filesInput, 10) || 0;
+    // PROMPT 05 — ACTUALS: Tokens used
+    const tokensInput = await ask('Roughly how many tokens did this session use? (press enter to skip)');
+    const tokensUsed = tokensInput.trim() ? parseInt(tokensInput, 10) : null;
+    // ──────────────────────────────────────────────────────────────
+    // WRITE-BACK OPERATIONS
+    // ──────────────────────────────────────────────────────────────
+    let decisionRecorded = false;
+    let dangerZoneRecorded = false;
+    // 1. DECISION ENTRY (if both assumption AND correction)
+    if (assumption && correction) {
+        try {
+            await recordDecision(mathaDir, {
+                id: `${sessionId}-decision`,
+                timestamp,
+                component: scope,
+                previous_assumption: assumption,
+                correction,
+                trigger: sessionId,
+                confidence: 'confirmed',
+                status: 'active',
+                supersedes: null,
+                session_id: sessionId,
+            });
+            decisionRecorded = true;
+        }
+        catch (err) {
+            // Gracefully handle duplicate decision (same sessionId)
+            // Decision is still recorded from the first run
+            if (linkedSessionId) {
+                decisionRecorded = false; // Don't claim it was recorded on duplicate
+            }
+        }
+    }
+    // 2. DANGER ZONE (if pattern provided)
+    if (dangerPattern) {
+        try {
+            const dangerZoneId = `${sessionId}-danger`;
+            await recordDangerZone(mathaDir, {
+                id: dangerZoneId,
+                component: scope,
+                pattern: 'Session-discovered pattern',
+                description: dangerPattern,
+            });
+            dangerZoneRecorded = true;
+        }
+        catch {
+            dangerZoneRecorded = false;
+        }
+    }
+    // 3. DOPAMINE ACTUAL (always written)
+    const actualRecord = {
+        session_id: sessionId,
+        timestamp,
+        contract_result: contractResult,
+        actual: {
+            files_changed: filesChanged,
+            tokens_used: tokensUsed,
+        },
+    };
+    const actualPath = path.join(mathaDir, `dopamine/actuals/${sessionId}.json`);
+    await writeAtomic(actualPath, actualRecord);
+    // 4. DOPAMINE DELTA
+    let predictionData = null;
+    try {
+        const predictionPath = path.join(mathaDir, `dopamine/predictions/${sessionId}.json`);
+        predictionData = await readJsonOrNull(predictionPath);
+    }
+    catch {
+        predictionData = null;
+    }
+    const tokenDelta = predictionData && tokensUsed ? tokensUsed - predictionData.predicted.token_budget : null;
+    const deltaEntry = {
+        session_id: sessionId,
+        timestamp,
+        operation_type: predictionData?.operation_type ?? 'unknown',
+        contract_result: contractResult,
+        token_delta: tokenDelta,
+        files_changed: filesChanged,
+        model_tier_used: predictionData?.predicted.model_tier ?? 'unknown',
+    };
+    const deltasPath = path.join(mathaDir, 'dopamine/deltas.json');
+    await appendToArray(deltasPath, deltaEntry);
+    // 5. CONTRACT VIOLATION LOG (only if violated or partial)
+    if (failedAssertions.length > 0) {
+        const violationPath = path.join(mathaDir, 'cerebellum/violation-log.json');
+        for (const assertionText of failedAssertions) {
+            const violationEntry = {
+                session_id: sessionId,
+                timestamp,
+                result: 'violated',
+                scope,
+                assertion: assertionText,
+                component: scope,
+            };
+            await appendToArray(violationPath, violationEntry);
+            await updateContractViolation(mathaDir, scope, assertionText, timestamp);
+        }
+    }
+    else if (contractResult === 'violated' || contractResult === 'partial') {
+        const violationEntry = {
+            session_id: sessionId,
+            timestamp,
+            result: contractResult,
+            scope,
+        };
+        const violationPath = path.join(mathaDir, 'cerebellum/violation-log.json');
+        await appendToArray(violationPath, violationEntry);
+    }
+    // ──────────────────────────────────────────────────────────────
+    // TERMINAL OUTPUT
+    // ──────────────────────────────────────────────────────────────
+    log('\n════════════════════════════════════════');
+    log(`MATHA WRITE-BACK COMPLETE — ${sessionId}`);
+    log('════════════════════════════════════════\n');
+    const decisionMark = decisionRecorded ? '✓' : '–';
+    const dangerMark = dangerZoneRecorded ? '✓' : '–';
+    const contractMark = '✓';
+    const dopamineMark = '✓';
+    log(`${decisionMark} Decision recorded` +
+        (decisionRecorded ? ` (${scope}: ${correction?.substring(0, 40)})` : ''));
+    log(`${dangerMark} Danger zone recorded` + (dangerZoneRecorded ? ` (${dangerPattern})` : ' (none)'));
+    log(`${contractMark} Contract result logged (${contractResult})`);
+    const tokenDeltaStr = tokenDelta !== null ? `${tokenDelta > 0 ? '+' : ''}${tokenDelta}` : 'N/A';
+    log(`${dopamineMark} Dopamine delta recorded (tokens: ${tokenDeltaStr} | files: ${filesChanged})`);
+    log('\nBrain updated. Next session starts warmer.');
+    log('════════════════════════════════════════\n');
+    return {
+        exitCode: 0,
+        sessionId,
+        scope,
+        decisionRecorded,
+        dangerZoneRecorded,
+    };
+}
+async function updateContractViolation(mathaDir, component, assertionText, timestamp) {
+    try {
+        const sanitizedComponent = component.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const contractPath = path.join(mathaDir, `cerebellum/contracts/${sanitizedComponent}.json`);
+        const contract = await readJsonOrNull(contractPath);
+        if (!contract || !Array.isArray(contract.assertions)) {
+            return;
+        }
+        let modified = false;
+        const searchTarget = assertionText.trim().toLowerCase();
+        for (const assertion of contract.assertions) {
+            if (assertion.description && assertion.description.trim().toLowerCase() === searchTarget) {
+                assertion.violation_count = (assertion.violation_count || 0) + 1;
+                assertion.last_violated = timestamp;
+                modified = true;
+            }
+        }
+        if (modified) {
+            await writeAtomic(contractPath, contract, { overwrite: true });
+        }
+    }
+    catch {
+        // Fail silently
+    }
+}
+// Default ask implementation using @inquirer/prompts
+async function defaultAsk(question) {
+    const { input } = await import('@inquirer/prompts');
+    return await input({ message: question });
+}
+export { runAfter };

package/dist/commands/before.js

@@ -0,0 +1,328 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { writeAtomic } from '../storage/writer.js';
+import { getRules } from '../brain/hippocampus.js';
+import { checkSchemaVersion, getSchemaMessage } from '../utils/schema-version.js';
+import { getSnapshot, getStability } from '../brain/cortex.js';
+import { matchAll } from '../analysis/contract-matcher.js';
+import { getRecommendation } from '../brain/dopamine.js';
+// Operation type mapping from menu choice to operation_type
+const operationTypeMap = {
+    '1': 'rename',
+    '2': 'crud',
+    '3': 'business_logic',
+    '4': 'architecture',
+    '5': 'frozen_component',
+};
+// Model tier and token budget mapping
+const modelTierBudget = {
+    rename: { modelTier: 'lightweight', tokenBudget: 2000 },
+    crud: { modelTier: 'lightweight', tokenBudget: 2000 },
+    business_logic: { modelTier: 'capable', tokenBudget: 8000 },
+    architecture: { modelTier: 'capable', tokenBudget: 16000 },
+    frozen_component: { modelTier: 'capable', tokenBudget: 16000 },
+};
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function generateSessionId(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    const randomHex = Array.from({ length: 4 })
+        .map(() => Math.floor(Math.random() * 16).toString(16))
+        .join('');
+    return `${year}${month}${day}-${hours}${minutes}${seconds}-${randomHex}`;
+}
+async function runBefore(projectRoot = process.cwd(), deps) {
+    const ask = deps?.ask ?? defaultAsk;
+    const log = deps?.log ?? console.log;
+    const now = deps?.now ?? (() => new Date());
+    const mathaDir = path.join(projectRoot, '.matha');
+    const configPath = path.join(mathaDir, 'config.json');
+    // GUARD: Check if .matha/config.json exists
+    const configExists = await pathExists(configPath);
+    if (!configExists) {
+        const message = 'MATHA is not initialised. Run `matha init` first.';
+        log(message);
+        return { exitCode: 1, message };
+    }
+    // SCHEMA VERSION CHECK
+    const schemaResult = await checkSchemaVersion(mathaDir);
+    const schemaMsg = getSchemaMessage(schemaResult);
+    if (schemaMsg)
+        log(schemaMsg);
+    if (schemaResult.status === 'newer') {
+        return { exitCode: 1, message: schemaMsg };
+    }
+    // Generate session ID
+    const sessionId = generateSessionId(now());
+    const timestamp = now().toISOString();
+    // GATE 01 — UNDERSTAND: What are you about to build or change?
+    const operationDescription = await ask('What are you about to build or change?');
+    // GATE 02 — BOUND: Which components or files will this affect?
+    const scopeInput = await ask('Which components or files will this affect? (comma separated)');
+    const scope = scopeInput;
+    // GATE 03 — ORIENT: Read cortex (via cortex module)
+    let cortexSnapshot = null;
+    let frozenFiles = [];
+    try {
+        cortexSnapshot = await getSnapshot(mathaDir);
+    }
+    catch {
+        cortexSnapshot = null;
+    }
+    if (cortexSnapshot && cortexSnapshot.stability && cortexSnapshot.stability.length > 0) {
+        const s = cortexSnapshot.summary;
+        log(`\nCORTEX (${cortexSnapshot.fileCount} files mapped):`);
+        log(`  frozen: ${s.frozen}  stable: ${s.stable}  volatile: ${s.volatile}  disposable: ${s.disposable}`);
+        // If scope was provided, check for frozen files in scope
+        if (scope) {
+            const scopeFiles = scope.split(',').map((f) => f.trim().replace(/\\/g, '/'));
+            try {
+                const stabilityMap = await getStability(mathaDir, scopeFiles);
+                for (const [fp, record] of Object.entries(stabilityMap)) {
+                    if (record && record.stability === 'frozen') {
+                        log(`  ⚠ ${fp} — FROZEN (${record.reason})`);
+                        frozenFiles.push(fp);
+                    }
+                    else if (record && record.stability === 'stable') {
+                        log(`  · ${fp} — STABLE`);
+                    }
+                }
+            }
+            catch {
+                // Gracefully handle stability lookup errors
+            }
+        }
+        log('');
+    }
+    else {
+        log('\n  Cortex empty — run matha init or commit some code\n');
+    }
+    // GATE 04 — SENSE PAST HISTORY: Run Contract Matcher
+    const matchContext = {
+        scope,
+        intent: operationDescription,
+        operationType: 'unknown',
+        filepaths: scope.split(',').map((s) => s.trim()).filter(Boolean),
+    };
+    let matchResults = [];
+    try {
+        matchResults = await matchAll(matchContext, mathaDir);
+    }
+    catch {
+        matchResults = [];
+    }
+    const criticals = matchResults.filter(r => r.severity === 'critical');
+    const warnings = matchResults.filter(r => r.severity === 'warning');
+    const infos = matchResults.filter(r => r.severity === 'info');
+    const hasCritical = criticals.length > 0;
+    if (matchResults.length === 0) {
+        log('\n✓ No issues detected for this scope.\n');
+    }
+    else {
+        log('');
+        if (criticals.length > 0) {
+            log(`🚨 CRITICAL — ${criticals.length} issue(s) require attention:`);
+            for (const res of criticals) {
+                log(`  ✗ ${res.title}`);
+                log(`    ${res.description}`);
+                log(`    → ${res.recommendation}`);
+            }
+        }
+        if (warnings.length > 0) {
+            log(`⚠  WARNINGS — ${warnings.length} prior finding(s):`);
+            for (const res of warnings) {
+                log(`  · ${res.title}`);
+                log(`    ${res.description}`);
+            }
+        }
+        if (infos.length > 0) {
+            log(`ℹ  CONTEXT — ${infos.length} relevant contract(s):`);
+            for (const res of infos) {
+                log(`  · ${res.title} — ${res.description}`);
+            }
+        }
+        log('');
+    }
+    // GATE 05 — CONTRACT: Write the behaviour contract
+    const contractInput = await ask('Write the behaviour contract for this session.\nWhat must be true after your changes? (one assertion per line, empty line to finish)');
+    const assertions = contractInput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (assertions.length === 0) {
+        log('⚠ No contract written — build gate will be advisory only.\n');
+    }
+    // GATE 06 — COST CHECK: What type of operation?
+    log('\nWhat type of operation is this?');
+    log('  1. Rename / Format');
+    log('  2. CRUD / Boilerplate');
+    log('  3. Business Logic');
+    log('  4. Architecture Change');
+    log('  5. Frozen Component Change');
+    log('');
+    const operationTypeChoice = await ask('What type of operation is this? (1-5):');
+    const operationType = operationTypeMap[operationTypeChoice] || 'rename';
+    const rec = await getRecommendation(mathaDir, operationType);
+    const defaultDef = modelTierBudget[operationType];
+    const modelTier = rec.tier;
+    const tokenBudget = rec.budget;
+    if (rec.source === 'learned') {
+        log(`Model: ${modelTier} (budget: ${tokenBudget} tokens) — learned from ${rec.sample_size} sessions (${rec.confidence} confidence)`);
+        if (modelTier !== defaultDef.modelTier) {
+            const isUpgrade = (modelTier === 'capable' && (defaultDef.modelTier === 'mid' || defaultDef.modelTier === 'lightweight')) ||
+                (modelTier === 'mid' && defaultDef.modelTier === 'lightweight');
+            if (isUpgrade) {
+                log(`  ↑ Upgraded from ${defaultDef.modelTier} based on history`);
+            }
+            else {
+                log(`  ↓ Downgraded from ${defaultDef.modelTier} based on history`);
+            }
+        }
+    }
+    else {
+        log(`Model: ${modelTier} (budget: ${tokenBudget} tokens) — default (insufficient history for this operation type)`);
+    }
+    // Read hippocampus context
+    let businessRules = [];
+    try {
+        businessRules = await getRules(mathaDir);
+    }
+    catch {
+        businessRules = [];
+    }
+    // Build session brief directly
+    const readyToBuild = assertions.length > 0; // Only ready if contract provided
+    const brief = {
+        sessionId,
+        scope,
+        operationType,
+        timestamp,
+        operation_description: operationDescription,
+        why: '', // Not collected interactively - would be from Gate 01 in full flow
+        business_rules: businessRules,
+        matchResults,
+        hasCritical,
+        contract: assertions,
+        assertions,
+        modelTier,
+        tokenBudget,
+        routingSource: rec.source,
+        routingConfidence: rec.confidence,
+        gatesCompleted: [1, 2, 3, 4, 5, 6],
+        readyToBuild,
+        cortexSummary: cortexSnapshot?.summary ?? null,
+        frozenFiles,
+    };
+    // Write session brief to .matha/sessions/[sessionId].brief
+    const briefPath = path.join(mathaDir, `sessions/${sessionId}.brief`);
+    await writeAtomic(briefPath, brief);
+    // Write dopamine prediction to .matha/dopamine/predictions/[sessionId].json
+    const prediction = {
+        session_id: sessionId,
+        timestamp,
+        operation_type: operationType,
+        scope,
+        predicted: {
+            model_tier: modelTier,
+            token_budget: tokenBudget,
+        },
+        actual: null,
+        delta: null,
+    };
+    const predictionPath = path.join(mathaDir, `dopamine/predictions/${sessionId}.json`);
+    await writeAtomic(predictionPath, prediction);
+    // Print human-readable brief to terminal
+    log('\n════════════════════════════════════════');
+    log(`MATHA SESSION BRIEF — ${sessionId}`);
+    log('════════════════════════════════════════\n');
+    log(`SCOPE:    ${scope}`);
+    log(`WHAT:     ${operationDescription}`);
+    log(`TYPE:     ${operationType}`);
+    const learnedSuffix = rec.source === 'learned' ? ` — learned from ${rec.sample_size} sessions (${rec.confidence} confidence)` : ' — default';
+    log(`MODEL:    ${modelTier} (budget: ${tokenBudget} tokens)${learnedSuffix}\n`);
+    log('BUSINESS RULES:');
+    if (businessRules.length > 0) {
+        for (const rule of businessRules) {
+            log(`  · ${rule}`);
+        }
+    }
+    else {
+        log('  (none defined)');
+    }
+    log('');
+    log('MATCH RESULTS:');
+    if (matchResults.length > 0) {
+        for (const res of matchResults) {
+            log(`  · [${res.severity.toUpperCase()}] ${res.title}`);
+        }
+    }
+    else {
+        log('  None detected');
+    }
+    log('');
+    log('CONTRACT:');
+    if (assertions.length > 0) {
+        for (const assertion of assertions) {
+            log(`  · ${assertion}`);
+        }
+    }
+    else {
+        log('  (no contract written — advisory only)');
+    }
+    log('');
+    log('════════════════════════════════════════');
+    log(`READY TO BUILD: ${brief.readyToBuild ? 'YES' : 'NO (advisory only)'}`);
+    if (hasCritical) {
+        log('⚠ Critical issues detected — proceed with caution');
+    }
+    log('════════════════════════════════════════\n');
+    log('Paste this brief into your AI agent before starting.\n');
+    return {
+        exitCode: 0,
+        sessionId,
+        brief,
+        readyToBuild: brief.readyToBuild,
+    };
+}
+// Default ask implementation using @inquirer/prompts
+async function defaultAsk(question) {
+    // Dynamically import to avoid ESM issues
+    const { input } = await import('@inquirer/prompts');
+    // Handle multiline input
+    if (question.includes('behaviour contract')) {
+        let lines = [];
+        let lineCount = 1;
+        log(question);
+        while (true) {
+            const line = await input({
+                message: `Line ${lineCount}:`,
+                default: '',
+            });
+            if (line.trim() === '') {
+                break;
+            }
+            lines.push(line);
+            lineCount++;
+        }
+        return lines.join('\n');
+    }
+    // Regular single-line input
+    return await input({ message: question });
+}
+// Log helper
+function log(msg) {
+    console.log(msg);
+}
+export { runBefore };