brainclaw 0.28.0 → 1.5.3

package/dist/commands/compact.js

@@ -0,0 +1,74 @@
+/**
+ * CLI command: brainclaw compact
+ *
+ * LLM-driven semantic memory compaction — assess pressure or archive old items.
+ *
+ * @module
+ */
+import { memoryExists } from '../core/io.js';
+import { compact as gcCompact, assessMemoryPressure, buildCompactionTemplate } from '../core/gc-semantic.js';
+export function runCompact(options = {}) {
+    if (!memoryExists(process.cwd())) {
+        console.error('Project memory not initialized. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    // --assess mode: show pressure assessment and template only, no archiving
+    if (options.assess) {
+        const assessment = assessMemoryPressure();
+        const maxItems = options.maxItems ?? 20;
+        const selected = assessment.eligible_items.slice(0, maxItems);
+        console.log(`Memory pressure: ${assessment.pressure ? 'YES' : 'no'}`);
+        console.log(`  Done plans: ${assessment.done_plans} (threshold: ${assessment.thresholds.plans})`);
+        console.log(`  Closed handoffs: ${assessment.closed_handoffs} (threshold: ${assessment.thresholds.handoffs})`);
+        console.log(`  Eligible items: ${assessment.eligible_items.length}`);
+        if (selected.length > 0) {
+            console.log('');
+            console.log(buildCompactionTemplate(selected));
+        }
+        else {
+            console.log('No items eligible for compaction.');
+        }
+        return;
+    }
+    // Default mode: compact (archive eligible items)
+    const result = gcCompact({
+        dryRun: options.dryRun,
+        maxItems: options.maxItems,
+        minAgeDays: options.minAge,
+        dedupHandoffs: !options.noDedupHandoffs,
+        purgeReleasedClaims: !options.noPurgeClaims,
+        purgeSessionNotes: !options.noPurgeSessionNotes,
+    });
+    if (result.dry_run) {
+        console.log(`🔍 Dry run — ${result.eligible_count} plan/handoff item(s) eligible for compaction.`);
+    }
+    else {
+        console.log(`✔ Compacted ${result.archived_count}/${result.eligible_count} plan/handoff item(s).`);
+        if (result.backup_path) {
+            console.log(`Backup: ${result.backup_path}`);
+        }
+    }
+    // Post-v1 extension summaries (pln#436)
+    const extras = [];
+    if ((result.claims_archived ?? 0) > 0) {
+        extras.push(`${result.claims_archived} released claim(s)`);
+    }
+    if ((result.session_notes_archived ?? 0) > 0) {
+        extras.push(`${result.session_notes_archived} session runtime_note(s)`);
+    }
+    if ((result.handoffs_deduped ?? 0) > 0) {
+        extras.push(`${result.handoffs_deduped} duplicate handoff(s)`);
+    }
+    if (extras.length > 0) {
+        const verb = result.dry_run ? 'eligible' : 'archived';
+        console.log(`  • ${verb}: ${extras.join(', ')}`);
+    }
+    if (result.template) {
+        console.log('');
+        console.log(result.template);
+    }
+    else if (result.eligible_count === 0 && extras.length === 0) {
+        console.log('No items eligible for compaction.');
+    }
+}
+//# sourceMappingURL=compact.js.map

package/dist/commands/complete-step.js

@@ -1,32 +1,22 @@
-import { loadState, persistState } from '../core/state.js';
-import { memoryExists } from '../core/io.js';
-import { nowISO } from '../core/ids.js';
+import { requireInitialized } from '../core/guards.js';
+import { completeStep } from '../core/operations/plan.js';
 export function runCompleteStep(planId, stepId) {
-    if (!memoryExists()) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
-    }
-    const state = loadState();
-    const plan = state.plan_items.find((p) => p.id === planId || p.short_label === planId);
-    if (!plan) {
-        console.error(`Error: Plan '${planId}' not found.`);
-        process.exit(1);
+    requireInitialized(process.cwd());
+    try {
+        const result = completeStep({ planId, stepId });
+        console.log(`✔ Step completed: [${result.stepId}]`);
+        console.log(`  Plan [${result.planId}] progress: ${result.doneSteps}/${result.totalSteps} steps done`);
+        if (result.planAutoCompleted) {
+            console.log(`  All steps done — plan auto-completed.`);
+        }
+        else if (result.doneSteps === result.totalSteps) {
+            console.log(`  All steps done — consider: brainclaw update-plan ${result.planId} --status done`);
+        }
     }
-    const step = (plan.steps ?? []).find((s) => s.id === stepId);
-    if (!step) {
-        console.error(`Error: Step '${stepId}' not found in plan '${planId}'.`);
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
         process.exit(1);
     }
-    step.status = 'done';
-    step.updated_at = nowISO();
-    plan.updated_at = nowISO();
-    persistState(state);
-    const total = plan.steps.length;
-    const done = plan.steps.filter((s) => s.status === 'done').length;
-    console.log(`✔ Step completed: [${step.id}] ${step.text}`);
-    console.log(`  Plan [${plan.id}] progress: ${done}/${total} steps done`);
-    if (done === total) {
-        console.log(`  All steps done — consider: brainclaw update-plan ${plan.id} --status done`);
-    }
 }
 //# sourceMappingURL=complete-step.js.map

package/dist/commands/constraint.js

@@ -1,17 +1,13 @@
-import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { loadConfig } from '../core/config.js';
-import { generateIdWithLabel, nowISO } from '../core/ids.js';
 import { scanText } from '../core/security.js';
-import { memoryExists } from '../core/io.js';
+import { requireInitialized } from '../core/guards.js';
 import { validateCliInput } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
+import { createConstraint } from '../core/operations/memory-write.js';
 export function runConstraint(text, options = {}) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
-    if (!memoryExists(cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
-    }
+    requireInitialized(cwd);
     validateCliInput(text, options.tag);
     const config = loadConfig(cwd);
     const warnings = scanText(text, config);
@@ -22,21 +18,13 @@ export function runConstraint(text, options = {}) {
             process.exit(1);
         }
     }
-    const state = loadState(cwd);
-    const { id, short_label } = generateIdWithLabel('active_constraints');
-    const entry = {
-        id,
-        short_label,
+    const result = createConstraint({
         text,
-        created_at: nowISO(),
         author: options.author ?? resolveCurrentAgentName(cwd),
-        status: 'active',
         category: options.category,
-        tags: options.tag ?? [],
-        related_paths: options.path,
-    };
-    state.active_constraints.push(entry);
-    persistState(state, cwd);
-    console.log(`✔ Constraint added: [${id}] ${text}`);
+        tags: options.tag,
+        relatedPaths: options.path,
+    }, cwd);
+    console.log(`✔ Constraint added: [${result.id}] ${text}`);
 }
 //# sourceMappingURL=constraint.js.map

package/dist/commands/decision.js

@@ -1,17 +1,13 @@
-import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { loadConfig } from '../core/config.js';
-import { generateIdWithLabel, nowISO } from '../core/ids.js';
 import { scanText } from '../core/security.js';
-import { memoryExists } from '../core/io.js';
+import { requireInitialized } from '../core/guards.js';
 import { validateCliInput } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
+import { createDecision } from '../core/operations/memory-write.js';
 export function runDecision(text, options = {}) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
-    if (!memoryExists(cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
-    }
+    requireInitialized(cwd);
     validateCliInput(text, options.tag);
     const config = loadConfig(cwd);
     const warnings = scanText(text, config);
@@ -22,21 +18,14 @@ export function runDecision(text, options = {}) {
             process.exit(1);
         }
     }
-    const state = loadState(cwd);
-    const { id, short_label } = generateIdWithLabel('recent_decisions');
-    const entry = {
-        id,
-        short_label,
+    const result = createDecision({
         text,
-        created_at: nowISO(),
         author: options.author ?? resolveCurrentAgentName(cwd),
         outcome: options.outcome,
-        tags: options.tag ?? [],
-        related_paths: options.path,
-        plan_id: options.plan,
-    };
-    state.recent_decisions.push(entry);
-    persistState(state, cwd);
-    console.log(`✔ Decision added: [${id}] ${text}`);
+        tags: options.tag,
+        relatedPaths: options.path,
+        planId: options.plan,
+    }, cwd);
+    console.log(`✔ Decision added: [${result.id}] ${text}`);
 }
 //# sourceMappingURL=decision.js.map

package/dist/commands/delete-plan.js

@@ -1,18 +1,16 @@
-import { loadState, persistState } from '../core/state.js';
-import { memoryExists } from '../core/io.js';
+import { requireInitialized } from '../core/guards.js';
+import { deletePlan } from '../core/operations/plan.js';
 export function runDeletePlan(id, options = {}) {
-    if (!memoryExists(options.cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
+    const cwd = options.cwd ?? process.cwd();
+    requireInitialized(cwd);
+    try {
+        const result = deletePlan(id, cwd);
+        console.log(`✔ Plan item deleted: [${result.id}] ${result.text}`);
     }
-    const state = loadState(options.cwd);
-    const index = state.plan_items.findIndex((item) => item.id === id || item.short_label === id);
-    if (index < 0) {
-        console.error(`Error: Plan item '${id}' not found.`);
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
         process.exit(1);
     }
-    const [plan] = state.plan_items.splice(index, 1);
-    persistState(state, options.cwd);
-    console.log(`✔ Plan item deleted: [${plan.id}] ${plan.text}`);
 }
 //# sourceMappingURL=delete-plan.js.map

package/dist/commands/delete-step.js

@@ -0,0 +1,16 @@
+import { requireInitialized } from '../core/guards.js';
+import { deleteStep } from '../core/operations/plan.js';
+export function runDeleteStep(planId, stepId) {
+    requireInitialized(process.cwd());
+    try {
+        const result = deleteStep({ planId, stepId });
+        console.log(`✔ Step deleted: [${result.stepId}]`);
+        console.log(`  Plan [${result.planId}]: ${result.totalSteps} step(s) remaining (${result.doneSteps} done)`);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=delete-step.js.map

package/dist/commands/dispatch.js

@@ -0,0 +1,163 @@
+/**
+ * CLI command: brainclaw dispatch
+ *
+ * Subcommands:
+ *   brainclaw dispatch analysis    — show lane status
+ *   brainclaw dispatch run         — send assignments to available agents
+ *   brainclaw dispatch run --dry   — preview assignments without sending
+ *
+ * @module
+ */
+import { memoryExists } from '../core/io.js';
+import { analyzeSequence, dispatch, dispatchReview } from '../core/dispatcher.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+export function runDispatchAnalysis(options) {
+    const cwd = options.cwd;
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const analysis = analyzeSequence(cwd ?? process.cwd());
+    if (!analysis) {
+        console.log('No active sequence found.');
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(analysis, null, 2));
+        return;
+    }
+    console.log(`\nDispatch Analysis — ${analysis.sequence.name}\n`);
+    // Ready
+    console.log(`🟢 Ready (${analysis.ready.length}):`);
+    for (const r of analysis.ready) {
+        const lane = r.lane ? ` [${r.lane}]` : '';
+        const assignee = r.plan.assignee ? ` → ${r.plan.assignee}` : '';
+        console.log(`  ${r.plan.short_label ?? r.plan.id}${lane}${assignee}`);
+        console.log(`    ${r.plan.text.slice(0, 100)}`);
+        console.log(`    ${r.reason}`);
+    }
+    // Active
+    if (analysis.active.length > 0) {
+        console.log(`\n🔵 Active (${analysis.active.length}):`);
+        for (const a of analysis.active) {
+            const lane = a.lane ? ` [${a.lane}]` : '';
+            // Codex r1 finding: on the dispatch surface, `young` is NOT a no-alarm
+            // state — it means the coordinator claim exists but no worker session
+            // has adopted it yet. "agent working" would mislead the operator into
+            // thinking the lane is actively progressing.
+            let status = 'working';
+            let livenessTag = '';
+            if (a.liveness === 'young' && !a.claim.session_id) {
+                status = 'pending adoption';
+            }
+            else if (a.liveness && a.liveness !== 'live' && a.liveness !== 'young') {
+                livenessTag = ` [${a.liveness.toUpperCase()}]`;
+            }
+            console.log(`  ${a.plan.short_label ?? a.plan.id}${lane} — ${a.agent} ${status}${livenessTag}`);
+        }
+    }
+    // Blocked
+    if (analysis.blocked.length > 0) {
+        console.log(`\n🔴 Blocked (${analysis.blocked.length}):`);
+        for (const b of analysis.blocked) {
+            const lane = b.lane ? ` [${b.lane}]` : '';
+            console.log(`  ${b.item.planId}${lane} — ${b.reason}`);
+        }
+    }
+    // Done
+    if (analysis.done.length > 0) {
+        console.log(`\n✅ Done (${analysis.done.length})`);
+    }
+    // Available agents
+    console.log(`\nAvailable agents: ${analysis.available_agents.length > 0 ? analysis.available_agents.join(', ') : '(none)'}`);
+    console.log('');
+}
+export async function runDispatch(options) {
+    const cwd = options.cwd;
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const effectiveCwd = cwd ?? process.cwd();
+    const dispatcherAgent = options.agent ?? resolveCurrentAgentName(effectiveCwd) ?? 'brainclaw';
+    const result = await dispatch({
+        agents: options.agents?.split(',').map(a => a.trim()),
+        lanes: options.lanes?.split(',').map(l => l.trim()),
+        maxAssignments: options.max,
+        dryRun: options.dry,
+        dispatcherAgent,
+        autoExecute: options.spawn,
+    }, effectiveCwd);
+    if (!result) {
+        console.log('No active sequence found.');
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const { analysis, result: dispatchResult } = result;
+    if (options.dry) {
+        console.log(`\n🔍 Dispatch dry run — ${analysis.sequence.name}\n`);
+    }
+    else {
+        console.log(`\n✔ Dispatch complete — ${analysis.sequence.name}\n`);
+    }
+    console.log(`  Ready: ${analysis.ready.length} | Active: ${analysis.active.length} | Blocked: ${analysis.blocked.length} | Done: ${analysis.done.length}`);
+    if (dispatchResult.messages_sent.length > 0) {
+        console.log(`\n  ${options.dry ? 'Would assign' : 'Assigned'}:`);
+        for (const msg of dispatchResult.messages_sent) {
+            const lane = msg.lane ? ` (lane: ${msg.lane})` : '';
+            const exec = msg.execution_status ? ` [${msg.execution_status}]` : ' [inbox]';
+            console.log(`    → ${msg.agent}: ${msg.plan_id}${lane}${exec}`);
+        }
+    }
+    if (dispatchResult.skipped.length > 0) {
+        console.log('\n  Skipped:');
+        for (const skip of dispatchResult.skipped) {
+            console.log(`    - ${skip.plan_id}: ${skip.reason}`);
+        }
+    }
+    console.log('');
+}
+export function runDispatchReview(options) {
+    const cwd = options.cwd;
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const effectiveCwd = cwd ?? process.cwd();
+    const dispatcherAgent = options.agent ?? resolveCurrentAgentName(effectiveCwd) ?? 'brainclaw';
+    const result = dispatchReview({
+        handoffId: options.handoff,
+        reviewer: options.reviewer,
+        dryRun: options.dry,
+        dispatcherAgent,
+    }, effectiveCwd);
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (options.dry) {
+        console.log('\n🔍 Review dispatch dry run\n');
+    }
+    else {
+        console.log('\n✔ Review dispatch complete\n');
+    }
+    if (result.reviews_sent.length > 0) {
+        for (const r of result.reviews_sent) {
+            console.log(`  → ${r.reviewer} reviewing ${r.handoff_id}${r.plan_id ? ` (${r.plan_id})` : ''} [inbox]`);
+        }
+    }
+    else {
+        console.log('  No handoffs ready for review.');
+    }
+    if (result.skipped.length > 0) {
+        console.log('\n  Skipped:');
+        for (const s of result.skipped) {
+            console.log(`    - ${s.handoff_id}: ${s.reason}`);
+        }
+    }
+    console.log('');
+}
+//# sourceMappingURL=dispatch.js.map