brainclaw 0.19.2

package/dist/commands/session-end.js

@@ -0,0 +1,187 @@
+import { execSync } from 'node:child_process';
+import { memoryExists } from '../core/io.js';
+import { buildOperationalIdentity, clearCurrentSession } from '../core/identity.js';
+import { buildContextDiff } from '../core/context-diff.js';
+import { listClaims, releaseClaim } from '../core/claims.js';
+import { listRuntimeNotes, saveRuntimeNote, generateRuntimeNoteId } from '../core/runtime.js';
+import { loadState } from '../core/state.js';
+import { createCandidateFromInput } from './reflect.js';
+import { suggestCandidateTypes } from './reflect-runtime-note.js';
+import { nowISO } from '../core/ids.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { loadSessionSnapshot } from '../commands/session-start.js';
+export function runSessionEnd(options = {}) {
+    try {
+        const result = endSession(options);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.open_work_warning) {
+            const w = result.open_work_warning;
+            console.log('⚠ Open work detected at session end:');
+            for (const c of w.active_claims) {
+                console.log(`  claim [${c.id}] ${c.description}`);
+                console.log(`    scope: ${c.scope}`);
+            }
+            for (const p of w.in_progress_plans) {
+                console.log(`  plan  [${p.id}] ${p.text}`);
+            }
+            if (w.auto_released) {
+                console.log('  → Claims auto-released and plans left for manual update.');
+            }
+            else {
+                console.log('  → Run `brainclaw claim release <id>` and `brainclaw plan update <id> --status done` to clean up.');
+            }
+        }
+        console.log(`✔ Session ended: ${result.session_id} (${result.agent})`);
+        console.log(`  Runtime notes in session: ${result.notes_in_session}`);
+        if (options.autoReflect) {
+            console.log(`  Candidates created from auto-reflect: ${result.candidates_created}`);
+        }
+        if (result.context_diff) {
+            console.log(`  ${result.context_diff}`);
+        }
+    }
+    catch (e) {
+        console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+    }
+}
+export function endSession(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        throw new Error('.brainclaw/ not found. Run `brainclaw init` first.');
+    }
+    const registered = requireRegisteredAgentIdentity({
+        agentName: options.agent,
+        agentId: options.agentId,
+        cwd: options.cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(registered, 'contributor');
+    const actor = buildOperationalIdentity(registered.agent_name, options.cwd, { agentId: registered.agent_id });
+    const sessionId = options.session ?? actor.session_id;
+    if (!sessionId) {
+        throw new Error('no session ID provided. Use --session <id> or set BRAINCLAW_SESSION_ID.');
+    }
+    // Hygiene check: find open work belonging to this agent
+    const allClaims = listClaims(options.cwd);
+    const activeClaims = allClaims.filter((c) => c.status === 'active' && (registered.agent_id ? c.agent_id === registered.agent_id : c.agent === registered.agent_name));
+    const state = loadState(options.cwd);
+    const claimPlanIds = new Set(activeClaims.map((c) => c.plan_id).filter(Boolean));
+    const inProgressPlans = state.plan_items.filter((p) => p.status === 'in_progress' && (p.assignee === registered.agent_name || claimPlanIds.has(p.id)));
+    let openWorkWarning;
+    if (activeClaims.length > 0 || inProgressPlans.length > 0) {
+        if (options.autoRelease) {
+            for (const c of activeClaims) {
+                releaseClaim(c.id, options.cwd);
+            }
+        }
+        openWorkWarning = {
+            active_claims: activeClaims.map(({ id, scope, description }) => ({ id, scope, description })),
+            in_progress_plans: inProgressPlans.map(({ id, text }) => ({ id, text })),
+            auto_released: options.autoRelease ?? false,
+        };
+    }
+    // Get session notes for summary
+    const agentNotes = listRuntimeNotes(actor.agent, options.cwd);
+    const sessionNotes = agentNotes.filter(n => n.session_id === sessionId);
+    const diff = buildContextDiff({
+        session: sessionId,
+        cwd: options.cwd,
+        includeItems: true,
+    });
+    const contextDiff = diff?.summary;
+    const summaryText = options.summary
+        ? options.summary
+        : `Session ended — ${sessionNotes.length} runtime note(s) created`;
+    // Write session_end runtime note
+    const noteId = generateRuntimeNoteId();
+    saveRuntimeNote({
+        id: noteId,
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        project_id: actor.project_id,
+        session_id: sessionId,
+        text: summaryText + (contextDiff ? `\n${contextDiff}` : ''),
+        created_at: nowISO(),
+        tags: ['session'],
+        visibility: 'shared',
+        note_type: 'session_end',
+    }, options.cwd);
+    appendAuditEntry({ action: 'session_end', actor: actor.agent, actor_id: actor.agent_id, item_id: sessionId, item_type: 'session' }, options.cwd);
+    clearCurrentSession(options.cwd, sessionId);
+    // Reflect-handoff: generate a handoff candidate from git commits since session start
+    if (options.reflectHandoff) {
+        try {
+            const snapshot = loadSessionSnapshot(sessionId, options.cwd);
+            const startSha = snapshot?.git_sha;
+            const ref = startSha ?? 'HEAD~10';
+            const cwd = options.cwd ?? process.cwd();
+            const commits = execSync(`git log --oneline ${ref}..HEAD`, { encoding: 'utf-8', cwd }).trim();
+            const diffStat = execSync(`git diff --stat ${ref}..HEAD`, { encoding: 'utf-8', cwd }).trim();
+            if (commits) {
+                const releasedScopes = listClaims(options.cwd)
+                    .filter((c) => c.status === 'released' && c.agent === registered.agent_name)
+                    .map((c) => c.scope)
+                    .join(', ');
+                const handoffText = [
+                    `Session ${sessionId} — auto-generated handoff`,
+                    '',
+                    `Commits:\n${commits}`,
+                    diffStat ? `\nChanged files:\n${diffStat}` : '',
+                    releasedScopes ? `\nReleased claims: ${releasedScopes}` : '',
+                    summaryText !== `Session ended — ${sessionNotes.length} runtime note(s) created` ? `\nSummary: ${summaryText}` : '',
+                ].filter(Boolean).join('\n');
+                createCandidateFromInput(handoffText, 'handoff', {
+                    author: actor.agent,
+                    authorId: actor.agent_id,
+                    sessionId,
+                    source: `session-end:git-diff:${sessionId}`,
+                    cwd: options.cwd,
+                }, false, false, true);
+            }
+        }
+        catch { /* non-fatal — no git or no commits */ }
+    }
+    // Auto-reflect: generate candidates from session notes
+    let candidatesCreated = 0;
+    if (options.autoReflect && sessionNotes.length > 0) {
+        for (const note of sessionNotes) {
+            if (note.note_type === 'observation' || !note.note_type) {
+                try {
+                    const detected = suggestCandidateTypes(note.text, note.tags).find((entry) => entry.type !== 'handoff');
+                    if (!detected || detected.score < 4) {
+                        continue;
+                    }
+                    const creation = createCandidateFromInput(note.text, detected.type, {
+                        tag: note.tags,
+                        author: note.agent,
+                        authorId: note.agent_id,
+                        projectId: note.project_id,
+                        sessionId: note.session_id,
+                        source: `runtime-note:${note.agent}:${note.id}`,
+                        cwd: options.cwd,
+                    }, false, false, true);
+                    if (creation.candidateId) {
+                        candidatesCreated++;
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    const result = {
+        session_id: sessionId,
+        agent: actor.agent,
+        notes_in_session: sessionNotes.length,
+        candidates_created: candidatesCreated,
+        context_diff: contextDiff,
+        summary: summaryText,
+        open_work_warning: openWorkWarning,
+    };
+    return result;
+}
+//# sourceMappingURL=session-end.js.map

package/dist/commands/session-start.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { memoryExists, resolveEntityDir } from '../core/io.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from '../core/migration.js';
+import { buildOperationalIdentity, saveCurrentSession } from '../core/identity.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveCurrentModel } from '../core/agent-registry.js';
+import { buildContext } from '../core/context.js';
+import { saveRuntimeNote, generateRuntimeNoteId } from '../core/runtime.js';
+import { nowISO, generateId } from '../core/ids.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { SessionSnapshotSchema } from '../core/schema.js';
+import { auditLocalAgentWorkspaceFiles } from '../core/agent-files.js';
+function sessionsDir(cwd) {
+    return resolveEntityDir('sessions', cwd ?? process.cwd(), 'read');
+}
+function sessionSnapshotPath(sessionId, cwd) {
+    return path.join(sessionsDir(cwd), `${sessionId}.json`);
+}
+function createHash(data) {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+        const chr = data.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0;
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+export function runSessionStart(options = {}) {
+    try {
+        const snapshot = startSession(options);
+        if (options.json) {
+            console.log(JSON.stringify(snapshot, null, 2));
+            return;
+        }
+        console.log(`✔ Session started: ${snapshot.session_id} (${snapshot.agent})`);
+        if (options.context)
+            console.log(`  Context target: ${options.context}`);
+        if (snapshot.agent_git_hygiene && (snapshot.agent_git_hygiene.missing_gitignore_paths.length > 0 || snapshot.agent_git_hygiene.tracked_paths.length > 0)) {
+            console.warn('⚠ Local Brainclaw agent files in this repo should stay unversioned.');
+            if (snapshot.agent_git_hygiene.missing_gitignore_paths.length > 0) {
+                console.warn(`  Missing .gitignore entries: ${snapshot.agent_git_hygiene.missing_gitignore_paths.join(', ')}`);
+                console.warn('  Fix: run `brainclaw doctor --fix-agent-ignore`');
+            }
+            if (snapshot.agent_git_hygiene.tracked_paths.length > 0) {
+                console.warn(`  Tracked local agent files: ${snapshot.agent_git_hygiene.tracked_paths.join(', ')}`);
+                console.warn('  After fixing .gitignore, untrack them with `git rm --cached <path>` as needed.');
+            }
+        }
+    }
+    catch (e) {
+        console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+    }
+}
+export function startSession(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        throw new Error('.brainclaw/ not found. Run `brainclaw init` first.');
+    }
+    const registered = requireRegisteredAgentIdentity({
+        agentName: options.agent,
+        agentId: options.agentId,
+        cwd: options.cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(registered, 'contributor');
+    const actor = buildOperationalIdentity(registered.agent_name, options.cwd, { agentId: registered.agent_id });
+    // Capture initial context snapshot
+    let initialContextHash;
+    try {
+        const ctx = buildContext({ target: options.context, agent: actor.agent, cwd: options.cwd });
+        initialContextHash = createHash(JSON.stringify(ctx.selected));
+    }
+    catch { /* non-fatal */ }
+    // Capture git HEAD SHA for later handoff generation
+    let gitSha;
+    try {
+        gitSha = execSync('git rev-parse HEAD', { encoding: 'utf-8', cwd: options.cwd ?? process.cwd() }).trim();
+    }
+    catch { /* non-fatal — not a git repo */ }
+    const model = options.model ?? resolveCurrentModel(options.cwd);
+    const snapshot = {
+        schema_version: 2,
+        session_id: actor.session_id ?? generateId('sessions'),
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        started_at: nowISO(),
+        context_target: options.context,
+        initial_context_hash: initialContextHash,
+        git_sha: gitSha,
+        ...(model ? { model } : {}),
+    };
+    // Persist snapshot
+    const dir = sessionsDir(options.cwd);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    saveVersionedJsonFile('session_snapshot', sessionSnapshotPath(snapshot.session_id, options.cwd), SessionSnapshotSchema.parse(snapshot));
+    saveCurrentSession({
+        schema_version: 2,
+        session_id: snapshot.session_id,
+        started_at: snapshot.started_at,
+        last_seen_at: snapshot.started_at,
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        host_id: actor.host_id,
+    }, options.cwd);
+    // Write session_start runtime note
+    const noteId = generateRuntimeNoteId();
+    saveRuntimeNote({
+        id: noteId,
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        project_id: actor.project_id,
+        session_id: snapshot.session_id,
+        text: `Session started${options.context ? ` — context: ${options.context}` : ''}`,
+        created_at: nowISO(),
+        tags: ['session'],
+        visibility: 'shared',
+        note_type: 'session_start',
+    }, options.cwd);
+    appendAuditEntry({ action: 'session_start', actor: actor.agent, actor_id: actor.agent_id, item_id: snapshot.session_id, item_type: 'session' }, options.cwd);
+    const agentGitHygiene = auditLocalAgentWorkspaceFiles(options.cwd ?? process.cwd());
+    return {
+        ...snapshot,
+        ...(agentGitHygiene.isGitRepo && (agentGitHygiene.missingGitignorePaths.length > 0 || agentGitHygiene.trackedPaths.length > 0)
+            ? {
+                agent_git_hygiene: {
+                    missing_gitignore_paths: agentGitHygiene.missingGitignorePaths,
+                    tracked_paths: agentGitHygiene.trackedPaths,
+                },
+            }
+            : {}),
+    };
+}
+export function loadSessionSnapshot(sessionId, cwd) {
+    const p = sessionSnapshotPath(sessionId, cwd);
+    if (!fs.existsSync(p))
+        return undefined;
+    try {
+        return SessionSnapshotSchema.parse(loadVersionedJsonFile('session_snapshot', p).document);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=session-start.js.map

package/dist/commands/set-trust.js

@@ -0,0 +1,92 @@
+import { memoryExists } from '../core/io.js';
+import { hasElevatedAgent, requireMinimumTrustLevel, requireRegisteredAgentIdentity, setAgentTrustLevel, } from '../core/agent-registry.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { buildOperationalIdentity } from '../core/identity.js';
+import { resetCircuitBreaker } from '../core/circuit-breaker.js';
+export function runSetTrust(agentName, options) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    // --reset-breaker path: only resets the circuit-breaker override, no trust change needed
+    if (options.resetBreaker) {
+        try {
+            resetCircuitBreaker(agentName, options.cwd);
+            if (options.json) {
+                console.log(JSON.stringify({ ok: true, agent: agentName, action: 'circuit_breaker_reset' }));
+            }
+            else {
+                console.log(`✔ Circuit-breaker reset for agent '${agentName}'. Auto-promote is restored.`);
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`Error: ${msg}`);
+            process.exit(1);
+        }
+        return;
+    }
+    if (!options.level) {
+        console.error('Error: --level is required unless --reset-breaker is specified.');
+        process.exit(1);
+    }
+    const level = options.level;
+    const validLevels = ['observer', 'contributor', 'trusted', 'curator'];
+    if (!validLevels.includes(level)) {
+        console.error(`Error: invalid trust level '${level}'. Must be one of: ${validLevels.join(', ')}`);
+        process.exit(1);
+    }
+    let actor = 'unknown';
+    let actorId;
+    try {
+        const identity = buildOperationalIdentity();
+        actor = identity.agent;
+        actorId = identity.agent_id;
+    }
+    catch { /* use default */ }
+    let bootstrapCurator = false;
+    if (!hasElevatedAgent()) {
+        if (level !== 'curator') {
+            console.error("Error: no trusted or curator agent exists yet. Bootstrap the first curator with `brainclaw set-trust <agent> --level curator`.");
+            process.exit(1);
+        }
+        bootstrapCurator = true;
+    }
+    else {
+        try {
+            const actorIdentity = requireRegisteredAgentIdentity();
+            requireMinimumTrustLevel(actorIdentity, 'curator');
+            actor = actorIdentity.agent_name;
+            actorId = actorIdentity.agent_id;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${msg}`);
+            process.exit(1);
+        }
+    }
+    let updated;
+    try {
+        updated = setAgentTrustLevel(agentName, level);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+    appendAuditEntry({
+        action: 'trust_change',
+        actor,
+        actor_id: actorId,
+        item_id: updated.agent_id,
+        item_type: 'agent',
+        after: { trust_level: level },
+        reason: bootstrapCurator ? 'bootstrap_curator' : `set by ${actor}`,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(updated, null, 2));
+        return;
+    }
+    console.log(`✔ Trust level for ${agentName} set to '${level}' (${updated.agent_id})`);
+}
+//# sourceMappingURL=set-trust.js.map