teamai-cli 0.23.0-beta.6 → 0.23.0-beta.8

package/README.md

@@ -195,7 +195,7 @@ Task: Fix duplicate project-level Hook injection
 Consider running /teamai-share-learnings to summarize what you learned and share it with your team.
 ```
 
-The hint names the non-zero friction signals that triggered it and, when available, includes a redacted, single-line summary of the first task. The `/teamai-share-learnings` skill summarizes the session and pushes a learning document directly to the team repo. Each session is prompted at most once.
+The hint names the non-zero friction signals that triggered it and, when available, includes a redacted, single-line summary of the first task. The `/teamai-share-learnings` skill summarizes the session and pushes a learning document directly to the team repo. Each session is prompted at most once. Teams can switch the hint off with `sharing.contributeHint.enabled: false` in `teamai.yaml` (members: `contributeHintEnabled` in local config) while keeping the rest of the Stop hook.
 
 ### Team Knowledge Recall
 

package/README.zh-CN.md

@@ -195,7 +195,7 @@ Task: Fix duplicate project-level Hook injection
 Consider running /teamai-share-learnings to summarize what you learned and share it with your team.
 ```
 
-提示会列出实际触发它的非零摩擦信号；如果能取得首个任务摘要，还会在脱敏、单行化后附上任务上下文。`/teamai-share-learnings` skill 自动总结 session 经验并推送到团队仓库。每个 session 最多提示一次。
+提示会列出实际触发它的非零摩擦信号；如果能取得首个任务摘要，还会在脱敏、单行化后附上任务上下文。`/teamai-share-learnings` skill 自动总结 session 经验并推送到团队仓库。每个 session 最多提示一次。团队可在 `teamai.yaml` 设置 `sharing.contributeHint.enabled: false` 关闭该提示（成员可用本地配置 `contributeHintEnabled` 覆盖），Stop hook 的其余功能不受影响。
 
 ### 团队知识检索
 

package/dist/index.js

@@ -250,6 +250,7 @@ __export(types_exports, {
   getStatePath: () => getStatePath,
   getTeamaiHome: () => getTeamaiHome,
   isAgentDisabled: () => isAgentDisabled,
+  isContributeHintEnabled: () => isContributeHintEnabled,
   isRecallEnabled: () => isRecallEnabled,
   isSelfMode: () => isSelfMode,
   legacyManagedMcpManifestPath: () => legacyManagedMcpManifestPath,
@@ -288,6 +289,11 @@ function isRecallEnabled(localConfig, teamConfig) {
   if (localConfig.recallEnabled !== void 0) return localConfig.recallEnabled;
   return getRecallSharing(teamConfig).enabled;
 }
+function isContributeHintEnabled(localConfig, teamConfig, env = process.env) {
+  if (env.TEAMAI_CONTRIBUTE_HINT_DISABLED === "1") return false;
+  if (localConfig.contributeHintEnabled !== void 0) return localConfig.contributeHintEnabled;
+  return teamConfig.sharing?.contributeHint?.enabled ?? true;
+}
 function resolveCoAuthor(localConfig, teamConfig) {
   if (localConfig.coAuthorEnabled !== void 0) return localConfig.coAuthorEnabled;
   return teamConfig.sharing?.coAuthor?.enabled;
@@ -478,6 +484,16 @@ var init_types = __esm({
       recall: z.object({
         enabled: z.boolean().default(false)
       }).optional(),
+      // Optional (not .default) so existing TeamaiConfig literals stay valid; use
+      // isContributeHintEnabled() for the resolved view.
+      contributeHint: z.object({
+        /** Team default: whether the Stop hook nudges members to run
+         *  /teamai-share-learnings after a high-friction session. Teams that route
+         *  knowledge sharing through their own review flow can turn the nudge off
+         *  without disabling the rest of the Stop hook (update check, votes sync,
+         *  dashboard reporting). */
+        enabled: z.boolean().default(true)
+      }).optional(),
       // Optional (not .default) so existing TeamaiConfig literals stay valid, AND so
       // "team has no opinion" (block absent) stays distinct from "team says off"
       // (enabled: false). Only the former is a no-op; see resolveCoAuthor().
@@ -638,6 +654,8 @@ var init_types = __esm({
       excludedSkills: z.array(z.string()).optional(),
       /** User-level override for recall feature. When set, takes precedence over team config. */
       recallEnabled: z.boolean().optional(),
+      /** User-level override for the share-learnings hint. When set, takes precedence over team config. */
+      contributeHintEnabled: z.boolean().optional(),
       /** Per-machine override for the co-author trailer in AI-tool commits. When set,
        *  takes precedence over the team `sharing.coAuthor` default. Undefined means
        *  "defer to the team" (see resolveCoAuthor). */
@@ -747,7 +765,18 @@ var init_types = __esm({
       "instead",
       "don't",
       "that's not",
-      "not what"
+      "not what",
+      // Japanese: "that's wrong" / "not that" / "redo" / "you got it wrong" / "on your own" / "put it back".
+      "\u9055\u3046",
+      "\u3061\u304C\u3046",
+      "\u305D\u3046\u3058\u3083\u306A",
+      "\u305D\u3046\u3067\u306F\u306A",
+      "\u3084\u308A\u76F4",
+      "\u3084\u308A\u306A\u304A\u3057",
+      "\u9593\u9055\u3063\u3066",
+      "\u9593\u9055\u3048",
+      "\u52DD\u624B\u306B",
+      "\u623B\u3057\u3066"
     ];
     INTERVENTION_SCAN_MAX_BYTES = 50 * 1024 * 1024;
     TRANSCRIPT_INTERRUPT_PREFIX = "[Request interrupted by user";
@@ -869,15 +898,17 @@ async function readJson(filePath) {
 async function writeJson(filePath, data) {
   await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
 }
-async function writeJsonAtomic(filePath, data) {
+async function writeJsonAtomic(filePath, data, options) {
   const expanded = expandHome(filePath);
   await fse.ensureDir(path3.dirname(expanded));
   const content = JSON.stringify(data, null, 2) + "\n";
-  let mode = 384;
-  try {
-    mode = (await fse.stat(expanded)).mode & 511;
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
+  let mode = options?.mode ?? 384;
+  if (options?.mode === void 0) {
+    try {
+      mode = (await fse.stat(expanded)).mode & 511;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
   }
   const tmp = `${expanded}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`;
   try {
@@ -6562,22 +6593,32 @@ async function readLastAssistantOutput(transcriptPath) {
   }
 }
 async function scanTranscriptStop(transcriptPath, opts) {
+  if (path20.basename(transcriptPath) === "index.json") {
+    const cb = await scanCodebuddyIndex(transcriptPath, opts?.frictionOnly ?? false);
+    if (cb) return cb;
+  }
+  const initial = await scanJsonlTranscriptOnce(transcriptPath);
+  if (opts?.frictionOnly || !isCodexTool(opts?.tool)) return initial.result;
+  const flushedSnapshot = await waitForCodexUsageFlush(transcriptPath, initial.codexSnapshot);
+  return flushedSnapshot ? { ...initial.result, tokens: flushedSnapshot.tokens, tokenScope: flushedSnapshot.scope } : initial.result;
+}
+async function scanJsonlTranscriptOnce(transcriptPath) {
   let interrupt = 0;
   let toolReject = 0;
   let toolError = 0;
   let prompts = 0;
   const tokens = emptyTokenUsage();
+  let codexSessionSnapshot = null;
+  let codexTranscriptSnapshot = null;
   const countedUsageKeys = /* @__PURE__ */ new Set();
-  if (path20.basename(transcriptPath) === "index.json") {
-    const cb = await scanCodebuddyIndex(transcriptPath, opts?.frictionOnly ?? false);
-    if (cb) return cb;
-  }
   try {
     const stat8 = await fs9.promises.stat(transcriptPath);
-    if (stat8.size === 0) return { interrupt, toolReject, toolError, tokens, prompts };
+    if (stat8.size === 0) {
+      return { result: { interrupt, toolReject, toolError, tokens, prompts }, codexSnapshot: null };
+    }
     if (stat8.size > INTERVENTION_SCAN_MAX_BYTES) {
       log.warn(`dashboard: transcript too large to scan (${stat8.size} bytes)`);
-      return { interrupt, toolReject, toolError, tokens, prompts };
+      return { result: { interrupt, toolReject, toolError, tokens, prompts }, codexSnapshot: null };
     }
     const rl = readline2.createInterface({
       input: fs9.createReadStream(transcriptPath, { encoding: "utf-8" }),
@@ -6585,13 +6626,19 @@ async function scanTranscriptStop(transcriptPath, opts) {
     });
     for await (const line of rl) {
       const trimmed = line.trim();
-      if (!trimmed || !trimmed.includes('"user"') && !trimmed.includes('"assistant"')) continue;
+      if (!trimmed || !trimmed.includes('"user"') && !trimmed.includes('"assistant"') && !trimmed.includes('"token_usage_record"') && !trimmed.includes('"token_count"')) continue;
       let entry;
       try {
         entry = JSON.parse(trimmed);
       } catch {
         continue;
       }
+      const codexUsage = parseCodexCumulativeUsage(entry);
+      if (codexUsage) {
+        if (codexUsage.scope === "session") codexSessionSnapshot = codexUsage;
+        else codexTranscriptSnapshot = codexUsage;
+        continue;
+      }
       if (entry.type === "assistant") {
         const usage = entry.message?.usage;
         const dedupKey2 = typeof entry.message?.id === "string" ? entry.message.id : typeof entry.requestId === "string" ? entry.requestId : void 0;
@@ -6638,7 +6685,97 @@ async function scanTranscriptStop(transcriptPath, opts) {
   } catch (e) {
     log.warn(`dashboard: failed to scan transcript: ${e.message}`);
   }
-  return { interrupt, toolReject, toolError, tokens, prompts };
+  const codexSnapshot = codexSessionSnapshot ?? codexTranscriptSnapshot;
+  const result = {
+    interrupt,
+    toolReject,
+    toolError,
+    tokens: codexSnapshot?.tokens ?? tokens,
+    prompts,
+    ...codexSnapshot ? { tokenScope: codexSnapshot.scope } : {}
+  };
+  return { result, codexSnapshot };
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function codexUsageToTokenUsage(usage) {
+  const inclusiveInput = toNum(usage.input_tokens);
+  const cacheRead = toNum(usage.cached_input_tokens);
+  const cacheCreation = toNum(usage.cache_write_input_tokens);
+  return {
+    input: Math.max(0, inclusiveInput - cacheRead - cacheCreation),
+    output: toNum(usage.output_tokens),
+    cacheRead,
+    cacheCreation
+  };
+}
+function parseCodexCumulativeUsage(entry) {
+  const payload = asRecord(entry.payload);
+  if (entry.type === "token_usage_record") {
+    const usage = asRecord(payload?.thread_token_usage);
+    return usage ? { tokens: codexUsageToTokenUsage(usage), scope: "session" } : null;
+  }
+  if (entry.type === "event_msg" && payload?.type === "token_count") {
+    const usage = asRecord(asRecord(payload.info)?.total_token_usage);
+    return usage ? { tokens: codexUsageToTokenUsage(usage), scope: "transcript" } : null;
+  }
+  return null;
+}
+function isCodexTool(tool) {
+  return typeof tool === "string" && tool.toLowerCase().includes("codex");
+}
+function codexSnapshotEquals(a, b) {
+  return a !== null && a.scope === b.scope && a.tokens.input === b.tokens.input && a.tokens.output === b.tokens.output && a.tokens.cacheRead === b.tokens.cacheRead && a.tokens.cacheCreation === b.tokens.cacheCreation;
+}
+function preferCodexSnapshot(current, observed) {
+  if (current?.scope === "session" && observed.scope === "transcript") return current;
+  return observed;
+}
+async function readLatestCodexUsageFromTail(transcriptPath) {
+  try {
+    const stat8 = await fs9.promises.stat(transcriptPath);
+    if (stat8.size === 0) return null;
+    const readSize = Math.min(stat8.size, CODEX_USAGE_TAIL_BYTES);
+    const offset = stat8.size - readSize;
+    const fh = await fs9.promises.open(transcriptPath, "r");
+    try {
+      const buffer = Buffer.alloc(readSize);
+      await fh.read(buffer, 0, readSize, offset);
+      const lines = buffer.toString("utf-8").split("\n");
+      if (offset > 0) lines.shift();
+      let latestSession = null;
+      let latestTranscript = null;
+      for (const line of lines) {
+        if (!line.includes('"token_usage_record"') && !line.includes('"token_count"')) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const snapshot = parseCodexCumulativeUsage(parsed);
+          if (snapshot?.scope === "session") latestSession = snapshot;
+          else if (snapshot) latestTranscript = snapshot;
+        } catch {
+        }
+      }
+      return latestSession ?? latestTranscript;
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return null;
+  }
+}
+async function waitForCodexUsageFlush(transcriptPath, initial) {
+  let latest = initial;
+  for (let attempt = 1; attempt < CODEX_USAGE_MAX_ATTEMPTS; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, CODEX_USAGE_RETRY_MS));
+    const observed = await readLatestCodexUsageFromTail(transcriptPath);
+    if (!observed) continue;
+    latest = preferCodexSnapshot(latest, observed);
+    if (!codexSnapshotEquals(initial, latest) && (initial !== null || totalTokenCount(latest.tokens) > 0)) {
+      return latest;
+    }
+  }
+  return latest;
 }
 async function readCodebuddyIndexOnce(transcriptPath) {
   try {
@@ -6834,7 +6971,7 @@ async function parseHookEvent(raw, tool) {
     if (output) {
       event.stoppedOutput = output;
     }
-    const scan = await scanTranscriptStop(hookData.transcript_path);
+    const scan = await scanTranscriptStop(hookData.transcript_path, { tool });
     if (scan.interrupt > 0 || scan.toolReject > 0 || scan.toolError > 0) {
       event.interventions = {
         interrupt: scan.interrupt,
@@ -6844,6 +6981,7 @@ async function parseHookEvent(raw, tool) {
     }
     if (scan.tokens.input > 0 || scan.tokens.output > 0 || scan.tokens.cacheRead > 0 || scan.tokens.cacheCreation > 0) {
       event.tokens = scan.tokens;
+      if (scan.tokenScope) event.tokenScope = scan.tokenScope;
     }
     if (scan.prompts > 0) {
       event.prompts = scan.prompts;
@@ -6984,11 +7122,23 @@ function rebuildSessions(events) {
   });
   return result;
 }
+function setLatestTokenSnapshot(snapshots, key, event) {
+  if (!event.tokens) return;
+  const current = snapshots.get(key);
+  const candidateTime = Date.parse(event.timestamp);
+  const currentTime = current ? Date.parse(current.timestamp) : Number.NaN;
+  if (!current || !Number.isFinite(candidateTime) || !Number.isFinite(currentTime) || candidateTime >= currentTime) {
+    snapshots.set(key, { timestamp: event.timestamp, tokens: event.tokens });
+  }
+}
 function aggregateSessionMetrics(events) {
   const map = /* @__PURE__ */ new Map();
   const lastStopAt = /* @__PURE__ */ new Map();
   const submitCount = /* @__PURE__ */ new Map();
   const stopPrompts = /* @__PURE__ */ new Map();
+  const unscopedTokens = /* @__PURE__ */ new Map();
+  const sessionTokens = /* @__PURE__ */ new Map();
+  const transcriptTokens = /* @__PURE__ */ new Map();
   for (const event of events) {
     let m = map.get(event.sessionId);
     if (!m) {
@@ -7001,7 +7151,18 @@ function aggregateSessionMetrics(events) {
         m.toolReject = event.interventions.toolReject;
       }
       if (event.tokens) {
-        m.tokens = { ...event.tokens };
+        if (event.tokenScope === "session") {
+          setLatestTokenSnapshot(sessionTokens, event.sessionId, event);
+        } else if (event.tokenScope === "transcript" && event.transcriptPath) {
+          let segments = transcriptTokens.get(event.sessionId);
+          if (!segments) {
+            segments = /* @__PURE__ */ new Map();
+            transcriptTokens.set(event.sessionId, segments);
+          }
+          setLatestTokenSnapshot(segments, event.transcriptPath, event);
+        } else {
+          setLatestTokenSnapshot(unscopedTokens, event.sessionId, event);
+        }
       }
       if (typeof event.prompts === "number") {
         stopPrompts.set(event.sessionId, event.prompts);
@@ -7020,6 +7181,18 @@ function aggregateSessionMetrics(events) {
     }
   }
   for (const [sid, m] of map) {
+    const sessionSnapshot = sessionTokens.get(sid);
+    const segments = transcriptTokens.get(sid);
+    if (sessionSnapshot) {
+      m.tokens = { ...sessionSnapshot.tokens };
+    } else if (segments && segments.size > 0) {
+      let total = emptyTokenUsage();
+      for (const segment of segments.values()) total = addTokenUsage(total, segment.tokens);
+      m.tokens = total;
+    } else {
+      const unscoped = unscopedTokens.get(sid);
+      if (unscoped) m.tokens = { ...unscoped.tokens };
+    }
     m.prompts = Math.max(submitCount.get(sid) ?? 0, stopPrompts.get(sid) ?? 0);
   }
   return map;
@@ -7062,7 +7235,7 @@ async function dashboardReport(toolArg) {
   compactEvents().catch(() => {
   });
 }
-var TRANSCRIPT_TAIL_BYTES, STOPPED_OUTPUT_MAX_CHARS, CODEBUDDY_USAGE_MAX_ATTEMPTS, CODEBUDDY_USAGE_RETRY_MS, CODEBUDDY_BLOB_MAX_COUNT, CODEBUDDY_REJECT_MARKER;
+var TRANSCRIPT_TAIL_BYTES, STOPPED_OUTPUT_MAX_CHARS, CODEX_USAGE_TAIL_BYTES, CODEX_USAGE_MAX_ATTEMPTS, CODEX_USAGE_RETRY_MS, CODEBUDDY_USAGE_MAX_ATTEMPTS, CODEBUDDY_USAGE_RETRY_MS, CODEBUDDY_BLOB_MAX_COUNT, CODEBUDDY_REJECT_MARKER;
 var init_dashboard_collector = __esm({
   "src/dashboard-collector.ts"() {
     "use strict";
@@ -7077,6 +7250,9 @@ var init_dashboard_collector = __esm({
     init_home();
     TRANSCRIPT_TAIL_BYTES = 10240;
     STOPPED_OUTPUT_MAX_CHARS = 500;
+    CODEX_USAGE_TAIL_BYTES = 256 * 1024;
+    CODEX_USAGE_MAX_ATTEMPTS = 8;
+    CODEX_USAGE_RETRY_MS = 250;
     CODEBUDDY_USAGE_MAX_ATTEMPTS = 8;
     CODEBUDDY_USAGE_RETRY_MS = 250;
     CODEBUDDY_BLOB_MAX_COUNT = 2e3;
@@ -8270,6 +8446,12 @@ import path26 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 import fse4 from "fs-extra";
+function modelAgentKind(tool) {
+  const normalized = normalizeAgentType(tool ?? "");
+  if (normalized === "codebuddy" || normalized === "codebuddy-internal") return "codebuddy";
+  if (normalized === "claude") return "claude";
+  return void 0;
+}
 function isUnimplementedCommand(command) {
   const type = command.type ?? "";
   if (IMPLEMENTED_HOOK_COMMAND_TYPES.has(type)) return false;
@@ -8287,6 +8469,9 @@ function getConfigPath2() {
 function getManifestPath() {
   return path26.join(getLocalAgentHome(), MANIFEST_FILE);
 }
+function getModelManifestPath() {
+  return path26.join(getLocalAgentHome(), MODEL_MANIFEST_FILE);
+}
 function getErrorLogPath() {
   return path26.join(getTeamaiHomePath(), REPORTER_ERROR_LOG);
 }
@@ -8994,7 +9179,7 @@ function collectManifestSlugs(manifest) {
   }
   return { skills, rules };
 }
-async function scanMcpFromManifest(scope, projectRoot) {
+async function scanMcpFromManifest(scope, tool, projectRoot) {
   const { resolveDataHomeForScope: resolveDataHomeForScope2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const dataHome = await resolveDataHomeForScope2(scope, projectRoot);
   let manifest;
@@ -9004,18 +9189,65 @@ async function scanMcpFromManifest(scope, projectRoot) {
   } else {
     manifest = await readJson(managedMcpManifestPath(dataHome)) ?? {};
   }
+  const manifestKey = `${tool}${scope === "project" ? ":project" : ""}`;
+  const records = manifest[manifestKey];
+  if (!Array.isArray(records)) return [];
   const seen = /* @__PURE__ */ new Set();
   const results = [];
-  for (const records of Object.values(manifest)) {
-    if (!Array.isArray(records)) continue;
-    for (const rec of records) {
-      if (!rec.name || seen.has(rec.name)) continue;
-      seen.add(rec.name);
-      results.push({ slug: rec.name, source: "enterprise" });
-    }
+  for (const rec of records) {
+    if (!rec.name || seen.has(rec.name)) continue;
+    seen.add(rec.name);
+    results.push({ slug: rec.name, source: "enterprise" });
   }
   return results.sort((a, b) => a.slug.localeCompare(b.slug));
 }
+async function scanModelsFromDisk(tool) {
+  const manifest = await readJson(getModelManifestPath()) ?? {};
+  const agentKind = modelAgentKind(tool);
+  const providers = (agentKind && manifest.providersByAgent?.[agentKind]) ?? manifest.providers ?? {};
+  if (agentKind === "codebuddy") {
+    const doc = await readJson(
+      path26.join(getUserHome(), ".codebuddy", "models.json")
+    );
+    const entries = Array.isArray(doc?.models) ? doc.models : [];
+    const owned = manifest.codebuddy ?? {};
+    const results = [];
+    for (const entry of entries) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const { id, vendor, name } = entry;
+      if (typeof id !== "string" || !id) continue;
+      if (typeof vendor !== "string" || !vendor) continue;
+      if (owned[id] === void 0 || providers[id] !== vendor) continue;
+      results.push({
+        provider: vendor,
+        model_id: id,
+        ...typeof name === "string" && name ? { name } : {},
+        source: "enterprise"
+      });
+    }
+    return results;
+  }
+  if (agentKind === "claude") {
+    const settings = await readJson(
+      path26.join(getUserHome(), ".claude", "settings.json")
+    );
+    const env = settings?.env;
+    if (typeof env !== "object" || env === null || Array.isArray(env)) return [];
+    const { ANTHROPIC_CUSTOM_MODEL_OPTION: modelId, ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: name } = env;
+    if (typeof modelId !== "string" || !modelId) return [];
+    const managed = manifest.claudeEnv?.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    if (managed === void 0 || entryHash(modelId) !== managed) return [];
+    const provider = providers[modelId];
+    if (!provider) return [];
+    return [{
+      provider,
+      model_id: modelId,
+      ...typeof name === "string" && name ? { name } : {},
+      source: "enterprise"
+    }];
+  }
+  return [];
+}
 async function pruneDeadWorkspaceBindings(config) {
   let changed = false;
   for (const workspacePath of Object.keys(config.workspaceBindings)) {
@@ -9068,8 +9300,10 @@ async function buildReportPayload(config, context) {
   const userLevel = { group_id: config.userGroupId };
   if (userScope.skills.length > 0) userLevel.skills = userScope.skills;
   if (userScope.rules.length > 0) userLevel.rules = userScope.rules;
-  const userMcps = await scanMcpFromManifest("user");
+  const userMcps = await scanMcpFromManifest("user", tool);
   if (userMcps.length > 0) userLevel.mcps = userMcps;
+  const userModels = await scanModelsFromDisk(tool);
+  if (userModels.length > 0) userLevel.models = userModels;
   const payload = {
     agent_type: normalizeAgentType(tool),
     agent_version: await getAgentVersion(tool),
@@ -9100,7 +9334,7 @@ async function buildReportPayload(config, context) {
         };
         if (wsScope.skills.length > 0) workspace.skills = wsScope.skills;
         if (wsScope.rules.length > 0) workspace.rules = wsScope.rules;
-        const wsMcps = await scanMcpFromManifest("project", wsPath);
+        const wsMcps = await scanMcpFromManifest("project", tool, wsPath);
         if (wsMcps.length > 0) workspace.mcps = wsMcps;
         return workspace;
       })
@@ -9484,6 +9718,226 @@ async function ackCommand(config, tag, command, status2, version2, error) {
     })
   });
 }
+function requireModelString(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`apply_model_config: ${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function optionalPositiveInteger(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const normalized = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+  if (!Number.isSafeInteger(normalized) || normalized < 0) {
+    throw new Error(`apply_model_config: ${field} must be a positive integer`);
+  }
+  if (normalized === 0) return void 0;
+  return normalized;
+}
+function parseDeliveredModels(raw) {
+  if (!raw) throw new Error("apply_model_config: missing cmd");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("apply_model_config: cmd must be valid JSON");
+  }
+  const fullSnapshot = typeof parsed === "object" && parsed !== null && "models" in parsed;
+  const values = fullSnapshot ? parsed.models : [parsed];
+  if (!Array.isArray(values)) {
+    throw new Error("apply_model_config: models must be an array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const models = values.map((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new Error("apply_model_config: each model must be an object");
+    }
+    const input = value;
+    const model = {
+      provider: requireModelString(input.provider, "provider"),
+      model_id: requireModelString(input.model_id, "model_id"),
+      name: requireModelString(input.name, "name"),
+      base_url: requireModelString(input.base_url, "base_url"),
+      api_key: requireModelString(input.api_key, "api_key"),
+      max_tokens: optionalPositiveInteger(input.max_tokens, "max_tokens") ?? DEFAULT_MAX_TOKENS,
+      context_window: optionalPositiveInteger(input.context_window, "context_window")
+    };
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(model.base_url);
+    } catch {
+      throw new Error("apply_model_config: base_url must be a valid URL");
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw new Error("apply_model_config: base_url must use http or https");
+    }
+    if (seen.has(model.model_id)) {
+      throw new Error(`apply_model_config: duplicate model_id "${model.model_id}"`);
+    }
+    seen.add(model.model_id);
+    return model;
+  });
+  return { models, fullSnapshot };
+}
+function codebuddyModelEntry(model) {
+  const baseUrl = model.base_url.replace(/\/+$/, "");
+  return {
+    id: model.model_id,
+    name: model.name,
+    vendor: model.provider,
+    apiKey: model.api_key,
+    ...model.context_window === void 0 ? {} : { maxInputTokens: model.context_window },
+    ...model.max_tokens === void 0 ? {} : { maxOutputTokens: model.max_tokens },
+    url: baseUrl.endsWith("/chat/completions") ? baseUrl : `${baseUrl}/chat/completions`,
+    supportsToolCall: true
+  };
+}
+async function readJsonObject(filePath) {
+  const source = await readFileSafe(filePath);
+  if (source === null) return {};
+  try {
+    const parsed = JSON.parse(source);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("root must be an object");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`apply_model_config: cannot parse ${filePath}: ${error.message}`);
+  }
+}
+async function writeModelJson(filePath, data) {
+  let targetPath = filePath;
+  try {
+    if ((await fs12.promises.lstat(filePath)).isSymbolicLink()) {
+      targetPath = await fs12.promises.realpath(filePath);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await writeJsonAtomic(targetPath, data, { mode: 384 });
+}
+async function reconcileCodebuddyModels(models, fullSnapshot, manifest) {
+  const targetFile = path26.join(getUserHome(), ".codebuddy", "models.json");
+  const doc = await readJsonObject(targetFile);
+  const existing = doc.models === void 0 ? [] : doc.models;
+  if (!Array.isArray(existing)) {
+    throw new Error(`apply_model_config: models must be an array in ${targetFile}`);
+  }
+  const previouslyManaged = manifest.codebuddy ?? {};
+  const nextManaged = fullSnapshot ? {} : { ...previouslyManaged };
+  const incomingIds = new Set(models.map((model) => model.model_id));
+  const removedManaged = /* @__PURE__ */ new Set();
+  const preserved = [];
+  const occupiedIds = /* @__PURE__ */ new Set();
+  for (const entry of existing) {
+    const id = typeof entry === "object" && entry !== null && typeof entry.id === "string" ? entry.id : void 0;
+    if (id && previouslyManaged[id] && entryHash(entry) === previouslyManaged[id]) {
+      if (fullSnapshot || incomingIds.has(id)) {
+        removedManaged.add(id);
+        continue;
+      }
+      preserved.push(entry);
+      occupiedIds.add(id);
+      continue;
+    }
+    preserved.push(entry);
+    if (id) occupiedIds.add(id);
+    if (id && previouslyManaged[id]) delete nextManaged[id];
+  }
+  for (const model of models) {
+    if (occupiedIds.has(model.model_id)) continue;
+    const entry = codebuddyModelEntry(model);
+    preserved.push(entry);
+    nextManaged[model.model_id] = entryHash(entry);
+  }
+  doc.models = preserved;
+  if (Array.isArray(doc.availableModels) && doc.availableModels.length > 0) {
+    const available = doc.availableModels.filter(
+      (id) => typeof id === "string" && !removedManaged.has(id)
+    );
+    for (const id of Object.keys(nextManaged)) {
+      if (!available.includes(id)) available.push(id);
+    }
+    doc.availableModels = available;
+  }
+  await writeModelJson(targetFile, doc);
+  manifest.codebuddy = nextManaged;
+}
+function claudeEnvForModel(model) {
+  const baseUrl = model.base_url.replace(/\/+$/, "").replace(/\/v1$/, "");
+  return {
+    ANTHROPIC_BASE_URL: baseUrl,
+    ANTHROPIC_AUTH_TOKEN: model.api_key,
+    ANTHROPIC_CUSTOM_MODEL_OPTION: model.model_id,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: model.name
+  };
+}
+async function reconcileClaudeModels(models, manifest) {
+  const settingsPath = path26.join(getUserHome(), ".claude", "settings.json");
+  const profilePath = path26.join(getUserHome(), ".claude", "teamai-models.json");
+  const previousHashes = manifest.claudeEnv ?? {};
+  const settings = await readJsonObject(settingsPath);
+  const rawEnv = settings.env === void 0 ? {} : settings.env;
+  if (typeof rawEnv !== "object" || rawEnv === null || Array.isArray(rawEnv)) {
+    throw new Error(`apply_model_config: env must be an object in ${settingsPath}`);
+  }
+  const env = { ...rawEnv };
+  if (models.length === 0) {
+    const canRemoveGateway = Object.entries(previousHashes).every(
+      ([key, hash]) => entryHash(env[key]) === hash
+    );
+    if (canRemoveGateway && Object.keys(previousHashes).length > 0) {
+      for (const key of Object.keys(previousHashes)) delete env[key];
+      settings.env = env;
+      await writeModelJson(settingsPath, settings);
+    }
+    await remove(profilePath);
+    manifest.claudeEnv = {};
+    return;
+  }
+  const desired = claudeEnvForModel(models[0]);
+  await writeModelJson(profilePath, { env: desired });
+  const conflictKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(desired),
+    "ANTHROPIC_API_KEY"
+  ]);
+  const canManage = [...conflictKeys].every((key) => env[key] === void 0 || previousHashes[key] !== void 0 && entryHash(env[key]) === previousHashes[key]);
+  if (!canManage) {
+    manifest.claudeEnv = {};
+    return;
+  }
+  for (const [key, hash] of Object.entries(previousHashes)) {
+    if (entryHash(env[key]) === hash) delete env[key];
+  }
+  Object.assign(env, desired);
+  settings.env = env;
+  await writeModelJson(settingsPath, settings);
+  manifest.claudeEnv = Object.fromEntries(
+    Object.entries(desired).map(([key, value]) => [key, entryHash(value)])
+  );
+}
+async function applyModelConfig(command, tool) {
+  const { models, fullSnapshot } = parseDeliveredModels(command.cmd);
+  const manifest = await readJson(getModelManifestPath()) ?? {};
+  const agentKind = modelAgentKind(tool);
+  if (!agentKind) {
+    throw new Error(`apply_model_config: unsupported agent "${tool ?? ""}"`);
+  }
+  const previousProviders = manifest.providersByAgent?.[agentKind] ?? manifest.providers ?? {};
+  const providers = {
+    ...fullSnapshot ? {} : previousProviders,
+    ...Object.fromEntries(models.map((model) => [model.model_id, model.provider]))
+  };
+  manifest.providersByAgent = {
+    ...manifest.providersByAgent,
+    [agentKind]: providers
+  };
+  if (agentKind === "codebuddy") {
+    await reconcileCodebuddyModels(models, fullSnapshot, manifest);
+  } else {
+    await reconcileClaudeModels(models, manifest);
+  }
+  await writeJsonAtomic(getModelManifestPath(), manifest);
+}
 function parseTeamaiCmd(raw) {
   const argv = [];
   let current = "";
@@ -9810,6 +10264,10 @@ async function runMcpCommand(config, command, context) {
   return command.version;
 }
 async function executeCommand(config, command, context) {
+  if (command.type === "apply_model_config") {
+    await applyModelConfig(command, context.tool);
+    return;
+  }
   if (command.type === "uninstall_teamai") {
     return runCmdCommand(command, context);
   }
@@ -9839,18 +10297,20 @@ async function executeCommand(config, command, context) {
 }
 async function processCommands(config, commands, context) {
   const tag = localAgentTag(context);
+  let modelConfigApplied = false;
   for (const command of commands) {
-    if (isUnimplementedCommand(command)) {
+    if (isUnimplementedCommand(command) || command.type !== "apply_model_config" && command.type !== "uninstall_teamai" && command.type !== "install_hook_rule" && command.type !== "uninstall_hook_rule" && command.type !== "install_mcp" && command.type !== "uninstall_mcp" && (!commandKind(command) || !commandAction(command))) {
       log.debug(`${tag} skipping unimplemented command ${command.id} (${command.type})`);
       continue;
     }
     try {
       const version2 = await executeCommand(config, command, context);
       await ackCommand(config, tag, command, "success", version2);
+      if (command.type === "apply_model_config") modelConfigApplied = true;
       log.debug(`${tag} command ${command.id} (${command.type ?? ""}) succeeded`);
       if (command.type === "uninstall_teamai") {
         log.debug(`${tag} uninstall_teamai completed \u2014 remaining commands skipped`);
-        return;
+        return modelConfigApplied;
       }
     } catch (e) {
       const error = e.message;
@@ -9862,6 +10322,7 @@ async function processCommands(config, commands, context) {
       }
     }
   }
+  return modelConfigApplied;
 }
 async function reportAndSyncLocalAgent(context) {
   const config = await loadLocalAgentConfig();
@@ -9911,13 +10372,22 @@ async function reportAndSyncLocalAgent(context) {
       config,
       tag,
       "sync",
-      { method: "POST", body: JSON.stringify(syncPayload) }
+      { method: "POST", body: JSON.stringify(syncPayload) },
+      { redactResponseLog: true }
     );
     const cmds = syncResponse.cmds;
     const commands = cmds && cmds.length > 0 ? cmds : syncResponse.commands ?? [];
     if (commands.length > 0) {
       log.debug(`${tag} sync returned ${commands.length} command(s): ${commands.map((c) => `${c.type}#${c.id}`).join(", ")}`);
-      await processCommands(config, commands, context);
+      const modelConfigApplied = await processCommands(config, commands, context);
+      if (modelConfigApplied && !skipReport) {
+        const reportPayload = await buildReportPayload(config, context);
+        await localAgentFetch(config, tag, "report", {
+          method: "POST",
+          body: JSON.stringify(reportPayload)
+        });
+        log.debug(`${tag} model config report OK`);
+      }
     }
     log.debug(`${tag} sync OK (${commands.length} command(s))`);
   } catch (e) {
@@ -10092,7 +10562,7 @@ async function bindCurrentProject(options) {
     log.info("\u672A\u7ED1\u5B9A\u9879\u76EE\u3002");
   }
 }
-var execFileAsync, LOCAL_AGENT_DIR, CONFIG_FILE, MANIFEST_FILE, REPORTER_ERROR_LOG, LOCAL_AGENT_FETCH_TIMEOUT_MS, LOCAL_AGENT_HOOK_FETCH_TIMEOUT_MS, activeFetchTimeoutMs, UNIMPLEMENTED_COMMAND_TYPES, IMPLEMENTED_HOOK_COMMAND_TYPES, DEFAULT_ROUTES, PLUGIN_PULL_INTERVAL_MS, PLUGIN_FAIL_BACKOFF_MS, ZIP_MAGIC, VALID_MCP_TRANSPORTS;
+var execFileAsync, LOCAL_AGENT_DIR, CONFIG_FILE, MANIFEST_FILE, MODEL_MANIFEST_FILE, REPORTER_ERROR_LOG, LOCAL_AGENT_FETCH_TIMEOUT_MS, LOCAL_AGENT_HOOK_FETCH_TIMEOUT_MS, activeFetchTimeoutMs, UNIMPLEMENTED_COMMAND_TYPES, IMPLEMENTED_HOOK_COMMAND_TYPES, DEFAULT_ROUTES, PLUGIN_PULL_INTERVAL_MS, PLUGIN_FAIL_BACKOFF_MS, ZIP_MAGIC, DEFAULT_MAX_TOKENS, VALID_MCP_TRANSPORTS;
 var init_local_agent = __esm({
   "src/local-agent.ts"() {
     "use strict";
@@ -10123,6 +10593,7 @@ var init_local_agent = __esm({
     LOCAL_AGENT_DIR = "local-agent";
     CONFIG_FILE = "config.json";
     MANIFEST_FILE = "manifest.json";
+    MODEL_MANIFEST_FILE = "model-manifest.json";
     REPORTER_ERROR_LOG = "reporter/errors.jsonl";
     LOCAL_AGENT_FETCH_TIMEOUT_MS = 15e3;
     LOCAL_AGENT_HOOK_FETCH_TIMEOUT_MS = 3e3;
@@ -10139,6 +10610,7 @@ var init_local_agent = __esm({
     PLUGIN_PULL_INTERVAL_MS = 12 * 60 * 60 * 1e3;
     PLUGIN_FAIL_BACKOFF_MS = 60 * 60 * 1e3;
     ZIP_MAGIC = Buffer.from([80, 75, 3, 4]);
+    DEFAULT_MAX_TOKENS = 4096;
     VALID_MCP_TRANSPORTS = /* @__PURE__ */ new Set(["stdio", "http", "sse"]);
   }
 });
@@ -27583,6 +28055,16 @@ var init_mr_hint = __esm({
 
 // src/hook-handlers.ts
 import path86 from "path";
+async function contributeHintAllowed() {
+  const { isContributeHintEnabled: isContributeHintEnabled2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  try {
+    const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { localConfig, teamConfig } = await autoDetectInit2();
+    return isContributeHintEnabled2(localConfig, teamConfig);
+  } catch {
+    return isContributeHintEnabled2({}, {});
+  }
+}
 function buildHandlerRegistry() {
   return [
     // ─── SessionStart ─────────────────────────────────
@@ -27729,6 +28211,7 @@ var init_hook_handlers = __esm({
     contributeCheckHandler = {
       name: "contribute-check",
       async execute(stdin, tool) {
+        if (!await contributeHintAllowed()) return null;
         const { contributeCheckForSession: contributeCheckForSession2 } = await Promise.resolve().then(() => (init_contribute_check(), contribute_check_exports));
         const { formatStopHookOutput: formatStopHookOutput2 } = await Promise.resolve().then(() => (init_hook_output(), hook_output_exports));
         const { STOP_STDOUT_UNSUPPORTED_TOOLS: STOP_STDOUT_UNSUPPORTED_TOOLS2 } = await Promise.resolve().then(() => (init_tool_names(), tool_names_exports));
@@ -27748,7 +28231,8 @@ var init_hook_handlers = __esm({
         if (!STOP_STDOUT_UNSUPPORTED_TOOLS2.has(tool)) return null;
         const sessionId = deriveSessionId(stdin, { includeCwd: true });
         const pending = await Promise.resolve().then(() => (init_contribute_check(), contribute_check_exports));
-        const hint = await pending.takePendingHint(sessionId);
+        const stashed = await pending.takePendingHint(sessionId);
+        const hint = await contributeHintAllowed() ? stashed : null;
         const votesHint = await pending.takePendingVotesHint(sessionId);
         const combined = [hint, votesHint].filter(Boolean).join("\n");
         if (!combined) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamai-cli",
-  "version": "0.23.0-beta.6",
+  "version": "0.23.0-beta.8",
   "description": "TeamAI — Make Every Team AI Native (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {