ai-worklens-agent 0.1.2 → 0.1.4

package/README.md

@@ -36,8 +36,8 @@ npm run mcp
 如果管理员已经把员工端发布到 npm 或企业私有 npm 源，可以使用 `npx` 首次安装：
 
 ```bash
-NPM_CONFIG_UPDATE_NOTIFIER=false npx -y --loglevel=error -p ai-worklens-agent@0.1.2 worklens-agent-install \
-  --server-url http://127.0.0.1:8797 \
+NPM_CONFIG_UPDATE_NOTIFIER=false npx -y --loglevel=error -p ai-worklens-agent@0.1.4 worklens-agent-install \
+  --server-url http://192.168.1.241:8797 \
   --tool codex \
   --employee-pinyin zhangsan
 ```
@@ -60,7 +60,7 @@ NPM_TOKEN=<npm_token> npm run client:npm:publish -- \
 如果管理员在官网发布了直链安装包，可以下载安装包后执行包内安装脚本：
 
 ```bash
-curl -fL http://127.0.0.1:8797/site/downloads/ai-worklens-codex-0.1.0.sh \
+curl -fL http://192.168.1.241:8797/site/downloads/ai-worklens-codex-0.1.4.sh \
   -o ai-worklens-install.sh
 chmod +x ai-worklens-install.sh
 ./ai-worklens-install.sh zhangsan

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-worklens-agent",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Employee-side collector agent for AI WorkLens.",
   "type": "module",
   "bin": {
@@ -18,5 +18,10 @@
     "claude-code",
     "opencode"
   ],
-  "license": "UNLICENSED"
+  "license": "UNLICENSED",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
 }

package/src/config.mjs

@@ -22,6 +22,92 @@ function readJson(filePath) {
   }
 }
 
+function readText(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return "";
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function firstValue(...values) {
+  return values.map((value) => String(value || "").trim()).find(Boolean) || "";
+}
+
+function knownModel(model) {
+  return Boolean(model?.label && model.label !== "unknown");
+}
+
+function rootTomlString(content, key) {
+  const keyPattern = new RegExp(`^${key}\\s*=\\s*["']([^"']+)["']`);
+  for (const line of String(content || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[")) return "";
+    const match = trimmed.match(keyPattern);
+    if (match) return match[1].trim();
+  }
+  return "";
+}
+
+function jsonishString(content, key) {
+  const match = String(content || "").match(new RegExp(`["']?${key}["']?\\s*[:=]\\s*["']([^"']+)["']`));
+  return match?.[1]?.trim() || "";
+}
+
+function inferCodexModel(homeDir, env) {
+  const codexConfig = readText(path.join(homeDir, ".codex", "config.toml"));
+  return normalizeModelInfo({
+    provider: firstValue(env.OPENAI_PROVIDER, "openai"),
+    name: firstValue(
+      env.CODEX_MODEL,
+      env.OPENAI_MODEL,
+      rootTomlString(codexConfig, "model"),
+      jsonishString(codexConfig, "model")
+    )
+  });
+}
+
+function inferClaudeModel(homeDir, env) {
+  const claudeSettings = readJson(path.join(homeDir, ".claude", "settings.json"));
+  const claudeJson = readJson(path.join(homeDir, ".claude.json"));
+  return normalizeModelInfo({
+    provider: firstValue(env.ANTHROPIC_PROVIDER, "anthropic"),
+    name: firstValue(
+      env.CLAUDE_CODE_MODEL,
+      env.CLAUDE_MODEL,
+      env.ANTHROPIC_MODEL,
+      claudeSettings.model,
+      claudeSettings.modelName,
+      claudeSettings.env?.ANTHROPIC_MODEL,
+      claudeJson.model,
+      claudeJson.modelName
+    )
+  });
+}
+
+function inferOpenCodeModel(homeDir, env) {
+  const candidates = [
+    path.join(homeDir, ".config", "opencode", "opencode.json"),
+    path.join(homeDir, ".config", "opencode", "opencode.jsonc"),
+    path.join(homeDir, ".opencode", "config.json"),
+    path.join(homeDir, ".opencode", "config.jsonc")
+  ];
+  const configText = candidates.map(readText).find(Boolean) || "";
+  return normalizeModelInfo({
+    name: firstValue(env.OPENCODE_MODEL, env.OPENAI_MODEL, jsonishString(configText, "model")),
+    provider: firstValue(env.OPENCODE_PROVIDER, jsonishString(configText, "provider"))
+  });
+}
+
+function inferToolModel({ tool, homeDir, env }) {
+  const normalizedTool = normalizeToolId(tool);
+  if (normalizedTool === "claude-code") return inferClaudeModel(homeDir, env);
+  if (normalizedTool === "opencode") return inferOpenCodeModel(homeDir, env);
+  return inferCodexModel(homeDir, env);
+}
+
 function defaultClientId() {
   const seed = `${os.hostname()}:${os.userInfo().username}`;
   return `device_${crypto.createHash("sha256").update(seed).digest("hex").slice(0, 12)}`;
@@ -38,9 +124,19 @@ export function defaultQueueFile(configFile = defaultConfigFile()) {
 export function loadClientConfig(options = {}) {
   const configFile = options.configFile || defaultConfigFile();
   const fileConfig = readJson(configFile);
-  const env = process.env;
+  const env = options.env || process.env;
+  const homeDir = options.homeDir || envValue(env, "WORKLENS_HOME_DIR") || fileConfig.homeDir || os.homedir();
+  const tool = normalizeToolId(options.tool || envValue(env, "WORKLENS_TOOL") || fileConfig.tool || "codex");
   const serverUrl = options.serverUrl || envValue(env, "WORKLENS_SERVER_URL") || fileConfig.serverUrl || "http://127.0.0.1:8797";
   const collection = normalizeCollectionSettings(options.collection || fileConfig.collection || {});
+  const configuredModel = normalizeModelInfo({
+    ...fileConfig.model,
+    provider: options.modelProvider || envValue(env, "WORKLENS_MODEL_PROVIDER") || fileConfig.model?.provider,
+    name: options.modelName || envValue(env, "WORKLENS_MODEL_NAME") || fileConfig.model?.name,
+    version: options.modelVersion || envValue(env, "WORKLENS_MODEL_VERSION") || fileConfig.model?.version,
+    family: options.modelFamily || envValue(env, "WORKLENS_MODEL_FAMILY") || fileConfig.model?.family
+  });
+  const inferredModel = inferToolModel({ tool, homeDir, env });
   const employee = {
     id: options.employeeId || envValue(env, "WORKLENS_EMPLOYEE_ID") || fileConfig.employee?.id || os.userInfo().username,
     name: options.employeeName || envValue(env, "WORKLENS_EMPLOYEE_NAME") || fileConfig.employee?.name || os.userInfo().username,
@@ -50,19 +146,14 @@ export function loadClientConfig(options = {}) {
   };
   return {
     configFile,
+    homeDir,
     queueFile: options.queueFile || defaultQueueFile(configFile),
     serverUrl,
     collectorToken: options.collectorToken || envValue(env, "WORKLENS_COLLECTOR_TOKEN") || fileConfig.collectorToken || "",
     clientId: options.clientId || envValue(env, "WORKLENS_CLIENT_ID") || fileConfig.clientId || defaultClientId(),
     clientVersion: options.clientVersion || fileConfig.clientVersion || "0.1.0",
-    tool: normalizeToolId(options.tool || envValue(env, "WORKLENS_TOOL") || fileConfig.tool || "codex"),
-    model: normalizeModelInfo({
-      ...fileConfig.model,
-      provider: options.modelProvider || envValue(env, "WORKLENS_MODEL_PROVIDER") || fileConfig.model?.provider,
-      name: options.modelName || envValue(env, "WORKLENS_MODEL_NAME") || fileConfig.model?.name,
-      version: options.modelVersion || envValue(env, "WORKLENS_MODEL_VERSION") || fileConfig.model?.version,
-      family: options.modelFamily || envValue(env, "WORKLENS_MODEL_FAMILY") || fileConfig.model?.family
-    }),
+    tool,
+    model: knownModel(configuredModel) ? configuredModel : inferredModel,
     workspaceRoot: options.workspaceRoot || envValue(env, "WORKLENS_WORKSPACE_ROOT") || process.cwd(),
     repoName: options.repoName || envValue(env, "WORKLENS_REPO_NAME") || path.basename(options.workspaceRoot || envValue(env, "WORKLENS_WORKSPACE_ROOT") || process.cwd()),
     branch: options.branch || envValue(env, "WORKLENS_BRANCH") || fileConfig.branch || "",

package/src/hook-adapter.mjs

@@ -70,11 +70,17 @@ function eventTypeFromHook(name, payload) {
   if (["pretooluse", "toolcall", "tooluse", "toolusebefore", "toolexecutebefore"].includes(compact)) {
     const toolName = toolNameFromPayload(payload);
     const command = commandFromPayload(payload);
+    if (skillNameFromPayload(payload)) return "skill_use";
+    if (mcpServerFromPayload(payload)) return "mcp_tool_call";
+    if (pluginNameFromPayload(payload)) return "plugin_use";
     return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_call";
   }
   if (["posttooluse", "posttoolbatch", "tooluseafter", "toolexecuteafter"].includes(compact)) {
     const toolName = toolNameFromPayload(payload);
     const command = commandFromPayload(payload);
+    if (skillNameFromPayload(payload)) return "skill_use";
+    if (mcpServerFromPayload(payload)) return "mcp_tool_call";
+    if (pluginNameFromPayload(payload)) return "plugin_use";
     return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_result";
   }
   if (["commandexecuted", "tuicommandexecute"].includes(compact)) return commandEventType(commandFromPayload(payload));
@@ -96,13 +102,32 @@ function commandEventType(command) {
 }
 
 function toolNameFromPayload(payload) {
-  return payload.toolName ||
-    payload.tool_name ||
-    payload.tool ||
-    payload.input?.tool ||
-    payload.output?.tool ||
-    payload.request?.tool ||
-    "";
+  return firstText(
+    payload.toolName,
+    payload.tool_name,
+    payload.tool,
+    payload.name,
+    payload.input?.toolName,
+    payload.input?.tool_name,
+    payload.input?.tool,
+    payload.input?.name,
+    payload.output?.toolName,
+    payload.output?.tool_name,
+    payload.output?.tool,
+    payload.output?.name,
+    payload.request?.toolName,
+    payload.request?.tool_name,
+    payload.request?.tool,
+    payload.tool_input?.toolName,
+    payload.tool_input?.tool_name,
+    payload.tool_input?.tool,
+    payload.toolInput?.toolName,
+    payload.toolInput?.tool_name,
+    payload.toolInput?.tool,
+    payload.tool_args?.toolName,
+    payload.tool_args?.tool_name,
+    payload.tool_args?.tool
+  );
 }
 
 function firstText(...values) {
@@ -127,6 +152,111 @@ function modeFromPayload(payload) {
   );
 }
 
+function skillNameFromPayload(payload) {
+  return firstText(
+    payload.skillName,
+    payload.skill_name,
+    payload.skill,
+    payload.metadata?.skillName,
+    payload.metadata?.skill_name,
+    payload.metadata?.skill,
+    payload.context?.skillName,
+    payload.context?.skill_name,
+    payload.context?.skill,
+    payload.input?.skillName,
+    payload.input?.skill_name,
+    payload.input?.skill,
+    payload.output?.skillName,
+    payload.output?.skill_name,
+    payload.output?.skill
+  );
+}
+
+function pluginNameFromPayload(payload) {
+  const explicit = firstText(
+    payload.pluginName,
+    payload.plugin_name,
+    payload.plugin,
+    payload.metadata?.pluginName,
+    payload.metadata?.plugin_name,
+    payload.metadata?.plugin,
+    payload.context?.pluginName,
+    payload.context?.plugin_name,
+    payload.context?.plugin,
+    payload.input?.pluginName,
+    payload.input?.plugin_name,
+    payload.input?.plugin,
+    payload.output?.pluginName,
+    payload.output?.plugin_name,
+    payload.output?.plugin
+  );
+  if (explicit) return explicit;
+  return pluginNameFromMcpNamespace(mcpNamespaceFromToolName(toolNameFromPayload(payload)));
+}
+
+function mcpServerFromPayload(payload) {
+  const explicit = firstText(
+    payload.mcpServer,
+    payload.mcp_server,
+    payload.server,
+    payload.metadata?.mcpServer,
+    payload.metadata?.mcp_server,
+    payload.metadata?.server,
+    payload.context?.mcpServer,
+    payload.context?.mcp_server,
+    payload.context?.server,
+    payload.input?.mcpServer,
+    payload.input?.mcp_server,
+    payload.input?.server,
+    payload.output?.mcpServer,
+    payload.output?.mcp_server,
+    payload.output?.server
+  );
+  if (explicit) return normalizeMcpServerName(explicit);
+  return normalizeMcpServerName(mcpNamespaceFromToolName(toolNameFromPayload(payload)));
+}
+
+function mcpNamespaceFromToolName(value) {
+  const toolName = String(value || "");
+  const match = toolName.match(/^mcp__(.+?)(?:[.:].*)?$/);
+  return match ? match[1] : "";
+}
+
+function normalizeMcpServerName(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  if (raw.startsWith("codex_apps__")) return raw.slice("codex_apps__".length).replaceAll("_", "-");
+  return raw.replaceAll("_", "-");
+}
+
+function pluginNameFromMcpNamespace(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  const normalized = normalizeMcpServerName(raw);
+  const key = normalized.toLowerCase();
+  const rawKey = raw.toLowerCase();
+  const mapping = {
+    playwright: "Browser",
+    browser: "Browser",
+    chrome: "Chrome",
+    "computer-use": "Computer Use",
+    figma: "Figma",
+    "outlook-email": "Outlook Email",
+    presentations: "Presentations",
+    spreadsheets: "Spreadsheets"
+  };
+  if (rawKey.startsWith("codex_apps__")) return mapping[key] || upperPluginName(normalized);
+  return mapping[key] || "";
+}
+
+function upperPluginName(value) {
+  return String(value || "")
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0]?.toUpperCase() || ""}${part.slice(1)}`)
+    .join(" ");
+}
+
 function previousModeFromPayload(payload) {
   return firstText(
     payload.previousMode,
@@ -268,6 +398,10 @@ export function normalizeHookPayload(payload, args, config) {
   const eventType = eventTypeFromHook(name, payload);
   const summary = pickSummary(payload, name, eventType);
   const metadata = payload.metadata && typeof payload.metadata === "object" ? payload.metadata : {};
+  const skillName = skillNameFromPayload(payload);
+  const pluginName = pluginNameFromPayload(payload);
+  const mcpServer = mcpServerFromPayload(payload);
+  const toolName = toolNameFromPayload(payload);
   return buildEvent({
     ...payload,
     eventType,
@@ -277,9 +411,9 @@ export function normalizeHookPayload(payload, args, config) {
     hookName: name,
     localSessionId: payload.sessionId || payload.session_id || payload.localSessionId,
     turnIndex: payload.turnIndex || payload.turn_index,
-    skillName: payload.skillName || payload.skill_name || payload.skill,
-    pluginName: payload.pluginName || payload.plugin_name || payload.plugin,
-    mcpServer: payload.mcpServer || payload.mcp_server || payload.server,
+    skillName,
+    pluginName,
+    mcpServer,
     files: fileRefsFromPayload(payload),
     commands: commandFromPayload(payload),
     durationSeconds: payload.durationSeconds || payload.duration_seconds || payload.duration_ms && Number(payload.duration_ms) / 1000,
@@ -289,7 +423,11 @@ export function normalizeHookPayload(payload, args, config) {
       sourceTool: config.tool,
       rawHookEvent: name,
       hookEventName: payload.hook_event_name || payload.hookEventName || payload.event || payload.type || name,
-      toolName: toolNameFromPayload(payload),
+      toolName,
+      skillName,
+      pluginName,
+      mcpServer,
+      mcpNamespace: mcpNamespaceFromToolName(toolName),
       codexMode: nextModeFromPayload(payload),
       interactionType: eventType,
       cwd: payload.cwd || payload.directory || payload.project?.directory,
@@ -305,7 +443,7 @@ export function normalizeHookPayload(payload, args, config) {
       previousMode: previousModeFromPayload(payload),
       nextMode: nextModeFromPayload(payload),
       phase: payload.phase || payload.input?.phase || payload.output?.phase,
-      toolName: toolNameFromPayload(payload),
+      toolName,
       toolStatus: statusFromPayload(payload),
       exitCode: payload.exitCode ?? payload.exit_code ?? payload.output?.exitCode ?? payload.output?.exit_code,
       permissionDecision: permissionDecisionFromPayload(payload),

package/src/install.mjs

@@ -2,12 +2,14 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { writeClientConfig } from "./config.mjs";
 import { getToolProfile, listToolProfiles, normalizeToolId } from "./protocol/tool-profiles.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const agentSrcDir = __dirname;
+const clientPackageVersion = readPackageVersion();
 
 function parseArgs(argv) {
   const result = {};
@@ -25,10 +27,20 @@ function parseArgs(argv) {
   return result;
 }
 
+function readPackageVersion() {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../package.json"), "utf8"));
+    return packageJson.version || "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+
 export function buildInstallManifest(targetDir, options = {}) {
   const node = process.execPath;
   const selectedTool = normalizeToolId(options.tool || "codex");
   const profile = getToolProfile(selectedTool);
+  const serverUrl = options.serverUrl || "http://127.0.0.1:8797";
   const displayTargetDir = displayPath(targetDir);
   const configFile = path.join(displayTargetDir, "client.json");
   const mcpCommand = node;
@@ -40,6 +52,7 @@ export function buildInstallManifest(targetDir, options = {}) {
     displayTargetDir,
     selectedTool,
     configFile,
+    serverUrl,
     mcpCommand,
     mcpArgs,
     hookCommand,
@@ -55,7 +68,7 @@ export function buildInstallManifest(targetDir, options = {}) {
       name: profile.mcpServerName,
       command: mcpCommand,
       args: mcpArgs,
-      env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: selectedTool }
+      env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: selectedTool, WORKLENS_SERVER_URL: serverUrl }
     },
     hook: {
       name: profile.hookName,
@@ -94,12 +107,13 @@ export function buildInstallManifest(targetDir, options = {}) {
       fullReplyUploaded: false,
       localRedaction: true
     },
-    serverUrl: options.serverUrl || "http://127.0.0.1:8797"
+    serverUrl
   };
 }
 
 export function installClient(options = {}) {
   const targetDir = options.targetDir || path.join(os.homedir(), ".ai-worklens");
+  const homeDir = options.homeDir || os.homedir();
   fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
   const configFile = path.join(targetDir, "client.json");
   const manifestFile = path.join(targetDir, "install-manifest.json");
@@ -113,11 +127,23 @@ export function installClient(options = {}) {
   const installOrUpdateScriptFile = path.join(targetDir, "worklens-install-or-update.sh");
   const readmeFile = path.join(targetDir, "README.md");
   const selectedTool = normalizeToolId(options.tool || "codex");
+  const installedClientVersion = options.clientVersion || clientPackageVersion;
+  const updatePolicyInput = options.updatePolicy || {};
+  const installedArtifactRevision = String(
+    options.artifactRevision
+    || (String(updatePolicyInput.clientVersion || "") === String(installedClientVersion) ? updatePolicyInput.artifactRevision : "")
+    || installedClientVersion
+  );
+  const updatePolicy = {
+    ...updatePolicyInput,
+    appliedRevision: options.appliedRevision || installedArtifactRevision,
+    lastUpdatedAt: updatePolicyInput.lastUpdatedAt || new Date().toISOString()
+  };
   writeClientConfig(configFile, {
     serverUrl: options.serverUrl || "http://127.0.0.1:8797",
     collectorToken: options.collectorToken || "",
     clientId: options.clientId || "",
-    clientVersion: options.clientVersion || "0.1.0",
+    clientVersion: installedClientVersion,
     tool: selectedTool,
     model: {
       provider: options.modelProvider || "",
@@ -134,7 +160,7 @@ export function installClient(options = {}) {
     },
     upload: options.upload || { timeoutMs: 5000, batchSize: 50 },
     collection: options.collection || {},
-    update: options.updatePolicy || {}
+    update: updatePolicy
   });
   const manifest = buildInstallManifest(targetDir, options);
   fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
@@ -166,12 +192,20 @@ export function installClient(options = {}) {
   fs.chmodSync(installOrUpdateScriptFile, 0o700);
   fs.writeFileSync(readmeFile, buildReadme(manifest), { mode: 0o600 });
   fs.chmodSync(readmeFile, 0o600);
+  const integrations = options.writeToolConfigs === false
+    ? { ok: true, skipped: true, items: [] }
+    : installToolIntegrations(manifest, {
+      homeDir,
+      integrations: options.integrations || "selected",
+      useToolCli: options.useToolCli !== false
+    });
   return {
     ok: true,
     targetDir,
     configFile,
     manifestFile,
     generatedFiles: manifest.generatedFiles,
+    integrations,
     manifest
   };
 }
@@ -200,7 +234,7 @@ function upperFirst(value) {
   return input ? `${input[0].toUpperCase()}${input.slice(1)}` : input;
 }
 
-function buildToolArtifacts({ targetDir, displayTargetDir, configFile, mcpCommand, mcpArgs }) {
+function buildToolArtifacts({ targetDir, displayTargetDir, configFile, serverUrl, mcpCommand, mcpArgs }) {
   return Object.fromEntries(listToolProfiles().map((profile) => {
     const hookArgs = [path.join(agentSrcDir, "hook-adapter.mjs"), "--config", configFile, "--tool", profile.id];
     const artifact = {
@@ -216,10 +250,11 @@ function buildToolArtifacts({ targetDir, displayTargetDir, configFile, mcpComman
         name: profile.mcpServerName,
         command: mcpCommand,
         args: mcpArgs,
-        env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+        env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id, WORKLENS_SERVER_URL: serverUrl }
       },
       config: toolConfigFor(profile, {
         configFile,
+        serverUrl,
         mcpCommand,
         mcpArgs,
         hookCommand: mcpCommand,
@@ -240,7 +275,7 @@ function buildToolArtifacts({ targetDir, displayTargetDir, configFile, mcpComman
   }));
 }
 
-function toolConfigFor(profile, { configFile, mcpCommand, mcpArgs, hookCommand, hookArgs }) {
+function toolConfigFor(profile, { configFile, serverUrl, mcpCommand, mcpArgs, hookCommand, hookArgs }) {
   if (profile.id === "codex") {
     return [
       `[mcp_servers.${profile.mcpServerName}]`,
@@ -249,7 +284,8 @@ function toolConfigFor(profile, { configFile, mcpCommand, mcpArgs, hookCommand,
       "",
       `[mcp_servers.${profile.mcpServerName}.env]`,
       `WORKLENS_CONFIG_FILE = ${tomlString(configFile)}`,
-      `WORKLENS_TOOL = ${tomlString(profile.id)}`
+      `WORKLENS_TOOL = ${tomlString(profile.id)}`,
+      `WORKLENS_SERVER_URL = ${tomlString(serverUrl)}`
     ].join("\n");
   }
   if (profile.id === "claude-code") {
@@ -258,7 +294,7 @@ function toolConfigFor(profile, { configFile, mcpCommand, mcpArgs, hookCommand,
         [profile.mcpServerName]: {
           command: mcpCommand,
           args: mcpArgs,
-          env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+          env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id, WORKLENS_SERVER_URL: serverUrl }
         }
       }
     }, null, 2);
@@ -271,12 +307,12 @@ function toolConfigFor(profile, { configFile, mcpCommand, mcpArgs, hookCommand,
           type: "local",
           command: [mcpCommand, ...mcpArgs],
           enabled: true,
-          environment: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+          environment: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id, WORKLENS_SERVER_URL: serverUrl }
         }
       }
     }, null, 2);
   }
-  return JSON.stringify({ command: mcpCommand, args: mcpArgs, env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id } }, null, 2);
+  return JSON.stringify({ command: mcpCommand, args: mcpArgs, env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id, WORKLENS_SERVER_URL: serverUrl } }, null, 2);
 }
 
 function extraFilesFor(profile, { targetDir, hookCommand, hookArgs }) {
@@ -332,8 +368,7 @@ function buildClaudeHooksSettings(command, baseArgs) {
       hooks: [
         {
           type: "command",
-          command,
-          args: [...baseArgs, "--event", eventName],
+          command: commandLine(command, [...baseArgs, "--event", eventName]),
           timeout: 10
         }
       ]
@@ -347,6 +382,249 @@ function buildClaudeHooksSettings(command, baseArgs) {
   }, null, 2);
 }
 
+function installToolIntegrations(manifest, { homeDir, integrations = "selected", useToolCli = true } = {}) {
+  const selected = selectedIntegrationTools(integrations, manifest);
+  const items = [];
+  const errors = [];
+  const run = (tool, fn) => {
+    if (!selected.includes(tool)) return;
+    try {
+      items.push({ tool, ok: true, ...fn() });
+    } catch (error) {
+      const item = { tool, ok: false, error: error.message };
+      items.push(item);
+      errors.push(item);
+    }
+  };
+  run("codex", () => installCodexIntegration(manifest, homeDir));
+  run("claude-code", () => installClaudeCodeIntegration(manifest, homeDir, { useToolCli }));
+  run("opencode", () => installOpenCodeIntegration(manifest, homeDir));
+  return { ok: errors.length === 0, items };
+}
+
+function selectedIntegrationTools(value, manifest) {
+  const raw = String(value || "selected").trim().toLowerCase();
+  if (["none", "false", "off", "0"].includes(raw)) return [];
+  if (raw === "selected") return [manifest.selectedTool];
+  if (raw === "all") return Object.keys(manifest.toolArtifacts);
+  return raw.split(",").map((item) => normalizeToolId(item.trim())).filter(Boolean);
+}
+
+function installCodexIntegration(manifest, homeDir) {
+  const artifact = manifest.toolArtifacts.codex;
+  const configPath = path.join(homeDir, ".codex", "config.toml");
+  const hooksPath = path.join(homeDir, ".codex", "hooks.json");
+  const config = readTextConfig(configPath);
+  const nextConfig = appendTomlSections(removeTomlSections(config, [
+    `mcp_servers.${artifact.profile.mcpServerName}`,
+    `mcp_servers.${artifact.profile.mcpServerName}.env`
+  ]), artifact.config);
+  writeTextConfig(configPath, nextConfig);
+
+  const hooks = readJsonConfig(hooksPath, { hooks: {} });
+  hooks.hooks = hooks.hooks && typeof hooks.hooks === "object" ? hooks.hooks : {};
+  const command = shellQuote(artifact.hookFile);
+  for (const eventName of ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"]) {
+    const entry = {
+      hooks: [{ type: "command", command, ...(eventName === "Stop" ? { timeout: 30 } : {}) }]
+    };
+    if (eventName === "SessionStart") entry.matcher = "startup|resume";
+    hooks.hooks[eventName] = ensureHookEntry(removeWorkLensHookEntries(hooks.hooks[eventName]), entry);
+  }
+  writeJsonConfig(hooksPath, hooks);
+  enableExistingCodexHookState(configPath, hooksPath, ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"]);
+  return { configPath, hooksPath };
+}
+
+function installClaudeCodeIntegration(manifest, homeDir, { useToolCli = true } = {}) {
+  const artifact = manifest.toolArtifacts["claude-code"];
+  const globalConfigPath = path.join(homeDir, ".claude.json");
+  const settingsPath = path.join(homeDir, ".claude", "settings.json");
+  const serverConfig = {
+    type: "stdio",
+    command: artifact.mcp.command,
+    args: artifact.mcp.args,
+    env: artifact.mcp.env
+  };
+  const mcpConfig = readJsonConfig(globalConfigPath, {});
+  mcpConfig.mcpServers = mcpConfig.mcpServers && typeof mcpConfig.mcpServers === "object" ? mcpConfig.mcpServers : {};
+  mcpConfig.mcpServers[artifact.profile.mcpServerName] = serverConfig;
+  writeJsonConfig(globalConfigPath, mcpConfig);
+
+  const settings = readJsonConfig(settingsPath, {});
+  const hooksSettings = JSON.parse(artifact.extraFiles.hooksSettings.content);
+  settings.hooks = mergeHookSettings(settings.hooks, hooksSettings.hooks);
+  writeJsonConfig(settingsPath, settings);
+  const cli = useToolCli ? installClaudeMcpWithCli(artifact.profile.mcpServerName, serverConfig, homeDir) : { ok: true, skipped: true };
+  return { globalConfigPath, settingsPath, cli };
+}
+
+function installOpenCodeIntegration(manifest, homeDir) {
+  const artifact = manifest.toolArtifacts.opencode;
+  const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path.join(homeDir, ".config", "opencode", "plugins", "ai-worklens.js");
+  const config = readJsonConfig(configPath, { $schema: "https://opencode.ai/config.json" });
+  const generated = JSON.parse(artifact.config);
+  config.$schema = config.$schema || generated.$schema;
+  config.mcp = config.mcp && typeof config.mcp === "object" ? config.mcp : {};
+  config.mcp[artifact.profile.mcpServerName] = generated.mcp[artifact.profile.mcpServerName];
+  writeJsonConfig(configPath, config);
+  writeTextConfig(pluginPath, `${artifact.extraFiles.plugin.content}\n`, 0o600);
+  return { configPath, pluginPath };
+}
+
+function mergeHookSettings(current, incoming) {
+  const hooks = current && typeof current === "object" ? { ...current } : {};
+  for (const [eventName, entries] of Object.entries(incoming || {})) {
+    const base = removeWorkLensHookEntries(hooks[eventName]);
+    hooks[eventName] = (entries || []).reduce((list, entry) => ensureHookEntry(list, entry), base);
+  }
+  return hooks;
+}
+
+function removeWorkLensHookEntries(current) {
+  const list = Array.isArray(current) ? current : [];
+  return list.filter((entry) => !hookEntryContainsWorkLens(entry));
+}
+
+function hookEntryContainsWorkLens(entry = {}) {
+  return (entry.hooks || []).some((hook) => workLensHookCommandPattern().test(String(hook.command || "")));
+}
+
+function workLensHookCommandPattern() {
+  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.sh|claude-code-hook\.sh|opencode-hook\.sh)/i;
+}
+
+function ensureHookEntry(current, entry) {
+  const list = Array.isArray(current) ? current : [];
+  const key = JSON.stringify(entry);
+  if (list.some((item) => JSON.stringify(item) === key)) return list;
+  return [...list, entry];
+}
+
+function commandLine(command, args) {
+  return [command, ...args].map(shellQuote).join(" ");
+}
+
+function readTextConfig(filePath) {
+  try {
+    return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+
+function readJsonConfig(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return structuredClone(fallback);
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return structuredClone(fallback);
+  return JSON.parse(raw);
+}
+
+function writeTextConfig(filePath, content, mode = 0o600) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const tempFile = `${filePath}.tmp-${process.pid}`;
+  fs.writeFileSync(tempFile, content, { mode });
+  fs.renameSync(tempFile, filePath);
+  fs.chmodSync(filePath, mode);
+}
+
+function writeJsonConfig(filePath, value) {
+  writeTextConfig(filePath, `${JSON.stringify(value, null, 2)}\n`, 0o600);
+}
+
+function enableExistingCodexHookState(configPath, hooksPath, eventNames) {
+  if (!fs.existsSync(configPath)) return;
+  const content = fs.readFileSync(configPath, "utf8");
+  const next = enableHookStateSections(content, hooksPath, eventNames);
+  if (next !== content) writeTextConfig(configPath, next);
+}
+
+function enableHookStateSections(content, hooksPath, eventNames) {
+  const hookEvents = new Set(eventNames.map(codexHookStateEventName));
+  const lines = String(content || "").split(/\n/);
+  let inWorkLensHookState = false;
+  let changed = false;
+  const output = lines.map((line) => {
+    const section = line.match(/^\[hooks\.state\."((?:\\.|[^"\\])*)"\]\s*$/);
+    if (section) {
+      const stateKey = parseTomlQuotedString(section[1]);
+      inWorkLensHookState = isWorkLensHookStateKey(stateKey, hooksPath, hookEvents);
+      return line;
+    }
+    if (/^\[[^\]]+\]\s*$/.test(line)) {
+      inWorkLensHookState = false;
+      return line;
+    }
+    if (inWorkLensHookState && /^enabled\s*=\s*false\s*$/.test(line)) {
+      changed = true;
+      return "enabled = true";
+    }
+    return line;
+  });
+  return changed ? output.join("\n") : content;
+}
+
+function parseTomlQuotedString(value) {
+  try {
+    return JSON.parse(`"${value}"`);
+  } catch {
+    return String(value || "");
+  }
+}
+
+function isWorkLensHookStateKey(stateKey, hooksPath, hookEvents) {
+  const prefix = `${hooksPath}:`;
+  if (!String(stateKey || "").startsWith(prefix)) return false;
+  const rest = String(stateKey).slice(prefix.length);
+  const eventName = rest.split(":")[0];
+  return hookEvents.has(eventName);
+}
+
+function codexHookStateEventName(eventName) {
+  return String(eventName || "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^a-zA-Z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .toLowerCase();
+}
+
+function installClaudeMcpWithCli(name, serverConfig, homeDir) {
+  const result = spawnSync("claude", [
+    "mcp",
+    "add-json",
+    "-s",
+    "user",
+    name,
+    JSON.stringify(serverConfig)
+  ], {
+    encoding: "utf8",
+    timeout: 10000,
+    env: { ...process.env, HOME: homeDir }
+  });
+  if (result.error) return { ok: false, error: result.error.message };
+  if (result.status !== 0) {
+    const stderr = String(result.stderr || "").trim();
+    const stdout = String(result.stdout || "").trim();
+    return { ok: false, status: result.status, error: stderr || stdout || "claude mcp add-json failed" };
+  }
+  return { ok: true };
+}
+
+function removeTomlSections(content, sectionNames) {
+  let output = String(content || "");
+  for (const sectionName of sectionNames) {
+    const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    output = output.replace(new RegExp(`(^|\\n)\\[${escaped}\\]\\n[\\s\\S]*?(?=\\n\\[[^\\]]+\\]|$)`, "g"), "\n");
+  }
+  return output.trimEnd();
+}
+
+function appendTomlSections(content, sections) {
+  const prefix = String(content || "").trimEnd();
+  return `${prefix ? `${prefix}\n\n` : ""}${sections.trim()}\n`;
+}
+
 function buildOpenCodePlugin(command, baseArgs) {
   const events = [
     "command.executed",
@@ -580,16 +858,53 @@ function buildReadme(manifest) {
   ].join("\n") + "\n";
 }
 
-function formatInstallSuccess(result, args) {
+function runPostInstall(result, args = {}) {
+  if (args["post-install"] === "false") return { ok: true, skipped: true };
+  const checkin = spawnSync(result.generatedFiles.checkinScript, [], {
+    encoding: "utf8",
+    timeout: Number(args["post-install-timeout-ms"] || 15000)
+  });
+  const register = spawnSync(result.generatedFiles.registerAutoUpdateScript, [], {
+    encoding: "utf8",
+    timeout: Number(args["post-install-timeout-ms"] || 15000)
+  });
+  return {
+    ok: checkin.status === 0,
+    registered: register.status === 0,
+    checkinStatus: checkin.status,
+    registerStatus: register.status,
+    error: checkin.error?.message || ""
+  };
+}
+
+function formatInstallSuccess(result, args, postInstall = {}) {
   const tool = result.manifest?.selectedTool || args.tool || "codex";
   const employeeAlias = args["employee-pinyin"] || args["employee-id"] || "未填写";
+  const integrationLine = result.integrations?.skipped
+    ? "工具配置: 已跳过"
+    : result.integrations?.ok
+      ? `工具配置: 已写入 ${integrationSummary(result.integrations.items)}`
+      : `工具配置: 部分失败 ${integrationSummary(result.integrations.items)}`;
+  const checkinLine = postInstall.skipped
+    ? "中心端登记: 已跳过"
+    : postInstall.ok
+      ? "中心端登记: 已完成"
+      : "中心端登记: 未完成，后台任务会继续重试";
   return [
     "AI WorkLens 安装成功",
     `工具: ${tool} / 注册名: ${employeeAlias}`,
-    `配置目录: ${result.targetDir}`
+    `配置目录: ${result.targetDir}`,
+    integrationLine,
+    checkinLine
   ].join("\n") + "\n";
 }
 
+function integrationSummary(items = []) {
+  if (!items.length) return "";
+  const labels = { codex: "Codex", "claude-code": "Claude Code", opencode: "OpenCode" };
+  return items.map((item) => `${labels[item.tool] || item.tool}${item.ok ? "" : "失败"}`).join(" / ");
+}
+
 function formatInstallFailure(error) {
   return [
     "AI WorkLens 安装失败",
@@ -620,13 +935,18 @@ if (isMainModule()) {
       role: args.role,
       clientId: args["client-id"],
       tool: args.tool,
+      homeDir: args["home-dir"],
+      integrations: args.integrations,
+      writeToolConfigs: args["write-tool-configs"] !== "false" && args["write-tool-configs"] !== "0",
+      useToolCli: args["use-tool-cli"] !== "false" && args["use-tool-cli"] !== "0",
       modelProvider: args["model-provider"],
       modelName: args["model-name"],
       modelVersion: args["model-version"],
       modelFamily: args["model-family"]
     });
-    if (args.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-    else process.stdout.write(formatInstallSuccess(result, args));
+    const postInstall = runPostInstall(result, args);
+    if (args.json) process.stdout.write(`${JSON.stringify({ ...result, postInstall }, null, 2)}\n`);
+    else process.stdout.write(formatInstallSuccess(result, args, postInstall));
   } catch (error) {
     if (args.json) process.stderr.write(`${JSON.stringify({ ok: false, error: error.message }, null, 2)}\n`);
     else process.stderr.write(formatInstallFailure(error));

package/src/protocol/client-update-policy.mjs

@@ -1,10 +1,10 @@
-export const CLIENT_AGENT_VERSION = "0.1.0";
+export const CLIENT_AGENT_VERSION = "0.1.4";
 
 export const DEFAULT_CLIENT_UPDATE_POLICY = {
   enabled: true,
   autoUpdate: true,
   clientVersion: CLIENT_AGENT_VERSION,
-  artifactRevision: "0.1.0",
+  artifactRevision: CLIENT_AGENT_VERSION,
   checkIntervalMinutes: 360,
   registerBackgroundTask: true,
   refreshArtifacts: true

package/src/protocol/event-types.mjs

@@ -31,6 +31,35 @@ export function eventTypeLabel(type) {
   return eventTypeDefinition(type)?.label || "工具调用";
 }
 
+const FALLBACK_SECONDS_BY_EVENT_TYPE = {
+  session_start: 10,
+  session_end: 10,
+  user_prompt: 30,
+  assistant_response: 45,
+  planning: 45,
+  research: 45,
+  implementation: 45,
+  document: 45,
+  tool_call: 20,
+  tool_result: 20,
+  mcp_tool_call: 20,
+  skill_use: 30,
+  plugin_use: 30,
+  command: 20,
+  mode_change: 10,
+  permission: 10,
+  verification: 30,
+  retry: 30,
+  rework: 30,
+  error: 10
+};
+
+function eventDurationSeconds(event = {}) {
+  const explicit = Number(event.metrics?.durationSeconds ?? event.durationSeconds ?? 0);
+  if (Number.isFinite(explicit) && explicit > 0) return explicit;
+  return FALLBACK_SECONDS_BY_EVENT_TYPE[event.eventType] || 20;
+}
+
 export function eventTypeDistribution(events = [], { includeZero = false, limit = EVENT_TYPE_DEFINITIONS.length } = {}) {
   const buckets = new Map(EVENT_TYPE_DEFINITIONS.map((item) => [
     item.type,
@@ -41,14 +70,14 @@ export function eventTypeDistribution(events = [], { includeZero = false, limit
       description: item.description,
       order: item.order,
       events: 0,
-      minutes: 0
+      seconds: 0
     }
   ]));
   for (const event of events) {
     const type = EVENT_TYPES.has(event.eventType) ? event.eventType : "tool_call";
     const bucket = buckets.get(type);
     bucket.events += 1;
-    bucket.minutes += Math.round(Number(event.metrics?.durationSeconds || 0) / 60);
+    bucket.seconds += eventDurationSeconds(event);
   }
   return [...buckets.values()]
     .filter((item) => includeZero || item.events > 0)
@@ -57,5 +86,8 @@ export function eventTypeDistribution(events = [], { includeZero = false, limit
       return a.order - b.order;
     })
     .slice(0, limit)
-    .map(({ order, ...item }) => item);
+    .map(({ order, seconds, ...item }) => ({
+      ...item,
+      minutes: item.events ? Math.max(1, Math.round(seconds / 60)) : 0
+    }));
 }

package/src/publish-npm.mjs

@@ -44,7 +44,7 @@ export function usage() {
     "Notes:",
     "  - Public npm scoped packages require --access public.",
     "  - For @scope/name, the npm account token must have permission for that scope.",
-    "  - Token can be passed through NPM_TOKEN or --token; it is written only to a temporary .npmrc."
+    "  - Token can be passed through NPM_TOKEN or --token; it is written only to a temporary .npmrc and deleted after publish."
   ].join("\n");
 }
 
@@ -109,7 +109,7 @@ export function buildNpmPublishArgs(stagedDir, options = {}) {
     "--access",
     options.access || "public",
     "--tag",
-    options.tag || "latest",
+    normalizeNpmPublishTag(options.tag),
     "--cache",
     path.join(stagedDir, ".npm-cache"),
     ...(options.dryRun ? ["--dry-run"] : []),
@@ -118,17 +118,73 @@ export function buildNpmPublishArgs(stagedDir, options = {}) {
   ];
 }
 
+export function normalizeNpmPublishTag(value = "latest") {
+  const tag = String(value || "latest").trim() || "latest";
+  if (/^(?:v)?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(tag)) return "latest";
+  if (/^[~^<>=*]*\d/.test(tag)) return "latest";
+  return tag;
+}
+
 export function publishToNpm(options = {}) {
   if (!options.dryRun && !options.token) {
     throw new Error("NPM_TOKEN is required for real public npm publish; use --dry-run to preview without token");
   }
-  const prepared = preparePublishDirectory(options);
-  const args = buildNpmPublishArgs(prepared.tempDir, options);
-  const result = spawnSync("npm", args, { stdio: "inherit" });
-  if (result.status !== 0) {
-    throw new Error(`npm publish failed with exit code ${result.status}`);
+  let prepared = null;
+  try {
+    prepared = preparePublishDirectory(options);
+    const args = buildNpmPublishArgs(prepared.tempDir, options);
+    const result = spawnSync("npm", args, { encoding: "utf8" });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      throw new Error(formatNpmPublishFailure(result));
+    }
+    return {
+      ...prepared,
+      ok: true,
+      registry: options.registry || PUBLIC_NPM_REGISTRY,
+      tag: normalizeNpmPublishTag(options.tag),
+      dryRun: options.dryRun === true,
+      status: result.status,
+      stdout: sanitizeNpmOutput(result.stdout || ""),
+      stderr: sanitizeNpmOutput(result.stderr || "")
+    };
+  } finally {
+    if (prepared?.tempDir && !options.keepStagedDir) {
+      fs.rmSync(prepared.tempDir, { recursive: true, force: true });
+    }
   }
-  return prepared;
+}
+
+export function formatNpmPublishFailure(result = {}) {
+  const status = result.status ?? result.signal ?? "unknown";
+  const output = summarizeNpmOutput([result.stderr, result.stdout].filter(Boolean).join("\n"));
+  const suffix = output ? `: ${output}` : "";
+  return `npm publish failed with exit code ${status}${suffix}`;
+}
+
+function sanitizeNpmOutput(value = "") {
+  return String(value || "")
+    .replace(/(_authToken=)[^\s]+/gi, "$1<redacted>")
+    .replace(/(\/\/[^:\s]+\/?:_authToken=)[^\s]+/gi, "$1<redacted>")
+    .trim()
+    .slice(0, 4000);
+}
+
+function summarizeNpmOutput(value = "") {
+  const lines = sanitizeNpmOutput(value)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => !/complete log of this run/i.test(line));
+  const errorLines = lines.filter((line) => /^npm\s+error\b/i.test(line));
+  const selected = errorLines.length
+    ? errorLines
+    : lines.filter((line) => !/^npm\s+notice\b/i.test(line));
+  return (selected.length ? selected : lines.slice(-8))
+    .join("\n")
+    .slice(0, 1600);
 }
 
 if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {

package/src/uploader.mjs

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { EventQueue } from "./queue.mjs";
 import { writeClientConfig } from "./config.mjs";
@@ -303,6 +304,7 @@ export class ClientAgent {
         clientId: this.config.clientId,
         clientVersion: policy.clientVersion,
         tool: this.config.tool,
+        homeDir: this.config.homeDir,
         modelProvider: this.config.model?.provider || "",
         modelName: this.config.model?.name || "",
         modelVersion: this.config.model?.version || "",
@@ -396,6 +398,20 @@ export class ClientAgent {
       this.config.update?.enabled !== false && this.config.update?.autoUpdate !== false,
       "中心端已关闭客户端静默更新"
     ));
+    if (this.config.tool === "codex") {
+      const codexHooks = codexHookDiagnostics(this.config);
+      checks.push(check(
+        "codex_hooks_configured",
+        codexHooks.configured,
+        "Codex hook 未配置到 ~/.codex/hooks.json，无法静默采集提示词、工具、MCP 和模式事件"
+      ));
+      checks.push(check(
+        "codex_hooks_enabled",
+        codexHooks.enabled,
+        codexHooks.message
+      ));
+      status.codexHooks = codexHooks;
+    }
 
     const issues = checks.filter((item) => !item.ok).map((item) => item.message);
     return {
@@ -413,6 +429,92 @@ function check(name, ok, message = "") {
   return { name, ok: Boolean(ok), message: ok ? "" : message };
 }
 
+function codexHookDiagnostics(config) {
+  const homeDir = config.homeDir || "";
+  const hooksPath = path.join(homeDir, ".codex", "hooks.json");
+  const configPath = path.join(homeDir, ".codex", "config.toml");
+  const hookEvents = new Set(["session_start", "pre_tool_use", "post_tool_use", "user_prompt_submit", "stop"]);
+  const configuredEvents = codexConfiguredHookEvents(hooksPath);
+  const disabledStates = codexDisabledHookStates(configPath, hooksPath, hookEvents);
+  return {
+    hooksPath,
+    configPath,
+    configured: configuredEvents.length > 0,
+    configuredEvents,
+    enabled: disabledStates.length === 0,
+    disabledStates,
+    message: disabledStates.length
+      ? `Codex hook 已配置但未启用：${disabledStates.join("、")}，请重新运行安装命令或执行 worklens-agent-install 修复。`
+      : ""
+  };
+}
+
+function codexConfiguredHookEvents(hooksPath) {
+  try {
+    if (!fs.existsSync(hooksPath)) return [];
+    const hooks = JSON.parse(fs.readFileSync(hooksPath, "utf8"));
+    return Object.entries(hooks.hooks || {})
+      .filter(([, entries]) => entriesContainWorkLensHook(entries))
+      .map(([eventName]) => eventName);
+  } catch {
+    return [];
+  }
+}
+
+function entriesContainWorkLensHook(entries) {
+  return (Array.isArray(entries) ? entries : []).some((entry) => {
+    return (entry.hooks || []).some((hook) => workLensHookPattern().test(String(hook.command || "")));
+  });
+}
+
+function workLensHookPattern() {
+  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.sh)/i;
+}
+
+function codexDisabledHookStates(configPath, hooksPath, hookEvents) {
+  try {
+    if (!fs.existsSync(configPath)) return [];
+    const lines = fs.readFileSync(configPath, "utf8").split(/\n/);
+    let current = "";
+    let currentMatches = false;
+    const disabled = [];
+    for (const line of lines) {
+      const section = line.match(/^\[hooks\.state\."((?:\\.|[^"\\])*)"\]\s*$/);
+      if (section) {
+        current = parseTomlQuotedString(section[1]);
+        currentMatches = isCodexHookStateKey(current, hooksPath, hookEvents);
+        continue;
+      }
+      if (/^\[[^\]]+\]\s*$/.test(line)) {
+        current = "";
+        currentMatches = false;
+        continue;
+      }
+      if (currentMatches && /^enabled\s*=\s*false\s*$/.test(line)) {
+        disabled.push(current.slice(`${hooksPath}:`.length).split(":")[0]);
+      }
+    }
+    return [...new Set(disabled)];
+  } catch {
+    return [];
+  }
+}
+
+function parseTomlQuotedString(value) {
+  try {
+    return JSON.parse(`"${value}"`);
+  } catch {
+    return String(value || "");
+  }
+}
+
+function isCodexHookStateKey(stateKey, hooksPath, hookEvents) {
+  const prefix = `${hooksPath}:`;
+  if (!String(stateKey || "").startsWith(prefix)) return false;
+  const eventName = String(stateKey).slice(prefix.length).split(":")[0];
+  return hookEvents.has(eventName);
+}
+
 function clampAccepted(value, batchLength) {
   const accepted = Number(value);
   if (!Number.isFinite(accepted)) return batchLength;