oh-my-knowledge 0.44.0 → 0.46.0

package/dist/renderer/skill-list-renderer.js

@@ -134,7 +134,7 @@ function renderPanel(a, lang) {
 // renderSkillModal 已移除:首页点行直接进 skill 详情页(doctor/eval/observe 已在该页合一),弹框预览冗余。
 function renderRow(entry, insights, langQ, lang) {
     const h = assessHealth(entry, insights, lang);
-    // 点行先进入 skill hub：Skill Map / 三阶段状态 / Evidence Card 是用户第一视角。
+    // 点行先进入 skill hub：Skill Map / 三阶段状态 / 图谱摘要是用户第一视角。
     const href = `/skills/${encodeURIComponent(entry.skillName)}${langQ}`;
     const dT = entry.doctor ? entry.doctor.passCount + entry.doctor.warnCount + entry.doctor.failCount : 0;
     const dP = dT > 0 ? Math.round(((entry.doctor.passCount + entry.doctor.warnCount * 0.5) / dT) * 100) : null;

package/dist/server/skill-index.js

@@ -412,6 +412,7 @@ function countGraphNodes(graph, nodeKind) {
 }
 function graphNodePreview(node) {
     return {
+        stableKey: node.stableKey,
         nodeKind: node.nodeKind,
         label: node.label,
         ...(node.status ? { status: node.status } : {}),
@@ -474,6 +475,8 @@ function projectEvalStage(graph, path, entry) {
     const nodesById = graphNodeMap(graph);
     const projectedNodeIds = new Set([variantNode.id]);
     const projectedEdgeIds = new Set();
+    const sampleStatusByNodeId = new Map();
+    const assertionStatusByNodeId = new Map();
     if (skillNode)
         projectedNodeIds.add(skillNode.id);
     const addEdge = (edge) => {
@@ -484,6 +487,9 @@ function projectEvalStage(graph, path, entry) {
     for (const edge of graph.edges) {
         if (edge.fromNodeId === variantNode.id && (edge.edgeKind === 'evaluates' || edge.edgeKind === 'derived_from')) {
             addEdge(edge);
+            const to = nodesById.get(edge.toNodeId);
+            if (edge.status && to?.nodeKind === 'sample')
+                sampleStatusByNodeId.set(to.id, edge.status);
         }
     }
     const evalResultNodes = graph.edges
@@ -499,6 +505,36 @@ function projectEvalStage(graph, path, entry) {
             addEdge(edge);
         }
     }
+    const declaredCoverageStableKeys = new Set();
+    const declaredCoverageEdges = [];
+    let coverageEdges = 0;
+    for (const edge of graph.edges) {
+        if (edge.edgeKind !== 'covers')
+            continue;
+        const from = nodesById.get(edge.fromNodeId);
+        const to = nodesById.get(edge.toNodeId);
+        if (from?.nodeKind !== 'sample' || !to)
+            continue;
+        if (!projectedNodeIds.has(from.id))
+            continue;
+        if (artifactHash && nodeArtifactHash(to) !== artifactHash)
+            continue;
+        addEdge(edge);
+        coverageEdges += 1;
+        if (to.stableKey)
+            declaredCoverageStableKeys.add(to.stableKey);
+        if (to.stableKey) {
+            const sampleStatus = sampleStatusByNodeId.get(from.id);
+            declaredCoverageEdges.push({
+                ...(from.stableKey ? { sampleStableKey: from.stableKey } : {}),
+                sampleLabel: from.label,
+                ...(sampleStatus ? { sampleStatus } : {}),
+                targetStableKey: to.stableKey,
+                targetNodeKind: to.nodeKind,
+                targetLabel: to.label,
+            });
+        }
+    }
     const sampleIds = new Set();
     const assertionIds = new Set();
     const diagnosticIds = new Set();
@@ -522,13 +558,31 @@ function projectEvalStage(graph, path, entry) {
             diagnosticIds.add(to.id);
         if (edge.edgeKind === 'fails')
             failedAssertionEdges += 1;
+        if ((edge.edgeKind === 'passes' || edge.edgeKind === 'fails') && edge.status) {
+            if (from?.nodeKind === 'assertion')
+                assertionStatusByNodeId.set(from.id, edge.status);
+            if (to?.nodeKind === 'assertion')
+                assertionStatusByNodeId.set(to.id, edge.status);
+        }
     }
     const measurementNodes = graphNodePreviews(graph, [
         'sample',
         'assertion',
         'eval_result',
         'diagnostic',
-    ], projectedNodeIds);
+    ], projectedNodeIds).map((node) => {
+        if (!node.stableKey)
+            return node;
+        const sourceNode = [...nodesById.values()].find((candidate) => candidate.stableKey === node.stableKey);
+        if (!sourceNode)
+            return node;
+        const status = sourceNode.nodeKind === 'sample'
+            ? sampleStatusByNodeId.get(sourceNode.id)
+            : sourceNode.nodeKind === 'assertion'
+                ? assertionStatusByNodeId.get(sourceNode.id)
+                : undefined;
+        return status ? { ...node, status } : node;
+    });
     return {
         stage: {
             sourceKind: 'eval',
@@ -544,6 +598,9 @@ function projectEvalStage(graph, path, entry) {
             failedAssertionEdges,
             diagnostics: diagnosticIds.size,
             measurementNodes,
+            coverageEdges,
+            declaredCoverageStableKeys: [...declaredCoverageStableKeys].sort(),
+            declaredCoverageEdges: declaredCoverageEdges.sort((a, b) => a.sampleLabel.localeCompare(b.sampleLabel) || a.targetStableKey.localeCompare(b.targetStableKey)),
         },
         ...(artifactHash ? { artifactHash } : {}),
         ...(sourceLocator ? { sourceLocator } : {}),

package/dist/shared/llm-prompts/registry.js

@@ -65,5 +65,6 @@ export const PROMPT_REGISTRY = [
     { promptId: 'sample-fixer', purpose: '坏用例修复', module: 'src/authoring/sample-fixer.ts', measurementInvariant: false },
     { promptId: 'skill-improve', purpose: 'skill 迭代改进(evolve)', module: 'src/authoring/evolver.ts', measurementInvariant: false },
     { promptId: 'doctor-fixer', purpose: 'doctor 健康项修复向导', module: 'src/doctor/fixer.ts', measurementInvariant: false },
-    { promptId: 'skill-health', purpose: 'skill 健康检查打分', module: 'src/shared/llm-prompts/skill-health.ts', measurementInvariant: false },
+    { promptId: 'skill-health', purpose: 'skill 健康度审计(仅 CLI doctor,不进 eval 评分门禁)', module: 'src/shared/llm-prompts/skill-health.ts', measurementInvariant: false },
+    { promptId: 'skill-health-merge', purpose: '多采样 finding 同根因归并(doctor 多采样默认 llm 归并)', module: 'src/shared/llm-prompts/skill-health-merge.ts', measurementInvariant: false },
 ];

package/dist/shared/llm-prompts/skill-health-merge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 多采样 finding 归并 prompt(option C:LLM 合并 pass)。
+ *
+ * 健康度体检跑 N 次后,同一个根因问题常被不同次用**不同措辞**描述。纯字符串键
+ * 去重(consensus.ts findingKey)对"措辞/引用写法不同"会漏并 —— 把同一问题拆成
+ * 多条低支持度 finding。本 prompt 让 LLM 做一次跨采样聚类,把同根因 + 同修复方向
+ * 的 finding 归到一组,框架再据此算 support(k/n)。
+ *
+ * 关键契约:
+ *   - 只在维度内部并(不跨 dim_id),保持维度归属稳定。
+ *   - 每个输入 finding 必须且只属于一个 cluster;无法并的自成一组。
+ *   - 宁可不并,也不要把两个不同问题错并(over-merge 会藏掉真问题,比漏并更糟)。
+ *   - LLM 只负责"哪些 id 归一组 + 合并后文案",**支持度 k/n 由框架算**(不信 LLM 算术)。
+ */
+import type { HealthDimensionSpec, HealthFinding } from '../../doctor/health/dimension-spec.js';
+/** 一条带稳定 id 的采样 finding(来自第 sampleIdx 次采样、dimId 维度)。 */
+export interface TaggedFindingView {
+    id: string;
+    dimId: string;
+    finding: HealthFinding;
+}
+export declare function buildHealthMergePrompt(dims: HealthDimensionSpec[], tagged: TaggedFindingView[]): string;

package/dist/shared/llm-prompts/skill-health-merge.js

@@ -0,0 +1,79 @@
+/**
+ * 多采样 finding 归并 prompt(option C:LLM 合并 pass)。
+ *
+ * 健康度体检跑 N 次后,同一个根因问题常被不同次用**不同措辞**描述。纯字符串键
+ * 去重(consensus.ts findingKey)对"措辞/引用写法不同"会漏并 —— 把同一问题拆成
+ * 多条低支持度 finding。本 prompt 让 LLM 做一次跨采样聚类,把同根因 + 同修复方向
+ * 的 finding 归到一组,框架再据此算 support(k/n)。
+ *
+ * 关键契约:
+ *   - 只在维度内部并(不跨 dim_id),保持维度归属稳定。
+ *   - 每个输入 finding 必须且只属于一个 cluster;无法并的自成一组。
+ *   - 宁可不并,也不要把两个不同问题错并(over-merge 会藏掉真问题,比漏并更糟)。
+ *   - LLM 只负责"哪些 id 归一组 + 合并后文案",**支持度 k/n 由框架算**(不信 LLM 算术)。
+ */
+export function buildHealthMergePrompt(dims, tagged) {
+    // 按维度分组,只列出有 finding 的维度。
+    const byDim = new Map();
+    for (const t of tagged) {
+        if (!byDim.has(t.dimId))
+            byDim.set(t.dimId, []);
+        byDim.get(t.dimId).push(t);
+    }
+    const sections = [];
+    for (const dim of dims) {
+        const items = byDim.get(dim.id);
+        if (!items || items.length === 0)
+            continue;
+        const lines = items.map((t) => {
+            const f = t.finding;
+            const sug = f.suggestion ? ` sug="${oneLine(f.suggestion)}"` : '';
+            return `- [${t.id}] level=${f.level} desc="${oneLine(f.description ?? '')}"${sug}`;
+        });
+        sections.push(`## 维度 dim_id=\`${dim.id}\`\n${lines.join('\n')}`);
+    }
+    const allIds = tagged.map((t) => `\`${t.id}\``).join(', ');
+    return `你在归并一个 skill 健康度体检的**多次采样结果**。下面是同一个 skill 跑了多次体检、各次产出的 finding(问题),按维度分组。同一个根因问题在不同次可能用**不同措辞**描述、引用文件名写法也可能不同。
+
+# 任务
+
+把**同根因 + 同修复方向**的 finding 归并成一组(cluster)。
+
+# 规则
+
+- **只在同一维度(dim_id)内部归并**,绝不跨维度合并。
+- "同根因"判定:指向同一处缺陷、修复动作本质相同。措辞不同、引用文件名写法不同(如 \`templates/01-x.tmpl.md\` vs \`templates/<NN>-<name>.tmpl.md\`)**不影响**判定。
+- **每个输入 finding 必须且只能属于一个 cluster**。和谁都并不了的,自成一个单元素 cluster。
+- **宁可不并,也不要把两个不同的问题错并成一组** —— 错并会藏掉真问题,比漏并更糟。
+- 每个 cluster 给一句最准确的合并后 \`description\` 和一条合并后 \`suggestion\`;\`level\` 取该组最严重的(错误 > 警告)。
+
+# 输入
+
+${sections.join('\n\n')}
+
+# 输出 JSON schema
+
+输出**必须是单一合法 JSON 对象**。第一字符 \`{\`,最后 \`}\`,**不要**用 \`\`\`json\`\`\` 围栏,**不要**寒暄。
+
+{
+  "clusters": [
+    {
+      "dim_id": "<该组所属维度 id>",
+      "finding_ids": ["<本组包含的输入 finding id>"],
+      "level": "错误 | 警告",
+      "description": "<合并后一句话讲清这个根因>",
+      "suggestion": "<合并后的统一修改建议>"
+    }
+  ]
+}
+
+# 约束
+
+- 所有输入 id(${allIds})必须出现且仅出现一次,分布在各 cluster 的 \`finding_ids\` 里。
+- \`finding_ids\` 同组的所有 finding 必须是**同一个 dim_id**。
+- \`level\` 用精确中文(错误 / 警告),不要英文或别名。`;
+}
+function oneLine(s) {
+    // 截断:防恶意/超长 SKILL.md 内容原样 ×N 灌进 merge prompt(无界膨胀 + 注入面)。
+    return s.replace(/\s+/g, ' ').replace(/"/g, "'").trim().slice(0, 300);
+}

package/dist/shared/llm-prompts/skill-health.js

@@ -92,7 +92,7 @@ function renderBlock3CommonRules() {
   - 缺少显式声明但从上下文可合理推断的信息
 - \`建议\`:**不要输出建议级别的 finding**。如果问题不够格做警告,就不要报。
 
-**数量控制:每个维度最多 2 条 finding。优先报错误,其次警告。宁可漏报也不要凑数。**
+**完整性:把该维度下**所有**够格(错误 / 警告)的真实问题都列出来,不要因为"已经报了几条"就漏掉同样真实的问题。同时严守上面的 level 门槛 —— 不够格的不要为了凑数硬塞。优先级:错误 > 警告。**
 
 # 维度 level 派生规则
 

package/dist/types/artifact-graph.d.ts

@@ -29,7 +29,7 @@ export type ArtifactGraphNodeRole = 'entity' | 'observation' | 'aggregate';
 export type ArtifactGraphNodeKind = 'skill' | 'skill_file' | 'frontmatter' | 'reference' | 'script' | 'tool' | 'env' | 'preflight' | 'hard_rule' | 'workflow' | 'workflow_node' | 'sample' | 'assertion' | 'variant' | 'doctor_rule_result' | 'eval_result' | 'judge_dimension' | 'diagnostic' | 'trace_session' | 'skill_invocation' | 'tool_call' | 'gap_signal';
 export type ArtifactGraphStatus = 'ok' | 'warning' | 'failed' | 'skipped' | 'unknown' | 'not_measured';
 export interface ArtifactGraphBinding {
-    bindingStrength: 'content-hash' | 'source-locator' | 'runtime-trace' | 'name-only' | 'aggregate';
+    bindingStrength: 'content-hash' | 'source-locator' | 'runtime-trace' | 'name-only' | 'aggregate' | 'explicit';
     keys: Record<string, string>;
 }
 export interface ArtifactGraphAttrs {

package/dist/types/doctor.d.ts

@@ -74,11 +74,25 @@ export interface DoctorContext {
     lang: 'zh' | 'en';
     timeoutMs: number;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
-    /** 深度健康检查(LLM-judge,多维度)开关。CLI doctor 默认 true,`--static-only`
-     *  会过滤 composer rule;programmatic API 默认 false,只跑静态 rule。true 时
-     *  skill_health composer 才真正调 LLM。composer 不在 BUILTIN_RULES,必须先
-     *  import './doctor/health/register.js' 让 registerRule 副作用生效。 */
+    /** 深度健康检查(LLM-judge,多维度)开关。CLI `omk doctor` 默认 true,并与
+     *  静态 rule 一起运行;`--static-only` 置 false。programmatic API 默认 false,
+     *  eval preflight 走静态 rule 路径。true 时 skill_health composer 才真正调 LLM。
+     *  composer 不在 BUILTIN_RULES,必须先 import './doctor/health/register.js'
+     *  让 registerRule 副作用生效。 */
     runHealthCheck?: boolean;
+    /** 健康度体检的采样次数(self-consistency)。composer 跑 N 次 LLM(默认并行),把各次
+     *  finding 取并集去重,每条标注支持度 k/N(N 次里出现 k 次)。默认 1 = 单次采样;注意
+     *  即便 N=1 也走统一归并路径,框架重算 dim level / overall(不再保留 LLM 自报值,
+     *  与历史单次路径在"LLM 自报 level 与 finding 矛盾"时会有差异)。N>1 压低采样方差。 */
+    healthSamples?: number;
+    /** 多采样 finding 归并策略。`string`(默认)= 反引号锚点 / 归一化文本字符串键去重,
+     *  便宜无额外 LLM 调用,但同根因不同措辞可能漏并。`llm` = 多跑一次 LLM 聚类
+     *  (skill-health-merge prompt),跨措辞归并最准,代价是 +1 次 LLM 调用;失败回退
+     *  string。仅 healthSamples>1 时生效。 */
+    healthMerge?: 'string' | 'llm';
+    /** 多采样并发数。默认 = healthSamples(全并行,样本相互独立)。设 1 = 串行。
+     *  并发只压墙钟时间,不改成本(调用次数不变),但会抬高瞬时并发(rate-limit 敏感时调小)。 */
+    healthConcurrency?: number;
 }
 export interface DoctorRule {
     id: string;
@@ -86,8 +100,9 @@ export interface DoctorRule {
     /** i18n key,terminal 渲染时用作 rule 标题。 */
     labelKey: string;
     /** true = 需要外部 I/O(网络 / LLM)的"在线"检查,跟 skill_health composer 同档:
-     *  默认 `omk doctor` 会跑,`--static-only` 离线模式跳过。endpoint 自定义维度置 true。
-     *  缺省(undefined/false)= 纯静态低成本检查(内置 4 条),静态模式才跑。 */
+     *  CLI `omk doctor` 默认会跑(endpoint 自定义维度置 true),`--static-only` 会跳过。
+     *  缺省(undefined/false)= 纯静态低成本检查(内置 4 条),由默认 doctor、
+     *  `--static-only` 与 eval preflight 共同复用。 */
     external?: boolean;
     check(ctx: DoctorContext): Promise<DoctorRuleCheckOutcome>;
 }
@@ -168,9 +183,18 @@ export interface DoctorRunOptions {
      *  既可以是普通 DoctorRule,也可以是 ComposerRule(健康度体检走这条)。 */
     rules?: DoctorRuleLike[];
     /** 深度健康检查(7 维 LLM-judge)。透传给 DoctorContext.runHealthCheck。
-     *  CLI doctor 默认开启;`--static-only` 通过过滤 composer rule 切到离线静态模式。
-     *  programmatic API 默认 false。 */
+     *  CLI `omk doctor` 默认 true;`--static-only` 置 false。programmatic API 默认 false
+     *  (eval preflight 只跑静态 rule)。 */
     runHealthCheck?: boolean;
+    /** 健康度体检采样次数(self-consistency)。透传给 DoctorContext.healthSamples。
+     *  默认 1(单次,行为与历史一致)。CLI 用 `--repeat` 暴露。 */
+    healthSamples?: number;
+    /** 多采样 finding 归并策略,透传给 DoctorContext.healthMerge。programmatic 默认 `string`;
+     *  CLI(`omk doctor`)恒传 `llm`(不暴露开关)。 */
+    healthMerge?: 'string' | 'llm';
+    /** 多采样并发数,透传给 DoctorContext.healthConcurrency。默认 = healthSamples(全并行)。
+     *  CLI 用 `--concurrency` 暴露。 */
+    healthConcurrency?: number;
     effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     /** 批量体检进度回调(per-skill)。CLI 非 gate 模式注入、写 stderr;eval 内嵌
      *  调用不传(eval 有自己的进度体系,不应冒出 doctor 进度)。 */

package/dist/types/eval.d.ts

@@ -27,6 +27,14 @@ export interface Assertion {
 export type SampleProvenance = 'human' | 'llm-generated' | 'production-trace';
 /** sample 难度等级。简单分桶,跟 IRT 风格 fine-grained difficulty 不同。 */
 export type SampleDifficulty = 'easy' | 'medium' | 'hard';
+/** Sample 可选声明的 skill 结构锚点。用于 Skill Map / 诊断，不参与 grading / judge / verdict。 */
+export type SampleCoverageTargetKind = 'skill' | 'skill_file' | 'frontmatter' | 'reference' | 'script' | 'hard_rule' | 'workflow' | 'workflow_node';
+export interface SampleCoverageTarget {
+    /** 目标类型。避免裸 kind，保持 Artifact.kind 语义唯一。 */
+    targetKind: SampleCoverageTargetKind;
+    /** 稳定引用：路径或 ID。reference/script 用 skill 根相对路径，workflow_node 用 workflowId.nodeId。 */
+    ref: string;
+}
 /** Sample 评测环境前置:声明性"已就绪"清单,LLM 看到后跳过环境探测,直接进入工作流。
  *  类比 unit test 的 fixture / setup —— 评测是测 skill 工作流,不是测环境探测能力。 */
 export interface SampleEnvironment {
@@ -112,6 +120,8 @@ export interface Sample {
      *  curated 用 `'human'`,production trace 抽样用 `'production-trace'`。
      *  纯文档 / 诊断用。 */
     provenance?: SampleProvenance;
+    /** 该 sample 可选声明的 skill 结构锚点。纯文档 / 图谱诊断用，不进入评分、评委或 verdict。 */
+    covers?: SampleCoverageTarget[];
     /** 诱错样本(tripwire)标记。true = 此 sample 故意设计成 LLM 应该 fail 的诱导陷阱
      *  (如:用户用错误前提诱导 / 跳步骤 / 用错参数类型),用于测 skill 是否能让 LLM
      *  识破并纠正。Diagnostic 看到 tripwire:true 时会建议"无需改 skill"(rootCause:

package/dist/types/report.d.ts

@@ -346,6 +346,7 @@ export interface ResultEntry {
  *   - assertions: 期望(运行后的 pass/fail 结果在 VariantResult.assertions.details 里)
  *   - mocks: 工具调用模拟返回(LLM 调到匹配的 tool/参数时拿到这段假返回,而不是真去调外部系统)
  *   - capability / construct / difficulty: 元数据
+ *   - covers: sample 可选声明的 skill 结构锚点
  *   - context: 附加上下文(代码片段等)
  *
  * 旧 report 没有这个字段,renderer 据此 fallback(隐藏单测 tab 或提示"无设计快照")。
@@ -361,6 +362,7 @@ export interface SampleSnapshot {
     difficulty?: import('./eval.js').SampleDifficulty;
     construct?: string;
     provenance?: import('./eval.js').SampleProvenance;
+    covers?: import('./eval.js').SampleCoverageTarget[];
     /** Diagnostic 用 — tripwire sample 不该建议改 skill。 */
     tripwire?: boolean;
 }
@@ -476,7 +478,7 @@ export interface AnalysisResult {
     coverage?: Record<string, KnowledgeCoverage>;
     /** Per-variant knowledge gap reports. See docs/specs/knowledge-gap-signal-spec.md */
     gapReports?: Record<string, GapReport>;
-    /** Sample design science aggregate. Built from sample metadata
+    /** Sample design science aggregate. Built from measurement metadata
      *  (capability / difficulty / construct / provenance); persisted on report
      *  for studio to surface coverage gaps. See docs/specs/sample-design-spec.md. */
     sampleQuality?: SampleQualityAggregate;

package/dist/types/skill-index.d.ts

@@ -52,9 +52,20 @@ export interface SkillGraphStageSnapshot {
     edgeCount: number;
 }
 export interface SkillGraphNodePreview {
+    stableKey?: string;
     nodeKind: string;
     label: string;
     status?: string;
+    coverage?: 'declared' | 'undeclared';
+    coveredBySamples?: string[];
+}
+export interface SkillGraphCoverageEdgePreview {
+    sampleStableKey?: string;
+    sampleLabel: string;
+    sampleStatus?: string;
+    targetStableKey: string;
+    targetNodeKind: string;
+    targetLabel: string;
 }
 export interface SkillGraphSnapshot {
     /** Studio 聚合 graph sidecar 时实际采用的绑定强度。 */
@@ -76,6 +87,9 @@ export interface SkillGraphSnapshot {
         failedAssertionEdges: number;
         diagnostics: number;
         measurementNodes: SkillGraphNodePreview[];
+        coverageEdges: number;
+        declaredCoverageStableKeys: string[];
+        declaredCoverageEdges: SkillGraphCoverageEdgePreview[];
     };
 }
 export interface SkillIndexEntry {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-knowledge",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "packageManager": "yarn@4.16.0",
   "description": "Evaluation framework for LLM knowledge inputs — prompts, RAG corpora, skills, agent workflows. Fix the model, vary the artifact. Built-in statistical rigor: bootstrap CI, Krippendorff α, length-debias, saturation curves.",
   "type": "module",
@@ -26,6 +26,7 @@
     "docs:preview": "vitepress preview docs",
     "typecheck": "tsc --noEmit",
     "lint": "eslint 'src/**/*.ts' 'test/**/*.ts' --cache --cache-location node_modules/.cache/eslint/ --max-warnings 0",
+    "lint-staged": "lint-staged",
     "test": "vitest run",
     "ci": "run-s lint typecheck build build:docs:check test",
     "prepublishOnly": "run-s clean build",
@@ -92,11 +93,11 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.143",
-    "@anthropic-ai/sdk": "^0.104.1",
+    "@anthropic-ai/sdk": "^0.105.0",
     "@inquirer/prompts": "^8.4.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@oclif/core": "^4",
-    "@openai/codex-sdk": "0.139.0",
+    "@openai/codex-sdk": "0.141.0",
     "ajv": "^8.18.0",
     "chart.js": "^4.5.1",
     "js-yaml": "^4.1.1",
@@ -111,11 +112,11 @@
     "@types/node": "^25.5.0",
     "eslint": "^10.1.0",
     "husky": "^9.1.7",
-    "lint-staged": "^17.0.4",
+    "lint-staged": "17.0.7",
     "npm-run-all2": "^9.0.1",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.3"
+    "vitest": "4.1.8"
   }
 }