brainclaw 0.29.2 → 1.5.3

package/dist/core/coordination.js

@@ -1,21 +1,32 @@
-import { findAgentIdentityByName, resolveAgentScope, resolveCurrentAgentIdentity } from './agent-registry.js';
+import { findAgentIdentityByName, listAgentIdentities, resolveAgentScope, resolveCurrentAgentIdentity } from './agent-registry.js';
 import { loadConfig } from './config.js';
 import { resolveCurrentHostId } from './host.js';
 import { listClaims } from './claims.js';
+import { listAssignments } from './assignments.js';
+import { listAgentRuns } from './agentruns.js';
+import { listActionRequired } from './actions.js';
+import { getActiveSequence } from './sequence.js';
+import { resolveCrossProjectLinks, listIncomingCrossProjectSignals } from './cross-project.js';
 import { inferProjectFromTarget, loadInstructions, resolveInstructions } from './instructions.js';
 import { buildReputationSummary, findAgentReputationSummary } from './reputation.js';
 import { listRuntimeNotes } from './runtime.js';
 import { loadState, persistState } from './state.js';
+import { getCapabilityProfile } from './agent-capability.js';
+import { loadAllSessions } from './identity.js';
+import { countActionable } from './messaging.js';
+import { listCandidates } from './candidates.js';
+import { pullSignalsFromLinkedProjects } from './federation-transport.js';
 export function buildCoordinationSnapshot(options = {}) {
     const config = loadConfig(options.cwd);
     const state = loadState(options.cwd);
     const currentHost = resolveCurrentHostId();
     const project = options.project ?? inferProjectFromTarget(options.target, config);
-    const agent = resolveAgentScope(options.agent, options.cwd);
+    const agent = options.skipAgentAutoDetect ? undefined : resolveAgentScope(options.agent, options.cwd);
     const resolvedAgentIdentity = agent
         ? (options.agent ? findAgentIdentityByName(agent, options.cwd) : resolveCurrentAgentIdentity(options.cwd))
         : undefined;
     const claims = listClaims(options.cwd).filter((claim) => claim.status === 'active');
+    const activeSequence = getActiveSequence(options.cwd);
     const runtimeNotes = listRuntimeNotes({
         agent,
         hostId: options.host,
@@ -75,37 +86,221 @@ export function buildCoordinationSnapshot(options = {}) {
         active_claims: agent
             ? filteredClaims.filter((claim) => claim.agent === agent)
             : filteredClaims,
+        active_assignments: (agent
+            ? listAssignments(options.cwd, { agent })
+            : listAssignments(options.cwd)).filter((assignment) => !['completed', 'failed', 'expired', 'rerouted'].includes(assignment.status) &&
+            (!project || !assignment.plan_id || filteredPlans.some((plan) => plan.id === assignment.plan_id))),
+        active_runs: (agent
+            ? listAgentRuns(options.cwd, { agent })
+            : listAgentRuns(options.cwd)).filter((run) => !['completed', 'failed', 'cancelled', 'timed_out', 'interrupted'].includes(run.status) &&
+            (!project || !run.plan_id || filteredPlans.some((plan) => plan.id === run.plan_id))),
+        active_actions: (agent
+            ? listActionRequired(options.cwd, { agent, status: 'pending' })
+            : listActionRequired(options.cwd, { status: 'pending' })).filter((action) => !project || !action.plan_id || filteredPlans.some((plan) => plan.id === action.plan_id)),
+        active_sequence: enrichSequenceWithPlanStatus(activeSequence, state.plan_items),
         runtime_notes: filteredNotes,
         session_meta_hidden: sessionMetaHidden,
         open_handoffs: filteredHandoffs,
         resolved_instructions: instructions,
         reputation_summary: reputationSummary,
         agent_reputation: agentReputation,
-        other_agents: buildOtherAgentsSummary(filteredClaims, filteredNotes, agent),
+        other_agents: buildOtherAgentsSummary(filteredClaims, runtimeNotes, agent, options.cwd),
+        linked_projects: buildLinkedProjectsSummary(options.cwd),
+        incoming_signals: buildIncomingSignalsSummary(options.cwd),
+        known_traps: state.known_traps
+            .filter((t) => t.visibility === 'shared' && (!t.status || t.status === 'active'))
+            .sort((a, b) => severityOrder(b.severity) - severityOrder(a.severity)),
+        pending_candidates: listCandidates('pending', options.cwd),
+        inbox_pending: agent ? countActionable(agent, options.cwd ?? process.cwd()) : 0,
     };
 }
-function buildOtherAgentsSummary(claims, notes, currentAgent) {
+function enrichSequenceWithPlanStatus(sequence, allPlans) {
+    if (!sequence)
+        return sequence;
+    const planMap = new Map(allPlans.map(p => [p.id, p]));
+    return {
+        ...sequence,
+        items: sequence.items.map((item) => {
+            const plan = planMap.get(item.planId);
+            let planStatus = plan?.status ?? 'unknown';
+            let planText = plan?.text?.slice(0, 80) ?? item.planId;
+            if (item.stepId && plan?.steps) {
+                const step = plan.steps.find((s) => s.id === item.stepId);
+                if (step) {
+                    planStatus = step.status === 'done' ? 'done' : plan.status;
+                    planText = step.text.slice(0, 80);
+                }
+            }
+            return {
+                ...item,
+                plan_status: planStatus,
+                plan_text: planText,
+                plan_priority: plan?.priority,
+                plan_assignee: plan?.assignee,
+            };
+        }),
+    };
+}
+/** Parse a duration string like '4h', '30m', '1d' to milliseconds. */
+function parseBoardTtl(value) {
+    const match = /^(\d+)([mhd])$/i.exec(value.trim());
+    if (!match)
+        return 4 * 3_600_000;
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (unit === 'm')
+        return amount * 60_000;
+    if (unit === 'h')
+        return amount * 3_600_000;
+    return amount * 86_400_000;
+}
+function buildOtherAgentsSummary(claims, notes, currentAgent, cwd) {
+    // Count active sessions per agent for instance_count — use config TTL
+    const sessions = loadAllSessions(cwd);
+    const now = Date.now();
+    let ttlStr = '4h';
+    try {
+        ttlStr = loadConfig(cwd).implicit_session_ttl ?? '4h';
+    }
+    catch { /* use default */ }
+    const TTL_MS = parseBoardTtl(ttlStr);
+    const sessionCounts = new Map();
+    for (const s of sessions) {
+        const lastSeen = new Date(s.last_seen_at).getTime();
+        if (!isNaN(lastSeen) && now - lastSeen < TTL_MS) {
+            sessionCounts.set(s.agent, (sessionCounts.get(s.agent) ?? 0) + 1);
+        }
+    }
+    // Start from ALL registered agents — they always appear
     const agentMap = new Map();
+    for (const identity of listAgentIdentities(cwd)) {
+        if (identity.agent_name === currentAgent)
+            continue;
+        const profile = getCapabilityProfile(identity.agent_name);
+        const maxTasks = profile?.max_concurrent_tasks ?? 1;
+        agentMap.set(identity.agent_name, {
+            name: identity.agent_name,
+            trust_level: identity.trust_level ?? 'contributor',
+            claim_count: 0,
+            scopes: [],
+            has_open_session: false,
+            instance_count: sessionCounts.get(identity.agent_name) ?? 0,
+            max_tasks: maxTasks,
+            slots_remaining: maxTasks, // will be reduced when claims are counted
+        });
+    }
+    // Enrich with active claims
     for (const claim of claims) {
         if (claim.agent === currentAgent)
             continue;
-        const existing = agentMap.get(claim.agent) ?? { name: claim.agent, claim_count: 0, scopes: [] };
+        const profile = getCapabilityProfile(claim.agent);
+        const maxTasks = profile?.max_concurrent_tasks ?? 1;
+        const existing = agentMap.get(claim.agent) ?? {
+            name: claim.agent, trust_level: 'contributor', claim_count: 0, scopes: [],
+            has_open_session: false, instance_count: sessionCounts.get(claim.agent) ?? 0,
+            max_tasks: maxTasks, slots_remaining: maxTasks,
+        };
         existing.claim_count++;
+        existing.slots_remaining = Math.max(0, existing.max_tasks - existing.claim_count);
         existing.scopes.push(claim.scope);
         if (!existing.last_active || claim.created_at > existing.last_active) {
             existing.last_active = claim.created_at;
         }
         agentMap.set(claim.agent, existing);
     }
+    // Enrich with runtime notes (including session lifecycle) for last_active + open session detection
     for (const note of notes) {
         if (note.agent === currentAgent)
             continue;
         const existing = agentMap.get(note.agent);
-        if (existing && (!existing.last_active || note.created_at > existing.last_active)) {
+        if (!existing)
+            continue; // skip unregistered agents in notes
+        if (!existing.last_active || note.created_at > existing.last_active) {
             existing.last_active = note.created_at;
         }
+        if (note.note_type === 'session_start') {
+            existing.has_open_session = true;
+        }
+        if (note.note_type === 'session_end') {
+            existing.has_open_session = false;
+        }
     }
     const result = [...agentMap.values()];
     return result.length > 0 ? result : undefined;
 }
+function buildLinkedProjectsSummary(cwd) {
+    const links = resolveCrossProjectLinks(cwd);
+    if (links.length === 0)
+        return undefined;
+    const summaries = [];
+    for (const link of links) {
+        const summary = {
+            name: link.projectName,
+            path: link.path,
+            role: link.role,
+            available: link.available,
+            active_claims: 0,
+            active_plans: 0,
+            agents: [],
+        };
+        if (link.available) {
+            try {
+                const claims = listClaims(link.absolutePath).filter(c => c.status === 'active');
+                const state = loadState(link.absolutePath);
+                const plans = state.plan_items.filter(p => p.status !== 'done' && p.status !== 'dropped');
+                summary.active_claims = claims.length;
+                summary.active_plans = plans.length;
+                const agentSet = new Set();
+                for (const c of claims)
+                    agentSet.add(c.agent);
+                summary.agents = [...agentSet];
+            }
+            catch { /* linked project read failed, skip */ }
+        }
+        summaries.push(summary);
+    }
+    return summaries.length > 0 ? summaries : undefined;
+}
+function buildIncomingSignalsSummary(cwd) {
+    const signals = listIncomingCrossProjectSignals(cwd);
+    const incomingSignals = signals.map((signal) => {
+        const text = 'text' in signal.payload ? signal.payload.text : '';
+        return {
+            id: signal.id,
+            entity_type: signal.entity_type,
+            from_project: signal.from_project.name,
+            from_agent: signal.from_agent.name,
+            created_at: signal.created_at,
+            preview: text.length > 120 ? text.slice(0, 117) + '...' : text,
+        };
+    });
+    try {
+        const fedSignals = pullSignalsFromLinkedProjects(cwd);
+        for (const sig of fedSignals) {
+            const payloadPreview = typeof sig.payload === 'string'
+                ? sig.payload.slice(0, 120)
+                : JSON.stringify(sig.payload).slice(0, 120);
+            incomingSignals.push({
+                id: sig.id,
+                entity_type: sig.type,
+                from_project: sig.from.project_name,
+                from_agent: sig.from.agent_name,
+                preview: payloadPreview,
+                created_at: sig.created_at,
+            });
+        }
+    }
+    catch { /* non-fatal */ }
+    if (incomingSignals.length === 0)
+        return undefined;
+    return incomingSignals;
+}
+function severityOrder(severity) {
+    switch (severity) {
+        case 'high': return 3;
+        case 'medium': return 2;
+        case 'low': return 1;
+        default: return 0;
+    }
+}
 //# sourceMappingURL=coordination.js.map

package/dist/core/cross-project.js

@@ -1,8 +1,34 @@
+import fs from 'node:fs';
 import path from 'node:path';
-import { loadConfig } from './config.js';
+import { loadConfig, saveConfig } from './config.js';
 import { loadState } from './state.js';
-import { saveRuntimeNote } from './runtime.js';
-import { memoryExists } from './io.js';
+import { generateId, nowISO } from './ids.js';
+import { memoryExists, resolveEntityDir } from './io.js';
+import { CrossProjectLinkSchema } from './schema.js';
+import { resolveProjectRef } from './store-resolution.js';
+function crossProjectSignalDir(cwd, mode = 'read') {
+    return path.join(resolveEntityDir('inbox', cwd ?? process.cwd(), mode), 'cross-project');
+}
+function ensureCrossProjectSignalDir(cwd) {
+    const dir = crossProjectSignalDir(cwd, 'write');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function resolveCrossProjectWritableTarget(nameOrPath, entityType, cwd) {
+    const link = resolveCrossProjectTarget(nameOrPath, cwd);
+    if (link.role !== 'publisher') {
+        throw new Error(`Cross-project link to '${link.projectName}' is role=subscriber — cannot push ${entityType} signals. Set role: publisher to enable push.`);
+    }
+    if (!link.available) {
+        throw new Error(`Target project not found or not initialized: ${link.absolutePath}`);
+    }
+    if (link.channels?.length && !link.channels.includes(entityType)) {
+        throw new Error(`Cross-project link to '${link.projectName}' does not allow ${entityType} signals. Allowed channels: ${link.channels.join(', ')}.`);
+    }
+    return link;
+}
 /**
  * Resolves cross_project_links from config, converting relative paths to absolute.
  */
@@ -65,22 +91,64 @@ export function loadCrossProjectState(absolutePath) {
     return loadState(absolutePath);
 }
 /**
- * Writes a runtime note into a target (publisher-linked) project's runtime dir.
- * Used by bclaw_write_note --cross-project.
+ * Writes a structured signal into a target (publisher-linked) project's inbox.
  */
-export function writeCrossProjectNote(targetAbsolutePath, note, sourceCwd) {
-    const links = resolveCrossProjectLinks(sourceCwd);
-    const link = links.find((l) => path.resolve(l.absolutePath) === path.resolve(targetAbsolutePath));
-    if (!link) {
-        throw new Error(`No cross_project_link configured for path: ${targetAbsolutePath}`);
-    }
-    if (link.role !== 'publisher') {
-        throw new Error(`Cross-project link to '${link.projectName}' is role=subscriber — cannot write notes. Set role: publisher to enable push.`);
+export function writeCrossProjectSignal(target, entityType, payload, sourceCwd) {
+    const link = typeof target === 'string'
+        ? resolveCrossProjectWritableTarget(target, entityType, sourceCwd)
+        : target;
+    const sourceRoot = path.resolve(sourceCwd ?? process.cwd());
+    const sourceConfig = loadConfig(sourceRoot);
+    const agentName = 'author' in payload ? payload.author : ('agent' in payload ? payload.agent : 'unknown');
+    const agentId = 'author_id' in payload ? payload.author_id : ('agent_id' in payload ? payload.agent_id : undefined);
+    const signal = {
+        schema_version: 1,
+        id: generateId('sig'),
+        entity_type: entityType,
+        created_at: nowISO(),
+        from_project: {
+            id: sourceConfig.project_id,
+            name: sourceConfig.project_name ?? path.basename(sourceRoot),
+            path: sourceRoot,
+        },
+        from_agent: {
+            name: agentName,
+            id: agentId,
+            host_id: payload.host_id,
+            session_id: payload.session_id,
+        },
+        target_project: {
+            name: link.projectName,
+            path: link.absolutePath,
+        },
+        payload,
+    };
+    const dir = ensureCrossProjectSignalDir(link.absolutePath);
+    const filepath = path.join(dir, `${signal.id}.json`);
+    fs.writeFileSync(filepath, JSON.stringify(signal, null, 2) + '\n', 'utf-8');
+    return signal;
+}
+/**
+ * Lists cross-project signals materialized in the local inbox.
+ */
+export function listIncomingCrossProjectSignals(cwd) {
+    const dir = crossProjectSignalDir(cwd);
+    if (!fs.existsSync(dir)) {
+        return [];
     }
-    if (!link.available) {
-        throw new Error(`Target project not found or not initialized: ${targetAbsolutePath}`);
+    const signals = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const filepath = path.join(dir, entry);
+        try {
+            signals.push(JSON.parse(fs.readFileSync(filepath, 'utf-8')));
+        }
+        catch {
+            // Ignore malformed signal files.
+        }
     }
-    saveRuntimeNote({ ...note, note_type: 'cross_project' }, targetAbsolutePath);
+    return signals.sort((a, b) => a.created_at.localeCompare(b.created_at));
 }
 /**
  * Returns the absolute path of a cross-project link by name or path fragment.
@@ -96,4 +164,150 @@ export function resolveCrossProjectTarget(nameOrPath, cwd) {
     }
     return match;
 }
+/**
+ * Resolve a `project` argument (name, path, or basename) to an absolute cwd
+ * usable by entity-operations / state / etc. Powers the optional `project?`
+ * parameter on the canonical grammar (bclaw_find/get/create/update/remove/
+ * transition/context/coordinate) — pln#359.
+ *
+ * Cross-project switching is intentionally limited to **linked projects only**
+ * — projects the user has explicitly opted into. Two link kinds count:
+ *
+ *   • cross_project_links (peer/sibling links via config.yaml).
+ *   • workspace store-chain children (monorepo-style nested projects), via
+ *     `resolveProjectRef`. These are also "linked" — the parent workspace
+ *     enumerates them through its config / discovery scan.
+ *
+ * Arbitrary directory paths that aren't reachable via either link kind are
+ * rejected. Adoption requires an explicit `brainclaw link add` or workspace
+ * registration — single point of control over what an agent can reach.
+ *
+ * Resolution order:
+ *   1. `projectArg` undefined or empty            → return `currentCwd` unchanged.
+ *   2. `projectArg` matches the current project's `project_name` (from config)
+ *      OR its directory basename                  → `currentCwd`.
+ *   3. `projectArg` matches a cross_project_link  → that link's `absolutePath`,
+ *      provided the link is `available` (target dir exists + brainclaw-init).
+ *      Match keys: projectName, name, path, absolutePath, basename(absolutePath).
+ *   4. `projectArg` matches a workspace store-chain child via resolveProjectRef
+ *      → that absolute path.
+ *   5. Otherwise                                  → throw with a hint listing
+ *      the configured cross_project_links so the agent can self-correct.
+ *
+ * Errors are intentionally explicit rather than falling back silently — a
+ * misrouted write is far worse than a clean "unknown project" error.
+ */
+export function resolveProjectCwd(projectArg, currentCwd) {
+    if (!projectArg || projectArg.trim() === '')
+        return currentCwd;
+    const trimmed = projectArg.trim();
+    const baseCwd = path.resolve(currentCwd);
+    // Case 2: matches current project (by configured name OR by basename)
+    try {
+        const currentConfig = loadConfig(currentCwd);
+        if (currentConfig.project_name === trimmed)
+            return currentCwd;
+    }
+    catch { /* no config in current cwd — fall through */ }
+    if (path.basename(baseCwd) === trimmed)
+        return currentCwd;
+    // Case 3: matches a configured cross_project_link
+    const links = resolveCrossProjectLinks(currentCwd);
+    const linkMatch = links.find((l) => l.projectName === trimmed ||
+        l.name === trimmed ||
+        l.path === trimmed ||
+        l.absolutePath === trimmed ||
+        path.basename(l.absolutePath) === trimmed);
+    if (linkMatch) {
+        if (!linkMatch.available) {
+            throw new Error(`Cross-project link '${linkMatch.projectName}' is not available at ${linkMatch.absolutePath} ` +
+                `(target dir missing or not brainclaw-initialised).`);
+        }
+        return linkMatch.absolutePath;
+    }
+    // Case 4: matches a workspace store-chain child (monorepo-style nesting)
+    const wsHit = resolveProjectRef(trimmed, currentCwd);
+    if (wsHit)
+        return wsHit;
+    // Case 5: nothing matched — throw with helpful hint
+    const knownLinks = links.map((l) => l.projectName).join(', ') || '<none>';
+    throw new Error(`Unknown project: '${projectArg}'. Configured cross_project_links: ${knownLinks}. ` +
+        `Add one with \`brainclaw link add <path>\` or check config.yaml. ` +
+        `Workspace store-chain children are also accepted.`);
+}
+/**
+ * Add a new cross_project_link entry to config.yaml.
+ *
+ * - Resolves a relative input path against `cwd` for the existence check, but
+ *   stores it as-given (relative paths are friendly for shared configs).
+ * - Validates the target directory exists and is brainclaw-initialised.
+ * - Derives `name` from the linked project's project_name when possible,
+ *   else from the basename of the resolved path.
+ * - Refuses duplicates by `name` or `path` unless `force: true`.
+ */
+export function addCrossProjectLink(input) {
+    const baseCwd = path.resolve(input.cwd ?? process.cwd());
+    const inputPath = input.path.trim();
+    if (!inputPath) {
+        throw new Error('path is required');
+    }
+    const absolutePath = path.isAbsolute(inputPath) ? inputPath : path.resolve(baseCwd, inputPath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Target path does not exist: ${absolutePath}`);
+    }
+    if (!memoryExists(absolutePath)) {
+        throw new Error(`Target is not brainclaw-initialised (no .brainclaw/ found): ${absolutePath}`);
+    }
+    let derivedName = input.name?.trim();
+    if (!derivedName) {
+        try {
+            derivedName = loadConfig(absolutePath).project_name;
+        }
+        catch { /* fall through to basename */ }
+    }
+    derivedName = derivedName ?? path.basename(absolutePath);
+    const config = loadConfig(input.cwd);
+    const existing = config.cross_project_links ?? [];
+    const conflict = existing.find((l) => l.name === derivedName ||
+        l.path === inputPath ||
+        path.resolve(baseCwd, l.path) === absolutePath);
+    if (conflict && !input.force) {
+        throw new Error(`Cross-project link already exists (name='${conflict.name ?? path.basename(conflict.path)}', path='${conflict.path}'). Use force: true to replace.`);
+    }
+    const link = CrossProjectLinkSchema.parse({
+        path: inputPath,
+        name: derivedName,
+        role: input.role ?? 'subscriber',
+        ...(input.channels?.length ? { channels: input.channels } : {}),
+    });
+    const next = conflict
+        ? existing.map((l) => (l === conflict ? link : l))
+        : [...existing, link];
+    saveConfig({ ...config, cross_project_links: next }, input.cwd);
+    return link;
+}
+/**
+ * Remove a cross_project_link entry from config.yaml.
+ *
+ * Matches by `name`, exact `path`, resolved absolute path, or basename of
+ * the resolved path — same matching rules as `resolveCrossProjectTarget`.
+ */
+export function removeCrossProjectLink(nameOrPath, cwd) {
+    const baseCwd = path.resolve(cwd ?? process.cwd());
+    const config = loadConfig(cwd);
+    const links = config.cross_project_links ?? [];
+    const match = links.find((l) => {
+        const abs = path.isAbsolute(l.path) ? l.path : path.resolve(baseCwd, l.path);
+        return l.name === nameOrPath
+            || l.path === nameOrPath
+            || abs === nameOrPath
+            || path.basename(abs) === nameOrPath;
+    });
+    if (!match) {
+        throw new Error(`No cross_project_link found matching: '${nameOrPath}'`);
+    }
+    const next = links.filter((l) => l !== match);
+    saveConfig({ ...config, cross_project_links: next }, cwd);
+    return match;
+}
 //# sourceMappingURL=cross-project.js.map

package/dist/core/default-profiles/doctor.yaml

@@ -0,0 +1,11 @@
+name: doctor
+description: Run diagnostics and fix issues automatically
+trust_level: trusted
+trigger: manual
+prompt: >-
+  Run bclaw_doctor, analyze the findings, and fix what can be fixed
+  automatically. For issues requiring human judgment, create plans.
+invoke: codex exec --full-auto "{prompt}"
+tags:
+  - diagnostics
+  - built-in

package/dist/core/default-profiles/janitor.yaml

@@ -0,0 +1,11 @@
+name: janitor
+description: Clean up stale claims, archive old notes, check for orphaned files
+trust_level: contributor
+trigger: manual
+prompt: >-
+  Clean up this project: prune stale claims, archive old runtime notes, check
+  for orphaned files. Use bclaw_doctor, prune, and release-claims.
+invoke: codex exec --full-auto "{prompt}"
+tags:
+  - maintenance
+  - built-in

package/dist/core/default-profiles/onboarder.yaml

@@ -0,0 +1,11 @@
+name: onboarder
+description: Generate a project summary for new team members
+trust_level: observer
+trigger: manual
+prompt: >-
+  Generate a project summary for a new team member. Read the board, plans,
+  decisions, constraints, and produce a concise onboarding document.
+invoke: claude -p "{prompt}" --allowedTools "Edit,Write,Bash,Read,Glob,Grep"
+tags:
+  - onboarding
+  - built-in

package/dist/core/default-profiles/reviewer.yaml

@@ -0,0 +1,13 @@
+name: reviewer
+description: Review pending candidates and give structured opinions
+trust_level: trusted
+trigger: manual
+prompt: >-
+  Review pending candidates in this project. For each, give a structured
+  opinion (approve/reject with reasons). Use
+  bclaw_find(entity: "candidate", filter: {status: "pending"}) and
+  bclaw_transition(entity: "candidate", id, to: "accepted" | "rejected").
+invoke: claude -p "{prompt}" --allowedTools "Edit,Write,Bash,Read,Glob,Grep"
+tags:
+  - review
+  - built-in