kibi-opencode 0.16.0 → 0.19.1

package/README.md

@@ -31,7 +31,7 @@ Use an exact semver entry when you want a fixed plugin version:
 
 ```json
 {
-  "plugin": ["kibi-opencode@0.15.0"]
+  "plugin": ["kibi-opencode@0.18.1"]
 }
 ```
 
@@ -54,9 +54,9 @@ The plugin now uses a posture-aware, low-token smart-enforcement model before em
 - **Risk classification**: separates `safe_docs_only`, `safe_test_only`, `kb_doc_structural`, `req_policy_candidate`, `behavior_candidate`, `traceability_candidate`, and `manual_kb_edit`
 - **Source-linked Kibi links**: risky code edits (`behavior_candidate`, `traceability_candidate`) prepend a concise list of existing Kibi links (e.g., `- Existing Kibi links: REQ-001, REQ-002`) when 1-3 concrete source-linked KB hits are found in `documentation/symbols.yaml`. Skip on cache hit.
 - **Start-task risky cue**: authoritative risky edits also add a compact Kibi context cue so agents can start with explicit source-linked guidance before acting, while staying inside the same single prompt block and token budget.
-- **Effective mode gating**: `advisory` (default) never blocks; `strict` escalates checks and reminders for `root_active` and `hybrid_root_plus_vendored` postures when `requireRootKbForStrict` is enabled; `hard` fails closed for authoritative roots and linked git worktrees, injecting a stop-state with MCP recovery steps until the Kibi checkpoint passes. `maintenanceDegraded` overrides everything back to `advisory`.
+- **Effective mode gating**: `advisory` (default) never blocks; `strict` escalates checks and reminders for `root_active` and `hybrid_root_plus_vendored` postures when `requireRootKbForStrict` is enabled; `hard` fails closed for authoritative roots and linked git worktrees, injecting capability-based recovery steps until the Kibi checkpoint passes. `maintenanceDegraded` overrides everything back to `advisory`.
 - **Low-token prompt policy**: docs-only and test-only edits avoid unnecessary discovery prompts; vendored-only repos suppress operational bootstrap nudges; at most one contextual block is injected per prompt (≤120 words, ≤5 bullets)
-- **Completion reminder**: when `completionReminder` is enabled, risky code edits append a single prompt-visible `kb_check` reminder exactly once per cached context
+- **Completion reminder**: when `completionReminder` is enabled, risky code edits append a single prompt-visible impact-enabled `kb_check` reminder exactly once per cached context
 - **Runtime maintenance overlay**: static `maintenanceDegraded` from posture is merged with a latched runtime overlay (sync disabled/unavailable/failing) so degraded state is consistently reflected in prompts, logs, and mode decisions
 - **Three-mode enforcement**: `advisory` by default keeps guidance non-blocking; opt-in `strict` adds elevated validation cues; `hard` blocks the prompt for authoritative workspaces until the checkpoint cycle succeeds. Git hooks and KB validation checks remain the durable enforcement boundary for all modes.
 - **Structured observability**: posture, risk, cache, degraded-mode, targeted-check, and guidance events flow through structured plugin logs
@@ -75,11 +75,13 @@ modified, the plugin evaluates KB freshness evidence and surfaces a visible
   discovery via `kb_search` or `kb_query(sourceFile=...)` and `kb_check`.
 - **Deferred/Failed**: Do not claim task completion.
 
+For meaningful source edits, the first gate is MCP `kb_check` with impact options, for example `kb_check({sourceFiles:["src/feature.ts"], includeImpactDiagnostics:true, includeWorkingTreeDiff:true})`. These diagnostics guide symbol granularity, requirement ownership, and semantic review of linked requirements/tests; they do not prove source behavior matches prose.
+
 ### Dynamic Contextual Guidance
 
 The plugin provides context-aware prompt guidance based on recent edits and workspace state:
 
-- **Code edits**: Guidance for querying Kibi by sourceFile, preferring Kibi over comments, and adding `// implements REQ-xxx` traceability
+- **Code edits**: Guidance for running impact-enabled `kb_check`, querying Kibi by sourceFile, preferring Kibi over comments, and adding or updating symbol traceability
 - **Requirement edits**: Guidance for maintaining separate REQ/SCEN/TEST artifacts and avoiding embedded scenarios
 - **KB doc edits**: Guidance for proper entity relationships and validation
 - **Bootstrap needed**: Detection and nudges for uninitialized repos
@@ -153,13 +155,13 @@ The plugin injects guidance into OpenCode sessions to improve agent grounding. U
 
 ### Bootstrap Command
 
-OpenCode exposes Kibi MCP prompts as slash commands. The \`/init-kibi\` command triggers the \`kb_autopilot_generate\` workflow to assist in retroactive bootstrap using only public MCP tools.
+OpenCode exposes Kibi MCP prompts as slash commands. The \`/init-kibi\` command triggers the \`kb_autopilot_generate\` workflow to assist in retroactive bootstrap. Agents use visible MCP tools when available, a trusted project-local CLI JSON route with `--input` when MCP is unavailable, and stop for operator action when neither interface is available.
 
 OpenCode may show Kibi MCP tools with the configured server prefix. For example, canonical MCP names such as `kb_autopilot_generate`, `kb_upsert`, and `kb_check` can appear to agents as `kibi_kb_autopilot_generate`, `kibi_kb_upsert`, and `kibi_kb_check`. Use the visible `kibi_kb_*` identifier when OpenCode requires an exact tool name; it maps to the same MCP operation.
 
-### Discovery-first MCP guidance
+### Discovery-first capability guidance
 
-Agent-visible guidance is intentionally limited to the curated public MCP surface:
+Agent-visible guidance selects the curated public MCP surface when visible or the equivalent dedicated CLI JSON routes in a trusted workspace:
 
 - Discovery/reporting: `kb_search`, `kb_query`, `kb_status`, `kb_find_gaps`, `kb_coverage`, `kb_graph`
 - Mutation/validation: `kb_upsert`, `kb_delete`, `kb_check`
@@ -305,7 +307,7 @@ If you see a false "workspace needs Kibi bootstrap" warning even though your wor
 
 This is a thin bridge layer per ADR-016:
 
-- **Agent-visible guidance**: Public MCP tools (`kb_query`, `kb_upsert`, `kb_check`, etc.) and sanctioned slash commands (`/init-kibi`)
+- **Agent-visible guidance**: visible public MCP tools or trusted project-local CLI JSON routes (`--input`), with a blocked/operator state when neither is available
 - **Discovery-first workflow**: Agents are guided to use `kb_search` first, then `kb_query`, then reporting tools like `kb_status`, `kb_find_gaps`, `kb_coverage`, and `kb_graph` when needed
 - **Internal maintenance**: Background sync operations handle KB synchronization; agents do NOT run sync commands directly
 - Does NOT own KB storage, parsing, or validation

package/dist/e2e-coverage-signals.js

@@ -19,7 +19,10 @@ function readTestDoc(worktree, testId) {
                 const content = readFileSync(fullPath, "utf8");
                 return parseTestDoc(content, testId);
             }
-            catch { }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+            }
         }
     }
     return null;

package/dist/enforcement-policy.js

@@ -25,6 +25,7 @@ const ADVISORY_EDIT_KINDS = new Set([
     "symbol",
     "kb",
 ]);
+const SOURCE_IMPACT_KINDS = new Set(["code"]);
 function normalizeCheckpointEvidence(evidence) {
     if (typeof evidence === "boolean") {
         return evidence;
@@ -126,6 +127,13 @@ function advisoryText(event) {
         return "- New file detected. Add or update the necessary Kibi entities and traceability before completing this task.";
     }
     if (event.lifecycle === "edited") {
+        if (SOURCE_IMPACT_KINDS.has(event.pathKind)) {
+            const impactCheckCall = `kb_check({sourceFiles:${JSON.stringify([event.normalizedPath])}, includeImpactDiagnostics:true, includeWorkingTreeDiff:true})`;
+            return [
+                `- Edited source file detected. Run \`${impactCheckCall}\` while the edit context is fresh.`,
+                "  Use the impact diagnostics to review symbol granularity, requirement ownership, and semantic review of linked requirements/tests before completing this task.",
+            ].join("\n");
+        }
         return `- Edited file detected. Review Kibi traceability for ${event.normalizedPath} before completing this task.`;
     }
     const ids = event.linkedEntityResult.ids;
@@ -185,7 +193,12 @@ function hardBlockText(events) {
             "Changed relevant files require Kibi verification before continuing:",
             ...pathLines,
             ...evidenceNotes,
-            "MCP-only checkpoint instructions:",
+            "Capability-based checkpoint instructions:",
+            "- If Kibi MCP tools are visible, use MCP.",
+            "- If MCP availability is unknown and a trusted local Kibi CLI is available, use its dedicated JSON routes with `--input <file|->`.",
+            "- If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI.",
+            "- Do not infer MCP availability from config file existence. Do not read or edit `.kb/` files directly.",
+            "- Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
             "- Run `kb_search` to discover impacted requirements, tests, ADRs, and facts.",
             `- Run \`kb_query\` with \`sourceFile\` (example sourceFile: \"${representativePath}\") for each listed path.`,
             "- Run `kb_status` if branch or snapshot freshness matters.",

package/dist/init-kibi-alias.js

@@ -33,7 +33,10 @@ export function buildInitKibiAlias() {
         "",
         "## Rules",
         "- Never apply changes without a user-facing preview and approval.",
-        "- Guidance must stay MCP-only; do not suggest `kibi` CLI commands.",
+        "- Prefer MCP tools; CLI routes are available when MCP is unavailable.",
+        "- If MCP availability is unknown and a trusted local Kibi CLI is available, use its dedicated JSON routes with `--input <file|->`. If neither interface is available, stop and tell the operator.",
+        "- Do not infer MCP availability from config file existence. Do not read or edit `.kb/` files directly.",
+        "- Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
     ];
     return lines.join("\n");
 }

package/dist/prompt.js

@@ -66,7 +66,7 @@ function buildBootstrapRequiredBody(capability = getInitKibiCommandCapability())
     const commandBullet = capability.supported
         ? "- When the Kibi OpenCode plugin is active and native injection is supported, use `/init-kibi` as the canonical short alias; `/kibi:init-kibi:mcp` remains the namespaced MCP fallback."
         : "- This host does not support native `/init-kibi` injection. Kibi must fail closed and does not register a fake native alias; use `/kibi:init-kibi:mcp` instead.";
-    return `This repository does not appear to have Kibi initialized. Agents should:\n${commandBullet}\n- The workflow uses \`kb_autopilot_generate\` for read-only synthesis; always preview and get approval before writes.\n- Ask the user/operator to run setup or repair outside this session if bootstrap is insufficient.\n- For comprehensive Kibi usage guidance, use \`kb_skills_load\` with skill id \`kibi-usage\`.\n\nUse public MCP tools only: \`kb_autopilot_generate\`, \`kb_search\`, \`kb_query\`, \`kb_status\`, \`kb_find_gaps\`, \`kb_coverage\`, \`kb_graph\`, \`kb_upsert\`, \`kb_delete\`, \`kb_check\`, \`kb_skills_load\`.`;
+    return `Kibi capability selection:\n1. If Kibi MCP tools are visible, use MCP.\n2. If MCP availability is unknown and a trusted local Kibi CLI is available, use its dedicated JSON routes with \`--input <file|->\`.\n3. If neither interface is available, Kibi operation is blocked; tell the operator.\nDo not infer MCP availability from config file existence. Do not read or edit \`.kb/\` files directly. Query before mutate. Run \`kb_upsert\` sequentially. Run \`kb_check\` before completion.\n\nThis repository does not appear to have Kibi initialized. Agents should:\n${commandBullet}\n- The workflow uses \`kb_autopilot_generate\` for read-only synthesis; always preview and get approval before writes.\n- Ask the operator to handle setup or repair if bootstrap is insufficient.\n- Load \`kibi-usage\` with \`kb_skills_load\` for comprehensive guidance.`;
 }
 function buildHardGateBlock(block) {
     const pathLines = block.shownPaths.map((path) => `- \`${path}\``);
@@ -80,7 +80,12 @@ function buildHardGateBlock(block) {
         reasonLine,
         "Affected files:",
         ...pathLines,
-        "MCP-only recovery steps:",
+        "Capability-based recovery steps:",
+        "- If Kibi MCP tools are visible, use MCP.",
+        "- If MCP availability is unknown and a trusted local Kibi CLI is available, use its dedicated JSON routes with `--input <file|->`.",
+        "- If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI.",
+        "- Do not infer MCP availability from config file existence. Do not read or edit `.kb/` files directly.",
+        "- Query before mutate. Run `kb_upsert` sequentially. Run `kb_check` before completion.",
         "- Run `kb_search` for impacted requirements, tests, ADRs, and facts.",
         "- Run `kb_query` with `sourceFile` for each affected file.",
         "- Run `kb_status` if branch or snapshot freshness matters.",
@@ -120,7 +125,8 @@ Production code: use \`implements\` (symbol→req) for requirement ownership. Te
 - documentation/symbols.yaml refresh is required when extraction output changes; do not revert as scope creep`,
     manual_kb_edit: `⚠️  **WARNING: Direct .kb/ edits bypass validation**
 
-The Kibi knowledge base is managed through public MCP tools. Direct manual edits to .kb/** can cause inconsistencies.
+The Kibi knowledge base is managed through visible MCP tools or trusted project-local CLI JSON routes when MCP is unavailable. Do not read or edit \`.kb/\` files directly.
+- Query before mutate and run kb_upsert sequentially
 - Use kb_upsert to create/update entities
 - Use kb_delete to remove entities
 - Use kb_check to validate consistency`,
@@ -292,8 +298,10 @@ If you're adding long explanatory comments, consider routing that knowledge to:
                 }
             }
         }
-        catch {
-            // Non-fatal: source-linked context is best-effort
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
         }
     }
     // ── File-operation reminder folding ─────────────────────────────────
@@ -471,13 +479,17 @@ Before implementing or explaining code:
  */
 function buildBaseGuidance(capability = getInitKibiCommandCapability()) {
     return `${SENTINEL}
-This project uses Kibi (via MCP). Prefer storing durable knowledge in Kibi over code comments.
+This project uses Kibi through capability-selected MCP or CLI JSON routes. Prefer storing durable knowledge in Kibi over code comments.
 
 Before changing behavior: use kb_search for discovery, then kb_query by sourceFile, id, type, or tags for exact follow-up; do not rely on undocumented tools.
 
 Keep changed symbols traceable: production code uses \`implements\` (symbol→req) for ownership; test code uses \`executable_for\`; \`covered_by\` is coverage evidence only. Inline \`// implements REQ-xxx\` comments remain backward-compatible.
 
-Run kb_check after KB mutations.
+Kibi capability selection:
+1. If Kibi MCP tools are visible, use MCP.
+2. If MCP availability is unknown and a trusted local Kibi CLI is available, use its dedicated JSON routes with \`--input <file|->\`.
+3. If neither interface is available, Kibi operation is blocked; tell the operator to enable MCP or the trusted project-local CLI.
+Do not infer MCP availability from config file existence. Do not read or edit \`.kb/\` files directly. Query before mutate. Run \`kb_upsert\` sequentially. Run \`kb_check\` before completion.
 
 Dogfood note for this repo: OpenCode here uses local built \`kibi-mcp\` and \`kibi-opencode\` artifacts. If you change package versions or local package wiring, run \`bun run build\` before relying on OpenCode in this workspace.
 
@@ -490,12 +502,10 @@ Dogfood note for this repo: OpenCode here uses local built \`kibi-mcp\` and \`ki
 6. **Validate**: Run kb_check after KB mutations to catch violations early.
 7. **Before completion/commit**: Kibi impact evidence is required before completion/commit. If extraction output changes, refresh documentation/symbols.yaml and do not revert that update as scope creep.
 
-**Public Kibi tools only:** kb_autopilot_generate, kb_search, kb_query, kb_status, kb_find_gaps, kb_coverage, kb_graph, kb_upsert, kb_delete, kb_check, kb_skills_load.
+MCP and CLI expose the same 18 Kibi operations. Use the exact MCP tool or dedicated CLI route; do not invent a generic runner.
 
 For comprehensive Kibi usage guidance (relationships, fact lanes, workflows), use \`kb_skills_load\` with skill id \`kibi-usage\`.
 
-Do not invoke Kibi CLI commands directly from the agent.
-
 ${buildInitKibiBootstrapReference(capability)}`;
 }
 /**

package/dist/repo-posture.js

@@ -111,7 +111,10 @@ function hasRootKibiIntent(cwd) {
             return true;
         }
     }
-    catch { }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+    }
     for (const guidanceFile of [
         "AGENTS.md",
         join(".github", "copilot-instructions.md"),
@@ -122,7 +125,10 @@ function hasRootKibiIntent(cwd) {
                 return true;
             }
         }
-        catch { }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+        }
     }
     return false;
 }

package/dist/scheduler.d.ts

@@ -24,7 +24,9 @@ export type SyncRunnerResult = {
 };
 export type SyncRunner = (worktree: string) => Promise<SyncRunnerResult>;
 export type CheckRunner = (worktree: string, rules: string[]) => Promise<{
-    exitCode: number;
+    readonly exitCode: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
 }>;
 export interface SchedulerOptions {
     worktree: string;

package/dist/scheduler.js

@@ -154,6 +154,7 @@ class WorktreeSyncScheduler {
                 }
                 else {
                     logger.info(`check.succeeded ${JSON.stringify({ rules: checkRules })}`);
+                    logAdvisoryQualityDiagnostics(checkRules, checkResult.stdout, checkResult.stderr);
                 }
             }
         }
@@ -280,11 +281,84 @@ async function runKibiSync(worktree) {
 async function runKibiCheck(worktree, rules) {
     return new Promise((resolve) => {
         const rulesArg = rules.join(",");
-        exec(`kibi check --rules ${rulesArg}`, { cwd: worktree }, (error) => {
-            resolve({ exitCode: error ? (error.code ?? 1) : 0 });
+        exec(`kibi check --rules ${rulesArg} --format json`, { cwd: worktree }, (error, stdout, stderr) => {
+            const truncatedOut = truncateSyncOutput(stdout || undefined);
+            const truncatedErr = truncateSyncOutput(stderr || undefined);
+            resolve({
+                exitCode: error ? (error.code ?? 1) : 0,
+                ...(truncatedOut !== undefined ? { stdout: truncatedOut } : {}),
+                ...(truncatedErr !== undefined ? { stderr: truncatedErr } : {}),
+            });
         });
     });
 }
+function logAdvisoryQualityDiagnostics(rules, stdout, stderr) {
+    const diagnostics = parseQualityDiagnostics(stdout, stderr).filter((diagnostic) => !diagnostic.blocking);
+    if (diagnostics.length === 0)
+        return;
+    const severityCounts = new Map();
+    for (const diagnostic of diagnostics) {
+        severityCounts.set(diagnostic.severity, (severityCounts.get(diagnostic.severity) ?? 0) + 1);
+    }
+    const first = diagnostics[0];
+    if (first === undefined)
+        return;
+    logger.warn(`check.advisory_quality ${JSON.stringify({
+        rules,
+        count: diagnostics.length,
+        ...Object.fromEntries(severityCounts),
+        firstId: first.id,
+        firstMessage: first.message,
+    })}`);
+}
+function parseQualityDiagnostics(stdout, stderr) {
+    for (const output of [stdout, stderr]) {
+        if (output === undefined || output.trim().length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(output);
+            const candidates = qualityDiagnosticCandidates(parsed);
+            const diagnostics = candidates.flatMap((candidate) => parseQualityDiagnostic(candidate) ?? []);
+            if (diagnostics.length > 0)
+                return diagnostics;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                continue;
+            throw error;
+        }
+    }
+    return [];
+}
+function qualityDiagnosticCandidates(value) {
+    if (!isRecord(value))
+        return [];
+    const structuredContent = value.structuredContent;
+    if (isRecord(structuredContent)) {
+        const diagnostics = structuredContent.qualityDiagnostics;
+        return Array.isArray(diagnostics) ? diagnostics : [];
+    }
+    const diagnostics = value.qualityDiagnostics;
+    return Array.isArray(diagnostics) ? diagnostics : [];
+}
+function parseQualityDiagnostic(value) {
+    if (!isRecord(value))
+        return null;
+    const id = value.id;
+    const severity = value.severity;
+    const blocking = value.blocking;
+    const message = value.message;
+    if (typeof id !== "string" ||
+        typeof severity !== "string" ||
+        typeof blocking !== "boolean" ||
+        typeof message !== "string") {
+        return null;
+    }
+    return { id, severity, blocking, message };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 // implements REQ-opencode-kibi-plugin-v1
 export function createSyncScheduler(opts) {
     return new WorktreeSyncScheduler(opts);

package/dist/version-metadata.json

@@ -1 +1 @@
-{"opencode":"0.16.0","mcp":"0.16.0","cli":"0.12.4","core":"0.6.0"}
+{"opencode":"0.19.1","mcp":"0.19.2","cli":"0.16.1","core":"0.7.1"}

package/dist/work-context-resolver.js

@@ -46,8 +46,9 @@ function directorySearchStart(candidatePath) {
     const stats = safeStat(resolved);
     return stats?.isDirectory() ? resolved : dirname(resolved);
 }
-function findGitMetadata(candidatePath) {
+function findGitMetadata(candidatePath, searchBoundary) {
     let current = directorySearchStart(candidatePath);
+    const boundary = searchBoundary ? resolve(searchBoundary) : null;
     while (true) {
         const dotGitPath = join(current, ".git");
         const dotGitStats = safeStat(dotGitPath);
@@ -70,6 +71,9 @@ function findGitMetadata(candidatePath) {
                 isLinkedWorktree: false,
             };
         }
+        if (boundary !== null && current === boundary) {
+            return null;
+        }
         const parent = dirname(current);
         if (parent === current) {
             return null;
@@ -174,8 +178,18 @@ const resolveWorkContext = function resolveWorkContext(input) {
             ? resolve(input.filePath)
             : resolve(declaredWorktreeRoot, input.filePath)
         : undefined;
-    const git = (absoluteFilePath ? findGitMetadata(absoluteFilePath) : null) ??
-        findGitMetadata(declaredWorktreeRoot);
+    const fileRelativeToDeclaredRoot = absoluteFilePath
+        ? relative(declaredWorktreeRoot, absoluteFilePath)
+        : null;
+    const fileSearchBoundary = fileRelativeToDeclaredRoot !== null &&
+        !fileRelativeToDeclaredRoot.startsWith(`..${sep}`) &&
+        fileRelativeToDeclaredRoot !== ".." &&
+        !isAbsolute(fileRelativeToDeclaredRoot)
+        ? declaredWorktreeRoot
+        : undefined;
+    const git = (absoluteFilePath
+        ? findGitMetadata(absoluteFilePath, fileSearchBoundary)
+        : null) ?? findGitMetadata(declaredWorktreeRoot, declaredWorktreeRoot);
     const worktreeRoot = git?.worktreeRoot ?? declaredWorktreeRoot;
     const kibiAuthorityRoot = git
         ? resolveAuthorityRoot(git, declaredDirectory)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.16.0",
+  "version": "0.19.1",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -37,9 +37,7 @@
       "default": "./dist/tui.js"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "engines": {
     "node": ">=18"
   },
@@ -62,7 +60,7 @@
     "@opencode-ai/plugin": "^1.4.7",
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
-    "kibi-cli": "^0.12.3"
+    "kibi-cli": "^0.16.0"
   },
   "devDependencies": {
     "@types/node": "latest",