brainclaw 0.29.2 → 1.5.4

package/dist/core/operations/plan.js

@@ -0,0 +1,190 @@
+/**
+ * Pure business logic for plan operations.
+ *
+ * No console.log, no process.exit, no MCP formatting.
+ * Both CLI commands and MCP handlers call these functions.
+ *
+ * @module
+ */
+import { mutateState } from '../state.js';
+import { generateIdWithLabel, generateId, nowISO } from '../ids.js';
+export function createPlan(input, cwd) {
+    if (input.estimatedEffort !== undefined) {
+        if (!Number.isInteger(input.estimatedEffort) || input.estimatedEffort <= 0) {
+            throw new Error('estimate must be a positive integer (minutes)');
+        }
+    }
+    const result = mutateState((state) => {
+        const { id, short_label } = generateIdWithLabel('plan_items', cwd);
+        const timestamp = nowISO();
+        const entry = {
+            id,
+            short_label,
+            text: input.text,
+            type: input.type,
+            created_at: timestamp,
+            updated_at: timestamp,
+            author: input.author,
+            status: 'todo',
+            priority: input.priority ?? 'medium',
+            assignee: input.assignee,
+            project: input.project,
+            tags: input.tags ?? [],
+            related_paths: input.relatedPaths,
+            depends_on: input.dependsOn ?? [],
+            estimated_effort: input.estimatedEffort,
+        };
+        state.plan_items.push(entry);
+        return { id, shortLabel: short_label, text: input.text };
+    }, cwd);
+    return result;
+}
+export function addStep(input, cwd) {
+    const result = mutateState((state) => {
+        const plan = state.plan_items.find((p) => p.id === input.planId || p.short_label === input.planId);
+        if (!plan) {
+            throw new Error(`Plan '${input.planId}' not found.`);
+        }
+        const step = {
+            id: generateId('plan_steps'),
+            text: input.text,
+            status: 'todo',
+            assignee: input.assignee,
+            created_at: nowISO(),
+            updated_at: nowISO(),
+        };
+        plan.steps = [...(plan.steps ?? []), step];
+        plan.updated_at = nowISO();
+        return {
+            stepId: step.id,
+            planId: plan.id,
+            totalSteps: plan.steps.length,
+            doneSteps: plan.steps.filter((s) => s.status === 'done').length,
+        };
+    }, cwd);
+    return result;
+}
+export function updatePlan(input, cwd) {
+    const result = mutateState((state) => {
+        const plan = state.plan_items.find((p) => p.id === input.id || p.short_label === input.id);
+        if (!plan) {
+            throw new Error(`Plan item '${input.id}' not found.`);
+        }
+        const timestamp = nowISO();
+        if (input.status) {
+            plan.status = input.status;
+            if (input.status === 'in_progress' && !plan.started_at)
+                plan.started_at = timestamp;
+            if (input.status === 'done' && !plan.completed_at)
+                plan.completed_at = timestamp;
+        }
+        if (input.assignee !== undefined)
+            plan.assignee = input.assignee;
+        if (input.priority)
+            plan.priority = input.priority;
+        if (input.actualEffort)
+            plan.actual_effort = input.actualEffort;
+        if (input.patch) {
+            Object.assign(plan, input.patch);
+        }
+        plan.updated_at = timestamp;
+        return { id: plan.id, text: plan.text, status: plan.status };
+    }, cwd);
+    return result;
+}
+export function completeStep(input, cwd) {
+    const result = mutateState((state) => {
+        const plan = state.plan_items.find((p) => p.id === input.planId || p.short_label === input.planId);
+        if (!plan) {
+            throw new Error(`Plan '${input.planId}' not found.`);
+        }
+        if (!plan.steps || plan.steps.length === 0) {
+            throw new Error(`Plan '${input.planId}' has no steps.`);
+        }
+        const step = plan.steps.find((s) => s.id === input.stepId || s.text.toLowerCase().includes(input.stepId.toLowerCase()));
+        if (!step) {
+            throw new Error(`Step '${input.stepId}' not found in plan '${input.planId}'.`);
+        }
+        const timestamp = nowISO();
+        step.status = 'done';
+        step.updated_at = timestamp;
+        plan.updated_at = timestamp;
+        const totalSteps = plan.steps.length;
+        const doneSteps = plan.steps.filter((s) => s.status === 'done').length;
+        let planAutoCompleted = false;
+        if (doneSteps === totalSteps && plan.status !== 'done') {
+            plan.status = 'done';
+            plan.completed_at = timestamp;
+            planAutoCompleted = true;
+        }
+        return { stepId: step.id, planId: plan.id, totalSteps, doneSteps, planAutoCompleted };
+    }, cwd);
+    return result;
+}
+export function updateStep(input, cwd) {
+    const result = mutateState((state) => {
+        const plan = state.plan_items.find((p) => p.id === input.planId || p.short_label === input.planId);
+        if (!plan) {
+            throw new Error(`Plan '${input.planId}' not found.`);
+        }
+        if (!plan.steps || plan.steps.length === 0) {
+            throw new Error(`Plan '${input.planId}' has no steps.`);
+        }
+        const step = plan.steps.find((s) => s.id === input.stepId);
+        if (!step) {
+            throw new Error(`Step '${input.stepId}' not found in plan '${input.planId}'.`);
+        }
+        const timestamp = nowISO();
+        if (input.status)
+            step.status = input.status;
+        if (input.text !== undefined)
+            step.text = input.text;
+        if (input.assignee !== undefined)
+            step.assignee = input.assignee || undefined;
+        step.updated_at = timestamp;
+        plan.updated_at = timestamp;
+        const totalSteps = plan.steps.length;
+        const doneSteps = plan.steps.filter((s) => s.status === 'done').length;
+        let planAutoCompleted = false;
+        if (doneSteps === totalSteps && plan.status !== 'done') {
+            plan.status = 'done';
+            plan.completed_at = timestamp;
+            planAutoCompleted = true;
+        }
+        return { stepId: step.id, planId: plan.id, totalSteps, doneSteps, planAutoCompleted };
+    }, cwd);
+    return result;
+}
+export function deleteStep(input, cwd) {
+    const result = mutateState((state) => {
+        const plan = state.plan_items.find((p) => p.id === input.planId || p.short_label === input.planId);
+        if (!plan) {
+            throw new Error(`Plan '${input.planId}' not found.`);
+        }
+        if (!plan.steps || plan.steps.length === 0) {
+            throw new Error(`Plan '${input.planId}' has no steps.`);
+        }
+        const idx = plan.steps.findIndex((s) => s.id === input.stepId);
+        if (idx < 0) {
+            throw new Error(`Step '${input.stepId}' not found in plan '${input.planId}'.`);
+        }
+        plan.steps.splice(idx, 1);
+        plan.updated_at = nowISO();
+        const totalSteps = plan.steps.length;
+        const doneSteps = plan.steps.filter((s) => s.status === 'done').length;
+        return { stepId: input.stepId, planId: plan.id, totalSteps, doneSteps };
+    }, cwd);
+    return result;
+}
+export function deletePlan(planId, cwd) {
+    const result = mutateState((state) => {
+        const idx = state.plan_items.findIndex((p) => p.id === planId || p.short_label === planId);
+        if (idx < 0) {
+            throw new Error(`Plan item '${planId}' not found.`);
+        }
+        const removed = state.plan_items.splice(idx, 1)[0];
+        return { id: removed.id, text: removed.text };
+    }, cwd);
+    return result;
+}
+//# sourceMappingURL=plan.js.map

package/dist/core/policy.js

@@ -0,0 +1,169 @@
+/**
+ * Pre-execution policy checks.
+ *
+ * Deterministic guardrails that verify whether an agent is allowed
+ * to act on a given scope.  No AI, no external dependencies —
+ * just claims, constraints, traps and instructions.
+ *
+ * @module
+ */
+import { listClaims, isClaimExpired } from './claims.js';
+import { loadState } from './state.js';
+import { loadInstructions, resolveInstructions } from './instructions.js';
+const CROSS_PROJECT_SIGNALING_ENTITIES = new Set(['candidate', 'handoff', 'runtime_note']);
+export function checkCrossProjectBoundary(entity, targetProject) {
+    if (!targetProject) {
+        return { allowed: true };
+    }
+    if (CROSS_PROJECT_SIGNALING_ENTITIES.has(entity)) {
+        return { allowed: true };
+    }
+    return {
+        allowed: false,
+        issue: {
+            kind: 'cross_project_boundary',
+            severity: 'block',
+            message: `Cross-project writes are limited to signaling entities (candidate, handoff, runtime_note). ${entity} stays local to the current project.`,
+        },
+    };
+}
+export function assertCrossProjectBoundary(entity, targetProject) {
+    const result = checkCrossProjectBoundary(entity, targetProject);
+    if (!result.allowed) {
+        throw new Error(result.issue?.message ?? 'Cross-project boundary violation.');
+    }
+}
+// ---------------------------------------------------------------------------
+// Path matching (reuses check-constraints pattern)
+// ---------------------------------------------------------------------------
+function normPath(p) {
+    return p.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+/**
+ * Returns true if `targetScope` overlaps with `relatedPath`.
+ * Matches exactly or via prefix (directory containment) in both directions.
+ */
+function scopeOverlaps(targetScope, relatedPath) {
+    const s = normPath(targetScope).replace(/\/$/, '');
+    const r = normPath(relatedPath).replace(/\/$/, '');
+    // Exact match
+    if (s === r)
+        return true;
+    // Target is inside related path (e.g. scope=src/core/foo.ts, related=src/core)
+    if (s.startsWith(r + '/'))
+        return true;
+    // Related path is inside target scope (e.g. scope=src/core, related=src/core/foo.ts)
+    if (r.startsWith(s + '/'))
+        return true;
+    return false;
+}
+/**
+ * Check if a claim's scope overlaps with the target scope.
+ * Claims use free-form scope strings — may be a single path, a directory,
+ * or multiple space-separated paths (e.g. "src/views/A.astro src/components/B.astro").
+ */
+function claimScopeOverlaps(targetScope, claimScope) {
+    // Split space-separated scopes and check each segment
+    const segments = claimScope.split(/\s+/).filter(Boolean);
+    return segments.some(segment => scopeOverlaps(targetScope, segment));
+}
+// ---------------------------------------------------------------------------
+// Core check
+// ---------------------------------------------------------------------------
+export function checkPolicy(options) {
+    const cwd = options.cwd;
+    const scope = options.scope;
+    const agent = options.agent;
+    const blocks = [];
+    const warnings = [];
+    // --- 1. Claim check ---
+    const allClaims = listClaims(cwd);
+    const activeClaims = allClaims.filter(c => c.status === 'active' && !isClaimExpired(c));
+    const claimsOnScope = activeClaims.filter(c => claimScopeOverlaps(scope, c.scope));
+    if (agent) {
+        const agentLower = agent.toLowerCase();
+        const myClaimsOnScope = claimsOnScope.filter(c => c.agent.toLowerCase() === agentLower ||
+            c.agent_id?.toLowerCase() === agentLower);
+        const otherClaimsOnScope = claimsOnScope.filter(c => c.agent.toLowerCase() !== agentLower &&
+            c.agent_id?.toLowerCase() !== agentLower);
+        if (myClaimsOnScope.length === 0 && claimsOnScope.length === 0) {
+            blocks.push({
+                kind: 'no_claim',
+                severity: 'block',
+                message: `No active claim on scope "${scope}". Run bclaw_claim first.`,
+            });
+        }
+        else if (myClaimsOnScope.length === 0 && otherClaimsOnScope.length > 0) {
+            for (const c of otherClaimsOnScope) {
+                blocks.push({
+                    kind: 'claim_conflict',
+                    severity: 'block',
+                    id: c.id,
+                    message: `Scope "${scope}" is claimed by ${c.agent} [${c.id}]: ${c.description}`,
+                });
+            }
+        }
+        // Check for expired claims by this agent (informational)
+        const expiredMyClaims = allClaims.filter(c => c.status === 'active' && isClaimExpired(c) &&
+            (c.agent.toLowerCase() === agentLower || c.agent_id?.toLowerCase() === agentLower) &&
+            claimScopeOverlaps(scope, c.scope));
+        for (const c of expiredMyClaims) {
+            warnings.push({
+                kind: 'claim_expired',
+                severity: 'warn',
+                id: c.id,
+                message: `Your claim [${c.id}] on "${c.scope}" has expired. Re-claim before editing.`,
+            });
+        }
+    }
+    else {
+        // No agent specified — just report claim state
+        if (claimsOnScope.length === 0) {
+            warnings.push({
+                kind: 'no_claim',
+                severity: 'warn',
+                message: `No active claim on scope "${scope}".`,
+            });
+        }
+    }
+    // --- 2. Constraint check ---
+    const state = loadState(cwd);
+    const matchingConstraints = state.active_constraints.filter(c => c.related_paths?.some(rp => scopeOverlaps(scope, rp)));
+    for (const c of matchingConstraints) {
+        const catLabel = c.category ? ` [${c.category}]` : '';
+        warnings.push({
+            kind: 'constraint',
+            severity: 'warn',
+            id: c.id,
+            message: `Constraint${catLabel}: ${c.text}`,
+        });
+    }
+    // --- 3. Trap check ---
+    const matchingTraps = state.known_traps.filter(t => t.status === 'active' &&
+        t.related_paths?.some(rp => scopeOverlaps(scope, rp)));
+    for (const t of matchingTraps) {
+        const sevLabel = t.severity ? ` [${t.severity}]` : '';
+        warnings.push({
+            kind: 'trap',
+            severity: 'warn',
+            id: t.id,
+            message: `Trap${sevLabel}: ${t.text}`,
+        });
+    }
+    // --- 4. Instructions (governance context — no matching in v1) ---
+    const allInstructions = loadInstructions(cwd);
+    const activeInstructions = resolveInstructions(allInstructions, {});
+    const allowed = blocks.length === 0;
+    return {
+        allowed,
+        blocks,
+        warnings,
+        governance_context: {
+            active_instructions: activeInstructions,
+            matching_constraints: matchingConstraints,
+            matching_traps: matchingTraps,
+            active_claims_on_scope: claimsOnScope,
+        },
+    };
+}
+//# sourceMappingURL=policy.js.map

package/dist/core/reputation.js

@@ -110,7 +110,13 @@ function trackCandidateSignals(candidate, bucket, store, sinceMs, config, resolv
         if (bucket === 'rejected') {
             stats.signals.rejected_candidates_authored += 1;
         }
-        if (candidate.source?.startsWith('runtime-note:')) {
+        // Count runtime-origin candidates: either explicit `source: 'auto'` (session-end
+        // auto handoffs) or any runtime-note / session-end origin string (back-compat
+        // with writers that still set only `origin`).
+        const isRuntimeOrigin = candidate.source === 'auto'
+            || candidate.origin?.startsWith('runtime-note:') === true
+            || candidate.origin?.startsWith('session-end:') === true;
+        if (isRuntimeOrigin) {
             stats.signals.promoted_runtime_candidates += 1;
             if (bucket === 'accepted') {
                 stats.signals.promoted_runtime_accepted += 1;
@@ -354,8 +360,8 @@ export function buildReputationRankingLookup(cwd) {
             return 0;
         }
         const trust = getInternalTrust(actorId, actorName);
-        const bonus = (trust / 100) * (rankingWeight * 10);
-        return Math.max(0, Math.min(1.5, Number(bonus.toFixed(2))));
+        const bonus = (trust / 100) * (rankingWeight * 20);
+        return Math.max(0, Math.min(3, Number(bonus.toFixed(2))));
     };
     return {
         enabled: snapshot.enabled,