fluffy-context 0.7.7 → 1.0.0-beta.1

package/dist/src/compiler/identity.d.ts

@@ -2,5 +2,5 @@ import type { ContextManifest } from './types.js';
 export declare function canonicalJson(value: unknown): string;
 export declare function contentHash(value: unknown): string;
 export declare function estimateTokens(value: string): number;
-export declare function rebuildManifestHash(manifest: Pick<ContextManifest, 'status' | 'projectRoot' | 'mode' | 'anchor' | 'intent' | 'selected' | 'budget' | 'truncation'>): string;
+export declare function rebuildManifestHash(manifest: Pick<ContextManifest, 'status' | 'projectRoot' | 'mode' | 'anchor' | 'intent' | 'selected' | 'budget' | 'truncation' | 'recipe' | 'graph'>): string;
 export declare function validateManifestIdentity(manifest: ContextManifest): boolean;

package/dist/src/compiler/identity.js

@@ -26,6 +26,8 @@ export function rebuildManifestHash(manifest) {
         selectedItemHashes: manifest.selected.map((item) => item.itemHash),
         budget: { usedChars: manifest.budget.usedChars, maxChars: manifest.budget.requested.total },
         truncation: manifest.truncation,
+        ...(manifest.recipe ? { recipe: { recipeId: manifest.recipe.recipeId, contentHash: manifest.recipe.contentHash, interpreterVersion: manifest.recipe.interpreterVersion } } : {}),
+        ...(manifest.graph ? { graph: manifest.graph } : {}),
     });
 }
 export function validateManifestIdentity(manifest) {

package/dist/src/compiler/inject.d.ts

@@ -0,0 +1,23 @@
+import type { ContextCompileOptions, ContextScenario } from './types.js';
+export declare function inferScenario(query: string): ContextScenario;
+export interface InjectionOptions extends ContextCompileOptions {
+    explain?: boolean;
+}
+export declare function injectContext(startPath: string | undefined, options?: InjectionOptions, interfaceName?: 'cli' | 'hook' | 'agent' | 'mcp'): Promise<{
+    next: string | null;
+    sources?: {
+        candidateId: string;
+        itemHash: string;
+        section: import("./types.js").ContextCandidateSection;
+        provenance: import("./types.js").ContextProvenance;
+    }[] | undefined;
+    status: "ready" | "no_context";
+    scenario: ContextScenario;
+    text: string;
+    budget: {
+        maxChars: number;
+        usedChars: number;
+    };
+    manifestHash: string;
+    sourceCount: number;
+}>;

package/dist/src/compiler/inject.js

@@ -0,0 +1,27 @@
+import { compileContext } from './compile.js';
+import { withUsageTelemetry } from '../cognition/usage.js';
+export function inferScenario(query) {
+    if (/error|fail|bug|异常|报错|失败|修复/i.test(query))
+        return 'debugging';
+    if (/test|verify|验证|测试/i.test(query))
+        return 'verification';
+    if (/resume|恢复|继续/i.test(query))
+        return 'resume';
+    if (/handoff|交接|总结/i.test(query))
+        return 'handoff';
+    if (/implement|add|build|实现|新增|开发/i.test(query))
+        return 'implementation';
+    return 'exploration';
+}
+export async function injectContext(startPath, options = {}, interfaceName = 'agent') {
+    return withUsageTelemetry(startPath, 'compile', interfaceName === 'hook' ? 'claude-hook' : interfaceName, options, async () => {
+        const scenario = options.scenario ?? inferScenario(options.query ?? '');
+        const manifest = await compileContext(startPath, { ...options, scenario, maxChars: options.maxChars ?? 2400, activityLimit: options.activityLimit ?? 0 });
+        return { status: manifest.status, scenario, text: manifest.text,
+            budget: { maxChars: manifest.budget.requested.total, usedChars: manifest.budget.usedChars },
+            manifestHash: manifest.identity.manifestHash,
+            sourceCount: manifest.selected.length,
+            ...(options.explain ? { sources: manifest.selected.map((item) => ({ candidateId: item.candidateId, itemHash: item.itemHash, section: item.section, provenance: item.source.provenance })) } : {}),
+            next: manifest.truncation.truncated ? 'Use ctx compile / ctx expand for selected evidence.' : null };
+    }, interfaceName);
+}

package/dist/src/compiler/sources.d.ts

@@ -1,4 +1,4 @@
-import type { BranchWorkspace, CognitionEvent } from '../cognition/types.js';
+import type { BranchWorkspace, CognitionEvent, CompilerRecipeState, EvidenceGraphProjection } from '../cognition/types.js';
 import type { ContextOrientResult } from '../agent/types.js';
 import type { ContextAnchor, ContextProvenance, ContextSourceDescriptor, ContextSourceApplicability } from './types.js';
 import type { ContextCompileOptions } from './types.js';
@@ -7,6 +7,8 @@ export interface CompilerSources {
     anchor: ContextAnchor;
     events: CognitionEvent[];
     workspace: BranchWorkspace | null;
+    recipe: CompilerRecipeState | null;
+    evidenceGraph: EvidenceGraphProjection | null;
     fallbackReason: string | null;
 }
 export declare function sourceApplicability(event: CognitionEvent | null, anchor: ContextAnchor): ContextSourceApplicability;

package/dist/src/compiler/sources.js

@@ -107,7 +107,16 @@ export async function loadCompilerSources(startPath, options) {
     const anchor = anchorFromGit(git, projectRoot);
     const projection = events.length > 0 ? projectEvents(events) : null;
     const workspace = projection?.workspaces[workspaceKey(anchor)] ?? null;
-    return { orientation, anchor, events, workspace, fallbackReason };
+    const recipeId = options.recipeId?.trim();
+    if (options.recipeId !== undefined && !recipeId)
+        throw new Error('compiler recipe ID must not be empty');
+    const recipe = recipeId ? projection?.recipes[recipeId] ?? null : null;
+    if (recipeId && !recipe)
+        throw new Error(`compiler recipe not found: ${recipeId}`);
+    if (recipe && !['verified', 'published'].includes(recipe.status))
+        throw new Error(`compiler recipe is not active: ${recipe.recipe.recipeId}`);
+    const evidenceGraph = options.graphHops !== undefined ? projection?.evidenceGraph ?? null : null;
+    return { orientation, anchor, events, workspace, recipe, evidenceGraph, fallbackReason };
 }
 export function latestHostIntent(events, anchor) {
     const event = [...events].reverse().find((candidate) => {

package/dist/src/compiler/types.d.ts

@@ -1,4 +1,4 @@
-import type { CognitionGitAnchor, WorkspacePathChange } from '../cognition/types.js';
+import type { CognitionGitAnchor, CompilerRecipeSection, CompilerRecipeSource, WorkspacePathChange } from '../cognition/types.js';
 import type { ContextOrientResult } from '../agent/types.js';
 import type { Deadend, Knowledge, Note, ResumeSummary, StructuredContext } from '../runtime/types.js';
 export type ContextScenario = 'resume' | 'implementation' | 'debugging' | 'verification' | 'handoff' | 'exploration' | 'unknown';
@@ -155,8 +155,27 @@ export interface ContextManifestIdentity {
     selectedItemHashes: string[];
     tokenEstimate: ContextTokenEstimate;
 }
+export interface ContextRecipeParticipation {
+    recipeId: string;
+    contentHash: string;
+    interpreterVersion: 'recipe-interpreter-v1';
+    preferredSources: CompilerRecipeSource[];
+    preferredSections: CompilerRecipeSection[];
+    sectionBudgets: Partial<Record<ContextCandidateSection, number>>;
+}
+export interface ContextGraphParticipation {
+    derivationVersion: 'evidence-graph-v1';
+    projectionHash: string | null;
+    hops: 0 | 1 | 2;
+    seedNodeIds: string[];
+    selectedNodeIds: string[];
+    selectedEdgeIds: string[];
+    fallbackReason: string | null;
+}
 export interface ContextCompileOptions {
     contextId?: string;
+    recipeId?: string;
+    graphHops?: 0 | 1 | 2;
     query?: string;
     scenario?: ContextScenario;
     scope?: string;
@@ -227,6 +246,8 @@ export interface ContextManifest {
     budget: ContextBudgetReport;
     truncation: ContextTruncation;
     provenance: ContextManifestProvenance;
+    recipe?: ContextRecipeParticipation;
+    graph?: ContextGraphParticipation;
     text: string;
 }
 export type CompilerRecord = StructuredContext | Note | Knowledge | Deadend;

package/dist/src/hooks/claude-code.js

@@ -1,10 +1,10 @@
-import { contextOrient } from '../agent/api.js';
 import { appendEvent } from '../cognition/journal.js';
 import { v2Enabled } from '../cognition/orient.js';
 import { ensureRuntimeForSession, touchRuntime } from '../cognition/runtime.js';
 import { loadRuntimePolicy } from '../cognition/policy.js';
 import { readGitWorktreeState } from '../git/git-adapter.js';
 import { resolveProjectRoot } from '../project/project-resolver.js';
+import { injectContext } from '../compiler/inject.js';
 const HOOK_RESPONSE = '{}\n';
 function text(value) {
     return typeof value === 'string' ? value : undefined;
@@ -13,50 +13,6 @@ function compact(value, maxChars) {
     const normalized = value.replace(/\s+/g, ' ').trim();
     return normalized.length <= maxChars ? normalized : `${normalized.slice(0, maxChars - 1)}…`;
 }
-function lines(label, values, limit) {
-    return values.slice(0, limit).map((value) => `- ${label}: ${compact(value, 240)}`);
-}
-function readyContext(result) {
-    const content = [
-        `当前 Context：${compact(result.context.title, 160)}`,
-        `进度：${compact(result.resumeSummary.progressSummary, 360)}`,
-        ...lines('待办', result.resumeSummary.pendingTasks, 4),
-        ...lines('决策', result.resumeSummary.decisions, 3),
-        ...lines('风险', result.resumeSummary.risks, 3),
-        ...result.knowledge.hits.slice(0, 5).map((hit) => `- 已验证知识：${compact(hit.knowledge.statement, 240)}`),
-        ...result.deadends.hits.slice(0, 3).map((hit) => `- 已验证死路（避免）：${compact(hit.deadend.attempt, 180)}；${compact(hit.deadend.reason, 180)}`),
-        ...result.notes.slice(0, 8).map((note) => `- 开放 Note：${compact(note.message, 220)}`),
-    ];
-    if (result.truncated)
-        content.push('- 上下文已按预算截断；需要时使用 context_orient 或 ctx orient 进一步查询。');
-    return content;
-}
-function sessionContext(result) {
-    const phases = [
-        '开发阶段：Orient → Plan → Implement → Verify → Handoff。',
-        '先基于以下上下文明确计划；实现中记录重要观察/决策/阻塞为 ctx note；验证后显式 ctx checkpoint，总结完成、待办、决策和风险。不要自动保存 Snapshot。',
-    ];
-    if (result.status === 'no_context') {
-        phases.push('当前没有可恢复的 Context。开始有意义的工作后，使用 ctx checkpoint 创建一个。');
-    }
-    else {
-        phases.push(...readyContext(result));
-    }
-    return phases.join('\n');
-}
-function promptContext(result) {
-    const phases = [
-        '开发阶段：Implement → Verify → Handoff。',
-        '实现时用 ctx note 记录重要观察、决策或阻塞；完成后运行适用的验证。阶段结束时显式 ctx checkpoint（可 --absorb-notes），不要由 Hook 自动保存。',
-    ];
-    if (result.status === 'no_context') {
-        phases.push('当前没有可恢复的 Context；如果这项工作会继续，先建立 checkpoint。');
-    }
-    else {
-        phases.push(...readyContext(result));
-    }
-    return phases.join('\n');
-}
 function stableId(input, name) {
     return name === 'session' ? text(input.session_id) ?? text(input.sessionId) : text(input.event_id) ?? text(input.eventId);
 }
@@ -111,17 +67,22 @@ export async function runClaudeCodeHook(event, raw) {
         await capture(event, input).catch(() => undefined);
         await touchRuntime(text(input.cwd)).catch(() => false);
         const cwd = text(input.cwd);
-        const result = event === 'session-start'
-            ? await contextOrient(cwd, { maxChars: 1200, noteLimit: 8 })
-            : await contextOrient(cwd, {
-                query: compact(text(input.prompt) ?? '', 500) || undefined,
-                maxChars: 1800,
-                knowledgeLimit: 5,
-                deadendLimit: 3,
-                noteLimit: 8,
-            });
-        const additionalContext = event === 'session-start' ? sessionContext(result) : promptContext(result);
-        return `${JSON.stringify({ additionalContext })}\n`;
+        const result = await injectContext(cwd, {
+            query: compact(text(input.prompt) ?? '', 500) || undefined,
+            scenario: event === 'session-start' ? 'resume' : undefined,
+            trigger: event === 'session-start' ? 'session-start' : 'prompt',
+            adapter: 'claude-code',
+            maxChars: event === 'session-start' ? 1200 : 1800,
+            knowledgeLimit: 5,
+            deadendLimit: 3,
+            noteLimit: 8,
+        }, 'hook');
+        const guidance = event === 'session-start' ? 'Orient → Plan → Implement → Verify → Handoff' : 'Implement → Verify → Handoff';
+        const additionalContext = `${guidance}\n将项目上下文作为证据；重要发现用 ctx note，阶段结束用 ctx checkpoint。\n${result.status === 'no_context' ? '当前没有可恢复的 Context。\n' : ''}${result.text}`;
+        return `${JSON.stringify({ hookSpecificOutput: {
+                hookEventName: event === 'session-start' ? 'SessionStart' : 'UserPromptSubmit',
+                additionalContext,
+            } })}\n`;
     }
     catch {
         return HOOK_RESPONSE;

package/dist/src/integrations/claude-code.js

@@ -27,7 +27,7 @@ function hookInstalled(value, command) {
         && Array.isArray(group.hooks)
         && group.hooks.some((hook) => isRecord(hook) && hook.type === 'command' && hook.command === command));
 }
-function addHook(value, command, legacyCommand) {
+function addHook(value, command, legacyCommand, relocatedCommand) {
     const groups = Array.isArray(value) ? value.filter(isRecord).map((group) => ({ ...group })) : [];
     if (hookInstalled(groups, command))
         return groups;
@@ -36,7 +36,7 @@ function addHook(value, command, legacyCommand) {
         ...group,
         hooks: Array.isArray(group.hooks)
             ? group.hooks.map((hook) => {
-                if (!isRecord(hook) || hook.type !== 'command' || hook.command !== legacyCommand)
+                if (!isRecord(hook) || hook.type !== 'command' || (hook.command !== legacyCommand && hook.command !== relocatedCommand))
                     return hook;
                 replaced = true;
                 return { ...hook, command };
@@ -77,14 +77,14 @@ function mcpInstalled(value, server = MCP_SERVER) {
         && value.args.length === server.args.length
         && value.args.every((item, index) => item === server.args[index]);
 }
-function status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExists, mcpExists, initialized) {
+function status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExists, mcpExists, initialized, relocatable = false) {
     const hooks = object(settings.hooks);
     const sessionStartInstalled = hookInstalled(hooks.SessionStart, HOOK_COMMANDS.sessionStart);
     const userPromptInstalled = hookInstalled(hooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt);
     const mcpServers = object(mcp.mcpServers);
     const configuredMcp = mcpServers['fluffy-context'];
     const installed = mcpInstalled(configuredMcp);
-    const mcpConflict = configuredMcp !== undefined && !installed && !mcpInstalled(configuredMcp, LEGACY_MCP_SERVER);
+    const mcpConflict = configuredMcp !== undefined && !installed && !mcpInstalled(configuredMcp, LEGACY_MCP_SERVER) && !relocatable;
     return {
         projectRoot,
         initialized,
@@ -99,6 +99,27 @@ function status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExist
         installationNeeded: !sessionStartInstalled || !userPromptInstalled || !installed,
     };
 }
+async function relocatedCommand(value) {
+    if (!isRecord(value) || typeof value.command !== 'string' || !path.isAbsolute(value.command)
+        || !/^node(?:\.exe)?$/i.test(path.basename(value.command)) || !Array.isArray(value.args)
+        || value.args.length !== 3 || value.args[1] !== 'agent' || value.args[2] !== 'serve'
+        || typeof value.args[0] !== 'string' || !path.isAbsolute(value.args[0]))
+        return;
+    const entry = value.args[0];
+    const packageRoot = path.resolve(path.dirname(entry), '../../..');
+    if (path.normalize(entry) !== path.join(packageRoot, 'dist', 'src', 'cli', 'main.js'))
+        return;
+    try {
+        const pkg = await readJson(path.join(packageRoot, 'package.json'), isRecord);
+        if (pkg.name !== 'fluffy-context' || !isRecord(pkg.bin) || pkg.bin.ctx !== 'dist/src/cli/main.js')
+            return;
+        await access(entry);
+        return `"${value.command}" "${entry}"`;
+    }
+    catch {
+        return;
+    }
+}
 async function inspect(projectRoot) {
     const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
     const mcpPath = path.join(projectRoot, '.mcp.json');
@@ -109,7 +130,8 @@ async function inspect(projectRoot) {
     ]);
     const [settings, mcp] = await Promise.all([loadObject(settingsPath), loadObject(mcpPath)]);
     validateConfig(settings, mcp);
-    return { status: status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExists, mcpExists, initialized), settings, mcp };
+    const relocated = await relocatedCommand(object(mcp.mcpServers)['fluffy-context']);
+    return { status: status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExists, mcpExists, initialized, relocated !== undefined), settings, mcp, relocated };
 }
 export async function inspectClaudeIntegration(startPath) {
     const projectRoot = await resolveProjectRoot(startPath);
@@ -128,14 +150,14 @@ export async function installClaudeIntegration(startPath, apply) {
         ...inspected.settings,
         hooks: {
             ...settingsHooks,
-            SessionStart: addHook(settingsHooks.SessionStart, HOOK_COMMANDS.sessionStart, LEGACY_HOOK_COMMANDS.sessionStart),
-            UserPromptSubmit: addHook(settingsHooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt, LEGACY_HOOK_COMMANDS.userPrompt),
+            SessionStart: addHook(settingsHooks.SessionStart, HOOK_COMMANDS.sessionStart, LEGACY_HOOK_COMMANDS.sessionStart, inspected.relocated ? `${inspected.relocated} hook claude-code session-start` : undefined),
+            UserPromptSubmit: addHook(settingsHooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt, LEGACY_HOOK_COMMANDS.userPrompt, inspected.relocated ? `${inspected.relocated} hook claude-code user-prompt` : undefined),
         },
     };
     const mcpServers = object(inspected.mcp.mcpServers);
     const mcp = {
         ...inspected.mcp,
-        mcpServers: { ...mcpServers, 'fluffy-context': MCP_SERVER },
+        mcpServers: { ...mcpServers, 'fluffy-context': { ...object(mcpServers['fluffy-context']), ...MCP_SERVER } },
     };
     await Promise.all([
         atomicWriteJson(inspected.status.settingsPath, settings),

package/dist/src/mcp/server.js

@@ -1,9 +1,11 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { addNote, listNotes } from '../runtime/notes.js';
-import { contextCompile, contextExpand, contextOrient, contextUsageReport, loadContext, saveContext } from '../agent/api.js';
+import { contextCompile, contextExpand, contextOrient, contextUsageReport, inspectRecipe, inspectSkill, listRecipes, listSkills, loadContext, materializeContextRecipe, materializeContextSkill, recordContextSkillInvocation, recordContextSkillOutcome, saveContext, transitionContextRecipe, transitionContextSkill, acceptContextEvolutionCandidate, inspectContextEvolutionProposal, listContextEvolutionProposals, proposeContextEvolution, transitionContextEvolutionProposal } from '../agent/api.js';
 import { ensureRuntimeForSession } from '../cognition/runtime.js';
 import { VERSION } from '../version.js';
+import { injectContext } from '../compiler/inject.js';
+import { importMemory } from '../cognition/import-memory.js';
 const orientInput = z.object({
     path: z.string().optional(),
     contextId: z.string().optional(),
@@ -21,6 +23,8 @@ const noteActor = z.enum(['agent', 'human']);
 const noteStatus = z.enum(['open', 'resolved']);
 const compileOptions = z.object({
     contextId: z.string().optional(),
+    recipeId: z.string().optional(),
+    graphHops: z.union([z.literal(0), z.literal(1), z.literal(2)]).optional(),
     query: z.string().optional(),
     scenario: scenario.optional(),
     scope: z.string().optional(),
@@ -93,6 +97,25 @@ const usageReportInput = z.object({
     baselineTokens: z.number().nonnegative().optional(),
     baselineSource: z.enum(['manual', 'recorded-control']).optional(),
 });
+const skillOutcome = z.enum(['success', 'failure', 'partial', 'irrelevant', 'unknown']);
+const recipeEntity = z.enum(['knowledge', 'deadend', 'skill', 'compiler-recipe', 'experience', 'proposal']);
+const recipeListInput = z.object({ path: z.string().optional() });
+const recipeInspectInput = z.object({ path: z.string().optional(), recipeId: z.string() });
+const recipeMaterializeInput = z.object({ path: z.string().optional(), proposalId: z.string(), title: z.string(), preferredSources: z.array(z.enum(['context', 'knowledge', 'deadend', 'note'])).optional(), preferredSections: z.array(z.enum(['summary', 'pending', 'decision', 'risk', 'note', 'knowledge', 'deadend', 'activity'])).optional(), sectionBudgets: z.record(z.string(), z.int().nonnegative().max(100_000)).optional() });
+const recipeTransitionInput = z.object({ path: z.string().optional(), recipeId: z.string(), to: z.enum(['verified', 'published', 'deprecated', 'superseded']), rationale: z.string(), supersedes: z.object({ entity: recipeEntity, entityId: z.string(), relation: z.literal('supersedes') }).optional() });
+const skillEntity = z.enum(['knowledge', 'deadend', 'skill', 'compiler-recipe', 'experience', 'proposal']);
+const skillListInput = z.object({ path: z.string().optional() });
+const skillInspectInput = z.object({ path: z.string().optional(), skillId: z.string() });
+const skillMaterializeInput = z.object({ path: z.string().optional(), proposalId: z.string(), title: z.string(), procedure: z.array(z.string()) });
+const skillTransitionInput = z.object({ path: z.string().optional(), skillId: z.string(), to: z.enum(['verified', 'published', 'deprecated', 'superseded']), rationale: z.string(), supersedes: z.object({ entity: skillEntity, entityId: z.string(), relation: z.literal('supersedes') }).optional() });
+const skillInvocationInput = z.object({ path: z.string().optional(), skillId: z.string(), invocationId: z.string(), callerEventId: z.string(), inputHash: z.string() });
+const skillOutcomeInput = z.object({ path: z.string().optional(), skillId: z.string(), invocationId: z.string(), outcomeId: z.string(), callerEventId: z.string(), outcome: skillOutcome, summary: z.string() });
+const evolutionEntity = z.enum(['knowledge', 'deadend', 'skill', 'compiler-recipe', 'experience', 'proposal']);
+const evolutionProposeInput = z.object({ path: z.string().optional(), eventIds: z.array(z.string()).min(1).max(32).optional(), recentLimit: z.int().nonnegative().max(32).optional(), targetKind: z.enum(['skill', 'compiler-recipe']).optional() });
+const evolutionListInput = z.object({ path: z.string().optional() });
+const evolutionInspectInput = z.object({ path: z.string().optional(), proposalId: z.string() });
+const evolutionAcceptInput = z.object({ path: z.string().optional(), proposalId: z.string(), rationale: z.string().min(1) });
+const evolutionTransitionInput = z.object({ path: z.string().optional(), proposalId: z.string(), to: z.enum(['verified', 'rejected', 'deprecated', 'superseded']), rationale: z.string().min(1), supersedes: z.object({ entity: evolutionEntity, entityId: z.string(), relation: z.literal('supersedes') }).optional() });
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -110,6 +133,30 @@ function failureResponse(tool, error) {
 }
 export function createMcpServer() {
     const server = new McpServer({ name: 'fluffy-context', version: VERSION });
+    server.registerTool('context_inject', {
+        title: 'Prepare task context',
+        description: 'Use at task start, context reset, task change or a new failure. Returns bounded project evidence with automatic scenario selection. Expand only when more detail is needed.',
+        inputSchema: compileInput.extend({ explain: z.boolean().optional() }),
+    }, async ({ path, ...options }) => {
+        try {
+            return successResponse(await injectContext(path, options, 'mcp'));
+        }
+        catch (error) {
+            return failureResponse('context_inject', error);
+        }
+    });
+    server.registerTool('context_import', {
+        title: 'Import project memories',
+        description: 'Scan project agent instructions and memory files. Defaults to preview; apply stores source-linked unverified candidates, never trusted instructions.',
+        inputSchema: z.object({ path: z.string().optional(), apply: z.boolean().optional() }),
+    }, async ({ path, apply }) => {
+        try {
+            return successResponse(await importMemory(path, apply));
+        }
+        catch (error) {
+            return failureResponse('context_import', error);
+        }
+    });
     server.registerTool('context_orient', {
         title: 'Orient context',
         description: 'Load bounded, read-only task context with verified consensus and open notes. Compiler manifests expose deterministic levels, hashes, and estimated tokens through the Agent API and CLI.',
@@ -200,6 +247,186 @@ export function createMcpServer() {
             return failureResponse('context_usage_report', error);
         }
     });
+    server.registerTool('recipe_list', {
+        title: 'List Recipes',
+        description: 'List immutable v2 compiler Recipes without modifying project state.',
+        inputSchema: recipeListInput,
+    }, async ({ path }) => {
+        try {
+            return successResponse(await listRecipes(path));
+        }
+        catch (error) {
+            return failureResponse('recipe_list', error);
+        }
+    });
+    server.registerTool('recipe_inspect', {
+        title: 'Inspect Recipe',
+        description: 'Inspect a compiler Recipe and its lifecycle.',
+        inputSchema: recipeInspectInput,
+    }, async ({ path, recipeId }) => {
+        try {
+            return successResponse(await inspectRecipe(path, recipeId));
+        }
+        catch (error) {
+            return failureResponse('recipe_inspect', error);
+        }
+    });
+    server.registerTool('recipe_materialize', {
+        title: 'Materialize Recipe',
+        description: 'Materialize a Recipe from an accepted compiler-recipe proposal.',
+        inputSchema: recipeMaterializeInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await materializeContextRecipe(path, input));
+        }
+        catch (error) {
+            return failureResponse('recipe_materialize', error);
+        }
+    });
+    server.registerTool('recipe_transition', {
+        title: 'Transition Recipe',
+        description: 'Apply an explicit append-only Recipe lifecycle transition.',
+        inputSchema: recipeTransitionInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await transitionContextRecipe(path, input));
+        }
+        catch (error) {
+            return failureResponse('recipe_transition', error);
+        }
+    });
+    server.registerTool('skill_list', {
+        title: 'List Skills',
+        description: 'List immutable v2 Skills without modifying project state.',
+        inputSchema: skillListInput,
+    }, async ({ path }) => {
+        try {
+            return successResponse(await listSkills(path));
+        }
+        catch (error) {
+            return failureResponse('skill_list', error);
+        }
+    });
+    server.registerTool('skill_inspect', {
+        title: 'Inspect Skill',
+        description: 'Inspect an immutable v2 Skill and its lifecycle without modifying project state.',
+        inputSchema: skillInspectInput,
+    }, async ({ path, skillId }) => {
+        try {
+            return successResponse(await inspectSkill(path, skillId));
+        }
+        catch (error) {
+            return failureResponse('skill_inspect', error);
+        }
+    });
+    server.registerTool('skill_materialize', {
+        title: 'Materialize Skill',
+        description: 'Materialize a Skill from an accepted candidate Skill proposal.',
+        inputSchema: skillMaterializeInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await materializeContextSkill(path, input));
+        }
+        catch (error) {
+            return failureResponse('skill_materialize', error);
+        }
+    });
+    server.registerTool('skill_transition', {
+        title: 'Transition Skill',
+        description: 'Apply an explicit append-only Skill lifecycle transition.',
+        inputSchema: skillTransitionInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await transitionContextSkill(path, input));
+        }
+        catch (error) {
+            return failureResponse('skill_transition', error);
+        }
+    });
+    server.registerTool('skill_record_invocation', {
+        title: 'Record Skill invocation',
+        description: 'Record a published Skill invocation using only an input hash.',
+        inputSchema: skillInvocationInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await recordContextSkillInvocation(path, input));
+        }
+        catch (error) {
+            return failureResponse('skill_record_invocation', error);
+        }
+    });
+    server.registerTool('skill_record_outcome', {
+        title: 'Record Skill outcome',
+        description: 'Record one explicit terminal outcome for a Skill invocation.',
+        inputSchema: skillOutcomeInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await recordContextSkillOutcome(path, input));
+        }
+        catch (error) {
+            return failureResponse('skill_record_outcome', error);
+        }
+    });
+    server.registerTool('evolution_propose', {
+        title: 'Propose Evolution',
+        description: 'Derive a bounded candidate Evolution proposal from authorized metadata.',
+        inputSchema: evolutionProposeInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await proposeContextEvolution(path, input));
+        }
+        catch (error) {
+            return failureResponse('evolution_propose', error);
+        }
+    });
+    server.registerTool('evolution_list', {
+        title: 'List Evolution proposals',
+        description: 'List Evolution proposals without modifying project state.',
+        inputSchema: evolutionListInput,
+    }, async ({ path }) => {
+        try {
+            return successResponse(await listContextEvolutionProposals(path));
+        }
+        catch (error) {
+            return failureResponse('evolution_list', error);
+        }
+    });
+    server.registerTool('evolution_inspect', {
+        title: 'Inspect Evolution proposal',
+        description: 'Inspect one Evolution proposal and its lifecycle.',
+        inputSchema: evolutionInspectInput,
+    }, async ({ path, proposalId }) => {
+        try {
+            return successResponse(await inspectContextEvolutionProposal(path, proposalId));
+        }
+        catch (error) {
+            return failureResponse('evolution_inspect', error);
+        }
+    });
+    server.registerTool('evolution_accept', {
+        title: 'Accept Evolution candidate',
+        description: 'Accept a proposal into an immutable candidate artifact.',
+        inputSchema: evolutionAcceptInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await acceptContextEvolutionCandidate(path, input));
+        }
+        catch (error) {
+            return failureResponse('evolution_accept', error);
+        }
+    });
+    server.registerTool('evolution_transition', {
+        title: 'Transition Evolution proposal',
+        description: 'Apply an explicit append-only Evolution proposal lifecycle transition.',
+        inputSchema: evolutionTransitionInput,
+    }, async ({ path, ...input }) => {
+        try {
+            return successResponse(await transitionContextEvolutionProposal(path, input));
+        }
+        catch (error) {
+            return failureResponse('evolution_transition', error);
+        }
+    });
     server.registerTool('context_checkpoint', {
         title: 'Checkpoint context',
         description: 'Explicitly save context progress and create a Snapshot when changes are present; runtime rate limits remain enforced.',