cawdex 1.35.65 → 1.35.67

package/dist/git-workflow.js

@@ -65,34 +65,34 @@ export function buildCommitPrompt(cwd) {
     const recentLog = gitLog(cwd, 5);
     if (!status && !stagedDiff && !unstagedDiff)
         return null;
-    return `Generate a git commit for the following changes.
-
-## Git Status
-\`\`\`
-${status}
-\`\`\`
-
-## Staged Changes
-\`\`\`diff
-${stagedDiff || '(no staged changes)'}
-\`\`\`
-
-## Unstaged Changes
-\`\`\`diff
-${unstagedDiff.slice(0, 5000) || '(no unstaged changes)'}
-\`\`\`
-
-## Recent Commits (for style reference)
-\`\`\`
-${recentLog}
-\`\`\`
-
-Instructions:
-1. If there are unstaged changes, suggest which files to stage with \`git add\`
-2. Write a concise commit message (imperative mood, <72 chars title)
-3. Add a body if the changes are complex
-4. Run the git commands to stage and commit
-
+    return `Generate a git commit for the following changes.
+
+## Git Status
+\`\`\`
+${status}
+\`\`\`
+
+## Staged Changes
+\`\`\`diff
+${stagedDiff || '(no staged changes)'}
+\`\`\`
+
+## Unstaged Changes
+\`\`\`diff
+${unstagedDiff.slice(0, 5000) || '(no unstaged changes)'}
+\`\`\`
+
+## Recent Commits (for style reference)
+\`\`\`
+${recentLog}
+\`\`\`
+
+Instructions:
+1. If there are unstaged changes, suggest which files to stage with \`git add\`
+2. Write a concise commit message (imperative mood, <72 chars title)
+3. Add a body if the changes are complex
+4. Run the git commands to stage and commit
+
 Follow the existing commit message style from the recent log.`;
 }
 /**
@@ -106,27 +106,27 @@ export function buildPRPrompt(cwd) {
     const diffStat = git(`diff ${baseBranch}...HEAD --stat`, cwd);
     const log = git(`log ${baseBranch}..HEAD --oneline`, cwd);
     const diff = git(`diff ${baseBranch}...HEAD`, cwd);
-    return `Create a GitHub Pull Request for branch \`${branch}\` into \`${baseBranch}\`.
-
-## Commits
-\`\`\`
-${log}
-\`\`\`
-
-## Diff Summary
-\`\`\`
-${diffStat}
-\`\`\`
-
-## Full Diff (truncated)
-\`\`\`diff
-${diff.slice(0, 10000)}
-\`\`\`
-
-Instructions:
-1. Write a PR title (<70 chars)
-2. Write a description with: Summary (bullet points), Test Plan
-3. Run: gh pr create --title "..." --body "..."
+    return `Create a GitHub Pull Request for branch \`${branch}\` into \`${baseBranch}\`.
+
+## Commits
+\`\`\`
+${log}
+\`\`\`
+
+## Diff Summary
+\`\`\`
+${diffStat}
+\`\`\`
+
+## Full Diff (truncated)
+\`\`\`diff
+${diff.slice(0, 10000)}
+\`\`\`
+
+Instructions:
+1. Write a PR title (<70 chars)
+2. Write a description with: Summary (bullet points), Test Plan
+3. Run: gh pr create --title "..." --body "..."
 4. Return the PR URL`;
 }
 function detectBaseBranch(cwd) {

package/dist/index.js

@@ -79,7 +79,7 @@ import { status as sandboxStatus } from './sandbox.js';
 // API key rotation pool (/keys)
 import { listStatus as keyPoolStatus, setPool as syncKeyPool } from './key-rotation.js';
 // Agentic swarm — fan-out concurrent agents on the same task (/swarm)
-import { runSwarm, resolveAgents, formatSwarmResults } from './swarm.js';
+import { buildSwarmAgentTask, buildSwarmPlan, decodeSwarmSentinel, encodeSwarmSentinel, formatSwarmResults, parseSwarmCommandArgs, resolveAgents, runSwarm, } from './swarm.js';
 // Voice / accessibility — built-in dictation (Whisper) + readout (ElevenLabs)
 import { printVoiceStatus, isVoiceEnabled, getTtsConfig, getSttConfig, getAccessibilityConfig, speak, dictateOnce, } from './voice.js';
 import { isFfmpegAvailable, audioCue, startRecording, probeMic, micProbeMessage } from './audio.js';
@@ -123,6 +123,31 @@ function applyModelSelection(config, model, catalogModel) {
         delete config.contextWindowTokens;
     }
 }
+function clipSetupValue(value, max = 120) {
+    const single = value.replace(/\s+/g, ' ').trim();
+    return single.length <= max ? single : single.slice(0, max - 1) + '…';
+}
+async function runSwarmSetupWizard(rl, plan) {
+    if (!stdin.isTTY || process.env.CAWDEX_SWARM_WIZARD === '0')
+        return plan;
+    const next = {
+        ...plan,
+        setup: { ...plan.setup },
+    };
+    const ask = async (label, current) => {
+        const prompt = theme.dim(`  ${label}`) + theme.syntaxPunctuation(` [${clipSetupValue(current)}]: `);
+        const answer = (await rl.question(prompt)).trim();
+        return answer || current;
+    };
+    console.log(theme.header('  Swarm setup'));
+    console.log(theme.dim('  Press Enter to accept an inferred value, or type a correction.'));
+    next.setup.goal = await ask('Goal', next.setup.goal);
+    next.setup.budget = await ask('Budget/time', next.setup.budget);
+    next.setup.target = await ask('Target platform/stack', next.setup.target);
+    next.setup.assets = await ask('Starting assets/resources', next.setup.assets);
+    next.setup.quality = await ask('Quality bar/release target', next.setup.quality);
+    return next;
+}
 // ── Setup Wizard ──────────────────────────────────────────
 function printCommandHelp(query) {
     const resolved = resolveCommandEntry(query);
@@ -780,7 +805,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             // silent aliases for power users but are not listed here.
             console.log(h('\n  ── Orchestration ──'));
             console.log(d('  ') + c('/orchestrate <task>') + d(' — decompose into parallel sub-agents'));
-            console.log(d('  ') + c('/swarm <agents> <task>') + d(' — true parallel fan-out: N agents on same task, results merged with attribution'));
+            console.log(d('  ') + c('/swarm <task>') + d(' — infer roles, run analysis-only agents, synthesize a handoff (expert: /swarm <agents> <task>)'));
             console.log(d('  ') + c('/pr-loop') + d('          — autonomous PR review loop'));
             console.log(d('  ') + c('/multi-plan <task>') + d(' — multi-agent planning'));
             console.log(d('  ') + c('/multi-execute') + d('    — multi-agent execution'));
@@ -1365,9 +1390,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             return { handled: true };
         case '/resume': {
             if (!args.trim()) {
-                console.log(chalk.yellow('  Usage: /resume <session-id> | <prefix> | last'));
-                console.log(chalk.dim('  /sessions lists what\'s saved.'));
-                return { handled: true };
+                return { handled: true, injectPrompt: '__RESUME_PICK__' };
             }
             // resolveSessionRef accepts exact ID, prefix match (like git),
             // "last"/"latest" shortcut, and strips angle/quote wrappers
@@ -1728,29 +1751,19 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             mode.current = 'architect';
             const orchPrompt = buildOrchestrationPrompt(args);
             return { handled: false, injectPrompt: orchPrompt };
-        // ── Agentic swarm — true parallel fan-out (M3 swarm audit) ──
-        // Run N agents concurrently on the same task. Each agent gets its
-        // own ECC prompt + the task as user message; outputs are merged
-        // with attribution headers. No tools available to swarm agents —
-        // analysis only, no file edits.
-        //
-        //   /swarm <agent1,agent2,...> <task>
-        //
-        // Each agent's request uses the key rotation pool from v1.23.0,
-        // so multi-account users get true parallel throughput.
+        // ── Agentic swarm ─────────────────────────────────
+        // Default: /swarm <natural task>. Cawdex infers roles, runs them
+        // analysis-only, then hands the synthesis back to the main agent.
+        // Expert shortcut remains: /swarm <agent1,agent2> <task>.
         case '/swarm': {
-            // Match: first whitespace-free token is the agents list, rest is task
-            const m = args.match(/^(\S+)\s+([\s\S]+)$/);
-            if (!m) {
-                console.log(chalk.yellow('  Usage: /swarm <agent1,agent2,...> <task>'));
-                console.log(chalk.dim('  Example: /swarm code-architect,silent-failure-hunter,type-design-analyzer  audit the auth flow'));
-                console.log(chalk.dim('  Run /ecc-guide agents to see available agents.'));
+            const parsed = parseSwarmCommandArgs(args);
+            if ('error' in parsed) {
+                console.log(chalk.yellow(`  ${parsed.error}`));
+                console.log(chalk.dim('  Example: /swarm Build a working browser game with tests'));
+                console.log(chalk.dim('  Expert:  /swarm code-architect,silent-failure-hunter audit the auth flow'));
                 return { handled: true };
             }
-            const [, agentsList, task] = m;
-            // Use a sentinel + delimiter approach so the main REPL loop can
-            // pick up the async swarm dispatch (slash handlers are sync).
-            return { handled: false, injectPrompt: '__SWARM__' + agentsList + '|||' + task };
+            return { handled: true, injectPrompt: encodeSwarmSentinel(parsed.payload) };
         }
         // ── Verification & Build ─────────────────────────
         case '/verify': {
@@ -3336,12 +3349,7 @@ async function main() {
     // saved before that check landed never see the warning. Print it
     // every launch so they get a chance to switch via /model before
     // they hit the "model returns nothing, REPL looks frozen" footgun.
-    const flakyPatterns = [
-        'owl-alpha', 'horizon-alpha', 'horizon-beta',
-        'optimus-alpha', 'quasar-alpha',
-    ];
-    const lowerModelAtLaunch = (config.model || '').toLowerCase();
-    if (flakyPatterns.some((p) => lowerModelAtLaunch.includes(p))) {
+    if (isKnownFlakyOpenRouterModel(config)) {
         console.log(theme.warning(`  ⚠  Active model "${config.model}" is an experimental / free model known to`));
         console.log(theme.warning(`     return empty or "ERROR" responses, or get stuck in token loops.`));
         console.log(theme.dim(`     Switch with /openrouter-free or /model openrouter/free.`));
@@ -4393,6 +4401,26 @@ async function main() {
                     }
                     continue;
                 }
+                else if (result.injectPrompt === '__RESUME_PICK__') {
+                    const sessions = listSessions();
+                    if (sessions.length === 0) {
+                        console.log(theme.dim('  No saved sessions.'));
+                        continue;
+                    }
+                    const { pickSession } = await import('./session-picker.js');
+                    const selectedId = await pickSession(sessions, { title: 'Cawdex · resume session' });
+                    if (!selectedId) {
+                        console.log(theme.dim('  Cancelled — session unchanged.'));
+                        continue;
+                    }
+                    const resumeResult = handleSlashCommand(`/resume ${selectedId}`, config, messages, session, mode);
+                    if (resumeResult.newMessages !== undefined) {
+                        messages.length = 0;
+                        messages.push(...resumeResult.newMessages);
+                    }
+                    await saveWithSnapshot();
+                    continue;
+                }
                 else if (result.injectPrompt === '__OPENAI_OAUTH_SMOKE__') {
                     const smoke = await runOpenAICodexSmokeTest(config);
                     console.log(formatOpenAICodexSmokeResult(smoke));
@@ -4432,29 +4460,30 @@ async function main() {
                     continue;
                 }
                 else if (result.injectPrompt.startsWith('__SWARM__')) {
-                    // Swarm dispatch: __SWARM__<agentsCsv>|||<task>. Same sentinel
-                    // trick as /dictate so the slash handler stays sync; the async
-                    // fan-out happens here in the main REPL loop where we already
-                    // have await + the live config object.
-                    const payload = result.injectPrompt.slice('__SWARM__'.length);
-                    const sepIdx = payload.indexOf('|||');
-                    const agentsCsv = payload.slice(0, sepIdx);
-                    const task = payload.slice(sepIdx + 3);
-                    const slugs = agentsCsv.split(',').map((s) => s.trim()).filter(Boolean);
+                    const payload = decodeSwarmSentinel(result.injectPrompt);
+                    if (!payload) {
+                        console.log(chalk.yellow('  /swarm: could not parse swarm payload.'));
+                        continue;
+                    }
+                    let plan = buildSwarmPlan(payload);
+                    if (payload.mode === 'auto') {
+                        plan = await runSwarmSetupWizard(rl, plan);
+                    }
                     try {
-                        const agents = resolveAgents(slugs);
-                        console.log(chalk.cyan(`  Swarming ${agents.length} agent(s) in parallel: ${agents.map((a) => a.name).join(', ')}`));
-                        console.log(chalk.dim(`  Task: ${task.length > 100 ? task.slice(0, 97) + '...' : task}`));
+                        const agents = resolveAgents(plan.agents);
+                        console.log(chalk.cyan(`  Swarming ${agents.length} agent(s): ${agents.map((a) => a.name).join(', ')}`));
+                        console.log(chalk.dim(`  Task: ${plan.task.length > 100 ? plan.task.slice(0, 97) + '...' : plan.task}`));
+                        console.log(chalk.dim('  Setup: goal, budget/time, platform, assets, quality bar inferred; workers stay analysis-only.'));
                         const swarmStart = Date.now();
-                        const results = await runSwarm(agents, task, config);
-                        const output = formatSwarmResults(results);
+                        const results = await runSwarm(agents, buildSwarmAgentTask(plan), config);
+                        const output = formatSwarmResults(results, plan);
                         console.log(output);
                         const elapsed = ((Date.now() - swarmStart) / 1000).toFixed(1);
                         const ok = results.filter((r) => !r.error).length;
                         console.log(chalk.dim(`\n  swarm complete: ${ok}/${results.length} agent(s) succeeded in ${elapsed}s`));
                         // Push the swarm as conversational context so follow-up
                         // turns can reason about the consolidated output.
-                        messages.push({ role: 'user', content: `[/swarm ${agents.map((a) => a.name).join(',')}] ${task}` });
+                        messages.push({ role: 'user', content: `[/swarm ${payload.mode === 'legacy' ? agents.map((a) => a.name).join(',') + ' ' : ''}${plan.task}]` });
                         messages.push({ role: 'assistant', content: output.slice(0, 8000) });
                     }
                     catch (e) {