brainclaw 1.8.0 → 1.9.0

package/dist/core/operations/memory-mutation.js

@@ -6,8 +6,53 @@
  *
  * @module
  */
-import { loadState, persistState } from '../state.js';
+import path from 'node:path';
+import { loadState, mutateState } from '../state.js';
 import { resolveStoreChain, resolveTargetStore } from '../store-resolution.js';
+function bucketFor(state, itemType) {
+    if (itemType === 'constraint')
+        return state.active_constraints;
+    if (itemType === 'decision')
+        return state.recent_decisions;
+    return state.known_traps;
+}
+function findInState(state, itemId, itemType) {
+    return bucketFor(state, itemType).find((item) => item.id === itemId || item.short_label === itemId);
+}
+function replaceInState(state, itemId, itemType, item) {
+    const bucket = bucketFor(state, itemType);
+    const idx = bucket.findIndex((entry) => entry.id === itemId || entry.short_label === itemId);
+    if (idx < 0)
+        return false;
+    bucket[idx] = item;
+    return true;
+}
+function removeFromState(state, itemId, itemType) {
+    const bucket = bucketFor(state, itemType);
+    const before = bucket.length;
+    const filtered = bucket.filter((item) => item.id !== itemId && item.short_label !== itemId);
+    if (itemType === 'constraint')
+        state.active_constraints = filtered;
+    if (itemType === 'decision')
+        state.recent_decisions = filtered;
+    if (itemType === 'trap')
+        state.known_traps = filtered;
+    return filtered.length !== before;
+}
+function applyMemoryPatch(item, input) {
+    const next = { ...item };
+    if (input.text)
+        next.text = input.text;
+    if (input.tags)
+        next.tags = input.tags;
+    if (input.status && input.type === 'trap') {
+        next.status = input.status;
+    }
+    if (input.patch) {
+        Object.assign(next, input.patch);
+    }
+    return next;
+}
 /**
  * Walk the store chain to find a memory item by type and id.
  * Searches by both id and short_label.
@@ -37,17 +82,11 @@ export function deleteMemoryItem(itemId, itemType, cwd) {
     if (!found) {
         throw new Error(`${itemType} with id '${itemId}' not found in any store`);
     }
-    const state = loadState(found.store.cwd);
-    if (itemType === 'constraint') {
-        state.active_constraints = state.active_constraints.filter((c) => c.id !== itemId && c.short_label !== itemId);
-    }
-    else if (itemType === 'decision') {
-        state.recent_decisions = state.recent_decisions.filter((d) => d.id !== itemId && d.short_label !== itemId);
-    }
-    else if (itemType === 'trap') {
-        state.known_traps = state.known_traps.filter((t) => t.id !== itemId && t.short_label !== itemId);
-    }
-    persistState(state, found.store.cwd);
+    mutateState((state) => {
+        if (!removeFromState(state, itemId, itemType)) {
+            throw new Error(`${itemType} with id '${itemId}' not found in ${found.store.role} store`);
+        }
+    }, found.store.cwd);
     return {
         deletedId: itemId,
         itemType,
@@ -59,65 +98,51 @@ export function updateMemoryItem(input, cwd) {
     if (!found) {
         throw new Error(`${input.type} with id '${input.id}' not found in any store`);
     }
-    const { item, store: sourceStore } = found;
+    const { store: sourceStore } = found;
     const previousStore = sourceStore.role;
-    // Apply field updates
-    if (input.text)
-        item.text = input.text;
-    if (input.tags)
-        item.tags = input.tags;
-    if (input.status && input.type === 'trap') {
-        item.status = input.status;
-    }
-    if (input.patch) {
-        Object.assign(item, input.patch);
-    }
     if (input.moveToStore) {
         const targetCwd = resolveTargetStore(cwd, input.moveToStore);
-        // Delete from source
-        const sourceState = loadState(sourceStore.cwd);
-        if (input.type === 'constraint') {
-            sourceState.active_constraints = sourceState.active_constraints.filter((c) => c.id !== input.id);
-        }
-        else if (input.type === 'decision') {
-            sourceState.recent_decisions = sourceState.recent_decisions.filter((d) => d.id !== input.id);
+        if (path.resolve(targetCwd) === path.resolve(sourceStore.cwd)) {
+            mutateState((state) => {
+                const current = findInState(state, input.id, input.type);
+                if (!current) {
+                    throw new Error(`${input.type} with id '${input.id}' not found in ${sourceStore.role} store`);
+                }
+                replaceInState(state, input.id, input.type, applyMemoryPatch(current, input));
+            }, sourceStore.cwd);
+            return {
+                updatedId: input.id,
+                itemType: input.type,
+                previousStore,
+                newStore: input.moveToStore,
+            };
         }
-        else if (input.type === 'trap') {
-            sourceState.known_traps = sourceState.known_traps.filter((t) => t.id !== input.id);
-        }
-        persistState(sourceState, sourceStore.cwd);
-        // Add to target
-        const targetState = loadState(targetCwd);
-        if (input.type === 'constraint') {
-            targetState.active_constraints.push(item);
-        }
-        else if (input.type === 'decision') {
-            targetState.recent_decisions.push(item);
-        }
-        else if (input.type === 'trap') {
-            targetState.known_traps.push(item);
-        }
-        persistState(targetState, targetCwd);
+        const movedItem = mutateState((state) => {
+            const current = findInState(state, input.id, input.type);
+            if (!current) {
+                throw new Error(`${input.type} with id '${input.id}' not found in ${sourceStore.role} store`);
+            }
+            return applyMemoryPatch(current, input);
+        }, sourceStore.cwd);
+        // Write target before deleting source. A failure can leave a duplicate, but
+        // not silent data loss.
+        mutateState((state) => {
+            if (!replaceInState(state, input.id, input.type, movedItem)) {
+                bucketFor(state, input.type).push(movedItem);
+            }
+        }, targetCwd);
+        mutateState((state) => {
+            removeFromState(state, input.id, input.type);
+        }, sourceStore.cwd);
     }
     else {
-        // Update in place
-        const state = loadState(sourceStore.cwd);
-        if (input.type === 'constraint') {
-            const idx = state.active_constraints.findIndex((c) => c.id === input.id);
-            if (idx >= 0)
-                state.active_constraints[idx] = item;
-        }
-        else if (input.type === 'decision') {
-            const idx = state.recent_decisions.findIndex((d) => d.id === input.id);
-            if (idx >= 0)
-                state.recent_decisions[idx] = item;
-        }
-        else if (input.type === 'trap') {
-            const idx = state.known_traps.findIndex((t) => t.id === input.id);
-            if (idx >= 0)
-                state.known_traps[idx] = item;
-        }
-        persistState(state, sourceStore.cwd);
+        mutateState((state) => {
+            const current = findInState(state, input.id, input.type);
+            if (!current) {
+                throw new Error(`${input.type} with id '${input.id}' not found in ${sourceStore.role} store`);
+            }
+            replaceInState(state, input.id, input.type, applyMemoryPatch(current, input));
+        }, sourceStore.cwd);
     }
     return {
         updatedId: input.id,

package/dist/core/operations/plan.js

@@ -52,6 +52,10 @@ export function addStep(input, cwd) {
             assignee: input.assignee,
             created_at: nowISO(),
             updated_at: nowISO(),
+            // PlanStepSchema preprocesses estimated_effort (string→minutes); the cast
+            // defers coercion to the schema parse on persist, matching plan-level.
+            estimated_effort: input.estimatedEffort,
+            actual_effort: input.actualEffort,
         };
         plan.steps = [...(plan.steps ?? []), step];
         plan.updated_at = nowISO();
@@ -106,7 +110,12 @@ export function completeStep(input, cwd) {
             throw new Error(`Step '${input.stepId}' not found in plan '${input.planId}'.`);
         }
         const timestamp = nowISO();
+        const previousStatus = step.status;
         step.status = 'done';
+        if (!step.started_at)
+            step.started_at = timestamp;
+        if (previousStatus !== 'done' || !step.completed_at)
+            step.completed_at = timestamp; // pln#495: stamp completion for per-step duration
         step.updated_at = timestamp;
         plan.updated_at = timestamp;
         const totalSteps = plan.steps.length;
@@ -135,12 +144,29 @@ export function updateStep(input, cwd) {
             throw new Error(`Step '${input.stepId}' not found in plan '${input.planId}'.`);
         }
         const timestamp = nowISO();
-        if (input.status)
+        if (input.status) {
+            const previousStatus = step.status;
             step.status = input.status;
+            // pln#495: stamp the step lifecycle so the report can sum per-step
+            // durations (started→completed) and exclude inter-step idle gaps.
+            if (input.status !== 'todo' && (!step.started_at || previousStatus === 'done'))
+                step.started_at = timestamp;
+            if (input.status === 'done') {
+                if (previousStatus !== 'done' || !step.completed_at)
+                    step.completed_at = timestamp;
+            }
+            else if (previousStatus === 'done') {
+                step.completed_at = undefined;
+            }
+        }
         if (input.text !== undefined)
             step.text = input.text;
         if (input.assignee !== undefined)
             step.assignee = input.assignee || undefined;
+        if (input.estimatedEffort !== undefined)
+            step.estimated_effort = input.estimatedEffort;
+        if (input.actualEffort !== undefined)
+            step.actual_effort = input.actualEffort;
         step.updated_at = timestamp;
         plan.updated_at = timestamp;
         const totalSteps = plan.steps.length;

package/dist/core/protocol-skills.js

@@ -0,0 +1,210 @@
+/**
+ * Protocol-skills pack (pln#519) — workflow-decomposed agent skills.
+ *
+ * Three SKILL.md files that package brainclaw's critical workflows so an agent
+ * loads THE right protocol at the right moment, instead of skimming a
+ * monolithic AGENTS.md. Orthogonal to the agent-PROFILE skills
+ * (openclaw/nano-/nemo-/pico-/zeroclaw): the same agent can load both. Marked
+ * `metadata.protocol: true` so skill-loader UIs can list protocols separately.
+ *
+ * Design: .brainclaw/coordination/briefs/pln519-protocol-skills-design.md.
+ * Content lives here as the single source of truth and is EMBEDDED (not read
+ * from a repo file) so it ships and installs identically whether brainclaw runs
+ * from source or an npm install — matching ensureUniversalBrainclawSkill.
+ *
+ * Guard-rails (design §E): skills carry NO dynamic state (claim/loop/plan ids
+ * are always live lookups, never literals), reference facade verbs by name only
+ * (never re-implement mcp.ts logic), show BOTH the MCP call and the CLI
+ * fallback (cold-start / worktree-without-.brainclaw cases), and stay capped at
+ * 3 for this version.
+ */
+const SESSION_BODY = `# brainclaw-session
+
+Open / resume / close a working session on a brainclaw project. Prefer the MCP
+facade; the \`brainclaw …\` CLI is the fallback when the MCP server is not
+reachable (cold start, or a worktree without \`.brainclaw/\`).
+
+## When to use
+
+- Starting a NEW session on a brainclaw project — any first call in the session, or after a context compaction.
+- RESUMING outstanding work — \`BRAINCLAW_CLAIM_ID\` is set, or the operator says "continue X".
+- About to EDIT a specific scope (file / dir / feature) that should be reserved against other agents.
+
+## Workflow
+
+1. \`bclaw_work(intent='consult')\` — loads project memory and reports active claims. Read \`bootstrap_recommended\`: if true the project has no usable PROJECT.md (see \`brainclaw-multi-agent\` → bootstrap loop).
+2. If you will edit a scope, claim it: \`bclaw_work(intent='execute', scope='<path-or-feature>')\`. The response's \`claim_id\` is yours; \`claim_status='created'\` = new, \`'existing'\` = resumed.
+3. Do the work. Honor the \`warnings\` array (claim conflicts, sensitive paths, high-severity traps on your scope).
+4. When done (committed, tested), \`bclaw_session_end(autoRelease: true)\` — closes the session record and releases your remaining claims. \`autoRelease\` defaults to false; pass it explicitly or claims survive the session.
+
+CLI fallback: \`brainclaw context --json\` · \`brainclaw claim create "<desc>" --scope <path>\` · \`brainclaw session-end --auto-release\`.
+
+## Anti-rationalizations
+
+- **"I'm just exploring, I'll skip session-end."** → A live claim outlives a crash. The next agent sees your stale claim and is blocked. Calling \`bclaw_session_end(autoRelease: true)\` is the zero-cost guarantee — without the flag the claim survives.
+- **"I know the project, I don't need to consult."** → State changes between sessions (commits, new traps, new constraints). Consult is cheap and surfaces what you'd miss.
+- **"I'll claim later once I know the exact scope."** → Claim-before-edit IS the contract; it is exactly what prevents races with parallel agents.
+
+## Red flags
+
+- \`claim_conflicts\` reports another agent's claim on your target scope → STOP. Route through coordination (\`bclaw_coordinate intent='reroute'\` or ask the operator); never override silently.
+- High-severity \`[trap]\`/\`[constraint]\` warning on your scope → read it before editing.
+- \`bootstrap_recommended=true\` while you're about to make architectural calls → the project has no PROJECT.md; consider a bootstrap loop first.
+
+## Verification
+
+- The \`claim_id\` returned stays stable across subsequent calls (session continuity).
+- After session-end, \`bclaw_find(entity='claim', filter={status:'active'})\` shows no active claim of yours on the scope.
+
+## See also
+
+- \`brainclaw-memory-capture\` — for decisions/traps captured DURING the session.
+- \`brainclaw-multi-agent\` — for delegating part of the work.
+`;
+const MEMORY_CAPTURE_BODY = `# brainclaw-memory-capture
+
+Capture project memory at the RIGHT granularity and type, so it is retrievable
+later. The entity type is not cosmetic — it drives retrieval and surfacing.
+
+## When to use
+
+- You made a **design call** future agents must respect → **decision**.
+- You hit an **externally-imposed rule** you cannot relax alone → **constraint**.
+- You found an **environment / process pitfall** another agent would also hit → **trap**.
+- You finished a chunk of work to be consumed by another agent → **handoff**.
+- A keep-worthy observation that is not a hard decision/constraint/trap → **runtime_note** (lowest signal).
+- You are genuinely unsure of the type → **candidate** (carries a proposed \`type\`; a reviewer reclassifies).
+
+## Workflow
+
+1. Pick the type:
+
+   \`\`\`
+   Negotiated + recorded as the way forward?        → decision
+   Imposed externally, cannot be relaxed by you?    → constraint
+   About HOW the system/env/tools behave (not WHAT)? → trap
+   A "danger ahead" pointer for a future agent?      → trap
+   Output of work to be consumed by another agent?   → handoff
+   Unsure between decision/constraint/trap?          → candidate (with type)
+   Else                                              → runtime_note
+   \`\`\`
+
+2. Write via the canonical grammar: \`bclaw_create(entity='<type>', data={ text, author, ...optional })\`. Declare the classifying field yourself (caller assertion wins over keyword heuristics): for a \`decision\` set \`outcome\` (one of \`approved | rejected | deferred | pending\` — \`pending\` until ratified); for a \`trap\` set \`severity\` (\`low | medium | high\`, defaults to medium); for a \`constraint\` set \`category\`; for a \`candidate\` its proposed \`type\` (\`constraint | decision | trap | handoff\` — required). \`handoff\` is NOT created via bclaw_create — use \`brainclaw handoff "<text>"\` (CLI) or let \`bclaw_session_end(reflectHandoff: true)\` materialize one from commits. For free-form capture restricted to \`decision | trap | constraint | note\`, \`bclaw_quick_capture(text, type)\` is the shortcut.
+3. Verify it is re-readable: \`bclaw_get(entity='<type>', id='<id>')\` returns your content. If \`bclaw_create\` returned \`validation_error\` (e.g. \`outcome\` not in enum), fix the field and retry — the error message lists the accepted values.
+
+CLI fallback: \`brainclaw memory create <type> "<text>"\` (decision | constraint | trap | handoff via top-level \`brainclaw handoff "<text>"\`).
+
+## Anti-rationalizations
+
+- **"I'll write a runtime_note, I'm unsure of the type."** → Notes are the lowest-signal type (aggregated, not surfaced). If it's actionable, pick decision/constraint/trap — being wrong is fine, that's what candidates are for.
+- **"I'll add it as a decision AND a runtime_note to be safe."** → Duplicates pollute search and retrieval. Pick ONE.
+- **"I'll write the decision without an outcome."** → \`outcome\` is optional but enum-validated when set; an invalid value (e.g. \`proposed\`, \`accepted\`) is rejected with the accepted list (\`approved | rejected | deferred | pending\`). Set \`pending\` early if not yet ratified — it makes the lifecycle explicit and lets reviewers transition it cleanly.
+- **"A 5-line trap for a 1-line problem."** → Traps are read under pressure. Severity + symptom + mitigation, scannable.
+
+## Red flags
+
+- The content already exists under a different id → \`bclaw_find\` first; \`bclaw_update\` the existing one instead of duplicating.
+- You're about to write 10+ items at once → pause; you're dumping context, not capturing signal. Consolidate.
+- The "decision" was proposed by someone else and not yet accepted → it's a \`candidate\`, not a \`decision\`.
+
+## Verification
+
+- \`bclaw_create\` returns an id (e.g. \`dec_…\`).
+- \`bclaw_get(entity='<type>', id)\` returns identical content; \`bclaw_search\`/\`bclaw_find\` index it.
+- Traps surface in \`bclaw_work\` warnings on the relevant scope.
+
+## See also
+
+- \`brainclaw-session\` — capture happens DURING a session.
+- \`brainclaw-multi-agent\` — capture review findings as decisions/traps.
+`;
+const MULTI_AGENT_BODY = `# brainclaw-multi-agent
+
+Coordinate work across agents — delegate, request review, drive parallel
+dispatch, run multi-turn loops. Use when the work exceeds one agent's
+competence or when parallelism gains outweigh orchestration cost.
+
+## When to use
+
+- A second pair of eyes before merging → **review loop**.
+- An open-ended design needing multiple perspectives → **ideation loop** (or **bootstrap loop** for PROJECT.md genesis).
+- N independent sub-tasks runnable in parallel → **dispatch**.
+- You're inside a loop someone else opened and must drive your turn → **loop verbs**.
+
+## Workflow — pick the verb first
+
+\`\`\`
+Delegate a scope (with a claim)?          → bclaw_coordinate(intent='assign')
+Ask an agent for input, no claim?         → bclaw_coordinate(intent='consult')
+Review a commit / branch / candidate?     → bclaw_coordinate(intent='review', open_loop=true)
+Brainstorm with multiple agents?          → bclaw_coordinate(intent='ideate')
+Parallelize a sequence's lanes?           → bclaw_dispatch(intent='execute')
+Drive YOUR turn in an open loop?          → bclaw_loop(intent='turn|complete_turn|advance|close')
+\`\`\`
+
+### Review loop
+1. Commit your changes first (or pass \`allow_dirty=true\` only if the worker doesn't need the dirty files — it spawns from HEAD).
+2. \`bclaw_coordinate(intent='review', open_loop=true, review_mode='symmetric', targetAgents=['<agent>'], scope='<commit/branch/feature>', task='<what to review + acceptance bar>')\`.
+3. Verify the worker is ALIVE — \`bclaw_dispatch_status(target_id='<asgn_…>')\` (health verdict + recommended action), not the bare \`delivered_and_started\` return.
+4. When findings land, apply fixes / push back via another turn.
+5. \`bclaw_loop(intent='close', loop_id='<id>', status='completed', reason='<verdict>')\`; release the worker's claim.
+
+### Parallel dispatch
+1. A sequence with lane declarations (or a plan with lanes).
+2. \`bclaw_dispatch(intent='execute')\` fans the items across agents per their lanes. Before merging the lanes back, run \`brainclaw worktree check\` (pre-merge conflict detection).
+
+## Anti-rationalizations
+
+- **"I'll call \`bclaw_loop(intent='open')\` to start the review."** → STOP. \`open\` creates the loop WITHOUT dispatching a turn; the reviewer never gets the work. Use \`bclaw_coordinate(intent='review', open_loop=true)\` — it opens AND dispatches.
+- **"It returned \`delivered_and_started\`, so the worker is running."** → That only means the brief-ack sentinel was touched. Verify with \`bclaw_dispatch_status\`; spawns die silently.
+- **"I'll dispatch with uncommitted changes, the worker will see them."** → It spawns from HEAD in a worktree; your dirty files are invisible. Commit, or pass \`allow_dirty=true\` consciously.
+
+## Red flags
+
+- \`agent_run.status='running'\` but the worker pid is dead → silent spawn death; check the captured stderr, retry or reassign. (Do NOT trust a stale \`LANE-RESULT.json\` inherited by the worktree — verify its \`assignment_id\` matches.)
+- Cross-project dispatch (\`project='<other>'\`) → auto-spawn is disabled by design; the target picks the brief up async via its own \`bclaw_work\`. Don't block waiting.
+- A dispatched worker operates in a worktree that has no \`.brainclaw/\` → its MCP/CLI may be limited (trp#336); it falls back to file-based output. Expect a file deliverable, harvest it.
+
+## Verification
+
+- Dispatch: \`bclaw_dispatch_status(target_id)\` returns \`healthy\` (pid alive, recent fs activity), or a terminal verdict with a recommended next action.
+- Review loop: \`bclaw_loop(intent='get', loop_id)\` shows the reviewer slot \`done\` and the findings artifact attached.
+- Bootstrap/ideate: at converge the loop is \`completed\` (and for bootstrap, PROJECT.md is materialized at the project root).
+
+## See also
+
+- \`brainclaw-session\` — start a session BEFORE dispatching.
+- \`brainclaw-memory-capture\` — capture review findings as typed memory.
+- Docs: \`docs/concepts/loop-engine.md\`, \`docs/concepts/dispatch-lifecycle.md\`, \`docs/concepts/parallel-merge-protocol.md\`.
+`;
+/** The single source of truth for what ships in the protocol-skills pack. */
+export const PROTOCOL_SKILLS = [
+    {
+        id: 'brainclaw-session',
+        description: 'Open / resume / close a working session on a brainclaw project. Use at session start, when resuming after a compaction, or before editing a scope that needs a claim.',
+        body: SESSION_BODY,
+    },
+    {
+        id: 'brainclaw-memory-capture',
+        description: 'Capture project memory (decision, constraint, trap, runtime_note, handoff, candidate) at the right type and granularity. Use after a design call, hitting a constraint, discovering a trap, or producing a handoff.',
+        body: MEMORY_CAPTURE_BODY,
+    },
+    {
+        id: 'brainclaw-multi-agent',
+        description: 'Coordinate across agents — delegate, request review, drive parallel dispatch, run multi-turn loops. Use when work exceeds one agent or parallelism beats orchestration cost.',
+        body: MULTI_AGENT_BODY,
+    },
+];
+/** Render the full SKILL.md (frontmatter + body) for a protocol skill. */
+export function renderProtocolSkill(skill, brainclawVersion) {
+    return `---
+name: ${skill.id}
+description: '${skill.description.replace(/'/g, "''")}'
+metadata:
+  protocol: true
+  brainclaw_version: ${brainclawVersion}
+---
+
+${skill.body}`;
+}
+//# sourceMappingURL=protocol-skills.js.map

package/dist/core/reflection-safety.js

@@ -1,5 +1,5 @@
 import { loadState } from './state.js';
-import { detectNewItemContradictions, hasBlockingContradictions, summarizeContradictions } from './contradictions.js';
+import { detectNewItemContradictions, summarizeContradictions } from './contradictions.js';
 export function evaluateReflectionSafety(input) {
     if (input.type === 'handoff') {
         return {};
@@ -8,14 +8,13 @@ export function evaluateReflectionSafety(input) {
     if (contradictions.length === 0) {
         return {};
     }
-    const contradictionSummary = summarizeContradictions(contradictions);
-    const promotionBlockedReason = input.automation && hasBlockingContradictions(contradictions)
-        ? 'contradiction_detected'
-        : undefined;
+    // Advisory only (pln#542, cnd_abe61d68 incident: 18 keyword false positives
+    // on a review summary blocked promotion). Contradictions ride along as
+    // metadata on the candidate for the human/curator to weigh — they never
+    // set promotion_blocked_reason anymore.
     return {
         contradictions_detected: contradictions,
-        contradiction_summary: contradictionSummary,
-        promotion_blocked_reason: promotionBlockedReason,
+        contradiction_summary: summarizeContradictions(contradictions),
     };
 }
 //# sourceMappingURL=reflection-safety.js.map

package/dist/core/reputation.js

@@ -4,6 +4,7 @@ import { listClaims } from './claims.js';
 import { loadConfig } from './config.js';
 import { nowISO } from './ids.js';
 import { listRuntimeNotes } from './runtime.js';
+import { loadState } from './state.js';
 function clampScore(value) {
     if (!Number.isFinite(value)) {
         return 0;
@@ -30,6 +31,12 @@ function createAccumulator(identity) {
             claims_created: 0,
             released_claims: 0,
             orphan_runtime_noise: 0,
+            memory_confirmations_authored: 0,
+            memory_infirmations_authored: 0,
+            memory_saved_me_reports: 0,
+            memory_misled_me_reports: 0,
+            memory_items_reinforced: 0,
+            memory_items_misled_others: 0,
         },
     };
 }
@@ -151,6 +158,55 @@ function trackRuntimeSignals(note, store, sinceMs, resolveIdentity) {
         stats.signals.plan_linked_activity += 1;
     }
 }
+/**
+ * pln#544 — memory lifecycle reinforcement signals.
+ *
+ * For each decision / constraint / trap, walk the bounded confirmations[]
+ * log and attribute:
+ *   - the event itself to the attesting agent (`by`/`by_id`), increasing
+ *     their confirmations/infirmations/saved-me/misled-me counters.
+ *   - reinforcement back to the item author (saved_me / misled_me) so that
+ *     "memory that actually helped" rewards whoever wrote it.
+ *
+ * The 30-day reputation window applies — older confirmation events do not
+ * count, mirroring how stale candidate signals are excluded above.
+ */
+function trackMemoryLifecycleSignals(item, store, sinceMs, resolveIdentity) {
+    const events = item.confirmations ?? [];
+    if (events.length === 0)
+        return;
+    const author = resolveIdentity(item.author_id ?? item.author);
+    for (const event of events) {
+        if (!withinWindow(event.at, sinceMs))
+            continue;
+        const attester = resolveIdentity(event.by_id ?? event.by);
+        if (attester) {
+            const stats = getAccumulator(store, attester);
+            if (event.kind === 'confirm')
+                stats.signals.memory_confirmations_authored += 1;
+            else if (event.kind === 'infirm')
+                stats.signals.memory_infirmations_authored += 1;
+            else if (event.kind === 'saved_me') {
+                stats.signals.memory_confirmations_authored += 1;
+                stats.signals.memory_saved_me_reports += 1;
+            }
+            else if (event.kind === 'misled_me') {
+                stats.signals.memory_infirmations_authored += 1;
+                stats.signals.memory_misled_me_reports += 1;
+            }
+        }
+        // Reinforcement back to the item author — only "explicitly reinforced" /
+        // "explicitly debunked" events flow there. Passive confirm/infirm are
+        // peer-review signals, not author signals.
+        if (author && attester && attester.key !== author.key) {
+            const ownerStats = getAccumulator(store, author);
+            if (event.kind === 'saved_me')
+                ownerStats.signals.memory_items_reinforced += 1;
+            else if (event.kind === 'misled_me')
+                ownerStats.signals.memory_items_misled_others += 1;
+        }
+    }
+}
 function trackClaimSignals(claim, store, sinceMs, resolveIdentity) {
     if (!withinWindow(claim.created_at, sinceMs) && !withinWindow(claim.released_at, sinceMs)) {
         return;
@@ -177,14 +233,24 @@ function finalizeSnapshot(accumulator) {
     const boundedPromotions = Math.min(accumulator.signals.promoted_runtime_candidates, 4);
     const boundedPlanActivity = Math.min(accumulator.signals.plan_linked_activity, 4);
     const boundedNoise = Math.min(accumulator.signals.orphan_runtime_noise, 4);
+    // pln#544 — memory-lifecycle reinforcement caps so a single noisy attester
+    // can't dominate the score. Saved-me on items I authored is the strongest
+    // positive signal ("my memory actually saved another agent"); misled-me on
+    // my items is the symmetric penalty.
+    const boundedSavedMeAuthored = Math.min(accumulator.signals.memory_items_reinforced, 5);
+    const boundedMisledOthers = Math.min(accumulator.signals.memory_items_misled_others, 5);
+    const boundedMemoryReviewVolume = Math.min(accumulator.signals.memory_confirmations_authored + accumulator.signals.memory_infirmations_authored, 10);
     const contributionQuality = clampScore(35 * accumulator.signals.accepted_candidates
         + 20 * accumulator.signals.promoted_runtime_accepted
         + 10 * boundedUses
         + 4 * boundedStars
-        - 12 * accumulator.signals.rejected_candidates_authored);
+        + 15 * boundedSavedMeAuthored
+        - 12 * accumulator.signals.rejected_candidates_authored
+        - 18 * boundedMisledOthers);
     const reviewReliability = clampScore(30 * accumulator.signals.accepted_reviews
         + 18 * accumulator.signals.rejected_reviews
-        + 4 * accumulator.signals.reasoned_rejections);
+        + 4 * accumulator.signals.reasoned_rejections
+        + 6 * boundedMemoryReviewVolume);
     const continuityHygiene = clampScore(12 * boundedRuntimeNotes
         + 12 * boundedPromotions
         + 8 * boundedPlanActivity
@@ -243,6 +309,22 @@ export function buildReputationSnapshot(cwd) {
     for (const claim of listClaims(cwd)) {
         trackClaimSignals(claim, store, sinceMs, resolvers.resolve);
     }
+    // pln#544 — feed memory-lifecycle confirmations back into reputation:
+    // attesting agents earn confirmation_authored; items reinforced by
+    // 'saved_me' reward their author. Best-effort: never let a lifecycle
+    // signal failure block reputation rebuild.
+    try {
+        const state = loadState(cwd);
+        const memoryItems = [
+            ...state.recent_decisions,
+            ...state.active_constraints,
+            ...state.known_traps,
+        ];
+        for (const item of memoryItems) {
+            trackMemoryLifecycleSignals(item, store, sinceMs, resolvers.resolve);
+        }
+    }
+    catch { /* state may be unreadable in cold-start scenarios */ }
     const agents = [...store.values()]
         .map((entry) => finalizeSnapshot(entry))
         .sort((a, b) => {