fluffy-context 0.7.7 → 0.8.0

package/dist/src/compiler/compile.js

@@ -4,6 +4,7 @@ import { queryTerms } from '../cognition/retrieval.js';
 import { listDeadends, listKnowledge } from '../runtime/knowledge.js';
 import { listNotes } from '../runtime/notes.js';
 import { extractActivity } from './activity.js';
+import { graphOrdering } from './graph.js';
 import { latestHostIntent, loadCompilerSources, sourceDescriptor } from './sources.js';
 const scenarioKeywords = [
     { scenario: 'debugging', words: ['bug', 'error', 'fail', 'failure', 'exception', 'regression', 'debug', '失败', '报错', '异常', '修复'] },
@@ -137,6 +138,50 @@ function sortCandidates(left, right) {
         || right.matchedTerms.length - left.matchedTerms.length
         || stableCompare(left.candidateId, right.candidateId);
 }
+function recipeParticipation(sources) {
+    const recipe = sources.recipe?.recipe;
+    if (!recipe)
+        return undefined;
+    return {
+        recipeId: recipe.recipeId,
+        contentHash: recipe.contentHash,
+        interpreterVersion: 'recipe-interpreter-v1',
+        preferredSources: [...(recipe.preferredSources ?? [])],
+        preferredSections: [...(recipe.preferredSections ?? [])],
+        sectionBudgets: { ...(recipe.sectionBudgets ?? {}) },
+    };
+}
+function sourcePreference(candidate, recipe) {
+    const source = candidate.source.kind === 'current-context' ? 'context' : candidate.source.kind;
+    const index = recipe.preferredSources.indexOf(source);
+    return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+}
+function sectionPreference(candidate, recipe) {
+    const index = recipe.preferredSections.indexOf(candidate.section);
+    return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+}
+function recipeApplicable(recipe, sources, paths) {
+    const applicability = sources.recipe.recipe.applicability;
+    if (applicability.branchMode === 'global')
+        return true;
+    if (applicability.branchMode !== 'exact')
+        return false;
+    const branch = sources.anchor.ref ?? sources.anchor.branch ?? 'detached';
+    if (applicability.branches?.length && !applicability.branches.includes(branch) && !applicability.branches.includes(sources.anchor.branch ?? ''))
+        return false;
+    if (applicability.sourceCommit && applicability.sourceCommit !== sources.anchor.head)
+        return false;
+    if (paths.length > 0 && applicability.paths?.length && !applicability.paths.some((path) => paths.includes(path.replaceAll('\\', '/'))))
+        return false;
+    return recipe.recipeId === sources.recipe.recipe.recipeId;
+}
+function sortWithRecipe(recipe) {
+    if (!recipe)
+        return sortCandidates;
+    return (left, right) => sourcePreference(left, recipe) - sourcePreference(right, recipe)
+        || sectionPreference(left, recipe) - sectionPreference(right, recipe)
+        || sortCandidates(left, right);
+}
 function truncateText(value, maxChars) {
     if (value.length <= maxChars)
         return { text: value, truncated: false };
@@ -237,6 +282,9 @@ export async function compileContext(startPath, options = {}) {
     const sources = await loadCompilerSources(startPath, options);
     const normalizedPaths = options.paths ? await filterPaths(sources.anchor.projectRoot, options.paths) : [];
     const intent = intentFor(sources, options, normalizedPaths);
+    const recipe = recipeParticipation(sources);
+    if (recipe && !recipeApplicable(recipe, sources, normalizedPaths))
+        throw new Error(`compiler recipe is not applicable: ${recipe.recipeId}`);
     const orientation = sources.orientation;
     const maxChars = intent.budget.total;
     const notes = orientation.status === 'ready' ? (await listNotes(sources.anchor.projectRoot, { contextId: orientation.context.id, openOnly: true, limit: options.noteLimit ?? 50, maxChars: Number.MAX_SAFE_INTEGER })).filter((note) => orientation.notes.some((selected) => selected.noteId === note.noteId)) : [];
@@ -250,14 +298,31 @@ export async function compileContext(startPath, options = {}) {
         if (!check.ok)
             excluded.push({ candidateId: candidate.candidateId, source: candidate.source, reason: check.reason ?? 'query_no_match' });
         return check.ok;
-    }).sort(sortCandidates);
+    }).sort(sortWithRecipe(recipe));
+    const graph = options.graphHops === undefined ? undefined : graphOrdering(sources.evidenceGraph, options.graphHops, sources.anchor, eligible);
+    if (graph) {
+        eligible.sort((left, right) => {
+            if (recipe) {
+                const sourceOrder = sourcePreference(left, recipe) - sourcePreference(right, recipe);
+                if (sourceOrder)
+                    return sourceOrder;
+                const sectionOrder = sectionPreference(left, recipe) - sectionPreference(right, recipe);
+                if (sectionOrder)
+                    return sectionOrder;
+            }
+            return (graph.distanceFor(left) ?? Number.MAX_SAFE_INTEGER) - (graph.distanceFor(right) ?? Number.MAX_SAFE_INTEGER)
+                || sortCandidates(left, right);
+        });
+    }
     const selected = [];
     const truncation = emptyTruncation();
     const sectionStats = {};
     let usedChars = 0;
     for (const candidate of eligible) {
         const separator = selected.length > 0 ? 1 : 0;
-        const available = maxChars - usedChars - separator;
+        const sectionBudget = recipe?.sectionBudgets[candidate.section] ?? maxChars;
+        const consumedInSection = sectionStats[candidate.section]?.consumed ?? 0;
+        const available = Math.min(maxChars - usedChars - separator, sectionBudget - consumedInSection - separator);
         if (available <= 0) {
             excluded.push({ candidateId: candidate.candidateId, source: candidate.source, reason: 'budget' });
             truncation.candidatesOmittedByBudget += 1;
@@ -274,7 +339,7 @@ export async function compileContext(startPath, options = {}) {
         const item = { ...candidate, text: limited.text, selectedChars: limited.text.length, selected: true, truncated: limited.truncated };
         selected.push(item);
         usedChars += separator + item.selectedChars;
-        const prior = sectionStats[item.section] ?? { allocated: maxChars, consumed: 0, truncated: false };
+        const prior = sectionStats[item.section] ?? { allocated: recipe?.sectionBudgets[item.section] ?? maxChars, consumed: 0, truncated: false };
         sectionStats[item.section] = { ...prior, consumed: prior.consumed + item.selectedChars + separator, truncated: prior.truncated || limited.truncated };
         if (limited.truncated) {
             truncation.candidatesPartiallyTruncated += 1;
@@ -318,6 +383,8 @@ export async function compileContext(startPath, options = {}) {
         selected,
         budget: { requested: intent.budget, usedChars, remainingChars: Math.max(0, maxChars - usedChars), sections: sectionStats },
         truncation,
+        ...(recipe ? { recipe } : {}),
+        ...(graph ? { graph: graph.participation } : {}),
     });
     return {
         schemaVersion: 1,
@@ -348,6 +415,8 @@ export async function compileContext(startPath, options = {}) {
             selectedEventIds: [...new Set(selected.flatMap((item) => item.source.provenance.eventId ? [item.source.provenance.eventId] : []))].sort(stableCompare),
             fallbackReason: sources.fallbackReason,
         },
+        ...(recipe ? { recipe } : {}),
+        ...(graph ? { graph: graph.participation } : {}),
         text: manifestText(selected),
     };
 }

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

@@ -0,0 +1,7 @@
+import type { EvidenceGraphProjection } from '../cognition/types.js';
+import type { ContextAnchor, ContextCandidate, ContextGraphParticipation } from './types.js';
+export interface GraphOrdering {
+    participation: ContextGraphParticipation;
+    distanceFor(candidate: ContextCandidate): number | null;
+}
+export declare function graphOrdering(graph: EvidenceGraphProjection | null, hops: 0 | 1 | 2, anchor: ContextAnchor, eligible: ContextCandidate[]): GraphOrdering;

package/dist/src/compiler/graph.js

@@ -0,0 +1,117 @@
+import { EVIDENCE_GRAPH_DERIVATION_VERSION, workspaceNodeId } from '../cognition/evidence-graph.js';
+import { contentHash } from './identity.js';
+const MAX_VISITED_NODES = 256;
+const MAX_TRAVERSED_EDGES = 512;
+const MAX_FAN_OUT = 32;
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function candidateNodeId(candidate) {
+    if (candidate.section === 'knowledge')
+        return `knowledge:${candidate.source.entityId}`;
+    if (candidate.section === 'deadend')
+        return `deadend:${candidate.source.entityId}`;
+    if (candidate.source.kind === 'current-context')
+        return `context:${candidate.source.contextId ?? candidate.source.entityId}`;
+    return null;
+}
+function validGraph(graph) {
+    if (graph.schemaVersion !== 1 || graph.derivationVersion !== EVIDENCE_GRAPH_DERIVATION_VERSION || !Array.isArray(graph.nodes) || !Array.isArray(graph.edges))
+        return false;
+    const nodeKinds = new Set(['context', 'snapshot', 'experience', 'proposal', 'knowledge', 'deadend', 'skill', 'recipe', 'path', 'test', 'commit', 'branch-worktree']);
+    const edgeTypes = new Set(['derived_from', 'supports', 'contradicts', 'supersedes', 'used_for', 'observed_in', 'changed_in', 'co_changed_with', 'tests']);
+    const nodes = new Set();
+    for (const node of graph.nodes) {
+        if (!node || typeof node.nodeId !== 'string' || node.nodeId.length === 0 || !nodeKinds.has(node.kind) || nodes.has(node.nodeId))
+            return false;
+        nodes.add(node.nodeId);
+    }
+    const edges = new Set();
+    for (const edge of graph.edges) {
+        if (!edge || typeof edge.edgeId !== 'string' || edge.edgeId.length === 0 || edges.has(edge.edgeId) || !nodes.has(edge.from) || !nodes.has(edge.to) || !edgeTypes.has(edge.type) || edge.derivationVersion !== EVIDENCE_GRAPH_DERIVATION_VERSION || typeof edge.occurredAt !== 'string' || edge.occurredAt.length === 0 || !Array.isArray(edge.sourceEventIds) || edge.sourceEventIds.some((id) => typeof id !== 'string' || !id) || (edge.confidence !== undefined && (typeof edge.confidence !== 'number' || !Number.isFinite(edge.confidence) || edge.confidence < 0 || edge.confidence > 1)))
+            return false;
+        edges.add(edge.edgeId);
+    }
+    return true;
+}
+function graphProjectionHash(graph) {
+    return contentHash(graph);
+}
+export function graphOrdering(graph, hops, anchor, eligible) {
+    const empty = (fallbackReason, seedNodeIds = []) => ({
+        participation: {
+            derivationVersion: EVIDENCE_GRAPH_DERIVATION_VERSION,
+            projectionHash: null,
+            hops,
+            seedNodeIds,
+            selectedNodeIds: [],
+            selectedEdgeIds: [],
+            fallbackReason,
+        },
+        distanceFor: () => null,
+    });
+    if (!graph)
+        return empty('graph-unavailable');
+    if (!validGraph(graph))
+        return empty('graph-invalid');
+    const projectionHash = graphProjectionHash(graph);
+    const nodes = new Set(graph.nodes.map((node) => node.nodeId));
+    const candidateNodes = new Map(eligible.map((candidate) => [candidate.candidateId, candidateNodeId(candidate)]));
+    const seedNodeIds = [...new Set([
+            workspaceNodeId(anchor),
+            ...eligible.filter((candidate) => candidate.source.kind === 'current-context').map(candidateNodeId).filter((node) => node !== null),
+        ].filter((node) => nodes.has(node)))].sort(compare);
+    if (seedNodeIds.length === 0)
+        return empty('graph-no-seeds');
+    if (hops === 0) {
+        const distances = new Map(seedNodeIds.map((node) => [node, 0]));
+        return {
+            participation: { derivationVersion: EVIDENCE_GRAPH_DERIVATION_VERSION, projectionHash, hops, seedNodeIds, selectedNodeIds: seedNodeIds, selectedEdgeIds: [], fallbackReason: null },
+            distanceFor: (candidate) => {
+                const node = candidateNodes.get(candidate.candidateId);
+                return node ? distances.get(node) ?? null : null;
+            },
+        };
+    }
+    const adjacency = new Map();
+    for (const edge of graph.edges) {
+        adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge]);
+        adjacency.set(edge.to, [...(adjacency.get(edge.to) ?? []), edge]);
+    }
+    for (const edges of adjacency.values())
+        edges.sort((left, right) => compare(left.edgeId, right.edgeId));
+    const distances = new Map(seedNodeIds.map((node) => [node, 0]));
+    const queue = [...seedNodeIds];
+    const selectedEdgeIds = new Set();
+    while (queue.length > 0 && distances.size < MAX_VISITED_NODES && selectedEdgeIds.size < MAX_TRAVERSED_EDGES) {
+        const node = queue.shift();
+        const distance = distances.get(node);
+        if (distance >= hops)
+            continue;
+        for (const edge of (adjacency.get(node) ?? []).slice(0, MAX_FAN_OUT)) {
+            if (selectedEdgeIds.size >= MAX_TRAVERSED_EDGES)
+                break;
+            const adjacent = edge.from === node ? edge.to : edge.from;
+            selectedEdgeIds.add(edge.edgeId);
+            if (!distances.has(adjacent) && distances.size < MAX_VISITED_NODES) {
+                distances.set(adjacent, distance + 1);
+                queue.push(adjacent);
+            }
+        }
+    }
+    return {
+        participation: {
+            derivationVersion: EVIDENCE_GRAPH_DERIVATION_VERSION,
+            projectionHash,
+            hops,
+            seedNodeIds,
+            selectedNodeIds: [...distances.keys()].sort(compare),
+            selectedEdgeIds: [...selectedEdgeIds].sort(compare),
+            fallbackReason: null,
+        },
+        distanceFor: (candidate) => {
+            const node = candidateNodes.get(candidate.candidateId);
+            return node ? distances.get(node) ?? null : null;
+        },
+    };
+}

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/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/mcp/server.js

@@ -1,7 +1,7 @@
 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';
 const orientInput = z.object({
@@ -21,6 +21,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 +95,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);
 }
@@ -200,6 +221,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.',

package/dist/src/storage/layout.d.ts

@@ -22,6 +22,11 @@ export declare function cognitionContextsProjectionPath(projectRoot: string): st
 export declare function cognitionKnowledgeProjectionPath(projectRoot: string): string;
 export declare function cognitionDeadendsProjectionPath(projectRoot: string): string;
 export declare function cognitionNotesProjectionPath(projectRoot: string): string;
+export declare function cognitionExperiencesProjectionPath(projectRoot: string): string;
+export declare function cognitionProposalsProjectionPath(projectRoot: string): string;
+export declare function cognitionSkillsProjectionPath(projectRoot: string): string;
+export declare function cognitionRecipesProjectionPath(projectRoot: string): string;
+export declare function cognitionEvidenceGraphProjectionPath(projectRoot: string): string;
 export declare function cognitionRetrievalProjectionPath(projectRoot: string): string;
 export declare function cognitionMigrationsDirectory(projectRoot: string): string;
 export declare function cognitionV1ImportPath(projectRoot: string): string;

package/dist/src/storage/layout.js

@@ -71,6 +71,21 @@ export function cognitionDeadendsProjectionPath(projectRoot) {
 export function cognitionNotesProjectionPath(projectRoot) {
     return path.join(cognitionProjectionsDirectory(projectRoot), 'notes.json');
 }
+export function cognitionExperiencesProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'experiences.json');
+}
+export function cognitionProposalsProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'proposals.json');
+}
+export function cognitionSkillsProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'skills.json');
+}
+export function cognitionRecipesProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'recipes.json');
+}
+export function cognitionEvidenceGraphProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'evidence-graph.json');
+}
 export function cognitionRetrievalProjectionPath(projectRoot) {
     return path.join(cognitionProjectionsDirectory(projectRoot), 'retrieval.json');
 }

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.7.7";
+export declare const VERSION = "0.8.0";

package/dist/src/version.js

@@ -1 +1 @@
-export const VERSION = '0.7.7';
+export const VERSION = '0.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluffy-context",
-  "version": "0.7.7",
+  "version": "0.8.0",
   "description": "Local context management CLI and MCP tools for AI coding agents",
   "license": "MIT",
   "author": "FluffyChi-Xing",