fuli-context 0.2.0 → 0.4.0

package/src/graphiti/federated-application.js

@@ -23,6 +23,23 @@ import {
   sourceConsoleUrl
 } from './source-marker.js';
 import { resolvePersonalProjectPath } from './project-path-context.js';
+import { TaskContextRegistry } from '../mcp/task-context-registry.js';
+import {
+  agentProjectResolution,
+  beginTaskContext as beginTaskContextWorkflow,
+  checkpointTaskKnowledge as checkpointTaskKnowledgeWorkflow,
+  discoverCommonKnowledgeCandidates as discoverCommonKnowledgeCandidatesWorkflow,
+  providerCommonKnowledgePromotion,
+  recordDecisionTrace as recordDecisionTraceWorkflow,
+  recordKnowledgeFeedback as recordKnowledgeFeedbackWorkflow,
+  searchCurrentProjectKnowledge as searchCurrentProjectKnowledgeWorkflow
+} from './agent-knowledge-workflows.js';
+import {
+  assertPublicKnowledgeEligible,
+  providerConfirmationActor,
+  providerConfirmationBasis,
+  providerEpisode
+} from './knowledge-provider-mapping.js';
 
 export function openFederatedGraphApplication({
   runtimeConfigPath,
@@ -51,7 +68,9 @@ export class FederatedGraphApplication {
     capturePolicyStore = new CapturePolicyStore(),
     agentAccessPolicyStore = new AgentAccessPolicyStore(),
     consoleUrl = sourceConsoleUrl(null),
-    projectPathResolver = resolvePersonalProjectPath
+    projectPathResolver = resolvePersonalProjectPath,
+    taskContextRegistry = new TaskContextRegistry(),
+    providerRequestTimeoutMs = undefined
   } = {}) {
     this.graphiti = true;
     this.config = config;
@@ -59,10 +78,12 @@ export class FederatedGraphApplication {
     this.agentAccessPolicyStore = agentAccessPolicyStore;
     this.consoleUrl = consoleUrl;
     this.projectPathResolver = projectPathResolver;
+    this.taskContextRegistry = taskContextRegistry;
     this.personal = new GraphitiProviderClient({
       baseUrl: config.personal.providerUrl,
       accessToken: config.personal.accessToken,
-      fetchImpl
+      fetchImpl,
+      requestTimeoutMs: providerRequestTimeoutMs
     });
     this.workspaces = new Map(
       config.workspaces.map((workspace) => {
@@ -72,13 +93,31 @@ export class FederatedGraphApplication {
           client: new GraphitiProviderClient({
             baseUrl: url,
             accessToken: workspace.accessToken,
-            fetchImpl
+            fetchImpl,
+            requestTimeoutMs: providerRequestTimeoutMs
           })
         }];
       })
     );
   }
 
+  async beginTaskContext(input) {
+    return beginTaskContextWorkflow(this, input);
+  }
+
+  async checkpointTaskKnowledge(input) {
+    return checkpointTaskKnowledgeWorkflow(this, input);
+  }
+
+  verifyTaskCheckpoint({ sessionId }) {
+    return this.taskContextRegistry.verify(sessionId);
+  }
+
+  async recordDecisionTrace(input) {
+    this.#assertActivePersonalSpace(input.personalSpaceId);
+    return recordDecisionTraceWorkflow(this, input);
+  }
+
   async captureSessionKnowledge(input) {
     const capturePolicy = this.getCapturePolicy();
     if (!capturePolicy.enabled) {
@@ -377,6 +416,36 @@ export class FederatedGraphApplication {
     };
   }
 
+  async searchCurrentProjectKnowledge(input) {
+    const resolution = await this.#resolvePreferenceProject({
+      personalProjectId: null,
+      projectPath: input.projectPath
+    });
+    return searchCurrentProjectKnowledgeWorkflow(this, resolution, input);
+  }
+
+  async discoverCommonKnowledgeCandidates(input) {
+    this.#assertActivePersonalSpace(input.personalSpaceId);
+    return discoverCommonKnowledgeCandidatesWorkflow(this, input);
+  }
+
+  async previewCommonKnowledgePromotion(input) {
+    this.#assertActivePersonalSpace(input.personalSpaceId);
+    assertSafeKnowledgeMutation(input);
+    return this.personal.previewCommonKnowledgePromotion(
+      providerCommonKnowledgePromotion(input)
+    );
+  }
+
+  async applyCommonKnowledgePromotion(input) {
+    this.#assertActivePersonalSpace(input.personalSpaceId);
+    assertSafeKnowledgeMutation(input);
+    return this.personal.applyCommonKnowledgePromotion({
+      ...providerCommonKnowledgePromotion(input),
+      operation_actor: input.operationActor ?? 'agent'
+    });
+  }
+
   async getKnowledgeGraph({
     spaceId,
     providerUrl = null,
@@ -425,6 +494,17 @@ export class FederatedGraphApplication {
     });
   }
 
+  async recordKnowledgeFeedback(input) {
+    this.#assertActivePersonalSpace(input.personalSpaceId);
+    assertSafeKnowledgeMutation({
+      items: input.items.map((item) => ({
+        existenceReason: item.reason,
+        quadrantReason: item.evidenceSummary
+      }))
+    });
+    return recordKnowledgeFeedbackWorkflow(this, input);
+  }
+
   async reviseKnowledgeItem(input) {
     this.#assertActivePersonalSpace(input.personalSpaceId);
     assertSafeKnowledgeMutation(input);
@@ -1039,22 +1119,11 @@ function preferenceConflictPairKey(leftId, rightId) {
   return [leftId, rightId].sort().join('\u0000');
 }
 
-function agentProjectResolution(resolution) {
-  const result = {
-    status: resolution.status,
-    basis: resolution.basis,
-    personal_project_id: resolution.personalProjectId
-  };
-  if (resolution.candidateCount !== undefined) {
-    result.candidate_count = resolution.candidateCount;
-  }
-  return result;
-}
-
 function assertNoCredentials(input) {
   const content = JSON.stringify({
     name: input.name,
     sourceDescription: input.sourceDescription,
+    sourceUri: input.sourceUri,
     sourceExcerpt: input.sourceExcerpt,
     summary: input.summary,
     entities: input.entities,
@@ -1120,6 +1189,7 @@ function assertSafeKnowledgeMutation(input) {
     note: input.note,
     newProjectName: input.newProjectName,
     newProjectPurpose: input.newProjectPurpose,
+    humanConfirmationReason: input.humanConfirmationReason,
     batchItems: input.items?.map((item) => ({
       existenceReason: item.existenceReason,
       quadrantReason: item.quadrantReason
@@ -1133,95 +1203,6 @@ function assertSafeKnowledgeMutation(input) {
   }
 }
 
-function providerEpisode(input) {
-  return {
-    idempotency_key: input.idempotencyKey,
-    session_id: input.sessionId,
-    name: input.name,
-    source_kind: input.sourceKind,
-    source_description: input.sourceDescription,
-    source_application: input.sourceApplication ?? null,
-    source_turn_id: input.sourceTurnId ?? null,
-    source_excerpt: input.sourceExcerpt ?? null,
-    reference_time: input.referenceTime,
-    summary: input.summary ?? '',
-    sensitivity: input.sensitivity ?? 'normal',
-    entities: input.entities.map((entity) => ({
-      key: entity.key,
-      name: entity.name,
-      type: entity.type,
-      summary: entity.summary ?? '',
-      origin_quadrant: entity.originQuadrant ?? 'known_known',
-      current_quadrant: entity.currentQuadrant ?? entity.originQuadrant ?? 'known_known',
-      epistemic_status: entity.epistemicStatus ?? 'confirmed',
-      confirmation_status: entity.confirmationStatus,
-      confirmation_basis: providerConfirmationBasis(entity.confirmationBasis),
-      reasoning_summary: entity.reasoningSummary ?? null,
-      profile_aspect: entity.profileAspect ?? null,
-      inheritance_mode: entity.inheritanceMode ?? 'local_only',
-      inherited_project_ids: entity.inheritedProjectIds ?? [],
-      attributes: entity.attributes ?? {}
-    })),
-    relationships: input.relationships.map((relationship) => ({
-      key: relationship.key,
-      source: relationship.source,
-      target: relationship.target,
-      type: relationship.type,
-      fact: relationship.fact,
-      valid_at: relationship.validAt ?? null,
-      invalid_at: relationship.invalidAt ?? null,
-      supersedes: relationship.supersedes ?? [],
-      confidence: relationship.confidence ?? 1,
-      origin_quadrant: relationship.originQuadrant ?? 'known_known',
-      current_quadrant: relationship.currentQuadrant ??
-        relationship.originQuadrant ?? 'known_known',
-      epistemic_status: relationship.epistemicStatus ?? 'confirmed',
-      confirmation_status: relationship.confirmationStatus,
-      confirmation_basis: providerConfirmationBasis(relationship.confirmationBasis),
-      reasoning_summary: relationship.reasoningSummary ?? null,
-      profile_aspect: relationship.profileAspect ?? null,
-      inheritance_mode: relationship.inheritanceMode ?? 'local_only',
-      inherited_project_ids: relationship.inheritedProjectIds ?? [],
-      attributes: relationship.attributes ?? {}
-    }))
-  };
-}
-
-function assertPublicKnowledgeEligible(episode) {
-  const blocked = [...episode.entities, ...episode.relationships].find((item) =>
-    item.profile_aspect ||
-    item.confirmation_status !== 'confirmed' ||
-    !item.confirmation_basis?.confirmed_by ||
-    !item.confirmation_basis?.confirmed_at ||
-    !['user', 'authoritative_source'].includes(item.confirmation_basis.confirmed_by.kind)
-  );
-  if (blocked) {
-    throw new TypeError(
-      'Only knowledge with an auditable confirmation can enter public review'
-    );
-  }
-}
-
-function providerConfirmationBasis(basis) {
-  if (!basis) return undefined;
-  return {
-    existence_reason: basis.existenceReason,
-    quadrant_reason: basis.quadrantReason,
-    proposed_by: providerConfirmationActor(basis.proposedBy),
-    confirmed_by: providerConfirmationActor(basis.confirmedBy),
-    confirmed_at: basis.confirmedAt ?? null,
-    agent_policy_version: basis.agentPolicyVersion ?? null
-  };
-}
-
-function providerConfirmationActor(actor) {
-  if (!actor) return null;
-  return {
-    kind: actor.kind,
-    label: actor.label ?? null
-  };
-}
-
 function providerProjectProfile(profile) {
   if (!profile || typeof profile !== 'object') throw new TypeError('Project profile is required');
   const assessment = profile.assessment ? sanitizeProjectAssessment(profile.assessment) : null;

package/src/graphiti/knowledge-provider-mapping.js

@@ -0,0 +1,91 @@
+import { onlineSourceUri } from './source-uri.js';
+
+export function providerEpisode(input) {
+  return {
+    idempotency_key: input.idempotencyKey,
+    session_id: input.sessionId,
+    name: input.name,
+    source_kind: input.sourceKind,
+    source_description: input.sourceDescription,
+    source_uri: onlineSourceUri(input.sourceUri),
+    source_application: input.sourceApplication ?? null,
+    source_turn_id: input.sourceTurnId ?? null,
+    source_excerpt: input.sourceExcerpt ?? null,
+    reference_time: input.referenceTime,
+    summary: input.summary ?? '',
+    sensitivity: input.sensitivity ?? 'normal',
+    entities: input.entities.map((entity) => ({
+      key: entity.key,
+      name: entity.name,
+      type: entity.type,
+      summary: entity.summary ?? '',
+      origin_quadrant: entity.originQuadrant ?? 'known_known',
+      current_quadrant: entity.currentQuadrant ?? entity.originQuadrant ?? 'known_known',
+      epistemic_status: entity.epistemicStatus ?? 'confirmed',
+      confirmation_status: entity.confirmationStatus,
+      confirmation_basis: providerConfirmationBasis(entity.confirmationBasis),
+      reasoning_summary: entity.reasoningSummary ?? null,
+      profile_aspect: entity.profileAspect ?? null,
+      inheritance_mode: entity.inheritanceMode ?? 'local_only',
+      inherited_project_ids: entity.inheritedProjectIds ?? [],
+      attributes: entity.attributes ?? {}
+    })),
+    relationships: input.relationships.map((relationship) => ({
+      key: relationship.key,
+      source: relationship.source,
+      target: relationship.target,
+      type: relationship.type,
+      fact: relationship.fact,
+      valid_at: relationship.validAt ?? null,
+      invalid_at: relationship.invalidAt ?? null,
+      supersedes: relationship.supersedes ?? [],
+      confidence: relationship.confidence ?? 1,
+      origin_quadrant: relationship.originQuadrant ?? 'known_known',
+      current_quadrant: relationship.currentQuadrant ??
+        relationship.originQuadrant ?? 'known_known',
+      epistemic_status: relationship.epistemicStatus ?? 'confirmed',
+      confirmation_status: relationship.confirmationStatus,
+      confirmation_basis: providerConfirmationBasis(relationship.confirmationBasis),
+      reasoning_summary: relationship.reasoningSummary ?? null,
+      profile_aspect: relationship.profileAspect ?? null,
+      inheritance_mode: relationship.inheritanceMode ?? 'local_only',
+      inherited_project_ids: relationship.inheritedProjectIds ?? [],
+      attributes: relationship.attributes ?? {}
+    }))
+  };
+}
+
+export function assertPublicKnowledgeEligible(episode) {
+  const blocked = [...episode.entities, ...episode.relationships].find((item) =>
+    item.profile_aspect ||
+    item.confirmation_status !== 'confirmed' ||
+    !item.confirmation_basis?.confirmed_by ||
+    !item.confirmation_basis?.confirmed_at ||
+    !['user', 'authoritative_source'].includes(item.confirmation_basis.confirmed_by.kind)
+  );
+  if (blocked) {
+    throw new TypeError(
+      'Only knowledge with an auditable confirmation can enter public review'
+    );
+  }
+}
+
+export function providerConfirmationBasis(basis) {
+  if (!basis) return undefined;
+  return {
+    existence_reason: basis.existenceReason,
+    quadrant_reason: basis.quadrantReason,
+    proposed_by: providerConfirmationActor(basis.proposedBy),
+    confirmed_by: providerConfirmationActor(basis.confirmedBy),
+    confirmed_at: basis.confirmedAt ?? null,
+    agent_policy_version: basis.agentPolicyVersion ?? null
+  };
+}
+
+export function providerConfirmationActor(actor) {
+  if (!actor) return null;
+  return {
+    kind: actor.kind,
+    label: actor.label ?? null
+  };
+}

package/src/graphiti/provider-client.js

@@ -133,6 +133,11 @@ export class GraphitiProviderClient {
       method: 'POST', body: input
     });
   }
+  recordKnowledgeFeedback(input) {
+    return this.#request('/v1/knowledge/feedback', {
+      method: 'POST', body: input
+    });
+  }
   reviewHumanChange(itemId, input) {
     return this.#request(
       `/v1/knowledge/items/${encodeURIComponent(itemId)}/agent-review`,
@@ -161,6 +166,16 @@ export class GraphitiProviderClient {
       { method: 'POST', body: input }
     );
   }
+  previewCommonKnowledgePromotion(input) {
+    return this.#request('/v1/knowledge/common-promotions/preview', {
+      method: 'POST', body: input
+    });
+  }
+  applyCommonKnowledgePromotion(input) {
+    return this.#request('/v1/knowledge/common-promotions', {
+      method: 'POST', body: input
+    });
+  }
   deferPreferenceConflict(input) {
     return this.#request('/v1/preference-conflicts/defer', {
       method: 'POST', body: input

package/src/graphiti/source-marker.js

@@ -90,13 +90,7 @@ function sourceLeadMarkdown({ consoleUrl, citations }) {
 }
 
 function sourceMarkerMarkdown({ consoleUrl, citations }) {
-  if (!citations.length) {
-    return [
-      '**FULI 来源 · 未命中**',
-      '',
-      `- [打开 Fuli](${safeLoopbackOrigin(consoleUrl) ?? DEFAULT_CONSOLE_URL}/)`
-    ].join('\n');
-  }
+  if (!citations.length) return '';
   const shown = citations.slice(0, MAX_CITATIONS);
   const hidden = citations.length - shown.length;
   return [

package/src/graphiti/source-uri.js

@@ -0,0 +1,29 @@
+const SOURCE_URI_ERROR =
+  'Source URI must be an absolute HTTP(S) URI without credentials';
+
+export function onlineSourceUri(value) {
+  if (value === undefined || value === null) return null;
+  if (
+    typeof value !== 'string'
+    || value.length < 1
+    || value.length > 2048
+    || /(?:\s|\p{C})/u.test(value)
+  ) {
+    throw new TypeError(SOURCE_URI_ERROR);
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new TypeError(SOURCE_URI_ERROR);
+  }
+  if (
+    !['http:', 'https:'].includes(parsed.protocol)
+    || !parsed.hostname
+    || parsed.username
+    || parsed.password
+  ) {
+    throw new TypeError(SOURCE_URI_ERROR);
+  }
+  return value;
+}

package/src/http/static-handler.js

@@ -1,9 +1,10 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { extname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const PROJECT_ROOT = resolve(fileURLToPath(new URL('../..', import.meta.url)));
 export const WEB_ROOT = join(PROJECT_ROOT, 'dist', 'web');
+const FULI_LOGO_PATTERN = /^fuli-logo(?:-[A-Za-z0-9_-]+)?\.png$/;
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
   '.css': 'text/css; charset=utf-8',
@@ -18,8 +19,17 @@ const MIME_TYPES = {
 
 export function serveStatic(pathname, response) {
   if (pathname === '/favicon.ico') {
-    response.writeHead(204);
-    response.end();
+    const filePath = faviconFilePath();
+    if (!filePath) {
+      response.writeHead(204);
+      response.end();
+      return;
+    }
+    response.writeHead(200, {
+      'cache-control': 'public, max-age=86400',
+      'content-type': 'image/png'
+    });
+    response.end(readFileSync(filePath));
     return;
   }
 
@@ -50,6 +60,22 @@ export function serveStatic(pathname, response) {
   response.end(readFileSync(filePath));
 }
 
+function faviconFilePath() {
+  const directPath = join(WEB_ROOT, 'favicon.png');
+  if (existsSync(directPath)) return directPath;
+
+  const assetsPath = join(WEB_ROOT, 'assets');
+  if (!existsSync(assetsPath)) return null;
+  try {
+    const filename = readdirSync(assetsPath)
+      .sort()
+      .find((candidate) => FULI_LOGO_PATTERN.test(candidate));
+    return filename ? join(assetsPath, filename) : null;
+  } catch {
+    return null;
+  }
+}
+
 function shouldServeApplication(pathname) {
   return extname(pathname) === '' && !pathname.startsWith('/api/');
 }

package/src/mcp/common-knowledge-preview-tokens.js

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+
+import { ApplicationError } from '../app/application-error.js';
+
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+export function createCommonKnowledgePreviewTokens({
+  now = Date.now,
+  createToken = randomUUID,
+  ttlMs = DEFAULT_TTL_MS
+} = {}) {
+  const previews = new Map();
+
+  return Object.freeze({
+    issue(input) {
+      pruneExpired(previews, now());
+      const token = createToken();
+      previews.set(token, {
+        expiresAt: now() + ttlMs,
+        intent: promotionIntent(input)
+      });
+      return token;
+    },
+
+    consume(token, input) {
+      if (!token) {
+        throw new ApplicationError(
+          'preview_required',
+          'Preview this exact common-knowledge promotion before applying it'
+        );
+      }
+      const preview = previews.get(token);
+      if (!preview || preview.expiresAt <= now()) {
+        previews.delete(token);
+        throw new ApplicationError(
+          'preview_expired',
+          'Common-knowledge preview authorization is missing or expired'
+        );
+      }
+      if (preview.intent !== promotionIntent(input)) {
+        throw new ApplicationError(
+          'preview_mismatch',
+          'Common-knowledge promotion no longer matches its preview'
+        );
+      }
+      previews.delete(token);
+    }
+  });
+}
+
+function promotionIntent(input) {
+  return JSON.stringify({
+    personalSpaceId: input.personalSpaceId,
+    parentProjectId: input.parentProjectId,
+    itemKind: input.itemKind,
+    canonicalItemId: input.canonicalItemId,
+    duplicateItemIds: [...(input.duplicateItemIds ?? [])].sort(),
+    reason: input.reason,
+    humanConfirmationReason: input.humanConfirmationReason
+  });
+}
+
+function pruneExpired(previews, currentTime) {
+  for (const [token, preview] of previews) {
+    if (preview.expiresAt <= currentTime) previews.delete(token);
+  }
+}

package/src/mcp/create-mcp-server.js

@@ -5,13 +5,23 @@ import { callAgentTool, listAgentTools } from '../agent-tools.js';
 import { FULI_VERSION } from '../package-metadata.js';
 import { MCP_INSTRUCTIONS } from './instructions.js';
 import { createProjectActionPreviewTokens } from './project-action-preview-tokens.js';
+import { createCommonKnowledgePreviewTokens } from './common-knowledge-preview-tokens.js';
+import { auditLifecycleTool } from './lifecycle-audit.js';
 import { annotationsFor } from './tool-annotations.js';
-import { errorToolResult, protocolErrorResult, successToolResult } from './tool-result.js';
+import {
+  errorToolResult,
+  hookAdditionalContextToolResult,
+  protocolErrorResult,
+  successToolResult
+} from './tool-result.js';
 import { jsonSchemaToZod, openObjectSchema } from './tool-schema.js';
 
 const TOOL_RESULT_LIMIT_BYTES = Object.freeze({
+  begin_task_context: 16 * 1024,
   get_collaboration_preferences: 16 * 1024,
-  search_knowledge_graph: 32 * 1024
+  search_knowledge_graph: 32 * 1024,
+  search_current_project_knowledge: 64 * 1024,
+  discover_common_knowledge_candidates: 32 * 1024
 });
 
 export function createMcpServer(app) {
@@ -27,6 +37,7 @@ export function createMcpServer(app) {
 }
 
 function createToolMap(app, projectActionPreviews) {
+  const commonKnowledgePreviews = createCommonKnowledgePreviewTokens();
   return new Map(listAgentTools().map((definition) => [definition.name, {
     definition,
     schema: jsonSchemaToZod(definition.inputSchema),
@@ -34,7 +45,8 @@ function createToolMap(app, projectActionPreviews) {
       app,
       definition.name,
       input,
-      projectActionPreviews
+      projectActionPreviews,
+      commonKnowledgePreviews
     )
   }]));
 }
@@ -62,15 +74,29 @@ function registerCallHandler(server, tools) {
 
 async function invokeTool(tool, input) {
   try {
-    return successToolResult(await tool.invoke(input), {
-      limitBytes: TOOL_RESULT_LIMIT_BYTES[tool.definition.name]
-    });
+    const value = await tool.invoke(input);
+    auditLifecycleTool(tool.definition.name);
+    const limitBytes = TOOL_RESULT_LIMIT_BYTES[tool.definition.name];
+    if (tool.definition.name === 'begin_task_context') {
+      return hookAdditionalContextToolResult(value, {
+        hookEventName: 'UserPromptSubmit',
+        label: 'Fuli task context. Apply effective_preferences and use taskContextToken for the final checkpoint.',
+        limitBytes
+      });
+    }
+    return successToolResult(value, { limitBytes });
   } catch (error) {
     return errorToolResult(error);
   }
 }
 
-async function invokeAgentTool(app, name, input, projectActionPreviews) {
+async function invokeAgentTool(
+  app,
+  name,
+  input,
+  projectActionPreviews,
+  commonKnowledgePreviews
+) {
   if (name === 'preview_personal_project_action') {
     const result = await callAgentTool(app, name, input);
     return {
@@ -81,5 +107,15 @@ async function invokeAgentTool(app, name, input, projectActionPreviews) {
   if (name === 'apply_personal_project_action') {
     projectActionPreviews.consume(input.previewToken, input);
   }
+  if (name === 'preview_common_knowledge_promotion') {
+    const result = await callAgentTool(app, name, input);
+    return {
+      ...result,
+      previewToken: commonKnowledgePreviews.issue(input)
+    };
+  }
+  if (name === 'apply_common_knowledge_promotion') {
+    commonKnowledgePreviews.consume(input.previewToken, input);
+  }
   return callAgentTool(app, name, input);
 }

package/src/mcp/instructions.js

@@ -1,10 +1,9 @@
 export const MCP_INSTRUCTIONS = [
-  "Each user task: call exactly get_collaboration_preferences before other tools/answer with projectPath=cwd; never substitute a project action or Fuli tool. Apply all effective_preferences: personal-global everywhere plus only Fuli's matched project. Resolve relevant deferred_conflict via resolve_deferred_preference_conflict; ignore others. Pending is search-only. Never guess personalProjectId. Writes must enforce preferences in the actual payload; final text is not compliance.",
-  'Before claiming URLs, routes, requirements, prior decisions, or runbooks are unknown, call search_knowledge_graph; resolve IDs via list_knowledge_spaces/list_personal_projects.',
-  'Search personal-global profile, exact personalProjectId, inheritable knowledge reached via PART_OF or USES_KNOWLEDGE_FROM, named contextPersonalProjectIds, and relevant subscribed public project IDs. Never inherit project preferences or traverse RELATED_TO. Pending results stay marked. On a location miss, ask to widen to all registered local personal projects; use all_local_confirmed only after explicit confirmation. It never expands public projects.',
-  'After a confirmed all-local miss, search current repository or workspace files with Grep or rg. Never scan user home, filesystem root, outside the workspace, credentials, browser data, or unrelated repositories. Require deployment evidence for live URLs.',
-  'Changing/live: use monitoring or Git MCP',
-  'Silently batch via capture_session_knowledge under personalProjectId. Never store secrets, transcripts, or guesses. Only human/source confirmed knowledge enters public review. Final checkpoint: flush or retain nothing.',
-  'When personal knowledge affects the final answer/action, call record_knowledge_usage. Retrieval/injection never count; it creates at most agent_confirmed, never public eligibility.',
-  'Searches return terminal-safe Markdown. Final MUST begin with sourceMarker.leadMarkdown and append sourceMarker.markdown unchanged; without support use noMatchSourceMarker. Never wrap markers in HTML, rewrite them, or cite writes as reads.'
+  "Each user task: if begin_task_context supplied hook-provided task context, apply. Otherwise call exactly get_collaboration_preferences with projectPath=cwd before other tools/answer as the fallback; never substitute a project action or Fuli tool. Apply all effective_preferences: personal-global everywhere plus only Fuli's matched project. Resolve relevant deferred_conflict first. Never guess personalProjectId. Writes enforce preferences in the actual payload; final text is not compliance.",
+  'For current-project facts use search_current_project_knowledge: exact active child first, then inheritable parent knowledge via outgoing PART_OF/USES_KNOWLEDGE_FROM within two hops. Child stable keys override. Never inherit project preferences or traverse RELATED_TO.',
+  'Before claiming facts unknown, use search_knowledge_graph. Use exact IDs for extra projects; mark pending. Widen a location miss to all_local_confirmed only after consent, then use rg only in the safe current repo/workspace. Never scan outside it. Live URLs need deployment evidence; changing state needs monitoring/Git MCP.',
+  'Use record_decision_trace for confirmed choices/rationale/validation. Use record_knowledge_feedback when retained knowledge is rejected, contradicted, outdated, or fails validation; preserve history.',
+  'Batch durable confirmed knowledge via capture_session_knowledge in exact scope. Never store secrets, transcripts, or guesses. Only human/source confirmation permits public review. Finish a hook-managed task with checkpoint_task_knowledge once: capture_candidates or retain_nothing; fallback Agents likewise flush or retain nothing.',
+  'When personal knowledge materially affects the answer/action, call record_knowledge_usage. Retrieval/injection never counts; it creates at most agent_confirmed and is never public-eligible.',
+  'Terminal-safe Markdown. Final MUST begin with sourceMarker.leadMarkdown; append sourceMarker.markdown unchanged only on match. On miss use noMatchSourceMarker leadMarkdown only (empty markdown). Never wrap markers in HTML or cite writes.'
 ].join(' ');