@lh8ppl/claude-memory-kit 0.1.2 → 0.2.1

package/README.md

@@ -4,9 +4,12 @@
 
 ## What it does
 
+- **Cross-project persona — the wedge (v0.2)** — when you state how you work *everywhere* ("always use uv, never pip", "from now on run the linter before committing"), the per-turn auto-extract promotes it into your **user tier** (`~/.claude-memory-kit/`) **that turn**. So a brand-new project **cold-opens already knowing your style** — layered structure, your tooling, your testing discipline — with no hand-curation and no waiting. Carry it between your own machines with `cmk persona export`/`import`, or pin a single fact across projects with `cmk lessons promote`.
 - **Frozen snapshot at session start** — MEMORY.md + USER.md + SOUL.md + INDEX.md + today's session log inject once at the first tool call, so Claude sees your context every session without you re-telling it.
 - **Auto-extract on every assistant turn** — a background `claude --print` subagent reads each turn and saves durable facts (decisions, preferences, environment) to memory. No manual writes needed.
-- **`memory-write` skill** — say "remember this", "from now on", "we decided", or "forget X" and the skill dedups, caps, and writes silently.
+- **Explicit capture when you want it** — say "remember this" / "from now on" / "we decided" / "forget X" (the `memory-write` skill), or run `cmk remember "<fact>"`. Both dedup, screen for secrets, abstract machine paths to `~`, and write silently.
+- **Search + MCP** — `cmk search "<term>"` (keyword/hybrid over facts + scratchpads); `cmk mcp` exposes the same to Claude Code as tools.
+- **Bounded by compression** — session → daily → weekly Haiku rollups (cron or lazy-on-read) keep the snapshot small as history grows.
 - **Per-project, in-repo** — `context/` lives inside your project and travels with `git clone`. Each project keeps its own memory.
 - **9 health checks** — `cmk doctor` validates install, hook wiring, distill freshness, INDEX consistency, cron registration, and stale locks.
 
@@ -19,11 +22,11 @@ Each route is complete on its own. **Don't run both** — they wire the same hoo
 ```bash
 npm install -g @lh8ppl/claude-memory-kit
 cd ~/my-project
-cmk install        # scaffolds context/ AND wires the lifecycle hooks into .claude/settings.json
+cmk install        # scaffolds context/ + the memory-write skill AND wires the lifecycle hooks into .claude/settings.json
 cmk doctor         # verify, then restart Claude Code
 ```
 
-`cmk install` is a complete entry point: it scaffolds `context/` and writes the 5 lifecycle hooks (PATH-resolved, cross-OS) into the project's `.claude/settings.json`. No separate `/plugin` step needed. Use `cmk install --no-hooks` for a scaffold-only install.
+`cmk install` is a complete entry point: it scaffolds `context/`, drops the `memory-write` skill into `.claude/skills/` (committed — travels with `git clone`), and writes the 5 lifecycle hooks (PATH-resolved, cross-OS) into the project's `.claude/settings.json`. No separate `/plugin` step needed. Use `cmk install --no-hooks` for a scaffold-only install.
 
 > Installing the package globally adds the `cmk` CLI **and** the installer. It's the `cmk install` *subcommand* that wires the hooks — not the bare `npm install`.
 
@@ -44,13 +47,17 @@ Most-used commands (full list via `cmk --help`):
 
 | Command | Purpose |
 | --- | --- |
-| `cmk install` | Scaffold `context/` + `.gitignore` + CLAUDE.md block + wire hooks (`--no-hooks` for scaffold-only) |
+| `cmk install` | Scaffold `context/` + the `memory-write` skill + `.gitignore` + CLAUDE.md block + wire hooks (`--no-hooks` for scaffold-only) |
 | `cmk doctor` | Run HC-1..HC-9 health checks, surface repair commands |
 | `cmk repair --hooks` / `--locks` / `--index` / `--all` | Idempotent self-repair |
 | `cmk search "<query>" [--mode keyword\|semantic\|hybrid]` | Search accumulated memory (keyword default) |
 | `cmk roll --scope now\|today\|recent` | Manually trigger a compression pipeline |
 | `cmk register-crons [--dry-run] [--unregister]` | Register daily + weekly jobs with cron / launchd / Task Scheduler |
 | `cmk forget <id>` | Tombstone a fact (preserves audit trail) |
+| `cmk lessons promote <id> [--to USER.md\|HABITS.md]` | Promote one captured fact to your cross-project **user tier** (the safe path — sanitized, secret-screened, audited) so it applies in **every** project |
+| `cmk disable-native-memory` / `enable-native-memory` | Opt out of Claude Code's built-in Auto Memory so the kit is your single, lean memory layer (committable — travels with `git clone`) |
+| `cmk persona generate` | Run cross-project persona synthesis on demand (instead of waiting for the weekly pass) |
+| `cmk persona export <file>` / `import <file>` | Carry your cross-project persona (the user tier) to another of **your** machines — export to one portable bundle, import on the other (overwrites with backup + rollback). The persona stays private (never committed to a project) |
 | `cmk import-anthropic-memory [--dry-run] [--yes]` | Merge bullets from Anthropic's native auto-memory into MEMORY.md |
 
 ## Requirements
@@ -74,4 +81,4 @@ Full docs, architecture, and design live in the repository:
 
 ## License
 
-MIT © Lior Hollander
+MIT © the maintainer

package/bin/cmk-auto-extract.mjs

@@ -15,6 +15,7 @@
 
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -29,12 +30,15 @@ if (!turnFile) {
 
 const autoExtractModulePath = join(__dirname, '..', 'src', 'auto-extract.mjs');
 const compressorModulePath = join(__dirname, '..', 'src', 'compressor.mjs');
+const tierPathsModulePath = join(__dirname, '..', 'src', 'tier-paths.mjs');
 
 let runAutoExtract;
 let HaikuViaAnthropicApi;
+let resolveTierRoot;
 try {
   ({ runAutoExtract } = await import(pathToFileURL(autoExtractModulePath).href));
   ({ HaikuViaAnthropicApi } = await import(pathToFileURL(compressorModulePath).href));
+  ({ resolveTierRoot } = await import(pathToFileURL(tierPathsModulePath).href));
 } catch (err) {
   process.stderr.write(
     `cmk-auto-extract: failed to load modules: ${err?.message ?? err}\n`,
@@ -42,6 +46,14 @@ try {
   process.exit(0);
 }
 
+// Task 61 — inline cross-project promotion: pass the user-tier dir so
+// cross-project doctrine promotes immediately. Resolve the base via the
+// shared tier-paths resolver (never re-derive ~/.claude-memory-kit inline —
+// CLAUDE.md shared-modules rule), and only pass it when the user tier
+// actually exists (skip gracefully on a fresh machine, like autoPersona).
+const userDirBase = resolveTierRoot({ tier: 'U' });
+const userDir = existsSync(userDirBase) ? userDirBase : undefined;
+
 try {
   const haikuBackend = new HaikuViaAnthropicApi();
   const r = await runAutoExtract({
@@ -49,6 +61,7 @@ try {
     projectRoot,
     haikuBackend,
     sessionId: process.env.CMK_SESSION_ID,
+    userDir,
   });
   process.stderr.write(
     `cmk-auto-extract: ${r.action} (observations: ${r.observation_count ?? 0}, ms: ${r.duration_ms ?? 0})\n`,

package/bin/cmk-compress-session.mjs

@@ -11,7 +11,7 @@
 // {"continue": true}. Always exit 0 — a crashed SessionEnd hook would
 // block the user from closing their terminal.
 
-import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
@@ -19,24 +19,20 @@ function emitContinue() {
   process.stdout.write('{"continue": true}');
 }
 
-let rawInput = '';
-try {
-  rawInput = readFileSync(0, 'utf8');
-} catch {
-  // stdin not connected — fine; SessionEnd still proceeds.
-}
-void rawInput;
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const compressSessionModulePath = join(__dirname, '..', 'src', 'compress-session.mjs');
+const readHookStdinPath = join(__dirname, '..', 'src', 'read-hook-stdin.mjs');
+const sessionEndTasksModulePath = join(__dirname, '..', 'src', 'session-end-tasks.mjs');
 const compressorModulePath = join(__dirname, '..', 'src', 'compressor.mjs');
 
-let compressSession;
+let readHookStdin;
+let runSessionEndTasks;
+let summarizeSessionEnd;
 let HaikuViaAnthropicApi;
 try {
-  ({ compressSession } = await import(pathToFileURL(compressSessionModulePath).href));
+  ({ readHookStdin } = await import(pathToFileURL(readHookStdinPath).href));
+  ({ runSessionEndTasks, summarizeSessionEnd } = await import(pathToFileURL(sessionEndTasksModulePath).href));
   ({ HaikuViaAnthropicApi } = await import(pathToFileURL(compressorModulePath).href));
 } catch (err) {
   process.stderr.write(
@@ -46,15 +42,33 @@ try {
   process.exit(0);
 }
 
+// Drain the hook payload so Claude Code's pipe closes cleanly — but NOT when
+// stdin is an interactive TTY (a manual run): readFileSync(0) would block
+// forever on a console that never sends EOF, hanging before any of the body
+// runs (DECISION-LOG 2026-06-06). The payload is discarded; we read state from
+// disk. readHookStdin returns '' for a TTY so a manual invocation finishes.
+readHookStdin({ isTTY: process.stdin.isTTY });
+
 const projectRoot = process.env.CMK_PROJECT_DIR ?? process.cwd();
 
 try {
-  const backend = new HaikuViaAnthropicApi();
-  const r = await compressSession({ projectRoot, backend });
-  process.stderr.write(
-    `cmk-compress-session: ${r.action}${r.reason ? ` (${r.reason})` : ''}${r.bytesIn ? ` (in: ${r.bytesIn}b, out: ${r.bytesOut}b)` : ''} ms: ${r.duration_ms ?? 0}\n`,
-  );
+  // Task 86b + D-42: run compressSession and the dedicated autoPersona classifier
+  // CONCURRENTLY (they have disjoint inputs/outputs, so they don't race), keeping
+  // the SessionEnd wall-clock at max(~50s) under the 60s hook ceiling instead of
+  // the sequential sum (~100s). See session-end-tasks.mjs for the full rationale.
+  const userDir = process.env.MEMORY_KIT_USER_DIR ?? join(homedir(), '.claude-memory-kit');
+  const outcomes = await runSessionEndTasks({
+    projectRoot,
+    userDir,
+    makeBackend: () => new HaikuViaAnthropicApi(),
+  });
+  for (const line of summarizeSessionEnd(outcomes)) {
+    process.stderr.write(line);
+  }
 } catch (err) {
+  // Defensive backstop: runSessionEndTasks uses allSettled so it should never
+  // reject, but a synchronous throw (e.g. resolving userDir) must not block the
+  // user from closing their terminal.
   process.stderr.write(
     `cmk-compress-session: unexpected error: ${err?.message ?? err}\n`,
   );

package/bin/cmk-inject-context.mjs

@@ -14,7 +14,7 @@
 // unconditionally — a throwing SessionStart hook would interrupt
 // session start, worse than an empty additionalContext.
 
-import { readFileSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
@@ -29,6 +29,16 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const modulePath = join(__dirname, '..', 'src', 'inject-context.mjs');
 
+// Resolve the sibling lazy-compress bin (ships in this same bin/ dir) so
+// inject-context can spawn `node <path>` directly instead of the shell:true
+// `.cmd` shim — the Windows console-popup fix (Task 81). Env override first;
+// null in a corrupt install → graceful shell:true fallback in spawnLazyCompress.
+const compressLazyPath =
+  process.env.CMK_COMPRESS_LAZY_PATH ??
+  (existsSync(join(__dirname, 'cmk-compress-lazy.mjs'))
+    ? join(__dirname, 'cmk-compress-lazy.mjs')
+    : null);
+
 let injectContext;
 try {
   ({ injectContext } = await import(pathToFileURL(modulePath).href));
@@ -50,7 +60,7 @@ try {
 }
 
 try {
-  const r = injectContext({ cwd: process.cwd() });
+  const r = injectContext({ cwd: process.cwd(), compressLazyPath });
   process.stdout.write(JSON.stringify(r.hookOutput));
   process.exit(0);
 } catch (err) {

package/bin/cmk-weekly-curate.mjs

@@ -12,6 +12,7 @@
 // cooldown marker are the load-bearing observability surfaces.
 
 import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -41,11 +42,22 @@ const envRoot = process.env.CMK_PROJECT_DIR && process.env.CMK_PROJECT_DIR.lengt
   : null;
 const projectRoot = argvRoot ?? envRoot ?? process.cwd();
 
+// User tier (cross-project) lives at ~/.claude-memory-kit. Passing it
+// activates the Design-B auto-persona hook (Task 45): the weekly cycle
+// synthesizes cross-project doctrine from the project's fact archive and
+// auto-promotes it into the user tier. Without userDir the curate runs
+// project-only (backward-compatible).
+const userDir = join(homedir(), '.claude-memory-kit');
+
 try {
   const backend = new HaikuViaAnthropicApi();
-  const r = await weeklyCurate({ projectRoot, backend });
+  const r = await weeklyCurate({ projectRoot, userDir, backend });
+  const p = r.persona;
+  const personaNote = p
+    ? ` | persona: ${p.action}${p.promoted?.length ? ` (+${p.promoted.length})` : ''}${p.superseded?.length ? ` (~${p.superseded.length})` : ''}`
+    : '';
   process.stderr.write(
-    `cmk-weekly-curate: ${r.action}${r.reason ? ` (${r.reason})` : ''}${r.archivedDays ? ` (archived: ${r.archivedDays}d, current: ${r.currentDays}d, in: ${r.bytesIn}b, out: ${r.bytesOut}b)` : ''} ms: ${r.duration_ms ?? 0}\n`,
+    `cmk-weekly-curate: ${r.action}${r.reason ? ` (${r.reason})` : ''}${r.archivedDays ? ` (archived: ${r.archivedDays}d, current: ${r.currentDays}d, in: ${r.bytesIn}b, out: ${r.bytesOut}b)` : ''}${personaNote} ms: ${r.duration_ms ?? 0}\n`,
   );
 } catch (err) {
   process.stderr.write(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lh8ppl/claude-memory-kit",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "cmk — the CLI for claude-memory-kit. Per-project, in-repo memory system for Claude Code.",
   "type": "module",
   "bin": {
@@ -25,6 +25,7 @@
   },
   "scripts": {
     "test": "vitest run",
+    "prepack": "node ../../scripts/prepublish-copy-template.mjs",
     "prepublishOnly": "node ../../scripts/prepublish-copy-template.mjs"
   },
   "dependencies": {
@@ -32,7 +33,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.10.0",
     "chokidar": "^5.0.0",
-    "commander": "^12.1.0",
+    "commander": "^15.0.0",
     "js-yaml": "^4.1.0",
     "zod": "^4.4.3"
   },

package/src/audit-log.mjs

@@ -35,6 +35,8 @@ export const REASON_CODES = Object.freeze({
   USER_REQUESTED: 'user-requested', // forget: user-initiated tombstone
   CURATED_MERGE: 'curated-merge', // mergeFacts: explicit merge of A + B → C
   SCRATCHPAD_APPEND: 'scratchpad-append', // scratchpad: appendScratchpadBullet (Task 12)
+  SCRATCHPAD_GRADUATED: 'scratchpad-graduated', // graduation: high-trust bullet moved out to a fact file under cap pressure (Task 91.1)
+  SCRATCHPAD_EVICTED: 'scratchpad-evicted', // consolidate: stale low/medium bullet dropped under cap pressure, archived to memory/archive/evicted-bullets.md (Task 91.2)
   TRUST_CHANGE: 'trust-change', // trust: overrideTrust (Task 15)
   CONFLICT_QUEUED: 'conflict-queued', // conflict-queue: new write contradicts existing higher-trust fact, routed to queues/conflicts.md (Task 25, design §6.8)
   CONFLICT_RESOLVED: 'conflict-resolved', // conflict-queue: user resolved a pending conflict via cmk queue conflicts (keep-old / keep-new / merge-both)
@@ -46,6 +48,10 @@ export const REASON_CODES = Object.freeze({
   REPAIR_HOOKS_NOOP: 'repair-hooks-noop', // cmk repair --hooks: settings.json already canonical, no-op (Task 39)
   INSTALL_HOOKS_WIRED: 'install-hooks-wired', // cmk install: settings.json wired with npm-route hooks (Task 49). NOTE: no NOOP counterpart — install audits only on change, to keep re-runs byte-idempotent (the audit.log is append-only).
   REPAIR_LOCK_REMOVED: 'repair-lock-removed', // cmk repair --locks: stale lock unlinked (Task 39)
+  PERSONA_PROMOTED: 'persona-promoted', // auto-persona: cross-project doctrine auto-promoted into a user-tier scratchpad at trust:medium (Task 45, design §16.16)
+  PERSONA_SUPERSEDED: 'persona-superseded', // auto-persona: a promoted persona fact auto-superseded a contradicting existing one (Task 45.6, reuses Task 25 conflict detection)
+  PERSONA_SECTION_CREATED: 'persona-section-created', // auto-persona: a new `## ` section was created on a user-tier scratchpad to land a candidate (Task 64 / F2)
+  PERSONA_IMPORTED: 'persona-imported', // persona-portability: a user-tier persona bundle was imported onto this machine (Task 72)
 });
 
 export function nowIso() {

package/src/auto-drain.mjs

@@ -0,0 +1,59 @@
+// Auto-drain the review + conflict queues (v0.2 Phase 2, decision-log D-6).
+//
+// The "i dont want to do anything, i want it to be automatic" posture: the
+// daily-distill / weekly-curate maintenance passes resolve the queues with
+// AUTOMATIC resolvers, instead of waiting for the user to run
+// `cmk queue review` / `cmk queue conflicts`. Those manual verbs still work
+// for anyone who wants explicit control — they are just no longer REQUIRED.
+//
+// Resolvers (optimistic):
+//   - Review queue — medium-trust auto-extractions awaiting blessing →
+//     **auto-promote**. Optimistic: trust the capture. Mistakes self-correct:
+//     a later contradicting fact auto-supersedes (the conflict path), and the
+//     14-day medium-trust staleness drop + consolidation clean up noise.
+//   - Conflict queue — a new LOWER-trust write that contradicted an existing
+//     HIGHER-trust fact (that's the only thing that lands here; equal-or-higher
+//     trust auto-supersedes upstream and never reaches the queue) →
+//     **keep-old**. Protect the established/hand-curated higher-trust fact; the
+//     lower-trust contradiction is discarded (logged via the resolver's audit).
+//     Optimism never lets noise override an established fact.
+//
+// Per design §6.2 (review queue) + §6.8 (conflict queue) + §8.7 (cron passes).
+
+import { resolveReviewQueue } from './review-queue.mjs';
+import { resolveConflictQueue } from './conflict-queue.mjs';
+import { mergeFacts } from './merge-facts.mjs';
+
+// Stateless optimistic resolvers (no per-entry judgement — that's the point).
+const AUTO_PROMOTE = async () => 'promote';
+const KEEP_OLD = async () => 'keep-old';
+
+/**
+ * Drain a tier's review + conflict queues with the optimistic auto-resolvers.
+ * Safe to call when the queues are absent/empty (the resolvers return
+ * zero-count results, not errors).
+ *
+ * @param {object} opts
+ * @param {'P'|'U'|'L'} [opts.tier='P']
+ * @param {string} [opts.projectRoot]
+ * @param {string} [opts.userDir]
+ * @param {string} [opts.scratchpad]  review-queue promotion target (default MEMORY.md)
+ * @param {string} [opts.section]     review-queue promotion section (default Active Threads)
+ * @returns {Promise<{review: object, conflict: object}>}
+ */
+export async function autoDrainQueues({ tier = 'P', projectRoot, userDir, scratchpad, section } = {}) {
+  const reviewOpts = { tier, projectRoot, userDir, prompter: AUTO_PROMOTE };
+  if (scratchpad) reviewOpts.scratchpad = scratchpad;
+  if (section) reviewOpts.section = section;
+  const review = await resolveReviewQueue(reviewOpts);
+
+  const conflict = await resolveConflictQueue({
+    tier,
+    projectRoot,
+    userDir,
+    prompter: KEEP_OLD,
+    mergeFn: mergeFacts, // never invoked under KEEP_OLD; wired for correctness
+  });
+
+  return { review, conflict };
+}

package/src/auto-extract.mjs

@@ -55,6 +55,11 @@ import { pidIsAlive } from './lock-discipline.mjs';
 import { nowIso } from './audit-log.mjs';
 import { ERROR_CATEGORIES } from './result-shapes.mjs';
 import { touchCooldownMarker } from './cooldown.mjs';
+// Task 61 — inline cross-project promotion. Reuse auto-persona's classifier
+// directive, parser, and promote-to-user-tier path so the SAME per-turn Haiku
+// call that extracts project facts ALSO promotes cross-project doctrine to the
+// user tier immediately (vs waiting for the weekly auto-persona janitor).
+import { parsePersonaCandidates, promoteCandidatesToUserTier, PERSONA_CONFIDENCE_RULE } from './auto-persona.mjs';
 
 const LOCK_FILENAME = 'auto-extract.lock';
 const NOW_MD_RELATIVE = ['context', 'sessions', 'now.md'];
@@ -100,6 +105,12 @@ const TRUST_RANK = Object.freeze({
   discarded: 0,
 });
 
+// Task 92 (G6): max chars of a discarded LOW candidate's text to record in the
+// extract.log trace. Enough to identify what was dropped without bloating the
+// log; the full turn still lives in transcripts/{date}.md if deeper recovery is
+// needed.
+const LOW_DISCARD_EXCERPT_MAX = 200;
+
 // --- Lock file primitives -------------------------------------------
 
 function acquireLock(lockPath) {
@@ -238,7 +249,7 @@ function parseTurnFile(rawTurn) {
 // Written from scratch per design §6.4 — no text copied from claude-
 // remember's prompts. Output format encodes origin so the routing
 // layer can apply the assistant-demotion rule (§6.4 amendment, 2026-05-26).
-function buildExtractionInstructions() {
+export function buildExtractionInstructions() {
   return [
     'You are a memory-extraction agent for claude-memory-kit.',
     'You read a captured turn pair (the user prompt + the assistant response) and identify durable facts worth saving.',
@@ -249,8 +260,8 @@ function buildExtractionInstructions() {
     'Save when EITHER turn reveals any of the six writing triggers:',
     '  1. User corrections — "don\'t do that again", "use this instead".',
     '  2. Discovered preferences — patterns across multiple turns.',
-    '  3. Environment facts — tool versions, paths, configurations.',
-    '  4. Project conventions — discovered through code inspection.',
+    '  3. Setup / configuration facts — concrete setup or configuration values the next session would otherwise have to re-derive to recover (the answer to "what\'s our setup / how is this configured"). **Capture these even when they surface from the WORK itself, not only from a stated preference** — a value recalled from memory is what saves the next session from re-deriving it.',
+    '  4. Project conventions — patterns discovered while working in the project (in its files, structure, or materials).',
     '  5. Completed complex workflows — 5+ tool calls; the approach is worth recording.',
     '  6. Tool quirks and workarounds — non-obvious findings.',
     '',
@@ -272,6 +283,15 @@ function buildExtractionInstructions() {
     '  - If a previous-entry context is included below, do NOT re-emit facts already in it.',
     '',
     'Note: assistant-origin candidates are auto-demoted one trust level before routing (HIGH → MEDIUM → LOW → discarded). This is intentional — assistant inferences need user review. Emit your honest trust assessment; the routing layer handles demotion.',
+    '',
+    'ALSO — cross-project doctrine. This is a REQUIRED, PER-FACT pass, separate from the TRUST_ lines above. Re-scan the SAME turn for EVERY fact that expresses how this user works in ALL their projects (tooling habits, how they structure their work, communication / process style — NOT specifics that belong to this ONE project, like a particular value, name, or detail that would not carry to their other projects). **For EACH such cross-project fact, emit its OWN PERSONA CANDIDATE line — one line per fact. If the turn states THREE cross-project rules, emit THREE PERSONA CANDIDATE lines. Never collapse several rules into one line, and never skip a rule because the turn is busy or already has TRUST_ lines.** Format (one line per cross-project fact):',
+    '  PERSONA CANDIDATE | target=<HABITS.md|LESSONS.md|USER.md> | section=<Section> | confidence=<high|medium|low> | <one-line restatement>',
+    '    - HABITS.md  → sections: Iteration Cadence | Destructive Operations | Communication Style',
+    '    - LESSONS.md → sections: Tooling Lessons | Process Lessons | Anti-patterns',
+    '    - USER.md    → sections: About | Preferences | Working Style',
+    '  PREFER an existing section above — route to the closest fit. Only if NONE genuinely fits may you name a new short Title-Case section (2-4 words, letters/spaces only, e.g. "Architecture Preferences"). Never invent a new section when an existing one fits.',
+    PERSONA_CONFIDENCE_RULE,
+    '  Emit no PERSONA CANDIDATE line if nothing is cross-project.',
   ].join('\n');
 }
 
@@ -460,6 +480,8 @@ export async function runAutoExtract({
   haikuBackend,
   now,
   sessionId,
+  userDir, // Task 61: when present, cross-project candidates promote to the user tier inline
+  settings,
 } = {}) {
   const ts = now ?? nowIso();
   const t0 = Date.now();
@@ -586,7 +608,14 @@ export async function runAutoExtract({
         instructions,
         maxOutputBytes: 2000,
         preserveCitationIds: false,
-        timeoutMs: 25_000,
+        // 90s, not 25s: the real `claude --print` extraction (full turn +
+        // instructions) consistently exceeded a 25s ceiling on a live machine
+        // and was KILLED mid-call (extract.log: success:false, haiku_timeout,
+        // duration ≈ 25000ms = hitting the cap, not finishing) → automatic
+        // capture + persona promotion (F2) silently never ran. This call is
+        // DETACHED (fire-and-forget, never blocks the session), so a generous
+        // ceiling is free. Live-test finding (2026-06-01, lior-test-4 baseline).
+        timeoutMs: 90_000,
       });
       // Touch the cooldown marker IMMEDIATELY after the Haiku call
       // resolves — this is the "we spent the budget" signal that
@@ -639,9 +668,61 @@ export async function runAutoExtract({
     candidates = applyRetainOverride(candidates, retainSegments);
     candidates = dedupByCanonicalId(candidates);
 
-    if (candidates.length === 0) {
+    // Task 61 — inline cross-project promotion. The SAME Haiku output may
+    // carry PERSONA CANDIDATE lines (cross-project doctrine); promote them to
+    // the user tier THIS run (vs the weekly auto-persona janitor). No second
+    // LLM call — same outputText. Runs BEFORE the project-empty check so a
+    // turn that is ONLY cross-project doctrine still promotes.
+    let persona = null;
+    if (userDir) {
+      // Inline persona promotion is SECONDARY to project extraction — a bug in
+      // the cross-project path must never take down the primary job (project
+      // facts + extract.log). Isolate it: on throw, record the error on the
+      // result and continue routing project candidates normally.
+      try {
+        const personaCandidates = parsePersonaCandidates(haikuResult.outputText);
+        if (personaCandidates.length > 0) {
+          // Task 78 — the wedge's AUTO half. Only confidence=high candidates
+          // clear the promote gate, and (post-Task-78 grading) confidence=high
+          // means the user EXPLICITLY STATED a standing rule THIS turn → it is
+          // user-attested, so promote at trust:high (durable; won't be clobbered
+          // by a later inferred-medium entry). Inferred (medium) candidates still
+          // queue to persona-review. The weekly janitor stays at the default
+          // medium (45.6) — it synthesizes from accumulated facts, not a fresh
+          // statement.
+          persona = promoteCandidatesToUserTier({
+            candidates: personaCandidates,
+            userDir,
+            now: ts,
+            settings,
+            trust: 'high',
+            source: 'user-explicit',
+          });
+        }
+      } catch (err) {
+        persona = { promoted: [], queued: [], superseded: [], conflicts: [], error: err?.message ?? String(err) };
+      }
+    }
+    const personaLanded =
+      !!persona && ((persona.promoted?.length ?? 0) + (persona.superseded?.length ?? 0)) > 0;
+    // Door 4 (observability): when the inline persona pass ran, the
+    // extract.log entry carries the promotion counts so a later debugger
+    // can see cross-project doctrine landed in the user tier without
+    // re-running the turn. Empty object when no userDir / no persona pass.
+    const personaLogFields = persona
+      ? {
+          persona_promoted: persona.promoted?.length ?? 0,
+          persona_superseded: persona.superseded?.length ?? 0,
+          persona_queued: persona.queued?.length ?? 0,
+          persona_conflicts: persona.conflicts?.length ?? 0,
+          ...(persona.error ? { persona_error: persona.error } : {}),
+        }
+      : {};
+
+    if (candidates.length === 0 && !personaLanded) {
       const entry = {
         ...baseEntry,
+        ...personaLogFields,
         success: true,
         skipped_reason: 'nothing_durable',
         duration_ms: Date.now() - t0,
@@ -654,6 +735,7 @@ export async function runAutoExtract({
         duration_ms: entry.duration_ms,
         logPath,
         candidates: [],
+        persona,
       };
     }
 
@@ -681,6 +763,27 @@ export async function runAutoExtract({
         writes.push({ ...candidate, written: 'review', result: r });
       } else {
         writes.push({ ...candidate, written: 'discarded' });
+        // Task 92 (G6): a LOW (or assistant-demoted-to-discarded) candidate is
+        // dropped from active memory, but leave a recoverable trace — the
+        // excerpt + reason — in extract.log, so a fact Haiku mis-graded LOW (or
+        // an assistant-origin fact demoted to LOW) is auditable, not silently
+        // vanished (the §6.5 "don't lose without trace" principle at the capture
+        // edge; MEDIUM already gets a review queue, LOW got nothing). Log-only
+        // by decision (92.1): NOT routed to the review queue — that would flood
+        // it with low-signal noise. One discrete NDJSON entry per drop (Door 4).
+        writeExtractLogEntry({
+          projectRoot,
+          ts,
+          entry: {
+            event: 'low_trust_discarded',
+            reason: 'low_trust_discarded',
+            trust: candidate.trust,
+            demoted_from: candidate.demotedFrom ?? null,
+            origin: candidate.origin ?? null,
+            excerpt: candidate.text.slice(0, LOW_DISCARD_EXCERPT_MAX),
+            excerpt_truncated: candidate.text.length > LOW_DISCARD_EXCERPT_MAX,
+          },
+        });
       }
     }
 
@@ -688,9 +791,14 @@ export async function runAutoExtract({
       (w) => w.written === 'memory' || w.written === 'review' || w.written === 'conflict',
     ).length;
 
-    if (observation_count === 0) {
+    // Persona-only turn: no project candidate landed, but cross-project
+    // doctrine promoted to the user tier this run. That IS a durable
+    // extraction — fall through to the 'extracted' return (observation_count
+    // stays 0; `persona` carries the user-tier result + Door 4 log fields).
+    if (observation_count === 0 && !personaLanded) {
       const entry = {
         ...baseEntry,
+        ...personaLogFields,
         success: true,
         skipped_reason: 'nothing_durable',
         duration_ms: Date.now() - t0,
@@ -703,11 +811,13 @@ export async function runAutoExtract({
         duration_ms: entry.duration_ms,
         logPath,
         candidates: writes,
+        persona,
       };
     }
 
     const entry = {
       ...baseEntry,
+      ...personaLogFields,
       success: true,
       observation_count,
       duration_ms: Date.now() - t0,
@@ -719,6 +829,7 @@ export async function runAutoExtract({
       duration_ms: entry.duration_ms,
       logPath,
       candidates: writes,
+      persona,
     };
   } finally {
     // Cleanup order: turn-file FIRST (frees disk), lock LAST (releases