@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/memories/index.ts

@@ -3,16 +3,16 @@ import type * as fsNode from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@prometheus-ai/agent-core";
-import { clampThinkingLevelForModel, completeSimple, Effort, type Model } from "@prometheus-ai/ai";
-import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@prometheus-ai/utils";
-import { readFile, walkUp } from "../capability/fs";
+import { type ApiKey, completeSimple, Effort, type Model } from "@prometheus-ai/ai";
+import { clampThinkingLevelForModel } from "@prometheus-ai/catalog/model-thinking";
+import { getAgentDbPath, getMemoriesDir, isEnoent, logger, parseJsonlLenient, prompt } from "@prometheus-ai/utils";
+
 import type { ModelRegistry } from "../config/model-registry";
-import { resolveModelRoleValue } from "../config/model-resolver";
+import { getModelMatchPreferences, resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
-import { SOURCE_PATHS } from "../discovery/helpers";
+import type { MemoryBackendSaveInput, MemoryBackendSaveResult } from "../memory-backend/types";
 import consolidationTemplate from "../prompts/memories/consolidation.md" with { type: "text" };
-import identityReviewTemplate from "../prompts/memories/identity_review.md" with { type: "text" };
-import postTurnReviewTemplate from "../prompts/memories/post_turn_review.md" with { type: "text" };
+import consolidationSystemTemplate from "../prompts/memories/consolidation_system.md" with { type: "text" };
 import readPathTemplate from "../prompts/memories/read-path.md" with { type: "text" };
 import stageOneInputTemplate from "../prompts/memories/stage_one_input.md" with { type: "text" };
 import stageOneSystemTemplate from "../prompts/memories/stage_one_system.md" with { type: "text" };
@@ -32,7 +32,6 @@ import {
 	markStage1SucceededNoOutput,
 	markStage1SucceededWithOutput,
 	openMemoryDb,
-	recordBackgroundStage1Output,
 	type Stage1Claim,
 	type Stage1OutputRow,
 	tryClaimGlobalPhase2Job,
@@ -41,13 +40,6 @@ import {
 
 interface MemoryRuntimeConfig {
 	enabled: boolean;
-	selfImprovementMode: "memory-and-skills" | "off";
-	backgroundReviewMode: "memory-and-skills" | "off";
-	backgroundReviewEveryNTurns: number;
-	identityReviewMode: "propose" | "off";
-	curatorMode: "dry-run" | "off";
-	generatedSkillStaleAfterDays: number;
-	generatedSkillArchiveAfterDays: number;
 	maxRolloutsPerStartup: number;
 	maxRolloutAgeDays: number;
 	minRolloutIdleHours: number;
@@ -67,13 +59,6 @@ interface MemoryRuntimeConfig {
 
 const DEFAULTS: MemoryRuntimeConfig = {
 	enabled: false,
-	selfImprovementMode: "memory-and-skills",
-	backgroundReviewMode: "memory-and-skills",
-	backgroundReviewEveryNTurns: 10,
-	identityReviewMode: "propose",
-	curatorMode: "dry-run",
-	generatedSkillStaleAfterDays: 30,
-	generatedSkillArchiveAfterDays: 90,
 	maxRolloutsPerStartup: 64,
 	maxRolloutAgeDays: 30,
 	minRolloutIdleHours: 12,
@@ -91,8 +76,6 @@ const DEFAULTS: MemoryRuntimeConfig = {
 	summaryInjectionTokenLimit: 5_000,
 };
 
-const GENERATED_MEMORY_SKILL_INDEX_LIMIT = 50;
-
 interface Stage1Stats {
 	claimed: number;
 	succeeded: number;
@@ -114,11 +97,6 @@ interface Stage1OutputSchema {
 	rollout_slug: string | null;
 }
 
-interface PostTurnReviewMessage {
-	role: "user" | "assistant";
-	content: string;
-}
-
 interface ConsolidationSkillFileSchema {
 	path: string;
 	content: string;
@@ -133,94 +111,10 @@ interface ConsolidationSkillSchema {
 }
 interface ConsolidationOutputSchema {
 	memory_md: string;
-	user_md: string;
 	memory_summary: string;
 	skills: ConsolidationSkillSchema[];
 }
 
-type GeneratedMemorySkillState = "active" | "stale" | "archived";
-type GeneratedMemorySkillEvent = "use" | "view" | "patch";
-
-interface GeneratedMemorySkillUsageRecord {
-	schemaVersion: 1;
-	name: string;
-	source: "memory-consolidation";
-	state: GeneratedMemorySkillState;
-	pinned: boolean;
-	createdAt: string;
-	updatedAt: string;
-	lastSeenInConsolidationAt: string | null;
-	archivedAt: string | null;
-	archiveReason: string | null;
-	useCount: number;
-	viewCount: number;
-	patchCount: number;
-	lastUsedAt: string | null;
-	lastViewedAt: string | null;
-	lastPatchedAt: string | null;
-}
-
-interface GeneratedMemorySkillUsageFile {
-	schemaVersion: 1;
-	skills: Record<string, GeneratedMemorySkillUsageRecord>;
-}
-
-interface IdentityReviewResult {
-	soulProposal: string;
-	nativeSoulPath: string | null;
-	error?: string;
-}
-
-interface SkillCurationResult {
-	usage: GeneratedMemorySkillUsageFile;
-	active: string[];
-	pinnedStale: string[];
-	archived: string[];
-	staleCandidates: string[];
-	archiveCandidates: string[];
-	markedStale: string[];
-	reactivated: string[];
-	report: string;
-}
-
-export const MEMORY_ARTIFACTS = {
-	summary: "memory_summary.md",
-	memory: "MEMORY.md",
-	user: "USER.md",
-	selfImprovementReport: "self_improvement_report.md",
-	skillUsage: "skill_usage.json",
-	skillCuratorReport: "skill_curator_report.md",
-	soulProposal: "SOUL.proposed.md",
-} as const;
-
-const USER_PROFILE_OPEN_TAG = '<user_profile role="durable_user_context">';
-const USER_PROFILE_CLOSE_TAG = "</user_profile>";
-const POST_TURN_REVIEW_THREAD_PREFIX = "post-turn-review";
-const postTurnReviewStates = new WeakMap<
-	AgentSession,
-	{ lastReviewedUserTurns: number; running: boolean; unsubscribe: () => void }
->();
-
-const FORBIDDEN_IDENTITY_ARTIFACT_PATTERNS: ReadonlyArray<{ label: string; pattern: RegExp }> = [
-	{ label: "soul_md", pattern: /\bsoul_md\b/i },
-	{ label: "SOUL.md", pattern: /\bSOUL\.md\b/i },
-	{ label: "SOUL.proposed.md", pattern: /\bSOUL\.proposed\.md\b/i },
-	{ label: "<soul>", pattern: /<\s*\/?\s*soul\b/i },
-	{ label: "<soul_proposal>", pattern: /<\s*\/?\s*soul[_-]?proposal\b/i },
-	{ label: "<soul_proposed>", pattern: /<\s*\/?\s*soul[_-]?proposed\b/i },
-	{ label: "<identity>", pattern: /<\s*\/?\s*identity\b/i },
-	{ label: "<personality>", pattern: /<\s*\/?\s*personality\b/i },
-	{ label: "agent_identity", pattern: /\bagent_identity\b/i },
-	{ label: "assistant_identity", pattern: /\bassistant_identity\b/i },
-	{ label: "prometheus_identity", pattern: /\bprometheus_identity\b/i },
-	{ label: "identity_md", pattern: /\bidentity_md\b/i },
-	{ label: "persona_md", pattern: /\bpersona_md\b/i },
-	{ label: "personality_md", pattern: /\bpersonality_md\b/i },
-	{ label: "agent_personality", pattern: /\bagent_personality\b/i },
-	{ label: "assistant_personality", pattern: /\bassistant_personality\b/i },
-	{ label: "prometheus_personality", pattern: /\bprometheus_personality\b/i },
-];
-
 /**
  * Start the background memory startup pipeline.
  *
@@ -248,8 +142,6 @@ export function startMemoryStartupTask(options: {
 		return;
 	}
 
-	attachPostTurnBackgroundReview({ session, settings, modelRegistry, agentDir, config: cfg });
-
 	void runMemoryStartup({ session, settings, modelRegistry, agentDir, config: cfg }).catch(error => {
 		logger.warn("Memory startup failed", { error: String(error) });
 	});
@@ -265,47 +157,31 @@ export async function buildMemoryToolDeveloperInstructions(
 	const cfg = loadMemoryConfig(settings);
 	if (!cfg.enabled) return undefined;
 	const memoryRoot = getMemoryRoot(agentDir, settings.getCwd());
-	const summaryPath = path.join(memoryRoot, MEMORY_ARTIFACTS.summary);
 
-	let text: string;
+	let summary = "";
 	try {
-		text = await Bun.file(summaryPath).text();
+		summary = (await Bun.file(path.join(memoryRoot, "memory_summary.md")).text()).trim();
 	} catch {
-		return undefined;
+		// Missing or unreadable summary: injection is best-effort; fall through
+		// so any captured lessons still surface on their own.
 	}
+	const learned = await readLearnedLessons(memoryRoot);
+	if (!summary && !learned) return undefined;
 
-	const summary = text.trim();
-	if (!summary) return undefined;
-	const truncated = truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit);
-	if (!truncated.trim()) return undefined;
-	const generatedMemorySkills = await buildGeneratedMemorySkillIndex(memoryRoot);
+	const summaryOut = summary ? truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit).trim() : "";
+	// Lessons share one injection budget with the summary so the combined block
+	// stays within `summaryInjectionTokenLimit` (~4 chars/token, matching
+	// truncateByApproxTokens). With no summary, lessons get the whole budget.
+	const learnedBudget = Math.max(0, cfg.summaryInjectionTokenLimit - Math.ceil(summaryOut.length / 4));
+	const learnedOut = learned && learnedBudget > 0 ? truncateByApproxTokens(learned, learnedBudget).trim() : "";
+	if (!summaryOut && !learnedOut) return undefined;
 
 	return prompt.render(readPathTemplate, {
-		memory_summary: truncated,
-		generated_memory_skills: generatedMemorySkills,
+		memory_summary: summaryOut,
+		learned: learnedOut,
 	});
 }
 
-async function buildGeneratedMemorySkillIndex(memoryRoot: string): Promise<string> {
-	const skillsDir = path.join(memoryRoot, "skills");
-	const dirents = await fs.readdir(skillsDir, { withFileTypes: true }).catch(() => []);
-	const names: string[] = [];
-	for (const dirent of dirents) {
-		if (!dirent.isDirectory()) continue;
-		const skillPath = path.join(skillsDir, dirent.name, "SKILL.md");
-		if (await Bun.file(skillPath).exists()) names.push(dirent.name);
-	}
-	names.sort((a, b) => a.localeCompare(b));
-	if (names.length === 0) return "None yet.";
-	const visible = names.slice(0, GENERATED_MEMORY_SKILL_INDEX_LIMIT);
-	const lines = visible.map(name => `- memory://root/skills/${name}/SKILL.md`);
-	const hidden = names.length - visible.length;
-	if (hidden > 0) {
-		lines.push(`- ... ${hidden} more generated memory skill${hidden === 1 ? "" : "s"} not listed`);
-	}
-	return lines.join("\n");
-}
-
 /**
  * Clear all persisted memory state and generated artifacts.
  */
@@ -343,107 +219,6 @@ async function runMemoryStartup(options: {
 	await options.session.refreshBaseSystemPrompt?.();
 }
 
-function attachPostTurnBackgroundReview(options: {
-	session: AgentSession;
-	settings: Settings;
-	modelRegistry: ModelRegistry;
-	agentDir: string;
-	config: MemoryRuntimeConfig;
-}): void {
-	const { session, config } = options;
-	if (config.backgroundReviewMode === "off") return;
-	if (config.backgroundReviewEveryNTurns <= 0) return;
-	if (postTurnReviewStates.has(session)) return;
-	if (typeof session.subscribe !== "function") return;
-
-	const state = { lastReviewedUserTurns: 0, running: false, unsubscribe: () => {} };
-	state.unsubscribe = session.subscribe(event => {
-		if (event.type !== "agent_end") return;
-		void maybeRunPostTurnBackgroundReview(options);
-	});
-	postTurnReviewStates.set(session, state);
-}
-
-async function maybeRunPostTurnBackgroundReview(options: {
-	session: AgentSession;
-	settings: Settings;
-	modelRegistry: ModelRegistry;
-	agentDir: string;
-	config: MemoryRuntimeConfig;
-}): Promise<void> {
-	const { session, modelRegistry, agentDir, config } = options;
-	const state = postTurnReviewStates.get(session);
-	if (!state || state.running) return;
-
-	const messages = extractPostTurnReviewMessages(session);
-	const userTurns = messages.filter(message => message.role === "user").length;
-	if (userTurns <= 0) return;
-	if (userTurns - state.lastReviewedUserTurns < config.backgroundReviewEveryNTurns) return;
-
-	state.running = true;
-	try {
-		const model = await resolveMemoryModel({ modelRegistry, session, fallbackRole: "default" });
-		if (!model) {
-			logger.debug("Post-turn memory review skipped: no model available");
-			return;
-		}
-		const apiKey = await modelRegistry.getApiKey(model, session.sessionId);
-		if (!apiKey) {
-			logger.debug("Post-turn memory review skipped: no API key", {
-				provider: model.provider,
-				model: model.id,
-			});
-			return;
-		}
-
-		const result = await runPostTurnReviewModel({
-			session,
-			messages,
-			userTurns,
-			model,
-			apiKey,
-			modelMaxTokens: computeModelTokenBudget(model, config),
-			config,
-			metadata: session.agent?.metadataForProvider(model.provider),
-		});
-		if (result.kind === "failed") {
-			logger.warn("Post-turn memory review failed", { reason: result.reason });
-			return;
-		}
-		if (result.kind === "no_output") {
-			state.lastReviewedUserTurns = userTurns;
-			return;
-		}
-
-		const sourceUpdatedAt = unixNow();
-		const threadId = buildPostTurnReviewThreadId(session.sessionManager.getSessionId(), userTurns);
-		const db = openMemoryDb(getAgentDbPath(agentDir));
-		try {
-			recordBackgroundStage1Output(db, {
-				threadId,
-				sourceUpdatedAt,
-				rolloutPath: session.sessionManager.getSessionFile() ?? threadId,
-				cwd: session.sessionManager.getCwd(),
-				rawMemory: result.output.rawMemory,
-				rolloutSummary: result.output.rolloutSummary,
-				rolloutSlug: result.output.rolloutSlug,
-				nowSec: sourceUpdatedAt,
-			});
-		} finally {
-			closeMemoryDb(db);
-		}
-		state.lastReviewedUserTurns = userTurns;
-
-		await runPhase2(options);
-		await session.refreshBaseSystemPrompt?.();
-		session.emitNotice("info", "Self-improvement review captured durable memory.", "Memory");
-	} catch (error) {
-		logger.warn("Post-turn memory review failed", { error: String(error) });
-	} finally {
-		state.running = false;
-	}
-}
-
 async function runPhase1(options: {
 	session: AgentSession;
 	settings: Settings;
@@ -506,7 +281,7 @@ async function runPhase1(options: {
 			const result = await runStage1Job({
 				claim,
 				model: phase1Model,
-				apiKey: phase1ApiKey,
+				apiKey: modelRegistry.resolver(phase1Model, session.sessionId),
 				modelMaxTokens: computeModelTokenBudget(phase1Model, config),
 				config,
 				metadata: session.agent?.metadataForProvider(phase1Model.provider),
@@ -663,24 +438,10 @@ async function runPhase2(options: {
 			const consolidated = await runConsolidationModel({
 				memoryRoot,
 				model: phase2Model,
-				apiKey: phase2ApiKey,
-				metadata: session.agent?.metadataForProvider(phase2Model.provider),
-			});
-			const identityReview = await runIdentityReviewModel({
-				cwd,
-				memoryRoot,
-				model: phase2Model,
-				apiKey: phase2ApiKey,
+				apiKey: modelRegistry.resolver(phase2Model, session.sessionId),
 				metadata: session.agent?.metadataForProvider(phase2Model.provider),
-				consolidated,
-				enabled: config.identityReviewMode === "propose",
-			});
-			await applyConsolidation(memoryRoot, consolidated, {
-				identityReview,
-				curatorMode: config.curatorMode,
-				generatedSkillStaleAfterDays: config.generatedSkillStaleAfterDays,
-				generatedSkillArchiveAfterDays: config.generatedSkillArchiveAfterDays,
 			});
+			await applyConsolidation(memoryRoot, consolidated);
 			if (heartbeatLostOwnership) {
 				throw new Error("Phase2 lease ownership lost before completion");
 			}
@@ -820,87 +581,10 @@ function extractPersistableMessages(payload: string): AgentMessage[] {
 	return messages;
 }
 
-async function runPostTurnReviewModel(options: {
-	session: AgentSession;
-	messages: PostTurnReviewMessage[];
-	userTurns: number;
-	model: Model;
-	apiKey: string;
-	modelMaxTokens: number;
-	config: MemoryRuntimeConfig;
-	metadata?: Record<string, unknown>;
-}): Promise<
-	| {
-			kind: "output";
-			output: { rawMemory: string; rolloutSummary: string; rolloutSlug: string | null };
-	  }
-	| { kind: "no_output" }
-	| { kind: "failed"; reason: string }
-> {
-	const { session, messages, userTurns, model, apiKey, modelMaxTokens, config } = options;
-	try {
-		const budgetTokens = Math.min(
-			config.phase1InputTokenLimit,
-			Math.floor(modelMaxTokens * config.rolloutPayloadPercent),
-		);
-		const input = prompt.render(postTurnReviewTemplate, {
-			thread_id: session.sessionManager.getSessionId() ?? "unknown",
-			cwd: session.sessionManager.getCwd(),
-			user_turns: String(userTurns),
-			review_every_n_turns: String(config.backgroundReviewEveryNTurns),
-			conversation_json: truncateByApproxTokens(JSON.stringify(messages), budgetTokens),
-		});
-		const response = await completeSimple(
-			model,
-			{
-				messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
-			},
-			{
-				apiKey,
-				metadata: options.metadata,
-				maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
-				reasoning: clampThinkingLevelForModel(model, Effort.Low),
-			},
-		);
-
-		if (response.stopReason === "error") {
-			return { kind: "failed", reason: response.errorMessage || "post-turn review model error" };
-		}
-		const text = response.content
-			.filter((c): c is { type: "text"; text: string } => c.type === "text")
-			.map(c => c.text)
-			.join("\n")
-			.trim();
-		const parsed = parseJsonObject(text);
-		if (!parsed) {
-			return { kind: "failed", reason: "post-turn review JSON parse failure" };
-		}
-		const schemaOutput = parseStage1OutputSchema(parsed);
-		if (!schemaOutput) {
-			return { kind: "failed", reason: "post-turn review JSON schema validation failure" };
-		}
-
-		const rawMemory = redactSecrets(schemaOutput.raw_memory).trim();
-		const rolloutSummary = redactSecrets(schemaOutput.rollout_summary).trim();
-		const rolloutSlug = schemaOutput.rollout_slug === null ? null : redactSecrets(schemaOutput.rollout_slug).trim();
-		if (!rawMemory || !rolloutSummary) return { kind: "no_output" };
-		return {
-			kind: "output",
-			output: {
-				rawMemory,
-				rolloutSummary,
-				rolloutSlug: rolloutSlug || null,
-			},
-		};
-	} catch (error) {
-		return { kind: "failed", reason: String(error) };
-	}
-}
-
 async function runStage1Job(options: {
 	claim: Stage1Claim;
 	model: Model;
-	apiKey: string;
+	apiKey: ApiKey;
 	modelMaxTokens: number;
 	config: MemoryRuntimeConfig;
 	metadata?: Record<string, unknown>;
@@ -1006,12 +690,8 @@ async function syncPhase2Artifacts(memoryRoot: string, outputs: Stage1OutputRow[
 }
 
 async function cleanupConsolidatedArtifacts(memoryRoot: string): Promise<void> {
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.memory), { force: true });
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.user), { force: true });
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.summary), { force: true });
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.selfImprovementReport), { force: true });
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.skillUsage), { force: true });
-	await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.skillCuratorReport), { force: true });
+	await fs.rm(path.join(memoryRoot, "MEMORY.md"), { force: true });
+	await fs.rm(path.join(memoryRoot, "memory_summary.md"), { force: true });
 	await fs.rm(path.join(memoryRoot, "skills"), { recursive: true, force: true });
 }
 
@@ -1048,11 +728,10 @@ async function readRolloutSummaries(memoryRoot: string): Promise<string> {
 async function runConsolidationModel(options: {
 	memoryRoot: string;
 	model: Model;
-	apiKey: string;
+	apiKey: ApiKey;
 	metadata?: Record<string, unknown>;
 }): Promise<{
 	memoryMd: string;
-	userMd: string;
 	memorySummary: string;
 	skills: Array<{
 		name: string;
@@ -1073,6 +752,7 @@ async function runConsolidationModel(options: {
 	const response = await completeSimple(
 		model,
 		{
+			systemPrompt: [consolidationSystemTemplate],
 			messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
 		},
 		{
@@ -1094,29 +774,7 @@ async function runConsolidationModel(options: {
 	if (!parsed) throw new Error("phase2 JSON parse failure");
 	const schemaOutput = parseConsolidationOutputSchema(parsed);
 	if (!schemaOutput) throw new Error("phase2 JSON schema validation failure");
-	assertNoIdentityArtifactLeak([
-		{ field: "memory_md", value: schemaOutput.memory_md },
-		{ field: "user_md", value: schemaOutput.user_md },
-		{ field: "memory_summary", value: schemaOutput.memory_summary },
-		...schemaOutput.skills.flatMap((skill, index) => [
-			{ field: `skills[${index}].name`, value: skill.name },
-			{ field: `skills[${index}].content`, value: skill.content ?? "" },
-			...(skill.scripts ?? []).map(file => ({
-				field: `skills[${index}].scripts.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-			...(skill.templates ?? []).map(file => ({
-				field: `skills[${index}].templates.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-			...(skill.examples ?? []).map(file => ({
-				field: `skills[${index}].examples.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-		]),
-	]);
 	const memoryMd = redactSecrets(schemaOutput.memory_md).trim();
-	const userMd = normalizeConsolidatedUserProfile(redactSecrets(schemaOutput.user_md));
 	const memorySummary = redactSecrets(schemaOutput.memory_summary).trim();
 	const skills = schemaOutput.skills
 		.map(item => {
@@ -1142,117 +800,16 @@ async function runConsolidationModel(options: {
 				examples: ConsolidationSkillFileSchema[];
 			} => item !== null,
 		);
-	assertNoIdentityArtifactLeak([
-		{ field: "memory_md", value: memoryMd },
-		{ field: "user_md", value: userMd },
-		{ field: "memory_summary", value: memorySummary },
-		...skills.flatMap(skill => [
-			{ field: `skills.${skill.name}.name`, value: skill.name },
-			{ field: `skills.${skill.name}.content`, value: skill.content },
-			...skill.scripts.map(file => ({
-				field: `skills.${skill.name}.scripts.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-			...skill.templates.map(file => ({
-				field: `skills.${skill.name}.templates.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-			...skill.examples.map(file => ({
-				field: `skills.${skill.name}.examples.${file.path}`,
-				value: `${file.path}\n${file.content}`,
-			})),
-		]),
-	]);
 	if (!memoryMd || !memorySummary) {
 		throw new Error("phase2 returned empty consolidated memory");
 	}
-	return { memoryMd, userMd, memorySummary, skills };
-}
-
-async function runIdentityReviewModel(options: {
-	cwd: string;
-	memoryRoot: string;
-	model: Model;
-	apiKey: string;
-	metadata?: Record<string, unknown>;
-	enabled: boolean;
-	consolidated: {
-		userMd: string;
-		memorySummary: string;
-		skills: Array<{ name: string }>;
-	};
-}): Promise<IdentityReviewResult> {
-	const nativeSoul = await readNativeSoulContext(options.cwd);
-	if (!options.enabled) {
-		return { soulProposal: "", nativeSoulPath: nativeSoul.path };
-	}
-
-	try {
-		const input = prompt.render(identityReviewTemplate, {
-			native_soul_path: nativeSoul.path ?? "No native SOUL.md found.",
-			native_soul: truncateByApproxTokens(nativeSoul.content || "No native SOUL.md found.", 8_000),
-			user_md: truncateByApproxTokens(options.consolidated.userMd || "No durable USER.md profile.", 4_000),
-			memory_summary: truncateByApproxTokens(options.consolidated.memorySummary, 4_000),
-			generated_skills:
-				options.consolidated.skills.length === 0
-					? "None."
-					: options.consolidated.skills
-							.map(skill => `- memory://root/skills/${skill.name}/SKILL.md`)
-							.sort((a, b) => a.localeCompare(b))
-							.join("\n"),
-		});
-
-		const response = await completeSimple(
-			options.model,
-			{
-				messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
-			},
-			{
-				apiKey: options.apiKey,
-				metadata: options.metadata,
-				maxTokens: 4096,
-				reasoning: clampThinkingLevelForModel(options.model, Effort.Low),
-			},
-		);
-		if (response.stopReason === "error") {
-			return {
-				soulProposal: "",
-				nativeSoulPath: nativeSoul.path,
-				error: response.errorMessage || "identity review model error",
-			};
-		}
-		const text = response.content
-			.filter((c): c is { type: "text"; text: string } => c.type === "text")
-			.map(c => c.text)
-			.join("\n")
-			.trim();
-		const parsed = parseJsonObject(text);
-		if (!parsed) {
-			return { soulProposal: "", nativeSoulPath: nativeSoul.path, error: "identity review JSON parse failure" };
-		}
-		const proposal = parseIdentityReviewOutputSchema(parsed);
-		if (proposal === undefined) {
-			return { soulProposal: "", nativeSoulPath: nativeSoul.path, error: "identity review JSON schema failure" };
-		}
-		return { soulProposal: proposal, nativeSoulPath: nativeSoul.path };
-	} catch (error) {
-		return { soulProposal: "", nativeSoulPath: nativeSoul.path, error: String(error) };
-	}
-}
-
-async function readNativeSoulContext(cwd: string): Promise<{ path: string | null; content: string }> {
-	const projectConfigDir = await walkUp(cwd, SOURCE_PATHS.native.projectDir, { file: false, dir: true });
-	if (!projectConfigDir) return { path: null, content: "" };
-	const soulPath = path.join(projectConfigDir, "SOUL.md");
-	const content = await readFile(soulPath);
-	return { path: soulPath, content: content ?? "" };
+	return { memoryMd, memorySummary, skills };
 }
 
 async function applyConsolidation(
 	memoryRoot: string,
 	consolidated: {
 		memoryMd: string;
-		userMd: string;
 		memorySummary: string;
 		skills: Array<{
 			name: string;
@@ -1262,146 +819,30 @@ async function applyConsolidation(
 			examples: ConsolidationSkillFileSchema[];
 		}>;
 	},
-	options: {
-		identityReview: IdentityReviewResult;
-		curatorMode: "dry-run" | "off";
-		generatedSkillStaleAfterDays: number;
-		generatedSkillArchiveAfterDays: number;
-	},
 ): Promise<void> {
-	await Bun.write(path.join(memoryRoot, MEMORY_ARTIFACTS.memory), `${consolidated.memoryMd.trim()}\n`);
-	await Bun.write(path.join(memoryRoot, MEMORY_ARTIFACTS.user), `${consolidated.userMd.trim()}\n`);
-	await Bun.write(path.join(memoryRoot, MEMORY_ARTIFACTS.summary), `${consolidated.memorySummary.trim()}\n`);
-	const curation = await applyGeneratedMemorySkills(memoryRoot, consolidated.skills, {
-		curatorMode: options.curatorMode,
-		staleAfterDays: options.generatedSkillStaleAfterDays,
-		archiveAfterDays: options.generatedSkillArchiveAfterDays,
-	});
-
-	if (options.identityReview.soulProposal.trim()) {
-		await Bun.write(
-			path.join(memoryRoot, MEMORY_ARTIFACTS.soulProposal),
-			`${options.identityReview.soulProposal.trim()}\n`,
-		);
-	}
-
-	await Bun.write(
-		path.join(memoryRoot, MEMORY_ARTIFACTS.selfImprovementReport),
-		buildSelfImprovementReport(consolidated, {
-			identityReview: options.identityReview,
-			curation,
-		}),
-	);
-}
-
-function buildSelfImprovementReport(
-	consolidated: {
-		memoryMd: string;
-		userMd: string;
-		memorySummary: string;
-		skills: Array<{ name: string }>;
-	},
-	options: {
-		identityReview: IdentityReviewResult;
-		curation: SkillCurationResult;
-	},
-): string {
-	const skillNames = consolidated.skills.map(skill => skill.name).sort((a, b) => a.localeCompare(b));
-	const generatedSkills = skillNames.length === 0 ? "- None" : skillNames.map(name => `- ${name}`).join("\n");
-	const userProfileState = consolidated.userMd.trim() ? "updated" : "empty";
-	const identityLines = options.identityReview.soulProposal.trim()
-		? [
-				"- SOUL proposal: written to memory://root/SOUL.proposed.md",
-				`- Native SOUL source: ${options.identityReview.nativeSoulPath ?? "none"}`,
-			]
-		: ["- SOUL proposal: none written", `- Native SOUL source: ${options.identityReview.nativeSoulPath ?? "none"}`];
-	if (options.identityReview.error) {
-		identityLines.push(`- Identity review warning: ${options.identityReview.error}`);
-	}
-	const curatorLines = options.curation.report.trim()
-		? [`- Skill curator dry-run report: memory://root/${MEMORY_ARTIFACTS.skillCuratorReport}`]
-		: ["- Skill curator: off"];
-
-	return [
-		"# Self-Improvement Report",
-		"",
-		"Trajectory: Hermes-style native Prometheus learning.",
-		"",
-		"Automatic write scope:",
-		"- MEMORY.md: project and operational memory",
-		"- USER.md: durable user profile",
-		"- skills/: generated procedural playbooks",
-		"",
-		"Stable identity boundary:",
-		"- SOUL.md is not generated or rewritten by memory consolidation.",
-		"- SOUL.proposed.md is reserved for an explicit identity-review flow.",
-		"- Do not present memory artifacts as Prometheus identity.",
-		"",
-		"Dry-run review:",
-		"- Memory/profile/skill consolidation completed through the native Prometheus memory pipeline.",
-		...identityLines,
-		...curatorLines,
-		"",
-		"Current artifacts:",
-		`- MEMORY.md chars: ${consolidated.memoryMd.trim().length}`,
-		`- USER.md state: ${userProfileState}`,
-		`- memory_summary.md chars: ${consolidated.memorySummary.trim().length}`,
-		`- skill_usage.json records: ${Object.keys(options.curation.usage.skills).length}`,
-		"",
-		"Generated skills:",
-		generatedSkills,
-		"",
-		"Skill lifecycle:",
-		`- Active generated skills: ${options.curation.active.length}`,
-		`- Pinned stale skills preserved: ${options.curation.pinnedStale.length}`,
-		`- Archived stale skills: ${options.curation.archived.length}`,
-		`- Dry-run stale candidates: ${options.curation.staleCandidates.length}`,
-		`- Dry-run archive candidates: ${options.curation.archiveCandidates.length}`,
-		"",
-	].join("\n");
-}
-
-async function applyGeneratedMemorySkills(
-	memoryRoot: string,
-	skills: Array<{
-		name: string;
-		content: string;
-		scripts: ConsolidationSkillFileSchema[];
-		templates: ConsolidationSkillFileSchema[];
-		examples: ConsolidationSkillFileSchema[];
-	}>,
-	options: {
-		curatorMode: "dry-run" | "off";
-		staleAfterDays: number;
-		archiveAfterDays: number;
-	},
-): Promise<SkillCurationResult> {
+	await Bun.write(path.join(memoryRoot, "MEMORY.md"), `${consolidated.memoryMd.trim()}\n`);
+	await Bun.write(path.join(memoryRoot, "memory_summary.md"), `${consolidated.memorySummary.trim()}\n`);
 	const skillsDir = path.join(memoryRoot, "skills");
 	await fs.mkdir(skillsDir, { recursive: true });
-	const usage = await readGeneratedMemorySkillUsage(memoryRoot);
-	const now = new Date().toISOString();
 	const keep = new Set<string>();
-	const active: string[] = [];
-	const pinnedStale: string[] = [];
-	const archived: string[] = [];
-	const staleCandidates: string[] = [];
-	const archiveCandidates: string[] = [];
-	const markedStale: string[] = [];
-	const reactivated: string[] = [];
-
-	for (const skill of skills) {
+	for (const skill of consolidated.skills) {
 		const dir = path.join(skillsDir, skill.name);
-		const files = buildSkillFileMap(skill);
-		const existed = await Bun.file(path.join(dir, "SKILL.md")).exists();
-		const changed = await skillFilesChanged(dir, files);
 		keep.add(skill.name);
-		active.push(skill.name);
-
 		await fs.mkdir(dir, { recursive: true });
+		const files = new Map<string, string>();
+		files.set("SKILL.md", `${skill.content.trim()}\n`);
+		for (const item of skill.scripts) {
+			files.set(path.posix.join("scripts", item.path), `${item.content.trim()}\n`);
+		}
+		for (const item of skill.templates) {
+			files.set(path.posix.join("templates", item.path), `${item.content.trim()}\n`);
+		}
+		for (const item of skill.examples) {
+			files.set(path.posix.join("examples", item.path), `${item.content.trim()}\n`);
+		}
+
 		for (const [relativePath, content] of [...files.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-			const filePath = path.join(dir, ...relativePath.split("/"));
-			await fs.mkdir(path.dirname(filePath), { recursive: true });
-			await Bun.write(filePath, content);
+			await Bun.write(path.join(dir, ...relativePath.split("/")), content);
 		}
 
 		const keepFiles = new Set(files.keys());
@@ -1411,436 +852,12 @@ async function applyGeneratedMemorySkills(
 			await fs.rm(path.join(dir, ...relativePath.split("/")), { force: true });
 		}
 		await pruneEmptyDirectories(dir);
-		await fs.rm(path.join(skillsDir, ".archive", skill.name), { recursive: true, force: true });
-
-		const record = normalizeGeneratedMemorySkillRecord(usage.skills[skill.name], skill.name, now);
-		record.state = "active";
-		record.updatedAt = now;
-		record.lastSeenInConsolidationAt = now;
-		record.archivedAt = null;
-		record.archiveReason = null;
-		if (existed && changed) {
-			record.patchCount += 1;
-			record.lastPatchedAt = now;
-		}
-		usage.skills[skill.name] = record;
 	}
-
 	const dirs = await fs.readdir(skillsDir, { withFileTypes: true }).catch(() => []);
 	for (const dirent of dirs) {
 		if (!dirent.isDirectory()) continue;
-		if (dirent.name === ".archive") continue;
 		if (keep.has(dirent.name)) continue;
-
-		const record = normalizeGeneratedMemorySkillRecord(usage.skills[dirent.name], dirent.name, now);
-		record.updatedAt = now;
-		if (record.pinned) {
-			record.state = "stale";
-			pinnedStale.push(dirent.name);
-			usage.skills[dirent.name] = record;
-			continue;
-		}
-
-		await archiveGeneratedMemorySkillDir(skillsDir, dirent.name);
-		record.state = "archived";
-		record.archivedAt = record.archivedAt ?? now;
-		record.archiveReason = record.archiveReason ?? "Omitted by memory consolidation; archived instead of deleted.";
-		archived.push(dirent.name);
-		usage.skills[dirent.name] = record;
-	}
-
-	if (options.curatorMode === "dry-run") {
-		applyGeneratedSkillDryRunClassification(usage, {
-			now,
-			staleAfterDays: options.staleAfterDays,
-			archiveAfterDays: options.archiveAfterDays,
-			staleCandidates,
-			archiveCandidates,
-			markedStale,
-			reactivated,
-		});
-	}
-
-	const sortedUsage = sortGeneratedMemorySkillUsage(usage);
-	await writeGeneratedMemorySkillUsage(memoryRoot, sortedUsage);
-	const report =
-		options.curatorMode === "dry-run"
-			? buildSkillCuratorReport(sortedUsage, {
-					active,
-					pinnedStale,
-					archived,
-					staleCandidates,
-					archiveCandidates,
-					markedStale,
-					reactivated,
-					curatorMode: options.curatorMode,
-					staleAfterDays: options.staleAfterDays,
-					archiveAfterDays: options.archiveAfterDays,
-				})
-			: "";
-	if (report.trim()) {
-		await Bun.write(path.join(memoryRoot, MEMORY_ARTIFACTS.skillCuratorReport), report);
-	} else {
-		await fs.rm(path.join(memoryRoot, MEMORY_ARTIFACTS.skillCuratorReport), { force: true });
-	}
-	return {
-		usage: sortedUsage,
-		active: active.sort((a, b) => a.localeCompare(b)),
-		pinnedStale: pinnedStale.sort((a, b) => a.localeCompare(b)),
-		archived: archived.sort((a, b) => a.localeCompare(b)),
-		staleCandidates: staleCandidates.sort((a, b) => a.localeCompare(b)),
-		archiveCandidates: archiveCandidates.sort((a, b) => a.localeCompare(b)),
-		markedStale: markedStale.sort((a, b) => a.localeCompare(b)),
-		reactivated: reactivated.sort((a, b) => a.localeCompare(b)),
-		report,
-	};
-}
-
-function buildSkillFileMap(skill: {
-	content: string;
-	scripts: ConsolidationSkillFileSchema[];
-	templates: ConsolidationSkillFileSchema[];
-	examples: ConsolidationSkillFileSchema[];
-}): Map<string, string> {
-	const files = new Map<string, string>();
-	files.set("SKILL.md", `${skill.content.trim()}\n`);
-	for (const item of skill.scripts) {
-		files.set(path.posix.join("scripts", item.path), `${item.content.trim()}\n`);
-	}
-	for (const item of skill.templates) {
-		files.set(path.posix.join("templates", item.path), `${item.content.trim()}\n`);
-	}
-	for (const item of skill.examples) {
-		files.set(path.posix.join("examples", item.path), `${item.content.trim()}\n`);
-	}
-	return files;
-}
-
-async function skillFilesChanged(dir: string, desired: Map<string, string>): Promise<boolean> {
-	const existing = await listRelativeFiles(dir);
-	if (existing.length !== desired.size) return true;
-	for (const relativePath of existing) {
-		const wanted = desired.get(relativePath);
-		if (wanted === undefined) return true;
-		const current = await Bun.file(path.join(dir, ...relativePath.split("/")))
-			.text()
-			.catch(() => undefined);
-		if (current !== wanted) return true;
-	}
-	return false;
-}
-
-async function readGeneratedMemorySkillUsage(memoryRoot: string): Promise<GeneratedMemorySkillUsageFile> {
-	const fallback: GeneratedMemorySkillUsageFile = { schemaVersion: 1, skills: {} };
-	const text = await Bun.file(path.join(memoryRoot, MEMORY_ARTIFACTS.skillUsage))
-		.text()
-		.catch(() => "");
-	if (!text.trim()) return fallback;
-	try {
-		const parsed = JSON.parse(text) as unknown;
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
-		const data = parsed as Record<string, unknown>;
-		if (data.schemaVersion !== 1 || !data.skills || typeof data.skills !== "object" || Array.isArray(data.skills)) {
-			return fallback;
-		}
-		const skills: Record<string, GeneratedMemorySkillUsageRecord> = {};
-		const now = new Date().toISOString();
-		for (const [name, record] of Object.entries(data.skills as Record<string, unknown>)) {
-			const sanitized = sanitizeSkillName(name);
-			if (!sanitized) continue;
-			skills[sanitized] = normalizeGeneratedMemorySkillRecord(record, sanitized, now);
-		}
-		return { schemaVersion: 1, skills };
-	} catch {
-		return fallback;
-	}
-}
-
-async function writeGeneratedMemorySkillUsage(memoryRoot: string, usage: GeneratedMemorySkillUsageFile): Promise<void> {
-	await Bun.write(
-		path.join(memoryRoot, MEMORY_ARTIFACTS.skillUsage),
-		`${JSON.stringify(sortGeneratedMemorySkillUsage(usage), null, 2)}\n`,
-	);
-}
-
-function sortGeneratedMemorySkillUsage(usage: GeneratedMemorySkillUsageFile): GeneratedMemorySkillUsageFile {
-	const sorted: Record<string, GeneratedMemorySkillUsageRecord> = {};
-	for (const name of Object.keys(usage.skills).sort((a, b) => a.localeCompare(b))) {
-		sorted[name] = usage.skills[name]!;
-	}
-	return { schemaVersion: 1, skills: sorted };
-}
-
-function normalizeGeneratedMemorySkillRecord(
-	value: unknown,
-	name: string,
-	now: string,
-): GeneratedMemorySkillUsageRecord {
-	const input = value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
-	const state = parseGeneratedMemorySkillState(input.state) ?? "active";
-	return {
-		schemaVersion: 1,
-		name,
-		source: "memory-consolidation",
-		state,
-		pinned: input.pinned === true,
-		createdAt: parseString(input.createdAt) ?? now,
-		updatedAt: parseString(input.updatedAt) ?? now,
-		lastSeenInConsolidationAt: parseString(input.lastSeenInConsolidationAt),
-		archivedAt: parseString(input.archivedAt),
-		archiveReason: parseString(input.archiveReason),
-		useCount: parseNonNegativeInteger(input.useCount),
-		viewCount: parseNonNegativeInteger(input.viewCount),
-		patchCount: parseNonNegativeInteger(input.patchCount),
-		lastUsedAt: parseString(input.lastUsedAt),
-		lastViewedAt: parseString(input.lastViewedAt),
-		lastPatchedAt: parseString(input.lastPatchedAt),
-	};
-}
-
-function parseGeneratedMemorySkillState(value: unknown): GeneratedMemorySkillState | undefined {
-	return value === "active" || value === "stale" || value === "archived" ? value : undefined;
-}
-
-function parseString(value: unknown): string | null {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed || null;
-}
-
-function parseNonNegativeInteger(value: unknown): number {
-	const parsed = typeof value === "number" ? value : Number(value);
-	if (!Number.isFinite(parsed) || parsed < 0) return 0;
-	return Math.floor(parsed);
-}
-
-function applyGeneratedSkillDryRunClassification(
-	usage: GeneratedMemorySkillUsageFile,
-	options: {
-		now: string;
-		staleAfterDays: number;
-		archiveAfterDays: number;
-		staleCandidates: string[];
-		archiveCandidates: string[];
-		markedStale: string[];
-		reactivated: string[];
-	},
-): void {
-	const nowMs = Date.parse(options.now);
-	const staleCutoff = nowMs - options.staleAfterDays * 24 * 60 * 60 * 1000;
-	const archiveCutoff = nowMs - options.archiveAfterDays * 24 * 60 * 60 * 1000;
-	for (const record of Object.values(usage.skills)) {
-		if (record.state === "archived" || record.pinned) continue;
-		const anchor = Date.parse(latestGeneratedMemorySkillActivity(record) ?? record.createdAt);
-		if (!Number.isFinite(anchor)) continue;
-		if (anchor <= archiveCutoff) {
-			options.archiveCandidates.push(record.name);
-			if (record.state === "active") {
-				options.markedStale.push(record.name);
-			}
-			continue;
-		}
-		if (anchor <= staleCutoff) {
-			options.staleCandidates.push(record.name);
-			if (record.state === "active") {
-				options.markedStale.push(record.name);
-			}
-			continue;
-		}
-		if (record.state === "stale") {
-			options.reactivated.push(record.name);
-		}
-	}
-}
-
-function latestGeneratedMemorySkillActivity(record: GeneratedMemorySkillUsageRecord): string | null {
-	const values = [record.lastUsedAt, record.lastViewedAt, record.lastPatchedAt].filter(
-		(value): value is string => typeof value === "string" && value.length > 0,
-	);
-	values.sort((a, b) => b.localeCompare(a));
-	return values[0] ?? record.lastSeenInConsolidationAt ?? null;
-}
-
-function buildSkillCuratorReport(
-	usage: GeneratedMemorySkillUsageFile,
-	options: {
-		active: string[];
-		pinnedStale: string[];
-		archived: string[];
-		staleCandidates: string[];
-		archiveCandidates: string[];
-		markedStale: string[];
-		reactivated: string[];
-		curatorMode: "dry-run" | "off";
-		staleAfterDays: number;
-		archiveAfterDays: number;
-	},
-): string {
-	const records = Object.values(usage.skills).sort((a, b) => a.name.localeCompare(b.name));
-	const recordLines =
-		records.length === 0
-			? ["- None"]
-			: records.map(
-					record =>
-						`- ${record.name}: state=${record.state}, pinned=${record.pinned ? "yes" : "no"}, ` +
-						`use=${record.useCount}, view=${record.viewCount}, patch=${record.patchCount}`,
-				);
-
-	return [
-		"# Generated Skill Curator Report",
-		"",
-		`Mode: ${options.curatorMode}`,
-		"Scope: generated memory skills only.",
-		"Mutation boundary: dry-run curation reports suggestions; stale skills removed by consolidation are archived, not deleted.",
-		`Stale threshold days: ${options.staleAfterDays}`,
-		`Archive threshold days: ${options.archiveAfterDays}`,
-		"",
-		"Current pass:",
-		`- Active generated skills: ${options.active.length ? options.active.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		`- Pinned stale skills preserved: ${
-			options.pinnedStale.length ? options.pinnedStale.sort((a, b) => a.localeCompare(b)).join(", ") : "none"
-		}`,
-		`- Archived stale skills: ${options.archived.length ? options.archived.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		"",
-		"Dry-run candidates:",
-		`- Would mark stale: ${options.markedStale.length ? options.markedStale.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		`- Would reactivate: ${options.reactivated.length ? options.reactivated.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		`- Stale candidates: ${options.staleCandidates.length ? options.staleCandidates.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		`- Archive candidates: ${options.archiveCandidates.length ? options.archiveCandidates.sort((a, b) => a.localeCompare(b)).join(", ") : "none"}`,
-		"",
-		"Lifecycle policy:",
-		"- pinned=true prevents automatic archive.",
-		"- state=stale means omitted by latest consolidation while pinned, or inactive past the stale threshold.",
-		"- state=archived means moved to memory://root/skills/.archive/<name>/ for recoverable restore.",
-		"",
-		"Usage records:",
-		...recordLines,
-		"",
-	].join("\n");
-}
-
-async function archiveGeneratedMemorySkillDir(skillsDir: string, name: string): Promise<void> {
-	const source = path.join(skillsDir, name);
-	if (!(await Bun.file(path.join(source, "SKILL.md")).exists())) return;
-	const archiveRoot = path.join(skillsDir, ".archive");
-	const target = path.join(archiveRoot, name);
-	await fs.mkdir(archiveRoot, { recursive: true });
-	await fs.rm(target, { recursive: true, force: true });
-	await fs.rename(source, target);
-}
-
-export async function recordGeneratedMemorySkillEvent(
-	memoryRoot: string,
-	rawName: string,
-	event: GeneratedMemorySkillEvent,
-): Promise<boolean> {
-	const name = sanitizeSkillName(rawName);
-	if (!name) return false;
-	const usage = await readGeneratedMemorySkillUsage(memoryRoot);
-	const now = new Date().toISOString();
-	const record = normalizeGeneratedMemorySkillRecord(usage.skills[name], name, now);
-	const activeSkillPath = path.join(memoryRoot, "skills", name, "SKILL.md");
-	if (!(await Bun.file(activeSkillPath).exists()) && record.state !== "archived") return false;
-	record.updatedAt = now;
-	if (event === "use") {
-		record.useCount += 1;
-		record.lastUsedAt = now;
-	} else if (event === "view") {
-		record.viewCount += 1;
-		record.lastViewedAt = now;
-	} else {
-		record.patchCount += 1;
-		record.lastPatchedAt = now;
-	}
-	usage.skills[name] = record;
-	await writeGeneratedMemorySkillUsage(memoryRoot, usage);
-	return true;
-}
-
-export async function pinGeneratedMemorySkill(memoryRoot: string, rawName: string, pinned = true): Promise<boolean> {
-	const name = sanitizeSkillName(rawName);
-	if (!name) return false;
-	const usage = await readGeneratedMemorySkillUsage(memoryRoot);
-	const now = new Date().toISOString();
-	const record = normalizeGeneratedMemorySkillRecord(usage.skills[name], name, now);
-	const activeSkillPath = path.join(memoryRoot, "skills", name, "SKILL.md");
-	const archivedSkillPath = path.join(memoryRoot, "skills", ".archive", name, "SKILL.md");
-	if (!(await Bun.file(activeSkillPath).exists()) && !(await Bun.file(archivedSkillPath).exists())) return false;
-	record.pinned = pinned;
-	record.updatedAt = now;
-	usage.skills[name] = record;
-	await writeGeneratedMemorySkillUsage(memoryRoot, usage);
-	return true;
-}
-
-export async function archiveGeneratedMemorySkill(
-	memoryRoot: string,
-	rawName: string,
-	reason: string,
-): Promise<boolean> {
-	const name = sanitizeSkillName(rawName);
-	if (!name) return false;
-	const skillsDir = path.join(memoryRoot, "skills");
-	const sourceSkillPath = path.join(skillsDir, name, "SKILL.md");
-	if (!(await Bun.file(sourceSkillPath).exists())) return false;
-	const usage = await readGeneratedMemorySkillUsage(memoryRoot);
-	const now = new Date().toISOString();
-	const existingRecord = normalizeGeneratedMemorySkillRecord(usage.skills[name], name, now);
-	if (existingRecord.pinned) return false;
-	await archiveGeneratedMemorySkillDir(skillsDir, name);
-	const record = existingRecord;
-	record.state = "archived";
-	record.updatedAt = now;
-	record.archivedAt = now;
-	record.archiveReason = reason.trim() || "Archived by native generated-skill lifecycle.";
-	usage.skills[name] = record;
-	await writeGeneratedMemorySkillUsage(memoryRoot, usage);
-	return true;
-}
-
-export async function restoreGeneratedMemorySkill(memoryRoot: string, rawName: string): Promise<boolean> {
-	const name = sanitizeSkillName(rawName);
-	if (!name) return false;
-	const skillsDir = path.join(memoryRoot, "skills");
-	const source = path.join(skillsDir, ".archive", name);
-	const target = path.join(skillsDir, name);
-	if (!(await Bun.file(path.join(source, "SKILL.md")).exists())) return false;
-	if (await Bun.file(path.join(target, "SKILL.md")).exists()) return false;
-	await fs.mkdir(skillsDir, { recursive: true });
-	await fs.rename(source, target);
-	const usage = await readGeneratedMemorySkillUsage(memoryRoot);
-	const now = new Date().toISOString();
-	const record = normalizeGeneratedMemorySkillRecord(usage.skills[name], name, now);
-	record.state = "active";
-	record.updatedAt = now;
-	record.archivedAt = null;
-	record.archiveReason = null;
-	usage.skills[name] = record;
-	await writeGeneratedMemorySkillUsage(memoryRoot, usage);
-	return true;
-}
-
-function normalizeConsolidatedUserProfile(input: string): string {
-	const trimmed = input.trim();
-	if (!trimmed) return "";
-	if (!trimmed.startsWith(USER_PROFILE_OPEN_TAG) || !trimmed.endsWith(USER_PROFILE_CLOSE_TAG)) {
-		throw new Error(
-			`phase2 user_md must be empty or a complete ${USER_PROFILE_OPEN_TAG}...${USER_PROFILE_CLOSE_TAG} block`,
-		);
-	}
-	return trimmed;
-}
-
-function assertNoIdentityArtifactLeak(fields: ReadonlyArray<{ field: string; value: string }>): void {
-	for (const { field, value } of fields) {
-		for (const { label, pattern } of FORBIDDEN_IDENTITY_ARTIFACT_PATTERNS) {
-			if (pattern.test(value)) {
-				throw new Error(
-					`phase2 attempted to write approval-gated identity artifact ${label} in ${field}; ` +
-						`${MEMORY_ARTIFACTS.soulProposal} must be proposed only by an explicit identity-review flow`,
-				);
-			}
-		}
+		await fs.rm(path.join(skillsDir, dirent.name), { recursive: true, force: true });
 	}
 }
 
@@ -1922,9 +939,8 @@ function parseStage1OutputSchema(value: Record<string, unknown>): Stage1OutputSc
 }
 
 function parseConsolidationOutputSchema(value: Record<string, unknown>): ConsolidationOutputSchema | undefined {
-	if (!hasExactKeys(value, ["memory_md", "user_md", "memory_summary", "skills"], true)) return undefined;
+	if (!hasExactKeys(value, ["memory_md", "memory_summary", "skills"])) return undefined;
 	if (typeof value.memory_md !== "string") return undefined;
-	if (!(value.user_md === undefined || typeof value.user_md === "string")) return undefined;
 	if (typeof value.memory_summary !== "string") return undefined;
 	if (!Array.isArray(value.skills)) return undefined;
 	const skills: ConsolidationSkillSchema[] = [];
@@ -1948,24 +964,11 @@ function parseConsolidationOutputSchema(value: Record<string, unknown>): Consoli
 	}
 	return {
 		memory_md: value.memory_md,
-		user_md: value.user_md ?? "",
 		memory_summary: value.memory_summary,
 		skills,
 	};
 }
 
-function parseIdentityReviewOutputSchema(value: Record<string, unknown>): string | undefined {
-	if (!hasExactKeys(value, ["soul_proposal"])) return undefined;
-	if (typeof value.soul_proposal !== "string") return undefined;
-	const proposal = redactSecrets(value.soul_proposal).trim();
-	if (!proposal) return "";
-	if (!proposal.startsWith("<soul_proposal") || !proposal.endsWith("</soul_proposal>")) return undefined;
-	if (/<\s*\/?\s*soul\b/i.test(proposal)) return undefined;
-	if (/<\s*\/?\s*identity\b/i.test(proposal)) return undefined;
-	if (/<\s*\/?\s*personality\b/i.test(proposal)) return undefined;
-	return proposal;
-}
-
 function hasExactKeys(value: Record<string, unknown>, expectedKeys: string[], allowMissing = false): boolean {
 	const sortedKeys = Object.keys(value).sort();
 	const sortedExpected = [...expectedKeys].sort();
@@ -1986,6 +989,12 @@ function redactSecrets(input: string): string {
 		/(?:sk|pk|rk|tok|key|secret|token|password)[-_A-Za-z0-9]{12,}/g,
 		/[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g,
 		/(?:AKIA|ASIA)[A-Z0-9]{16}/g,
+		// Common provider token prefixes (GitHub, npm, Slack, Google).
+		/(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g,
+		/github_pat_[A-Za-z0-9_]{20,}/g,
+		/npm_[A-Za-z0-9]{30,}/g,
+		/xox[baprs]-[A-Za-z0-9-]{10,}/g,
+		/AIza[A-Za-z0-9_-]{30,}/g,
 	];
 	for (const pattern of patterns) {
 		out = out.replace(pattern, "[REDACTED]");
@@ -2064,65 +1073,6 @@ function extractMessageText(message: AgentMessage): string {
 		.join("\n");
 }
 
-function extractPostTurnReviewMessages(session: AgentSession): PostTurnReviewMessage[] {
-	const manager = session.sessionManager as {
-		getEntries?: () => Array<{ type?: string; message?: { role?: unknown; content?: unknown } }>;
-	};
-	const entries = manager.getEntries?.();
-	if (!entries) return [];
-	const messages: PostTurnReviewMessage[] = [];
-	for (const entry of entries) {
-		if (entry.type !== "message") continue;
-		const message = entry.message;
-		if (!message) continue;
-		const role = message.role;
-		if (role !== "user" && role !== "assistant") continue;
-		const content =
-			role === "user" ? extractPostTurnUserText(message.content) : extractPostTurnAssistantText(message.content);
-		const trimmed = content.trim();
-		if (!trimmed) continue;
-		messages.push({ role, content: trimmed });
-	}
-	return messages;
-}
-
-function extractPostTurnUserText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	const parts: string[] = [];
-	for (const item of content) {
-		if (!item || typeof item !== "object") continue;
-		const block = item as { type?: unknown; text?: unknown };
-		if (block.type === "text" && typeof block.text === "string") {
-			parts.push(block.text);
-		}
-	}
-	return parts.join("\n");
-}
-
-function extractPostTurnAssistantText(content: unknown): string {
-	if (!Array.isArray(content)) return "";
-	const parts: string[] = [];
-	for (const item of content) {
-		if (!item || typeof item !== "object") continue;
-		const block = item as { type?: unknown; text?: unknown };
-		if (block.type === "text" && typeof block.text === "string") {
-			parts.push(block.text);
-		}
-	}
-	return parts.join("\n");
-}
-
-function buildPostTurnReviewThreadId(sessionId: string | undefined, userTurns: number): string {
-	const rawId = sessionId?.trim() || "unknown-session";
-	const safeSessionId =
-		rawId
-			.replace(/[^A-Za-z0-9_-]+/g, "_")
-			.replace(/^_+|_+$/g, "")
-			.slice(0, 80) || "unknown-session";
-	return `${POST_TURN_REVIEW_THREAD_PREFIX}-${safeSessionId}-${userTurns}`;
-}
-
 function truncateByApproxTokens(text: string, tokenLimit: number): string {
 	if (tokenLimit <= 0) return "";
 	const maxChars = tokenLimit * 4;
@@ -2134,7 +1084,9 @@ function truncateByApproxTokens(text: string, tokenLimit: number): string {
 
 function computeModelTokenBudget(model: Model, config: MemoryRuntimeConfig): number {
 	const maxTokens =
-		Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : config.fallbackTokenLimit;
+		model.contextWindow !== null && Number.isFinite(model.contextWindow) && model.contextWindow > 0
+			? model.contextWindow
+			: config.fallbackTokenLimit;
 	return Math.max(2048, Math.floor(maxTokens));
 }
 
@@ -2148,7 +1100,7 @@ async function resolveMemoryModel(options: {
 	if (requestedModel) {
 		const resolved = resolveModelRoleValue(requestedModel, modelRegistry.getAll(), {
 			settings: session.settings,
-			matchPreferences: { usageOrder: session.settings.getStorage()?.getModelUsageOrder() },
+			matchPreferences: getModelMatchPreferences(session.settings),
 			modelRegistry,
 		});
 		if (resolved.model) return resolved.model;
@@ -2157,28 +1109,8 @@ async function resolveMemoryModel(options: {
 }
 
 function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig {
-	const selfImprovementMode = settings.get("selfImprovement.mode") ?? DEFAULTS.selfImprovementMode;
-	const backgroundReviewMode = settings.get("selfImprovement.backgroundReviewMode") ?? DEFAULTS.backgroundReviewMode;
-	const backgroundReviewEveryNTurns =
-		settings.get("selfImprovement.backgroundReviewEveryNTurns") ?? DEFAULTS.backgroundReviewEveryNTurns;
-	const identityReviewMode = settings.get("selfImprovement.identityReviewMode") ?? DEFAULTS.identityReviewMode;
-	const curatorMode = settings.get("selfImprovement.curatorMode") ?? DEFAULTS.curatorMode;
-	const generatedSkillStaleAfterDays =
-		settings.get("selfImprovement.generatedSkillStaleAfterDays") ?? DEFAULTS.generatedSkillStaleAfterDays;
-	const generatedSkillArchiveAfterDays =
-		settings.get("selfImprovement.generatedSkillArchiveAfterDays") ?? DEFAULTS.generatedSkillArchiveAfterDays;
-	const localMemoryRequested = settings.get("memory.backend") === "local" || settings.get("memories.enabled") === true;
 	return {
-		enabled: selfImprovementMode !== "off" && localMemoryRequested,
-		selfImprovementMode,
-		backgroundReviewMode,
-		backgroundReviewEveryNTurns: Number.isFinite(backgroundReviewEveryNTurns)
-			? Math.max(0, Math.floor(backgroundReviewEveryNTurns))
-			: DEFAULTS.backgroundReviewEveryNTurns,
-		identityReviewMode,
-		curatorMode,
-		generatedSkillStaleAfterDays,
-		generatedSkillArchiveAfterDays,
+		enabled: settings.get("memory.backend") === "local" || settings.get("memories.enabled") === true,
 		maxRolloutsPerStartup: settings.get("memories.maxRolloutsPerStartup") ?? DEFAULTS.maxRolloutsPerStartup,
 		maxRolloutAgeDays: settings.get("memories.maxRolloutAgeDays") ?? DEFAULTS.maxRolloutAgeDays,
 		minRolloutIdleHours: settings.get("memories.minRolloutIdleHours") ?? DEFAULTS.minRolloutIdleHours,
@@ -2202,6 +1134,120 @@ export function getMemoryRoot(agentDir: string, cwd: string): string {
 	return path.join(getMemoriesDir(agentDir), encodeProjectPath(cwd));
 }
 
+/**
+ * Filename of the captured-lessons file under a project's memory root.
+ *
+ * Written by the `learn` tool via {@link saveLearnedLesson} and read back by
+ * {@link buildMemoryToolDeveloperInstructions}. Deliberately distinct from the
+ * consolidation artifacts (`MEMORY.md`, `memory_summary.md`, `skills/`) so a
+ * consolidation pass never clobbers manually captured lessons.
+ */
+const LEARNED_LESSONS_FILE = "learned.md";
+/** Newest-first cap on retained lessons, bounding file growth by entry count. */
+const MAX_LEARNED_LESSONS = 100;
+/** Per-field char caps so a single huge capture can't bloat learned.md. */
+const MAX_LEARNED_CONTENT_CHARS = 2000;
+const MAX_LEARNED_CONTEXT_CHARS = 400;
+
+/**
+ * Strip prompt-injection vectors from a single line of lesson text: control/
+ * format chars, angle brackets (`</skills>`), backticks, and `~~~` fences, then
+ * collapse whitespace. Applied on BOTH write and read (the block renders
+ * unescaped into the system prompt), mirroring managed-skill descriptions.
+ */
+function neutralizeInjection(text: string): string {
+	return text
+		.replace(/[\p{Cc}\p{Cf}]/gu, " ")
+		.replace(/[<>`]/g, "")
+		.replace(/~{2,}/g, "~")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/** Slice to `maxChars`, dropping a trailing unpaired high surrogate. */
+function boundChars(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	const sliced = text.slice(0, maxChars);
+	return /[\uD800-\uDBFF]$/.test(sliced) ? sliced.slice(0, -1) : sliced;
+}
+
+/**
+ * Normalize one lesson field for storage: neutralize injection delimiters
+ * first, then redact secrets, then bound the length.
+ */
+function normalizeLearnedText(text: string, maxChars: number): string {
+	return boundChars(redactSecrets(neutralizeInjection(text)).trim(), maxChars);
+}
+
+/** Per-path write chains serializing `learned.md` read-modify-write. */
+const learnedWriteChains = new Map<string, Promise<unknown>>();
+
+/**
+ * Append one lesson to the project's `learned.md` (newest-first, deduped,
+ * capped, secret-redacted, injection-neutralized). The file backs the `learn`
+ * tool when `memory.backend` is `local`.
+ */
+export async function saveLearnedLesson(
+	agentDir: string,
+	cwd: string,
+	input: MemoryBackendSaveInput,
+): Promise<MemoryBackendSaveResult> {
+	const content = normalizeLearnedText(input.content, MAX_LEARNED_CONTENT_CHARS);
+	if (!content) {
+		return { backend: "local", stored: 0, message: "Empty lesson; nothing stored." };
+	}
+	const context = input.context ? normalizeLearnedText(input.context, MAX_LEARNED_CONTEXT_CHARS) : "";
+	const line = context ? `- ${content} _(context: ${context})_` : `- ${content}`;
+	const filePath = path.join(getMemoryRoot(agentDir, cwd), LEARNED_LESSONS_FILE);
+
+	// Serialize the read-modify-write per file: parallel `learn` calls (sibling
+	// subagents, or two shared tool calls in one turn) share the project memory
+	// root, so an unguarded RMW would let the last writer drop the other's lesson.
+	const run = (learnedWriteChains.get(filePath) ?? Promise.resolve()).then(() => appendLearnedLine(filePath, line));
+	const guarded = run.catch(() => {});
+	learnedWriteChains.set(filePath, guarded);
+	try {
+		await run;
+	} finally {
+		if (learnedWriteChains.get(filePath) === guarded) learnedWriteChains.delete(filePath);
+	}
+	return { backend: "local", stored: 1, message: `Lesson saved to ${LEARNED_LESSONS_FILE}.` };
+}
+
+async function appendLearnedLine(filePath: string, line: string): Promise<void> {
+	let existing = "";
+	try {
+		existing = await Bun.file(filePath).text();
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
+	}
+	const prior = existing
+		.split("\n")
+		.map(l => l.trim())
+		.filter(l => l.startsWith("- ") && l !== line);
+	const lessons = [line, ...prior].slice(0, MAX_LEARNED_LESSONS);
+	await Bun.write(filePath, `${lessons.join("\n")}\n`);
+}
+
+/**
+ * Read `learned.md`, neutralizing each line on read too — a hand-edited or
+ * pre-existing file bypasses write-time normalization and the block renders
+ * unescaped into the system prompt. Returns "" when absent/unreadable.
+ */
+async function readLearnedLessons(memoryRoot: string): Promise<string> {
+	let raw = "";
+	try {
+		raw = (await Bun.file(path.join(memoryRoot, LEARNED_LESSONS_FILE)).text()).trim();
+	} catch {
+		return "";
+	}
+	if (!raw) return "";
+	return raw
+		.split("\n")
+		.map(line => redactSecrets(neutralizeInjection(line)))
+		.join("\n");
+}
+
 function encodeProjectPath(cwd: string): string {
 	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
 }