fuli-context 0.4.0 → 0.7.2

package/src/local-runtime/lifecycle.js

@@ -4,22 +4,30 @@ import { existsSync, unlinkSync } from 'node:fs';
 import {
   checkLocalConsoleHealth,
   ensureGraphRuntime,
-  MANAGED_PERSONAL_PROVIDER_URL,
-  MANAGED_WORKSPACE_PROVIDER_URL,
   stopGraphProviders
 } from '../setup/graph-runtime.js';
 import { readJsonFile } from '../storage/json-file.js';
+import {
+  DEFAULT_RUNTIME_SETTINGS,
+  managedProviderUrls
+} from '../system/runtime-settings.js';
 
 export async function startLocalRuntime(input, dependencies = {}) {
   const deps = lifecycleDependencies(dependencies);
+  const runtimeSettings = input.runtimeSettings ?? DEFAULT_RUNTIME_SETTINGS;
   const config = deps.readConfig(input.paths.graphRuntimeConfigPath);
-  const managesDevelopmentWorkspace = hasManagedDevelopmentWorkspace(config);
+  const managesDevelopmentWorkspace = hasManagedDevelopmentWorkspace(
+    config,
+    runtimeSettings
+  );
   const buildProviders = input.rebuild === true || !config ||
     !deps.fileExists(input.paths.graphEnvPath);
   const runtime = await deps.ensureRuntime({
     paths: input.paths,
     personalSpaceName: input.personalSpaceName,
     port: input.port,
+    lan: input.lan === true,
+    runtimeSettings,
     personalOnly: !managesDevelopmentWorkspace,
     buildProviders,
     noStart: false,
@@ -36,12 +44,13 @@ export async function startLocalRuntime(input, dependencies = {}) {
 
 export async function stopLocalRuntime(input, dependencies = {}) {
   const deps = lifecycleDependencies(dependencies);
+  const runtimeSettings = input.runtimeSettings ?? DEFAULT_RUNTIME_SETTINGS;
   const config = deps.readConfig(input.paths.graphRuntimeConfigPath);
   const state = deps.readState(input.paths.graphRuntimeStatePath);
   const consoleResult = await stopRecordedConsole(state, input.paths, deps);
   const managesDevelopmentWorkspace = state?.managedProviders?.includes(
     'development-workspace'
-  ) || hasManagedDevelopmentWorkspace(config);
+  ) || hasManagedDevelopmentWorkspace(config, runtimeSettings);
 
   let providers = 'not_initialized';
   if (deps.fileExists(input.paths.graphEnvPath)) {
@@ -63,7 +72,7 @@ export async function stopLocalRuntime(input, dependencies = {}) {
 export async function restartLocalRuntime(input, dependencies = {}) {
   const stopped = await stopLocalRuntime(input, dependencies);
   if (stopped.status === 'partial') {
-    throw new Error('无法安全确认原本地界面的进程身份，已拒绝重启。');
+    throw new Error('Could not safely verify the existing local UI process; restart was refused.');
   }
   const started = await startLocalRuntime(input, dependencies);
   return { stopped, ...started, status: 'restarted' };
@@ -71,6 +80,7 @@ export async function restartLocalRuntime(input, dependencies = {}) {
 
 export async function inspectLocalRuntime(input, dependencies = {}) {
   const deps = lifecycleDependencies(dependencies);
+  const runtimeSettings = input.runtimeSettings ?? DEFAULT_RUNTIME_SETTINGS;
   const config = deps.readConfig(input.paths.graphRuntimeConfigPath);
   const state = deps.readState(input.paths.graphRuntimeStatePath);
   const stateLooksOwned = isRuntimeState(state) && isLoopbackConsoleUrl(state.url);
@@ -80,13 +90,14 @@ export async function inspectLocalRuntime(input, dependencies = {}) {
     state.pid,
     state.version
   );
-  const personalUrl = config?.personal?.providerUrl ?? MANAGED_PERSONAL_PROVIDER_URL;
+  const managedUrls = managedProviderUrls(runtimeSettings);
+  const personalUrl = config?.personal?.providerUrl ?? managedUrls.personal;
   const personal = config
     ? await deps.providerHealth(personalUrl)
     : { url: personalUrl, status: 'not_configured' };
   const workspaces = await Promise.all((config?.workspaces ?? []).map(async (workspace) => ({
     ...(await deps.providerHealth(workspace.providerUrl)),
-    managedDevelopment: isManagedDevelopmentUrl(workspace.providerUrl)
+    managedDevelopment: isManagedDevelopmentUrl(workspace, runtimeSettings)
   })));
 
   let status = 'stopped';
@@ -99,7 +110,10 @@ export async function inspectLocalRuntime(input, dependencies = {}) {
     console: {
       status: consoleReady ? 'ready' : processAlive ? 'unverified' : 'stopped',
       url: stateLooksOwned ? state.url : `http://127.0.0.1:${input.port}`,
-      pid: processAlive ? state.pid : null
+      pid: processAlive ? state.pid : null,
+      ...(stateLooksOwned && state.lan === true
+        ? { lan: true, lanUrls: safeLanUrls(state.lanUrls) }
+        : {})
     },
     personal,
     public: {
@@ -116,7 +130,7 @@ export async function openLocalConsole(input, dependencies = {}) {
   if (!isRuntimeState(state) || !isLoopbackConsoleUrl(state.url) ||
       !deps.isProcessAlive(state.pid) ||
       !await deps.consoleHealth(state.url, state.pid, state.version)) {
-    throw new Error('本地界面尚未运行，请先执行 fl start。');
+    throw new Error('The local UI is not running. Run fl start first.');
   }
   await deps.openExternal(state.url);
   return { status: 'opened', url: state.url };
@@ -197,17 +211,18 @@ export function externalOpenInvocation(url, platform = process.platform) {
   return { command: 'xdg-open', args: [url] };
 }
 
-function hasManagedDevelopmentWorkspace(config) {
-  return (config?.workspaces ?? []).some(({ providerUrl }) =>
-    isManagedDevelopmentUrl(providerUrl));
+function hasManagedDevelopmentWorkspace(config, runtimeSettings) {
+  return (config?.workspaces ?? []).some((workspace) =>
+    isManagedDevelopmentUrl(workspace, runtimeSettings));
 }
 
-function isManagedDevelopmentUrl(value) {
+function isManagedDevelopmentUrl(workspace, runtimeSettings) {
+  if (workspace?.managedDevelopment === true) return true;
   try {
-    const url = new URL(value);
+    const url = new URL(workspace?.providerUrl);
     return url.protocol === 'http:' &&
       ['127.0.0.1', 'localhost', '::1', '[::1]'].includes(url.hostname) &&
-      url.port === new URL(MANAGED_WORKSPACE_PROVIDER_URL).port;
+      [8788, runtimeSettings.ports.workspaceProvider].includes(Number(url.port));
   } catch {
     return false;
   }
@@ -233,10 +248,16 @@ function publicProviderStatus(workspaces) {
 }
 
 function isRuntimeState(state) {
-  return (state?.version === 2 || state?.version === 3) &&
+  return (state?.version === 2 || state?.version === 3 || state?.version === 4) &&
     Number.isInteger(state.pid) && typeof state.url === 'string';
 }
 
+function safeLanUrls(value) {
+  return Array.isArray(value)
+    ? value.filter((url) => typeof url === 'string' && url.startsWith('http://'))
+    : [];
+}
+
 function isProcessAlive(pid) {
   try { process.kill(pid, 0); return true; } catch { return false; }
 }

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

@@ -20,6 +20,7 @@ const TOOL_RESULT_LIMIT_BYTES = Object.freeze({
   begin_task_context: 16 * 1024,
   get_collaboration_preferences: 16 * 1024,
   search_knowledge_graph: 32 * 1024,
+  search_connected_knowledge: 64 * 1024,
   search_current_project_knowledge: 64 * 1024,
   discover_common_knowledge_candidates: 32 * 1024
 });

package/src/mcp/instructions.js

@@ -1,9 +1,9 @@
 export const MCP_INSTRUCTIONS = [
-  "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.'
+  "Each user task: apply hook-provided task context from begin_task_context. Otherwise, before other tools/answer, call exactly get_collaboration_preferences with projectPath=cwd and taskPrompt=current user request as fallback; never substitute a project action/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.",
+  'Before asking the user to repeat a stable project fact or method, inspect task_knowledge_recall. On miss use search_current_project_knowledge with 1-4 focused action, artifact, target-system, or identifier queries; never use the whole conversational request as the only query. Search the exact active child first, then inheritable parent PART_OF/USES_KNOWLEDGE_FROM knowledge 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. Widen a miss to all_local_confirmed only after consent, then rg only in the safe current repo/workspace. Never scan outside it. Live state needs deployment/monitoring/Git MCP evidence. External/public evidence: search_connected_knowledge; agent_decide is response-only.',
+  'Use record_decision_trace for confirmed choices and record_knowledge_feedback when knowledge is rejected, contradicted, outdated, or fails validation.',
+  'Batch durable confirmed knowledge via capture_session_knowledge in exact scope; never secrets, transcripts, or guesses. Finish once with checkpoint_task_knowledge: capture_candidates or retain_nothing.',
+  'After material personal-knowledge use call record_knowledge_usage; retrieval alone never counts or permits public use.',
+  'Terminal-safe Markdown. Final MUST begin with sourceMarker.leadMarkdown; append sourceMarker.markdown unchanged on match. On miss use noMatchSourceMarker leadMarkdown only (empty markdown). Never wrap markers in HTML.'
 ].join(' ');

package/src/mcp/tool-annotations.js

@@ -5,6 +5,7 @@ const READ_TOOLS = new Set([
   'preview_common_knowledge_promotion',
   'list_knowledge_spaces',
   'list_personal_projects',
+  'list_knowledge_review_candidates',
   'preview_personal_project_action',
   'list_project_releases',
   'list_project_relations',
@@ -21,6 +22,7 @@ const WRITE_TOOLS = new Set([
   'capture_session_knowledge',
   'record_decision_trace',
   'search_knowledge_graph',
+  'search_connected_knowledge',
   'record_knowledge_usage',
   'record_knowledge_feedback',
   'apply_common_knowledge_promotion',
@@ -28,6 +30,9 @@ const WRITE_TOOLS = new Set([
   'search_human_knowledge_changes',
   'review_human_knowledge_change',
   'upsert_personal_project',
+  'start_knowledge_review',
+  'record_knowledge_review_progress',
+  'finish_knowledge_review',
   'revise_personal_knowledge',
   'reassign_personal_knowledge',
   'set_personal_preference_scope',
@@ -64,6 +69,7 @@ export function annotationsFor(name) {
       name === 'record_knowledge_feedback' ||
       name === 'checkpoint_task_knowledge',
     openWorldHint: name === 'capture_session_knowledge' ||
+      name === 'search_connected_knowledge' ||
       name === 'record_decision_trace' ||
       name === 'record_knowledge_feedback' ||
       name === 'checkpoint_task_knowledge' ||

package/src/mcp/tool-result.js

@@ -4,6 +4,7 @@ const OMITTED_KEYS = new Set([
   'store',
   'dbpath',
   'databasepath',
+  'privatepath',
   'snapshot',
   'fullsnapshot'
 ]);

package/src/server/application-lifecycle.js

@@ -1,21 +1,12 @@
-import { createApplication } from '../app/create-application.js';
 import { openFederatedGraphApplication } from '../graphiti/federated-application.js';
-import { openLocalApplication } from '../runtime-options.js';
 
 export function createServerApplication({
   app,
-  store,
-  dbPath,
   runtimeConfigPath,
-  personalSpaceName,
   closeApplicationOnShutdown
 }) {
-  const application = app ?? (store
-    ? createApplication({ store, activePersonalSpaceName: personalSpaceName })
-    : dbPath
-      ? openLocalApplication({ dbPath, personalSpaceName })
-      : openFederatedGraphApplication({ runtimeConfigPath }));
-  const owned = closeApplicationOnShutdown ?? (!app && !store);
+  const application = app ?? openFederatedGraphApplication({ runtimeConfigPath });
+  const owned = closeApplicationOnShutdown ?? !app;
   return {
     application,
     close: closeOnce(() => {

package/src/server/blocked-ports.js

@@ -0,0 +1,11 @@
+const FETCH_BLOCKED_PORTS = new Set([
+  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95,
+  101, 102, 103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389,
+  427, 465, 512, 513, 514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636,
+  989, 990, 993, 995, 1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566,
+  6665, 6666, 6667, 6668, 6669, 6697, 10080
+]);
+
+export function isFetchBlockedPort(port) {
+  return FETCH_BLOCKED_PORTS.has(Number(port));
+}

package/src/server/lan-access.js

@@ -0,0 +1,52 @@
+import { isIPv4 } from 'node:net';
+import { networkInterfaces } from 'node:os';
+
+export const LAN_ACCESS_USERNAME = 'fuli';
+
+export function discoverLanAddresses(interfaces = networkInterfaces()) {
+  const addresses = [];
+  for (const entries of Object.values(interfaces ?? {})) {
+    for (const entry of entries ?? []) {
+      if (!entry || entry.internal || !isIpv4Family(entry.family)) continue;
+      if (!isPrivateLanIpv4(entry.address)) continue;
+      addresses.push(entry.address);
+    }
+  }
+  return [...new Set(addresses)].sort(compareIpv4);
+}
+
+export function lanConsoleUrls(addresses, port) {
+  return addresses.map((address) => `http://${consoleAuthority(address, port)}`);
+}
+
+export function lanServerAuthorities(addresses, port) {
+  return lanConsoleUrls(addresses, port).map((url) => new URL(url).host);
+}
+
+function isIpv4Family(family) {
+  return family === 'IPv4' || family === 4;
+}
+
+function isPrivateLanIpv4(address) {
+  if (!isIPv4(address)) return false;
+  const [first, second] = address.split('.').map(Number);
+  return first === 10 ||
+    (first === 172 && second >= 16 && second <= 31) ||
+    (first === 192 && second === 168) ||
+    (first === 169 && second === 254);
+}
+
+function consoleAuthority(address, port) {
+  return Number(port) === 80 ? address : `${address}:${port}`;
+}
+
+function compareIpv4(left, right) {
+  const leftParts = left.split('.').map(Number);
+  const rightParts = right.split('.').map(Number);
+  for (let index = 0; index < 4; index += 1) {
+    if (leftParts[index] !== rightParts[index]) {
+      return leftParts[index] - rightParts[index];
+    }
+  }
+  return 0;
+}

package/src/server.js

@@ -1,59 +1,94 @@
 #!/usr/bin/env node
 import { createServer as createHttpServer } from 'node:http';
+import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { handleApiRequest } from './http/api-router.js';
 import { mapHttpError } from './http/error-mapping.js';
-import { localServerAuthority, rejectDisallowedRequest } from './http/request-policy.js';
+import { localServerAuthority, rejectRequestOutsidePolicy } from './http/request-policy.js';
 import { sendJson } from './http/response.js';
 import { serveStatic } from './http/static-handler.js';
 import { DEFAULT_FULI_PORT } from './defaults.js';
 import { resolveGraphRuntimeOptions } from './graphiti/runtime-config.js';
+import { isFetchBlockedPort } from './server/blocked-ports.js';
+import {
+  discoverLanAddresses,
+  lanConsoleUrls,
+  lanServerAuthorities
+} from './server/lan-access.js';
 import { createServerApplication } from './server/application-lifecycle.js';
 import { listenServer } from './server/listen.js';
+import { resolveSetupPaths } from './setup/paths.js';
+import { createSystemService } from './system/system-service.js';
 
-const FETCH_BLOCKED_PORTS = new Set([
-  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102,
-  103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465,
-  512, 513, 514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993,
-  995, 1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668,
-  6669, 6697, 10080
-]);
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 
 export async function createServer(options = {}) {
   const {
     port = DEFAULT_FULI_PORT,
-    store,
     app,
     closeApplicationOnShutdown,
-    isBlockedPort = isFetchBlockedPort
+    isBlockedPort = isFetchBlockedPort,
+    lan = false,
+    lanAccessToken = null,
+    lanAddresses: configuredLanAddresses = null
   } = options;
+  const lanEnabled = lan === true;
+  const lanToken = lanEnabled ? requiredLanToken(lanAccessToken) : null;
+  const lanAddresses = lanEnabled
+    ? [...new Set(configuredLanAddresses ?? discoverLanAddresses())]
+    : [];
+  if (lanEnabled && lanAddresses.length === 0) {
+    throw new Error('No private IPv4 LAN address is available');
+  }
   if (Number(port) !== 0 && isBlockedPort(port)) {
     throw new Error(`Port ${port} is blocked for local fetch`);
   }
-  const legacyRuntime = app || store || Object.hasOwn(options, 'dbPath');
-  const localOptions = legacyRuntime
-    ? { dbPath: options.dbPath, personalSpaceName: options.personalSpaceName ?? '我' }
-    : resolveServerGraphOptions(options);
+  const localOptions = app ? {} : resolveServerGraphOptions(options);
   const runtime = createServerApplication({
     app,
-    store,
     ...localOptions,
     closeApplicationOnShutdown
   });
   const application = runtime.application;
+  const externalKnowledge = options.externalKnowledge ??
+    application.externalKnowledge ?? null;
+  const connectedKnowledge = options.connectedKnowledge ??
+    application.connectedKnowledge ?? null;
+  const system = options.system ?? (!app
+    ? createSystemService({
+        paths: resolveSetupPaths({
+          dataDir: dirname(localOptions.runtimeConfigPath),
+          packageRoot: PACKAGE_ROOT
+        }),
+        packageRoot: PACKAGE_ROOT,
+        activePort: port,
+        activeLan: lanEnabled
+      })
+    : null);
 
   for (let attempt = 0; attempt < 20; attempt += 1) {
     let authority = null;
+    let allowedLanAuthorities = [];
     const server = createHttpServer((request, response) => {
-      handleRequest({ request, response, app: application, authority }).catch((error) => {
+      handleRequest({
+        request,
+        response,
+        app: application,
+        system,
+        externalKnowledge,
+        connectedKnowledge,
+        authority,
+        lanAuthorities: allowedLanAuthorities,
+        lanAccessToken: lanToken
+      }).catch((error) => {
         const mapped = mapHttpError(error);
         sendJson(response, mapped.status, mapped.body);
       });
     });
 
     try {
-      await listenServer(server, port);
+      await listenServer(server, port, lanEnabled ? '0.0.0.0' : '127.0.0.1');
     } catch (error) {
       runtime.close();
       throw error;
@@ -66,6 +101,9 @@ export async function createServer(options = {}) {
       throw new Error(`Port ${address.port} is blocked for local fetch`);
     }
     authority = localServerAuthority(address);
+    allowedLanAuthorities = lanEnabled
+      ? lanServerAuthorities(lanAddresses, address.port)
+      : [];
     if (!authority) {
       await new Promise((resolveClose) => server.close(resolveClose));
       runtime.close();
@@ -73,7 +111,12 @@ export async function createServer(options = {}) {
     }
 
     server.once('close', runtime.close);
-    return { server, url: `http://${authority}`, app: application };
+    return {
+      server,
+      url: `http://${authority}`,
+      lanUrls: lanEnabled ? lanConsoleUrls(lanAddresses, address.port) : [],
+      app: application
+    };
   }
 
   runtime.close();
@@ -90,13 +133,34 @@ function resolveServerGraphOptions(options) {
   });
 }
 
-export function isFetchBlockedPort(port) {
-  return FETCH_BLOCKED_PORTS.has(Number(port));
-}
+export { isFetchBlockedPort } from './server/blocked-ports.js';
 
-async function handleRequest({ request, response, app, authority }) {
-  if (rejectDisallowedRequest({ request, response, authority })) return;
-  if (await handleApiRequest({ request, response, app })) return;
+async function handleRequest({
+  request,
+  response,
+  app,
+  system,
+  externalKnowledge,
+  connectedKnowledge,
+  authority,
+  lanAuthorities,
+  lanAccessToken
+}) {
+  if (rejectRequestOutsidePolicy({
+    request,
+    response,
+    authority,
+    lanAuthorities,
+    lanAccessToken
+  })) return;
+  if (await handleApiRequest({
+    request,
+    response,
+    app,
+    system,
+    externalKnowledge,
+    connectedKnowledge
+  })) return;
   serveStatic(new URL(request.url, 'http://127.0.0.1').pathname, response);
 }
 
@@ -110,7 +174,13 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
 async function runProgram(args) {
   const runtimeOptions = resolveGraphRuntimeOptions(args, process.env);
   const port = numberOption(args, '--port', DEFAULT_FULI_PORT);
-  const { server, url } = await createServer({ ...runtimeOptions, port });
+  const lan = args.includes('--lan');
+  const { server, url, lanUrls } = await createServer({
+    ...runtimeOptions,
+    port,
+    lan,
+    lanAccessToken: lan ? process.env.FULI_LAN_ACCESS_TOKEN : null
+  });
   const handlers = new Map();
   const close = () => server.close();
   for (const signal of ['SIGINT', 'SIGTERM']) {
@@ -122,6 +192,14 @@ async function runProgram(args) {
     for (const [signal, handler] of handlers) process.off(signal, handler);
   });
   console.log(`复利工作台 running at ${url}`);
+  for (const lanUrl of lanUrls) console.log(`复利工作台 LAN at ${lanUrl}`);
+}
+
+function requiredLanToken(value) {
+  if (typeof value !== 'string' || value.length < 16) {
+    throw new TypeError('LAN mode requires a generated access token');
+  }
+  return value;
 }
 
 function numberOption(args, flag, fallback) {

package/src/setup/agent-installation-status.js

@@ -17,7 +17,8 @@ export function inspectAgentInstallations(agents, context, {
     const registration = inspectRegistration(agent, context, { readText, readJson });
     const skillPairs = [
       [context.sessionSkillPath, agent.skillPath],
-      [context.projectSkillPath, agent.projectSkillPath]
+      [context.projectSkillPath, agent.projectSkillPath],
+      [context.reviewSkillPath, agent.reviewSkillPath]
     ];
     const skillsPresent = skillPairs.some(([, targetPath]) => fileExists(targetPath));
     const skillsCurrent = skillPairs.every(

package/src/setup/agents.js

@@ -9,6 +9,7 @@ import {
 } from './claude-code-config.js';
 import { connectCursor, disconnectCursor } from './cursor-config.js';
 import { connectCodex, disconnectCodex } from './codex-config.js';
+import { adaptAgentForReviewSkill } from './review-skill-adapters.js';
 
 export function discoverAgents({
   platform = process.platform,
@@ -52,7 +53,7 @@ export function discoverAgents({
       projectSkillPath: pathApi.join(homeDir, '.cursor', 'skills', projectSkillName),
       available: Boolean(commandExists('cursor'))
     }
-  ];
+  ].map((agent) => adaptAgentForReviewSkill(agent, { homeDir, pathApi }));
 }
 
 export function buildAgentCommands(agent, context) {

package/src/setup/claude-code-config.js

@@ -115,7 +115,8 @@ function withManagedHooks(settings) {
     ...(hooks.UserPromptSubmit ?? []),
     managedHookGroup('begin_task_context', {
       sessionId: '${session_id}',
-      projectPath: '${cwd}'
+      projectPath: '${cwd}',
+      taskPrompt: '${prompt}'
     }, 'Loading Fuli task context')
   ];
   hooks.Stop = [

package/src/setup/codex-bootstrap.js

@@ -9,18 +9,23 @@ import {
 } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 
+import { codexReviewCommandBridge } from './review-skill-adapters.js';
+
 const BLOCK_START = '<!-- BEGIN FULI MANAGED INSTRUCTIONS -->';
 const BLOCK_END = '<!-- END FULI MANAGED INSTRUCTIONS -->';
 
 const GLOBAL_INSTRUCTIONS = `${BLOCK_START}
 At the start of every user task, before any other tool or answer, call exactly
-\`get_collaboration_preferences\` with \`projectPath\`=current working directory. Never substitute
-project action or Fuli tool.
-Apply all returned \`effective_preferences\` before answers or tools. For write tools, enforce
-them in the actual payload; mentioning them later is not compliance.
-Before using a relevant \`deferred_conflict\`, call
-\`resolve_deferred_preference_conflict\`; ignore unrelated ones.
-The current request wins on conflict.
+\`get_collaboration_preferences\` with \`projectPath\`=current working directory and
+\`taskPrompt\`=current user request; never substitute a project action/Fuli tool. Fuli uses both
+transiently and never stores or returns them. Apply all returned \`effective_preferences\`.
+Before asking the user to repeat a stable project fact or method, inspect
+\`task_knowledge_recall\`. On miss call \`search_current_project_knowledge\` with 1-4 focused
+action/artifact/target/identifier queries; never use the full request as the only query.
+For write tools enforce them in the actual payload; mentioning them later is not compliance.
+Relevant \`deferred_conflict\`: call \`resolve_deferred_preference_conflict\` first; ignore others.
+Current request wins.
+${codexReviewCommandBridge()}
 ${BLOCK_END}`;
 
 export function installCodexBootstrap(agent, _context, {