@devflow-tools/mcp-server 0.17.7 → 0.18.0

package/dist/tools.js

@@ -1,13 +1,15 @@
-import { buildChannelQueryPlan, buildRetrievalTaskPlan, extractStructuralSemanticEvidence, getKnowledgeResult, getMemoryResult, getProjectContextResult, mergeSemanticAuthority, parseIntent, } from "@devflow-tools/context-engine";
-import { assertTaskSemanticFrameV2, projectSemanticFrameToLegacyIntent, resolveSemanticResolutionMode, } from "@devflow-tools/sdk";
+import { loadSemanticExecutionContext, retrieveProjectEvidence, } from './retrieval-composition.js';
+import { projectTaskKnowledgeResult, projectTaskMemoryResult, queryAuthoritativeTaskEvidence, } from './task-evidence-service.js';
+import { resolveTaskSemanticContext, } from '@devflow-tools/semantic-engine';
 import { resolveCapabilityRollout } from "@devflow-tools/sdk/capability-rollout";
 import { canonicalizeProjectRoot, wrapHandlerRequireRoot } from "./plugin-guards.js";
 import { getReportResourceUri, readToolReport } from "./report-store.js";
 import { normalizeTurnId, openGlobalDevFlowDatabase, } from "@devflow-tools/database";
-import { createHash } from "node:crypto";
 import { isAbsolute, normalize, relative } from "node:path";
 import { normalizeMemoryCandidates, OBSERVATION_TYPE_SCHEMA, rejectedToolResult, TOOL_RESULT_OUTPUT_SCHEMA, } from "./tool-contracts.js";
-import { emitSemanticControlLog } from '@devflow-tools/telemetry';
+import { emitSemanticControlLog, SemanticRuntimeEventProjector } from '@devflow-tools/telemetry';
+import { ActivationSnapshotStore, TaskEventStore, TaskKernel } from '@devflow-tools/task-runtime';
+import { createHash } from 'node:crypto';
 export const GUARDED_CORE_TOOL_NAMES = new Set([
     "get_project_context",
     "search_symbol",
@@ -57,6 +59,7 @@ export function getCoreTools(knowledgeScopes = []) {
                 type: "object",
                 properties: {
                     query: { type: "string", description: "自然语言查询" },
+                    budgetTokens: { type: "number", description: "Maximum response tokens", default: 2000, minimum: 1 },
                     mode: { type: "string", enum: ["fast", "deep"], default: "fast" },
                     expandedTerms: { type: "string", description: "Agent 预翻译的英文关键词（空格分隔），用于提升中文查询的搜索效果" },
                     retrievalSessionId: { type: "string", description: "首轮上下文返回的检索会话 ID；仅用于最多三轮的定向补检" },
@@ -133,9 +136,6 @@ export function getCoreTools(knowledgeScopes = []) {
                     status: { type: "string", enum: ["done", "failed", "skipped", "waiting_user"] },
                     output: { type: "string", description: "Bounded step result summary" },
                     duration: { type: "number", minimum: 0, description: "Step duration in milliseconds" },
-                    contextReceipt: { type: "string", description: "Context receipt used for the host action" },
-                    executionId: { type: "string", description: "Host execution identity" },
-                    toolUseIds: { type: "array", items: { type: "string" }, maxItems: 100 },
                     changedFiles: { type: "array", items: { type: "string" }, maxItems: 100 },
                     verification: {
                         type: "object",
@@ -179,7 +179,7 @@ export function getCoreTools(knowledgeScopes = []) {
         },
         {
             name: "get_memory",
-            description: "获取项目记忆：技术栈、约定、偏好、历史决策",
+            description: "投影当前 canonical task authoritative receipt 中的 Memory 证据",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -261,6 +261,16 @@ export function getCoreTools(knowledgeScopes = []) {
                                     items: { type: "string", minLength: 1 },
                                     description: "Exact, verbatim substrings copied from the canonical user prompt that support this candidate. Required when refining an already committed explicit-memory turn.",
                                 },
+                                operation: {
+                                    type: "string",
+                                    enum: ["add", "reinforce", "supersede", "link", "hold", "retire", "none"],
+                                    description: "Requested lifecycle operation. supersede/retire require referencedFactIds and exact evidenceSpans; omit when uncertain.",
+                                },
+                                referencedFactIds: {
+                                    type: "array",
+                                    items: { type: "string", minLength: 1 },
+                                    description: "Exact existing fact IDs affected by reinforce/link/supersede/retire. Entity or alias matches are not fact identity.",
+                                },
                             },
                         },
                     },
@@ -351,7 +361,7 @@ export function getCoreTools(knowledgeScopes = []) {
         },
         {
             name: "get_knowledge",
-            description: "查询技术文档知识库",
+            description: "投影当前 canonical task authoritative receipt 中的 Knowledge 证据",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -582,14 +592,9 @@ function resolveBoundContextTask(input) {
             || record.turnId !== input.turnId || record.requestId !== input.requestId) {
             throw new Error('TASK_IDENTITY_MISMATCH:intent artifact does not belong to this MCP request');
         }
-        const planRecord = database.getChannelQueryPlanForIntent({
-            projectRoot: record.projectRoot,
-            sessionId: record.sessionId,
-            turnId: record.turnId,
-            sourceIntentHash: record.artifactHash,
-        });
-        if (!planRecord)
-            throw new Error(`QUERY_PLAN_NOT_FOUND:${record.artifactHash}`);
+        if (!record.executionId) {
+            throw new Error('TASK_IDENTITY_INCOMPLETE:intent artifact execution identity is missing');
+        }
         const identity = {
             projectRoot: record.projectRoot,
             projectId: record.projectId,
@@ -597,7 +602,7 @@ function resolveBoundContextTask(input) {
             sessionId: record.sessionId,
             turnId: record.turnId,
             requestId: record.requestId,
-            ...(record.executionId ? { executionId: record.executionId } : {}),
+            executionId: record.executionId,
         };
         const artifact = {
             identity,
@@ -619,75 +624,80 @@ function resolveBoundContextTask(input) {
             artifactHash: record.artifactHash,
             createdAt: record.createdAt,
         };
-        const queryPlan = {
-            identity,
-            sourceIntentHash: planRecord.sourceIntentHash,
-            planHash: planRecord.planHash,
-            code: planRecord.code,
-            memory: planRecord.memory,
-            knowledge: planRecord.knowledge,
-            generatedBy: planRecord.generatedBy,
-            ...(planRecord.degradation ? { degradation: planRecord.degradation } : {}),
-            createdAt: planRecord.createdAt,
-        };
         const query = stripArtifactCommand(artifact.normalizedPrompt, artifact.command);
         const expandedTerms = [input.agentQuery, input.expandedTerms]
             .filter((value) => typeof value === 'string' && value.trim().length > 0)
             .join(' ')
             .slice(0, 4_000) || undefined;
-        return { query, expandedTerms, requestId: record.requestId, turnId: record.turnId, intentArtifact: artifact, queryPlan };
+        return { query, expandedTerms, requestId: record.requestId, turnId: record.turnId, intentArtifact: artifact };
     }
     finally {
         database.close();
     }
 }
 export async function resolveBoundContextTaskWithSemantics(input, engines, dependencies) {
-    const legacy = resolveBoundContextTask(input);
-    const artifact = legacy.intentArtifact;
+    const bound = resolveBoundContextTask(input);
+    const artifact = bound.intentArtifact;
     if (!artifact)
-        return legacy;
-    const semanticMode = resolveSemanticResolutionMode(input.projectRoot);
-    if (semanticMode === 'off' || !engines.semanticRouter)
-        return legacy;
+        return bound;
     const database = openGlobalDevFlowDatabase(undefined, { busyTimeoutMs: 250 });
     try {
-        const latest = database.getLatestSemanticResolution(artifact.identity.projectRoot, artifact.identity.sessionId, artifact.identity.turnId);
-        if (!latest)
-            return legacy;
-        if (latest.artifactRevision >= 2) {
-            const resolvedArtifact = database.getTaskIntentArtifact(latest.artifactHash);
-            const resolvedPlan = resolvedArtifact && database.getChannelQueryPlanForIntent({
-                projectRoot: resolvedArtifact.projectRoot,
-                sessionId: resolvedArtifact.sessionId,
-                turnId: resolvedArtifact.turnId,
-                sourceIntentHash: resolvedArtifact.artifactHash,
-            });
-            if (resolvedArtifact && resolvedPlan && semanticMode !== 'shadow') {
-                return boundTaskFromRecords(legacy, resolvedArtifact, resolvedPlan);
+        const currentContext = database.getSemanticExecutionContext(artifact.identity.projectRoot, artifact.identity.sessionId, artifact.identity.turnId, artifact.version);
+        if (currentContext) {
+            const snapshot = database.getTaskAggregateSnapshot(artifact.identity.projectRoot, artifact.identity.sessionId, artifact.identity.turnId, artifact.version);
+            const definition = database.getTaskDefinitionV2(currentContext.taskDefinitionHash);
+            const activation = database.getRuntimeActivation(artifact.identity.projectRoot, artifact.identity.sessionId, artifact.identity.turnId, artifact.version);
+            if (snapshot && definition && activation
+                && snapshot.semanticFactsHash === currentContext.facts.factsHash
+                && snapshot.semanticContextHash === currentContext.contextHash
+                && snapshot.channelPlanHash === currentContext.plan.planHash
+                && snapshot.taskDefinitionHash === definition.definitionHash
+                && snapshot.activationSnapshotHash === activation.snapshotHash
+                && definition.semanticContextHash === currentContext.contextHash) {
+                return { ...bound, queryPlan: currentContext.plan };
             }
-            return legacy;
-        }
-        let provisional;
-        try {
-            assertTaskSemanticFrameV2(latest.frame, artifact.normalizedPrompt);
-            provisional = latest.frame;
-        }
-        catch {
-            return legacy;
         }
-        const structural = extractStructuralSemanticEvidence({
-            prompt: artifact.normalizedPrompt,
-            command: artifact.command,
+        const activation = new ActivationSnapshotStore(database).get(artifact.identity, artifact.version);
+        if (!activation)
+            throw new Error(`RUNTIME_ACTIVATION_MISSING:${artifact.artifactHash}`);
+        const revision = artifact.version;
+        const resolvedContext = await resolveTaskSemanticContext({
+            normalizedPrompt: artifact.normalizedPrompt,
+            sourceHash: artifact.sourceHash,
+            identity: artifact.identity,
+            revision,
+            activation,
+            ...(engines.semanticRouter ? { router: engines.semanticRouter } : {}),
+            ...(dependencies.semanticSampling ? {
+                hostSampling: { sample: dependencies.semanticSampling },
+            } : {}),
+            ...(dependencies.retrievalQuerySampling ? {
+                retrievalQuerySampling: { sample: dependencies.retrievalQuerySampling },
+            } : {}),
+            ...(artifact.command ? { command: artifact.command } : {}),
             targetAnchors: artifact.targetAnchors,
+            policy: {
+                policyHash: `policy:${activation.rolloutPolicyVersion}`,
+                activeSkill: artifact.activeSkill,
+                budgets: {
+                    hookDeadlineMs: 3_000,
+                    contextTokens: 8_000,
+                    responseReserveTokens: 2_000,
+                    perChannelMs: { code: 1_500, memory: 800, knowledge: 1_500 },
+                },
+                sourceEvidenceIds: artifact.sourceEventIds,
+            },
         });
-        const route = await engines.semanticRouter.route(structural.normalizedPrompt);
+        const finalResolution = resolvedContext.resolution;
+        const facts = finalResolution.facts;
+        const route = finalResolution.route;
         emitSemanticControlLog({
             event: 'semantic.route.scored',
             identity: { ...artifact.identity, intentArtifactHash: artifact.artifactHash },
             level: route.status === 'unavailable' ? 'warn' : 'info',
             timestamp: Date.now(),
             data: {
-                mode: semanticMode,
+                mode: activation.semantic,
                 status: route.status,
                 modelId: route.modelId,
                 modelRevision: route.modelRevision,
@@ -703,228 +713,95 @@ export async function resolveBoundContextTaskWithSemantics(input, engines, depen
             identity: { ...artifact.identity, intentArtifactHash: artifact.artifactHash },
             level: 'debug', timestamp: Date.now(),
             data: {
-                mode: semanticMode, modelId: route.modelId, modelRevision: route.modelRevision,
-                thresholdVersion: route.thresholdVersion, catalogVersion: provisional.resolver.routeCatalogVersion,
+                mode: activation.semantic, modelId: route.modelId, modelRevision: route.modelRevision,
+                thresholdVersion: route.thresholdVersion,
                 status: route.status, latencyMs: route.latencyMs,
             },
         });
-        let sampled;
-        if ((route.status === 'escalation_required' || hasCompositionalStructure(structural))
-            && dependencies.semanticSampling) {
+        if (finalResolution.sampling.attempted) {
             emitSemanticControlLog({
                 event: 'semantic.resolution.escalated', identity: artifact.identity, level: 'info', timestamp: Date.now(),
-                data: { mode: semanticMode, frameHash: provisional.frameHash, reason: route.reason },
-            });
-            sampled = await dependencies.semanticSampling({
-                normalizedPrompt: structural.normalizedPrompt,
-                sourceHash: artifact.sourceHash,
-                structural,
-                route,
-                provisionalFrame: provisional,
-                timeoutMs: 3_000,
+                data: { mode: activation.semantic, factsHash: facts.factsHash, reason: route.reason,
+                    providerReceiptId: finalResolution.sampling.receiptId },
             });
         }
-        const resolved = mergeSemanticAuthority({
-            sourceHash: artifact.sourceHash,
-            structural,
-            route,
-            ...(sampled?.status === 'resolved' && sampled.frame ? { sampledFrame: sampled.frame } : {}),
-            provisionalFrame: provisional,
+        const semanticPlan = resolvedContext.context.plan;
+        const kernel = new TaskKernel(new TaskEventStore(database), new SemanticRuntimeEventProjector());
+        kernel.dispatch({
+            definition: resolvedContext.definition,
+            kind: 'activation_bound',
+            payload: { activationSnapshotHash: activation.snapshotHash },
+            idempotencyKey: `activation:${artifact.artifactHash}:${revision}`,
+            producer: 'mcp-semantic-adapter',
         });
-        const finalResolution = withSamplingResult(resolved, sampled);
-        const projection = projectSemanticFrameToLegacyIntent(finalResolution.frame);
-        const revisedBody = {
-            ...artifact,
-            version: 2,
-            supersedesHash: artifact.artifactHash,
-            intent: projection.intent,
-            action: projection.action,
-            entities: finalResolution.frame.entities,
-            targetAnchors: finalResolution.frame.targetAnchors,
-            policyConstraints: finalResolution.frame.constraints,
-            classificationEvidence: finalResolution.frame.evidence.flatMap((evidence) => {
-                const field = evidence.field === 'negation' || evidence.field === 'condition'
-                    ? 'constraint'
-                    : evidence.field;
-                if (field !== 'intent' && field !== 'action' && field !== 'entity'
-                    && field !== 'target' && field !== 'constraint')
-                    return [];
-                const source = evidence.source === 'structural'
-                    || evidence.source === 'lexical_feature'
-                    ? 'deterministic_parser'
-                    : evidence.source === 'host_sampling'
-                        ? 'host_semantic'
-                        : evidence.source;
-                return [{
-                        source,
-                        field,
-                        value: evidence.value,
-                        reason: `semantic_frame:${finalResolution.frame.frameHash}`,
-                        confidence: evidence.confidence,
-                    }];
-            }),
-            createdAt: finalResolution.frame.createdAt,
-        };
-        const { artifactHash: _oldHash, ...unhashedArtifact } = revisedBody;
-        const revisedArtifact = {
-            ...unhashedArtifact,
-            artifactHash: hashCanonical(unhashedArtifact),
-        };
-        const taskPlan = buildRetrievalTaskPlan({
-            query: legacy.query,
-            parsedIntent: parseIntent(legacy.query),
-            targetAnchors: revisedArtifact.targetAnchors,
-            activeSkill: revisedArtifact.activeSkill,
-            command: revisedArtifact.command,
-            authoritativeArtifact: revisedArtifact,
-            semanticFrame: finalResolution.frame,
+        kernel.dispatch({
+            definition: resolvedContext.definition,
+            kind: 'semantic_resolved',
+            payload: {
+                semanticFactsHash: facts.factsHash,
+                semanticContextHash: resolvedContext.context.contextHash,
+            },
+            idempotencyKey: `semantic:${artifact.artifactHash}:${revision}:${facts.factsHash}`,
+            producer: 'mcp-semantic-adapter',
         });
-        const revisedPlan = buildChannelQueryPlan({
-            artifact: revisedArtifact,
-            taskPlan,
-            expandedTerms: legacy.expandedTerms,
-            generatedBy: 'hybrid',
+        kernel.dispatch({
+            definition: resolvedContext.definition,
+            kind: 'plan_compiled',
+            payload: { channelPlanHash: semanticPlan.planHash },
+            idempotencyKey: `plan:${artifact.artifactHash}:${revision}:${semanticPlan.planHash}`,
+            producer: 'mcp-semantic-adapter',
         });
-        database.appendTaskIntentArtifact(toTaskIntentRecord(revisedArtifact));
-        database.appendChannelQueryPlan(toChannelQueryPlanRecord(revisedPlan));
-        database.appendSemanticResolution({
-            frameHash: finalResolution.frame.frameHash,
-            ...artifact.identity,
-            sourceHash: artifact.sourceHash,
-            artifactHash: revisedArtifact.artifactHash,
-            artifactRevision: 2,
-            supersedesFrameHash: provisional.frameHash,
-            state: finalResolution.frame.state,
-            generatedBy: finalResolution.frame.resolver.generatedBy,
-            modelId: finalResolution.frame.resolver.modelId,
-            modelRevision: finalResolution.frame.resolver.modelRevision,
-            routeCatalogVersion: finalResolution.frame.resolver.routeCatalogVersion,
-            thresholdVersion: finalResolution.frame.resolver.thresholdVersion,
-            route: finalResolution.route,
-            sampling: finalResolution.sampling,
-            conflicts: finalResolution.conflicts,
-            frame: finalResolution.frame,
-            durationMs: Math.round(finalResolution.route.latencyMs + (finalResolution.sampling.latencyMs ?? 0)),
-            createdAt: finalResolution.frame.createdAt,
+        database.putCanonicalSemanticTask({
+            revision,
+            activation,
+            context: resolvedContext.context,
+            definition: resolvedContext.definition,
         });
-        logSemanticResolution(artifact, semanticMode, finalResolution, projection);
-        return semanticMode === 'shadow'
-            ? legacy
-            : { ...legacy, intentArtifact: revisedArtifact, queryPlan: revisedPlan };
+        logSemanticResolution(artifact, resolvedContext.context.mode, finalResolution);
+        return { ...bound, queryPlan: semanticPlan };
     }
     finally {
         database.close();
     }
 }
-function boundTaskFromRecords(legacy, artifactRecord, planRecord) {
-    return {
-        ...legacy,
-        intentArtifact: toSdkIntentArtifact(artifactRecord),
-        queryPlan: toSdkChannelQueryPlan(planRecord),
-    };
-}
-function hasCompositionalStructure(structural) {
-    return structural.conditions.length > 0 || structural.prohibitions.length > 0
-        || new Set(structural.positiveActionSpans.map(item => item.value)).size > 1;
-}
-function withSamplingResult(resolution, sampled) {
-    if (!sampled)
-        return resolution;
-    return {
-        ...resolution,
-        sampling: {
-            attempted: true,
-            status: sampled.status,
-            ...(sampled.model ? { model: sampled.model } : {}),
-            latencyMs: sampled.latencyMs,
-            ...(sampled.responseHash ? { responseHash: sampled.responseHash } : {}),
-        },
-    };
+const semanticInitializationLocks = new Map();
+async function ensureBoundContextTaskWithSemantics(input, engines, dependencies) {
+    if (!input.intentArtifactHash)
+        return resolveBoundContextTaskWithSemantics(input, engines, dependencies);
+    const key = `${input.projectRoot}\0${input.intentArtifactHash}`;
+    const pending = semanticInitializationLocks.get(key);
+    if (pending)
+        return pending;
+    const current = resolveBoundContextTaskWithSemantics(input, engines, dependencies);
+    semanticInitializationLocks.set(key, current);
+    try {
+        return await current;
+    }
+    finally {
+        if (semanticInitializationLocks.get(key) === current)
+            semanticInitializationLocks.delete(key);
+    }
 }
-function logSemanticResolution(artifact, mode, resolution, projection) {
-    const event = resolution.frame.state === 'resolved'
-        ? 'semantic.resolution.completed'
-        : 'semantic.resolution.abstained';
+function logSemanticResolution(artifact, mode, resolution) {
+    const event = resolution.facts.conflicts.length === 0
+        ? 'semantic.resolution.completed' : 'semantic.resolution.abstained';
     emitSemanticControlLog({
         event, identity: { ...artifact.identity, intentArtifactHash: artifact.artifactHash },
-        level: resolution.frame.state === 'resolved' ? 'info' : 'warn', timestamp: Date.now(),
+        level: resolution.facts.conflicts.length === 0 ? 'info' : 'warn', timestamp: Date.now(),
         data: {
-            mode, frameHash: resolution.frame.frameHash, state: resolution.frame.state,
-            permission: resolution.frame.mutationPermission, intent: projection.intent,
-            action: projection.action, samplingStatus: resolution.sampling.status,
-            conflictCount: resolution.conflicts.length,
+            mode, factsHash: resolution.facts.factsHash,
+            mutation: resolution.actionAuthority.mutation,
+            intents: resolution.facts.intents,
+            actions: resolution.facts.actions,
+            samplingStatus: resolution.sampling.status,
+            conflictCount: resolution.facts.conflicts.length,
         },
     });
-    if (resolution.conflicts.length > 0)
+    if (resolution.facts.conflicts.length > 0)
         emitSemanticControlLog({
             event: 'semantic.authority.conflicted', identity: artifact.identity, level: 'warn', timestamp: Date.now(),
-            data: { frameHash: resolution.frame.frameHash, conflicts: resolution.conflicts },
+            data: { factsHash: resolution.facts.factsHash, conflicts: resolution.facts.conflicts },
         });
-    if (projection.intent !== artifact.intent || projection.action !== artifact.action)
-        emitSemanticControlLog({
-            event: 'semantic.regex.shadow_mismatch', identity: artifact.identity, level: 'info', timestamp: Date.now(),
-            data: { mode, frameHash: resolution.frame.frameHash, legacyIntent: artifact.intent,
-                legacyAction: artifact.action, semanticIntent: projection.intent, semanticAction: projection.action },
-        });
-}
-function toTaskIntentRecord(artifact) {
-    return {
-        ...artifact.identity, version: artifact.version, supersedesHash: artifact.supersedesHash,
-        rawPrompt: artifact.rawPrompt, normalizedPrompt: artifact.normalizedPrompt,
-        command: artifact.command, slashArgs: artifact.slashArgs, activeSkill: artifact.activeSkill,
-        intent: artifact.intent, action: artifact.action, entities: artifact.entities,
-        targetAnchors: artifact.targetAnchors, policyConstraints: artifact.policyConstraints,
-        classificationEvidence: artifact.classificationEvidence.map(item => ({ ...item })),
-        sourceEventIds: artifact.sourceEventIds, sourceHash: artifact.sourceHash,
-        artifactHash: artifact.artifactHash, createdAt: artifact.createdAt,
-    };
-}
-function toChannelQueryPlanRecord(plan) {
-    return {
-        ...plan.identity, sourceIntentHash: plan.sourceIntentHash, planHash: plan.planHash,
-        code: plan.code.map(item => ({ ...item })), memory: plan.memory.map(item => ({ ...item })),
-        knowledge: plan.knowledge.map(item => ({ ...item })), generatedBy: plan.generatedBy,
-        ...(plan.degradation ? { degradation: { ...plan.degradation } } : {}), createdAt: plan.createdAt,
-    };
-}
-function toSdkIntentArtifact(record) {
-    return {
-        identity: { projectRoot: record.projectRoot, projectId: record.projectId, hostId: record.hostId,
-            sessionId: record.sessionId, turnId: record.turnId, requestId: record.requestId,
-            ...(record.executionId ? { executionId: record.executionId } : {}) },
-        version: record.version, ...(record.supersedesHash ? { supersedesHash: record.supersedesHash } : {}),
-        rawPrompt: record.rawPrompt, normalizedPrompt: record.normalizedPrompt,
-        ...(record.command ? { command: record.command } : {}), slashArgs: record.slashArgs,
-        ...(record.activeSkill ? { activeSkill: record.activeSkill } : {}), intent: record.intent,
-        action: record.action, entities: record.entities, targetAnchors: record.targetAnchors,
-        policyConstraints: record.policyConstraints, classificationEvidence: record.classificationEvidence,
-        sourceEventIds: record.sourceEventIds, sourceHash: record.sourceHash,
-        artifactHash: record.artifactHash, createdAt: record.createdAt,
-    };
-}
-function toSdkChannelQueryPlan(record) {
-    return { identity: { projectRoot: record.projectRoot, projectId: record.projectId, hostId: record.hostId,
-            sessionId: record.sessionId, turnId: record.turnId, requestId: record.requestId,
-            ...(record.executionId ? { executionId: record.executionId } : {}) },
-        sourceIntentHash: record.sourceIntentHash, planHash: record.planHash, code: record.code,
-        memory: record.memory, knowledge: record.knowledge, generatedBy: record.generatedBy,
-        ...(record.degradation ? { degradation: record.degradation } : {}), createdAt: record.createdAt };
-}
-function hashCanonical(value) {
-    return createHash('sha256').update(stableCanonicalJson(value)).digest('hex');
-}
-function stableCanonicalJson(value) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean')
-        return JSON.stringify(value);
-    if (typeof value === 'number')
-        return Number.isFinite(value) ? JSON.stringify(value) : 'null';
-    if (Array.isArray(value))
-        return `[${value.map(stableCanonicalJson).join(',')}]`;
-    if (!value || typeof value !== 'object')
-        return JSON.stringify(String(value));
-    const record = value;
-    return `{${Object.keys(record).sort().filter(key => record[key] !== undefined)
-        .map(key => `${JSON.stringify(key)}:${stableCanonicalJson(record[key])}`).join(',')}}`;
 }
 function stripArtifactCommand(prompt, command) {
     if (!command)
@@ -935,9 +812,41 @@ function stripArtifactCommand(prompt, command) {
 export function createToolHandlers(engines, boundProjectRoot, dependencies = {}) {
     const hasBoundProjectRoot = typeof boundProjectRoot === 'string' && boundProjectRoot.trim().length > 0;
     const canonicalProjectRoot = canonicalizeProjectRoot(String(boundProjectRoot ?? process.cwd()));
-    // Resolution is invoked by the rollout-aware context path in the next stage.
-    // Retaining the injected dependency here keeps handler construction backward compatible.
-    void dependencies.semanticSampling;
+    const taskEvidence = dependencies.taskEvidence ?? {
+        load: loadSemanticExecutionContext,
+        query: queryAuthoritativeTaskEvidence,
+    };
+    async function authoritativeEvidence(projection, runtime) {
+        const sessionId = typeof runtime.sessionId === 'string' ? runtime.sessionId : undefined;
+        const turnId = typeof runtime.turnId === 'string' ? runtime.turnId : undefined;
+        if (!sessionId || !turnId) {
+            return {
+                status: 'unavailable',
+                authority: 'authoritative_task',
+                reasonCode: 'task_identity_required',
+            };
+        }
+        const loaded = taskEvidence.load({ projectRoot: canonicalProjectRoot, sessionId, turnId });
+        if (!loaded) {
+            return {
+                status: 'unavailable',
+                authority: 'authoritative_task',
+                reasonCode: 'task_evidence_unavailable',
+            };
+        }
+        const result = await taskEvidence.query({
+            engines,
+            request: {
+                schemaVersion: 'authoritative-task-evidence-request.v1',
+                identity: loaded.context.identity,
+                taskRevision: loaded.definition.revision,
+                semanticContextHash: loaded.context.contextHash,
+                requestedProjection: projection,
+            },
+            ...(dependencies.evidenceReranker ? { reranker: dependencies.evidenceReranker } : {}),
+        });
+        return result;
+    }
     function getFreshnessMs() {
         try {
             const stats = engines.codegraph.getStats();
@@ -948,8 +857,8 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
         }
     }
     const handlers = {
-        get_project_context: async ({ query, mode, expandedTerms, retrievalSessionId, baselineReceipt, missingContext, _devflow_session_id, _devflow_execution_id, _devflow_request_id, _devflow_turn_id, _devflow_intent_artifact_hash, _devflow_active_skill, activeSkill }) => {
-            const boundTask = await resolveBoundContextTaskWithSemantics({
+        get_project_context: async ({ query, budgetTokens, mode, expandedTerms, retrievalSessionId, baselineReceipt, missingContext, _devflow_session_id, _devflow_execution_id, _devflow_request_id, _devflow_turn_id, _devflow_intent_artifact_hash, _devflow_active_skill, activeSkill }) => {
+            const boundTask = await ensureBoundContextTaskWithSemantics({
                 projectRoot: canonicalProjectRoot,
                 sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : undefined,
                 requestId: typeof _devflow_request_id === 'string' ? _devflow_request_id : undefined,
@@ -958,26 +867,28 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 agentQuery: query,
                 expandedTerms: typeof expandedTerms === 'string' ? expandedTerms : undefined,
             }, engines, dependencies);
-            return getProjectContextResult(engines.context, {
-                query: boundTask.query,
-                mode: mode ?? "fast",
-                expandedTerms: boundTask.expandedTerms,
-                retrievalSessionId: typeof retrievalSessionId === 'string' ? retrievalSessionId : undefined,
-                baselineReceipt: typeof baselineReceipt === 'string' ? baselineReceipt : undefined,
-                missingContext: Array.isArray(missingContext) ? missingContext : undefined,
-                sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : process.env.DEVFLOW_SESSION_ID ?? undefined,
-                executionId: typeof _devflow_execution_id === 'string' ? _devflow_execution_id : undefined,
-                requestId: boundTask.requestId,
+            const sessionId = typeof _devflow_session_id === 'string'
+                ? _devflow_session_id : process.env.DEVFLOW_SESSION_ID ?? undefined;
+            const semantic = loadSemanticExecutionContext({
+                projectRoot: canonicalProjectRoot,
+                sessionId,
                 turnId: boundTask.turnId,
-                intentArtifact: boundTask.intentArtifact,
-                queryPlan: boundTask.queryPlan,
-                activeSkill: boundTask.intentArtifact?.activeSkill ?? (typeof _devflow_active_skill === 'string'
-                    ? _devflow_active_skill
-                    : typeof activeSkill === 'string' ? activeSkill : undefined),
-                projectRoot: boundProjectRoot,
-                host: 'claude-code',
-                command: boundTask.intentArtifact?.command ?? 'devflow:context',
-            }, getFreshnessMs());
+            });
+            if (semantic) {
+                return retrieveProjectEvidence({
+                    engines,
+                    context: semantic.context,
+                    definition: semantic.definition,
+                    ...(typeof budgetTokens === 'number' ? { tokenBudget: budgetTokens } : {}),
+                    query: boundTask.query,
+                    ...(dependencies.evidenceReranker ? { reranker: dependencies.evidenceReranker } : {}),
+                });
+            }
+            return {
+                status: 'unavailable',
+                authority: 'authoritative_task',
+                reasonCode: 'semantic_execution_context_unavailable',
+            };
         },
         search_symbol: async ({ symbol }) => {
             const result = await engines.indexer.findSymbol(symbol);
@@ -1018,7 +929,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                     _accuracy: {
                         data_freshness_ms: getFreshnessMs(),
                         source_layer: "codegraph",
-                        degradation: "fallback",
+                        execution_status: "unavailable",
                     },
                     seeds: [t],
                     depth: d,
@@ -1038,7 +949,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 _accuracy: {
                     data_freshness_ms: getFreshnessMs(),
                     source_layer: "codegraph",
-                    degradation: result.edges.length === 0 && result.nodes.length > 0 ? "partial" : "none",
+                    execution_status: result.edges.length === 0 && result.nodes.length > 0 ? "unavailable" : "executed",
                 },
             };
         },
@@ -1126,7 +1037,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 },
             };
         },
-        devflow_report_step: async ({ runId, stepId, status, output, duration, contextReceipt, executionId, toolUseIds, changedFiles, verification, _devflow_session_id, _devflow_execution_id, }) => {
+        devflow_report_step: async ({ runId, stepId, status, output, duration, changedFiles, verification, _devflow_session_id, _devflow_execution_id, _devflow_tool_use_id, }) => {
             const canonicalRunId = String(runId ?? '').trim();
             const canonicalStepId = String(stepId ?? '').trim();
             if (!canonicalRunId || !canonicalStepId) {
@@ -1185,29 +1096,30 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 if (!hostRun || !hostStep) {
                     return rejectedToolResult('WORKFLOW_ENGINE_MAPPING_MISSING', 'The workflow engine run mapping is unavailable.', false);
                 }
-                const canonicalExecutionId = typeof executionId === 'string'
-                    ? executionId.trim()
-                    : typeof _devflow_execution_id === 'string' ? _devflow_execution_id.trim() : '';
-                const canonicalReceipt = typeof contextReceipt === 'string' ? contextReceipt.trim() : '';
                 const sessionId = typeof _devflow_session_id === 'string' ? _devflow_session_id.trim() : '';
-                const activeReceipt = sessionId && canonicalExecutionId
-                    ? database.getActiveContextReceipt(canonicalProjectRoot, sessionId, canonicalExecutionId)
-                    : null;
-                if (!canonicalReceipt || canonicalReceipt !== action.contextReceipt || activeReceipt?.contextHash !== canonicalReceipt) {
-                    return rejectedToolResult('STALE_CONTEXT_RECEIPT', 'A current context receipt bound to this execution is required.', true);
+                const canonicalExecutionId = typeof _devflow_execution_id === 'string'
+                    ? _devflow_execution_id.trim() : '';
+                const canonicalToolUseId = typeof _devflow_tool_use_id === 'string'
+                    ? _devflow_tool_use_id.trim() : '';
+                if (!sessionId || !canonicalExecutionId || !canonicalToolUseId) {
+                    return rejectedToolResult('WORKFLOW_IDENTITY_MISSING', 'Canonical session, execution, and tool-use identity are required.', false);
+                }
+                if (sessionId !== action.sessionId || canonicalExecutionId !== action.executionId) {
+                    return rejectedToolResult('WORKFLOW_ACTION_IDENTITY_MISMATCH', 'The canonical report identity does not match the host action.', false);
                 }
-                if (!canonicalExecutionId || canonicalExecutionId !== action.executionId) {
-                    return rejectedToolResult('EXECUTION_ID_MISMATCH', 'The report execution does not match the host action.', false);
+                const activeReceipt = database.getActiveContextReceipt(canonicalProjectRoot, sessionId, canonicalExecutionId);
+                if (!activeReceipt || activeReceipt.contextHash !== action.contextReceipt) {
+                    return rejectedToolResult('STALE_CONTEXT_RECEIPT', 'The host action is not bound to the active context receipt.', true);
                 }
                 const files = sanitizeChangedFiles(canonicalProjectRoot, changedFiles);
-                const tools = boundedStringArray(toolUseIds);
+                const tools = [canonicalToolUseId];
                 const verificationRecord = verification && typeof verification === 'object' && !Array.isArray(verification)
                     ? verification
                     : undefined;
                 const report = {
                     status: requestedStatus,
                     summary: typeof output === 'string' ? output.trim().slice(0, 4000) : '',
-                    contextReceipt: canonicalReceipt,
+                    contextReceipt: activeReceipt.contextHash,
                     executionId: canonicalExecutionId,
                     toolUseIds: tools.sort(),
                     changedFiles: files.sort(),
@@ -1223,6 +1135,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 };
                 const evidenceHash = workflowEvidenceHash(report);
                 let terminal;
+                let retrievalProof;
                 if (requestedStatus === 'failed') {
                     terminal = database.failHostAction({
                         actionId: action.actionId,
@@ -1283,6 +1196,17 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                         report,
                         evidenceHash,
                     });
+                    if (actionKind === 'verify') {
+                        retrievalProof = database.verifyReceiptBoundRetrieval({
+                            projectRoot: canonicalProjectRoot,
+                            sessionId,
+                            executionId: canonicalExecutionId,
+                            contextReceipt: activeReceipt.contextHash,
+                            toolUseId: canonicalToolUseId,
+                            verificationReceipt: evidenceHash,
+                            verifiedAt: finishedAt,
+                        });
+                    }
                 }
                 let telemetryDegraded = false;
                 try {
@@ -1295,7 +1219,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 return {
                     ok: true,
                     acknowledged: true,
-                    status: telemetryDegraded ? 'degraded' : 'accepted',
+                    status: 'accepted',
                     runId: canonicalRunId,
                     stepId: canonicalStepId,
                     receipt: {
@@ -1303,8 +1227,11 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                         evidenceHash,
                         stepState: terminal.state,
                         runState: resumed.metadata?.canonicalStatus,
+                        ...(retrievalProof ? { retrievalProof } : {}),
                     },
-                    ...(telemetryDegraded ? { degradation: { reason: 'telemetry_write_failed', fallback: 'durable_host_action' } } : {}),
+                    ...(telemetryDegraded ? { warnings: [{
+                                code: 'TELEMETRY_WRITE_FAILED', message: 'Host action was accepted but telemetry persistence failed.',
+                            }] } : {}),
                 };
             }
             catch (error) {
@@ -1329,15 +1256,29 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 steps: run.steps.map(step => ({ ...step, stepId: step.stepId ?? step.name })),
             };
         },
-        get_memory: async ({ query, purpose, budgetTokens, scopes, _devflow_session_id, _devflow_execution_id, _devflow_request_id }) => getMemoryResult(engines.memory, {
-            query: typeof query === "string" ? query : undefined,
-            purpose: typeof purpose === "string" ? purpose : undefined,
-            budgetTokens: typeof budgetTokens === "number" ? budgetTokens : undefined,
-            scopes: Array.isArray(scopes) ? scopes.filter((scope) => typeof scope === 'string') : undefined,
-            sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : undefined,
-            executionId: typeof _devflow_execution_id === 'string' ? _devflow_execution_id : undefined,
-            requestId: typeof _devflow_request_id === 'string' ? _devflow_request_id : undefined,
-        }),
+        get_memory: async ({ query, purpose, budgetTokens, scopes, _devflow_session_id, _devflow_execution_id, _devflow_request_id, _devflow_turn_id, _devflow_intent_artifact_hash }) => {
+            await ensureBoundContextTaskWithSemantics({
+                projectRoot: canonicalProjectRoot,
+                sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : undefined,
+                requestId: typeof _devflow_request_id === 'string' ? _devflow_request_id : undefined,
+                turnId: typeof _devflow_turn_id === 'string' ? _devflow_turn_id : undefined,
+                intentArtifactHash: typeof _devflow_intent_artifact_hash === 'string' ? _devflow_intent_artifact_hash : undefined,
+                agentQuery: typeof query === 'string' ? query : '',
+            }, engines, dependencies);
+            const authoritative = await authoritativeEvidence('memory', {
+                sessionId: _devflow_session_id,
+                executionId: _devflow_execution_id,
+                requestId: _devflow_request_id,
+                turnId: _devflow_turn_id,
+            });
+            if (authoritative.status === 'unavailable')
+                return authoritative;
+            const [project, user] = await Promise.all([
+                engines.memory.getProjectContext(),
+                engines.memory.getUserPreferences(),
+            ]);
+            return projectTaskMemoryResult(authoritative.receipt, { project, user });
+        },
         memory_request_distill: async ({ sessionId, batchId, page, pageSize }) => {
             const memory = engines.memory;
             const requestedPage = typeof page === "number" && Number.isFinite(page) ? page : 0;
@@ -1402,7 +1343,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 const memory = engines.memory;
                 if (pending.status === 'pending' && recovery?.operation === 'commit_explicit' && recovery.explicitContent?.trim()) {
                     await ensureMemoryTurnEvent(memory, pending, recovery);
-                    const saved = await memory.saveExplicitMemoryIntent(recovery.explicitContent.trim(), sessionId, pending.eventId);
+                    const saved = await memory.saveExplicitMemoryIntent(recovery.explicitContent.trim(), { actorId: 'actor:mcp-host', sessionId }, pending.eventId);
                     const recoveredMemoryIds = [...new Set([saved.id, ...(saved.relatedMemoryIds ?? [])])];
                     const receipt = commitMemoryReceipt(database, pending, recoveredMemoryIds, 'explicit_intent', 'explicit_user_request_mcp_recovery');
                     if (memory.finalizeTurnDecision && receipt.receiptId) {
@@ -1467,13 +1408,13 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                     if (explicitRefinement) {
                         return {
                             ...replayMemoryDecision(pending),
-                            status: 'degraded',
+                            status: 'accepted',
                             replayed: false,
                             refined: false,
-                            degradation: {
-                                reason: 'invalid_host_refinement_candidates',
-                                fallback: 'deterministic_explicit_memory',
-                            },
+                            warnings: [{
+                                    code: 'INVALID_HOST_REFINEMENT_CANDIDATES',
+                                    message: 'The explicit memory remains committed; host refinement candidates were rejected.',
+                                }],
                             rejectedCandidates: validation.rejected,
                         };
                     }
@@ -1500,18 +1441,20 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                     sourceEventIds: candidate.sourceEventIds,
                     evidenceSpans: candidate.evidenceSpans,
                     disposition: candidate.disposition,
+                    operation: candidate.operation,
+                    referencedFactIds: candidate.referencedFactIds,
                 }));
                 await ensureMemoryTurnEvent(memory, pending, recovery);
                 if (explicitRefinement) {
                     if (!memory.refineExplicitTurnObservations) {
                         return {
                             ...replayMemoryDecision(pending),
-                            status: 'degraded',
+                            status: 'accepted',
                             replayed: false,
-                            degradation: {
-                                reason: 'explicit_refinement_unavailable',
-                                fallback: 'deterministic_explicit_memory',
-                            },
+                            warnings: [{
+                                    code: 'EXPLICIT_REFINEMENT_UNAVAILABLE',
+                                    message: 'The explicit memory remains committed; host refinement is unavailable.',
+                                }],
                         };
                     }
                     try {
@@ -1570,7 +1513,7 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                                 refinedMemoryIds,
                                 retiredMemoryIds: refined.retiredMemoryIds,
                                 operations: refined.operations,
-                                fallbackReceiptPreserved: true,
+                                explicitReceiptPreserved: true,
                             },
                         };
                     }
@@ -1583,22 +1526,22 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                             metadata: {
                                 projectRoot: String(projectRoot), sessionId, turnId: pending.turnId,
                                 receiptId: pending.receiptId, reason,
-                                fallback: 'deterministic_explicit_memory',
+                                warningCode: 'EXPLICIT_REFINEMENT_FAILED',
                             },
                         });
                         emitSemanticControlLog({
-                            event: 'memory.write.degraded',
+                            event: 'memory.write.completed',
                             identity: { projectRoot: String(projectRoot), sessionId, turnId: pending.turnId },
                             level: 'warn',
                             timestamp: Date.now(),
-                            data: { stage: 'explicit_host_refinement', reason, fallback: 'deterministic_explicit_memory' },
+                            data: { stage: 'explicit_host_refinement', reason, warningCode: 'EXPLICIT_REFINEMENT_FAILED' },
                         });
                         return {
                             ...replayMemoryDecision(pending),
-                            status: 'degraded',
+                            status: 'accepted',
                             replayed: false,
                             refined: false,
-                            degradation: { reason, fallback: 'deterministic_explicit_memory' },
+                            warnings: [{ code: 'EXPLICIT_REFINEMENT_FAILED', message: reason }],
                         };
                     }
                 }
@@ -1806,10 +1749,13 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 }
                 catch (error) {
                     emitSemanticControlLog({
-                        event: 'memory.write.degraded',
+                        event: 'memory.write.completed',
                         identity: { projectRoot: canonicalProjectRoot, sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : undefined },
                         level: 'warn', timestamp: Date.now(),
-                        data: { stage: 'distill_vector_enqueue', batchId, reason: error.message, fallback: 'lexical_memory_ready' },
+                        data: {
+                            stage: 'distill_vector_enqueue', batchId, reason: error.message,
+                            warningCode: 'VECTOR_BACKFILL_ENQUEUE_FAILED',
+                        },
                     });
                 }
                 finally {
@@ -1832,11 +1778,25 @@ export function createToolHandlers(engines, boundProjectRoot, dependencies = {})
                 },
             };
         },
-        get_knowledge: async ({ query, scope, budgetTokens }) => getKnowledgeResult(engines.knowledge, {
-            query: query,
-            scope: typeof scope === 'string' ? scope : undefined,
-            budgetTokens: typeof budgetTokens === 'number' ? budgetTokens : undefined,
-        }),
+        get_knowledge: async ({ query, scope, budgetTokens, _devflow_session_id, _devflow_execution_id, _devflow_request_id, _devflow_turn_id, _devflow_intent_artifact_hash }) => {
+            await ensureBoundContextTaskWithSemantics({
+                projectRoot: canonicalProjectRoot,
+                sessionId: typeof _devflow_session_id === 'string' ? _devflow_session_id : undefined,
+                requestId: typeof _devflow_request_id === 'string' ? _devflow_request_id : undefined,
+                turnId: typeof _devflow_turn_id === 'string' ? _devflow_turn_id : undefined,
+                intentArtifactHash: typeof _devflow_intent_artifact_hash === 'string' ? _devflow_intent_artifact_hash : undefined,
+                agentQuery: typeof query === 'string' ? query : '',
+            }, engines, dependencies);
+            const authoritative = await authoritativeEvidence('knowledge', {
+                sessionId: _devflow_session_id,
+                executionId: _devflow_execution_id,
+                requestId: _devflow_request_id,
+                turnId: _devflow_turn_id,
+            });
+            if (authoritative.status === 'unavailable')
+                return authoritative;
+            return projectTaskKnowledgeResult(authoritative.receipt);
+        },
         devflow_report_event: async (args) => {
             const truncate = (s, max) => {
                 if (!s || s.length <= max)