brainclaw 0.19.2

package/dist/commands/check-constraints.js

@@ -0,0 +1,63 @@
+import { execSync } from 'node:child_process';
+import { loadState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
+/** Normalise a path to forward slashes and strip leading ./ */
+function normPath(p) {
+    return p.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+/** Returns true if any staged file matches a related_path (prefix or exact). */
+function pathMatches(stagedFile, relatedPath) {
+    const f = normPath(stagedFile);
+    const r = normPath(relatedPath).replace(/\/$/, '');
+    return f === r || f.startsWith(r + '/');
+}
+export function runCheckConstraints(options = {}) {
+    if (!memoryExists()) {
+        // Silent exit — hook context, not interactive
+        process.exit(0);
+    }
+    let filesToCheck = options.files ?? [];
+    if (options.staged) {
+        try {
+            const output = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+            filesToCheck = output.split('\n').map((f) => f.trim()).filter(Boolean);
+        }
+        catch {
+            // Not in a git repo or no staged files — silent pass
+            process.exit(0);
+        }
+    }
+    if (filesToCheck.length === 0) {
+        process.exit(0);
+    }
+    const state = loadState();
+    const violations = [];
+    for (const constraint of state.active_constraints) {
+        if (!constraint.related_paths || constraint.related_paths.length === 0)
+            continue;
+        const matched = filesToCheck.filter((f) => constraint.related_paths.some((rp) => pathMatches(f, rp)));
+        if (matched.length > 0) {
+            violations.push({
+                constraintId: constraint.id,
+                constraintText: constraint.text,
+                matchedFiles: matched,
+            });
+        }
+    }
+    if (options.json) {
+        console.log(JSON.stringify({ violations, staged_files: filesToCheck }, null, 2));
+        process.exit(violations.length > 0 ? 1 : 0);
+    }
+    if (violations.length === 0) {
+        process.exit(0);
+    }
+    process.stderr.write('\nbrainclaw: active constraint(s) cover staged files — commit blocked.\n\n');
+    for (const v of violations) {
+        process.stderr.write(`  ⚠  [${v.constraintId}] ${v.constraintText}\n`);
+        process.stderr.write(`     Files: ${v.matchedFiles.join(', ')}\n\n`);
+    }
+    process.stderr.write('  Review constraints: brainclaw status\n');
+    process.stderr.write('  To bypass (not recommended): git commit --no-verify\n\n');
+    process.exit(1);
+}
+//# sourceMappingURL=check-constraints.js.map

package/dist/commands/claim-resource.js

@@ -0,0 +1,54 @@
+import { runClaim } from './claim.js';
+import { runListClaims } from './list-claims.js';
+import { runReleaseClaim } from './release-claim.js';
+export function runClaimResource(subcommand, args, options) {
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'create') {
+        const description = args.join(' ').trim();
+        if (!description) {
+            console.error('Error: claim create requires <description>');
+            process.exit(1);
+        }
+        if (!options.scope) {
+            console.error('Error: claim create requires --scope <scope>');
+            process.exit(1);
+        }
+        runClaim(description, options);
+        return;
+    }
+    if (normalized === 'list' || normalized === 'ls') {
+        runListClaims({
+            json: options.json,
+            all: options.all,
+            project: options.project,
+            plan: options.plan,
+            agent: options.agent,
+            cwd: options.cwd,
+        });
+        return;
+    }
+    if (normalized === 'release') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: claim release requires <id>');
+            process.exit(1);
+        }
+        runReleaseClaim(id, {
+            planStatus: options.planStatus,
+            cwd: options.cwd,
+        });
+        return;
+    }
+    // Compatibility path: `brainclaw claim "description" --scope ...`
+    const legacyDescription = [subcommand, ...args].join(' ').trim();
+    if (!legacyDescription) {
+        console.error('Error: missing claim subcommand or description.');
+        process.exit(1);
+    }
+    if (!options.scope) {
+        console.error('Error: claim create requires --scope <scope>');
+        process.exit(1);
+    }
+    runClaim(legacyDescription, options);
+}
+//# sourceMappingURL=claim-resource.js.map

package/dist/commands/claim.js

@@ -0,0 +1,92 @@
+import { buildOperationalIdentity } from '../core/identity.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { saveClaim, generateClaimId, listClaims } from '../core/claims.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { loadState, saveState } from '../core/state.js';
+import { nowISO } from '../core/ids.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { validateCliTtl } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+function parseTtl(ttl) {
+    const match = /^(\d+)([mhd])$/.exec(ttl.trim().toLowerCase());
+    if (!match)
+        return new Date(Date.now() + 8 * 3_600_000).toISOString();
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const ms = unit === 'm' ? value * 60_000 : unit === 'h' ? value * 3_600_000 : value * 86_400_000;
+    return new Date(Date.now() + ms).toISOString();
+}
+export function runClaim(description, options) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    options = { ...options, cwd };
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (options.ttl)
+        validateCliTtl(options.ttl);
+    let actor;
+    try {
+        const registered = requireRegisteredAgentIdentity({
+            agentName: options.agent,
+            agentId: options.agentId,
+            cwd: options.cwd,
+            allowCurrent: true,
+            allowEnv: true,
+        });
+        requireMinimumTrustLevel(registered, 'contributor');
+        actor = buildOperationalIdentity(registered.agent_name, options.cwd, { agentId: registered.agent_id });
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    // Check for overlapping active claims on the same scope
+    const existing = listClaims(options.cwd).filter(c => c.status === 'active' && c.scope === options.scope);
+    if (existing.length > 0) {
+        console.warn(`⚠ Active claim(s) already exist for scope "${options.scope}":`);
+        for (const c of existing) {
+            console.warn(`  [${c.id}] by ${c.agent}: ${c.description}`);
+        }
+        console.warn('  Proceeding anyway (advisory only).');
+    }
+    const state = loadState(options.cwd);
+    const plan = options.plan ? state.plan_items.find((item) => item.id === options.plan) : undefined;
+    if (options.plan && !plan) {
+        console.error(`Error: Plan item '${options.plan}' not found.`);
+        process.exit(1);
+    }
+    const id = generateClaimId();
+    const claim = {
+        id,
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        project_id: actor.project_id,
+        host_id: actor.host_id,
+        session_id: actor.session_id,
+        scope: options.scope,
+        description,
+        created_at: nowISO(),
+        project: options.project ?? plan?.project,
+        plan_id: options.plan,
+        status: 'active',
+        expires_at: options.ttl ? parseTtl(options.ttl) : undefined,
+    };
+    if (plan) {
+        if (!plan.assignee) {
+            plan.assignee = actor.agent;
+        }
+        if (plan.status === 'todo') {
+            plan.status = 'in_progress';
+        }
+        plan.updated_at = nowISO();
+        saveState(state, options.cwd);
+    }
+    saveClaim(claim, options.cwd);
+    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(plan ? state : loadState(options.cwd), options.cwd));
+    const planInfo = claim.plan_id ? ` [plan ${claim.plan_id}]` : '';
+    const ttlInfo = claim.expires_at ? ` (expires ${claim.expires_at.slice(0, 16).replace('T', ' ')})` : '';
+    const storeLabel = options.store && options.store !== 'local' ? ` [store:${options.store}]` : '';
+    console.log(`✔ Claim created: [${id}] ${actor.agent} → ${options.scope}: ${description}${planInfo}${ttlInfo}${storeLabel}`);
+}
+//# sourceMappingURL=claim.js.map

package/dist/commands/complete-step.js

@@ -0,0 +1,34 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { nowISO } from '../core/ids.js';
+import { generateMarkdown } from '../core/markdown.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);
+    }
+    const step = (plan.steps ?? []).find((s) => s.id === stepId);
+    if (!step) {
+        console.error(`Error: Step '${stepId}' not found in plan '${planId}'.`);
+        process.exit(1);
+    }
+    step.status = 'done';
+    step.updated_at = nowISO();
+    plan.updated_at = nowISO();
+    saveState(state);
+    writeFileAtomic(memoryPath('project.md'), generateMarkdown(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

@@ -0,0 +1,44 @@
+import { loadState, saveState } from '../core/state.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+import { loadConfig } from '../core/config.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { scanText } from '../core/security.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.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);
+    }
+    validateCliInput(text, options.tag);
+    const config = loadConfig(cwd);
+    const warnings = scanText(text, config);
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error('Blocked: strict redaction is enabled. Entry not added.');
+            process.exit(1);
+        }
+    }
+    const state = loadState(cwd);
+    const { id, short_label } = generateIdWithLabel('active_constraints');
+    const entry = {
+        id,
+        short_label,
+        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);
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    console.log(`✔ Constraint added: [${id}] ${text}`);
+}
+//# sourceMappingURL=constraint.js.map

package/dist/commands/context-diff.js

@@ -0,0 +1,32 @@
+import { buildContextDiff, resolveContextDiffSince } from '../core/context-diff.js';
+import { memoryExists } from '../core/io.js';
+export function runContextDiff(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const resolved = resolveContextDiffSince(options);
+    if (!resolved.since) {
+        if (options.session) {
+            console.error(`Error: session '${options.session}' not found in session snapshots or audit log.`);
+            process.exit(1);
+        }
+        console.error('Error: provide --since <ISO date> or --session <id>, or run `brainclaw context` first to seed a marker.');
+        process.exit(1);
+    }
+    const diff = buildContextDiff({ ...options, includeItems: true });
+    if (!diff) {
+        console.error('Error: unable to build context diff.');
+        process.exit(1);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(diff, null, 2));
+        return;
+    }
+    if (diff.counts.total === 0) {
+        console.log(`${diff.summary} since ${diff.since}.`);
+        return;
+    }
+    console.log(`${diff.summary} since ${diff.since}.`);
+}
+//# sourceMappingURL=context-diff.js.map

package/dist/commands/context.js

@@ -0,0 +1,63 @@
+import { memoryExists } from '../core/io.js';
+import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from '../core/context.js';
+import { writeContextMarker } from '../core/freshness.js';
+import { nowISO } from '../core/ids.js';
+import { logger } from '../core/logger.js';
+export function runContext(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                initialized: false,
+                action_required: 'Run `brainclaw init` to initialize project memory.',
+            }, null, 2));
+        }
+        else {
+            console.log('brainclaw: project memory not initialized. Run `brainclaw init` first.');
+        }
+        return;
+    }
+    const result = buildContext({
+        target: options.for,
+        project: options.project,
+        agent: options.agent,
+        host: options.host,
+        allHosts: options.allHosts,
+        includePending: options.includePending,
+        profile: options.profile,
+        maxItems: options.maxItems,
+        maxChars: options.maxChars,
+        digest: options.digest,
+        bootstrap: options.bootstrap,
+        refreshBootstrap: options.refreshBootstrap,
+        sinceSession: options.sinceSession,
+        cwd,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (options.template) {
+        const compact = options.compactTemplate || result.profile === 'openclaw';
+        console.log(renderContextPromptTemplate(result, compact));
+    }
+    else {
+        console.log(renderContextMarkdown(result, options.explain));
+    }
+    writeLastContextMarker(result, options, cwd);
+}
+function writeLastContextMarker(result, options, cwd) {
+    try {
+        writeContextMarker({
+            read_at: nowISO(),
+            memory_version: result.memory_version,
+            host_id: result.current_host,
+            target: options.for,
+            project: result.project,
+            all_hosts: options.allHosts ?? false,
+        }, cwd);
+    }
+    catch (err) {
+        logger.debug('Failed to write context marker:', err);
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/commands/decision.js

@@ -0,0 +1,45 @@
+import { loadState, saveState } from '../core/state.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+import { loadConfig } from '../core/config.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { scanText } from '../core/security.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.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);
+    }
+    validateCliInput(text, options.tag);
+    const config = loadConfig(cwd);
+    const warnings = scanText(text, config);
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error('Blocked: strict redaction is enabled. Entry not added.');
+            process.exit(1);
+        }
+    }
+    const state = loadState(cwd);
+    const { id, short_label } = generateIdWithLabel('recent_decisions');
+    const entry = {
+        id,
+        short_label,
+        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);
+    saveState(state, cwd);
+    // Rebuild markdown
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    console.log(`✔ Decision added: [${id}] ${text}`);
+}
+//# sourceMappingURL=decision.js.map

package/dist/commands/delete-plan.js

@@ -0,0 +1,20 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
+export function runDeletePlan(id, options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    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.`);
+        process.exit(1);
+    }
+    const [plan] = state.plan_items.splice(index, 1);
+    saveState(state, options.cwd);
+    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    console.log(`✔ Plan item deleted: [${plan.id}] ${plan.text}`);
+}
+//# sourceMappingURL=delete-plan.js.map

package/dist/commands/diff.js

@@ -0,0 +1,99 @@
+import { memoryExists, memoryPath, readFileSync, writeFileAtomic } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { listCandidates, listArchivedCandidates } from '../core/candidates.js';
+import { nowISO } from '../core/ids.js';
+export function runDiff(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .memory/ not found. Run `team-memory init` first.');
+        process.exit(1);
+    }
+    const markerPath = memoryPath('.last-context');
+    const usingMarker = !options.since;
+    let since;
+    if (options.since) {
+        since = new Date(options.since);
+        if (isNaN(since.getTime())) {
+            console.error(`Error: invalid date '${options.since}'. Use ISO 8601 format, e.g. 2026-03-14T10:00:00Z`);
+            process.exit(1);
+        }
+    }
+    else {
+        try {
+            const ts = readFileSync(markerPath).trim();
+            since = new Date(ts);
+            if (isNaN(since.getTime()))
+                throw new Error('invalid date in .last-context');
+        }
+        catch {
+            console.error('Error: no --since date provided and no .last-context marker found.');
+            console.error('Hint: run `team-memory context` first to set the marker, or use:');
+            console.error('  team-memory diff --since <ISO date>');
+            process.exit(1);
+        }
+    }
+    const sinceISO = since.toISOString();
+    const state = loadState();
+    const makeEntry = (section, type) => (e) => ({
+        id: e.id, entry_type: type, section, text: e.text, created_at: e.created_at,
+    });
+    const stateEntries = [
+        ...state.active_constraints.filter(e => e.created_at > sinceISO).map(makeEntry('active_constraints', 'constraint')),
+        ...state.recent_decisions.filter(e => e.created_at > sinceISO).map(makeEntry('recent_decisions', 'decision')),
+        ...state.known_traps.filter(e => e.created_at > sinceISO).map(makeEntry('known_traps', 'trap')),
+        ...state.open_handoffs.filter(e => e.created_at > sinceISO).map(makeEntry('open_handoffs', 'handoff')),
+    ].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const newPending = listCandidates('pending').filter(c => c.created_at > sinceISO);
+    const newAccepted = listArchivedCandidates('accepted').filter(c => (c.resolved_at ?? c.created_at) > sinceISO);
+    const total = stateEntries.length + newPending.length + newAccepted.length;
+    if (options.json) {
+        console.log(JSON.stringify({
+            since: sinceISO,
+            checked_at: new Date().toISOString(),
+            total_changes: total,
+            state_entries: stateEntries,
+            new_candidates: newPending,
+            accepted_candidates: newAccepted,
+        }, null, 2));
+    }
+    else {
+        if (total === 0) {
+            console.log(`No changes in .memory/ since ${sinceISO}`);
+        }
+        else {
+            console.log(`Changes since ${sinceISO}:`);
+            console.log('');
+            if (stateEntries.length > 0) {
+                console.log(`New canonical entries (${stateEntries.length}):`);
+                for (const e of stateEntries) {
+                    console.log(`  + [${e.id}] (${e.entry_type}) ${e.text}`);
+                }
+            }
+            if (newPending.length > 0) {
+                if (stateEntries.length > 0)
+                    console.log('');
+                console.log(`New candidates pending review (${newPending.length}):`);
+                for (const c of newPending) {
+                    console.log(`  ? [${c.id}] (${c.type}) ${c.text}`);
+                }
+            }
+            if (newAccepted.length > 0) {
+                console.log('');
+                console.log(`Candidates accepted into memory (${newAccepted.length}):`);
+                for (const c of newAccepted) {
+                    console.log(`  \u2714 [${c.id}] (${c.type}) ${c.text}`);
+                }
+            }
+        }
+    }
+    // When called without explicit --since, advance the marker so the next
+    // diff (no --since) starts from here — acts as a cursor.
+    if (usingMarker) {
+        try {
+            writeFileAtomic(markerPath, nowISO());
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
+//# sourceMappingURL=diff.js.map