kibi-cursor 1.0.1 → 2.0.1

package/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "kibi-cursor",
   "displayName": "Kibi",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Optional Cursor adapter for Kibi. Requires SWI-Prolog 9+ and project-local kibi-cli, kibi-mcp, and kibi-core before the bundled MCP server can start.",
   "license": "AGPL-3.0-or-later",
   "author": {

package/CHANGELOG.md

@@ -1,5 +1,68 @@
 # kibi-cursor
 
+## 2.0.1
+
+### Patch Changes
+
+- 96a1ebd: Local Cursor MCP builds now compile plugin SDK/builtin dist before the CLI, so a fresh checkout no longer fails with a missing `kibi-plugin-builtin` type package.
+
+  - `build:cli-stack` runs plugin-sdk + plugin-builtin + CLI
+  - Worktree resolver uses that stack instead of `build:cli` alone
+
+- 188f875: No user-facing behavior change: `kibi-runtime` now resolves its bundled-skills directory lazily on first use instead of at import time, `isWithinRoot` drops a redundant same-path comparison, `kibi-cursor` drops a provably dead `planDelivered` early return and an always-true stdin branch, and the hook runners' stdin buffering is simplified to an unconditional `Buffer.from`. The reshaping lets the new mutation-testing suite (`docs/mutation-testing.md`, run via `bun run test:mutation`) prove these paths exhaustively — the suite holds a 100% mutation score over `kibi-runtime`, `kibi-codex`, and `kibi-cursor` sources.
+- db07d8f: Proof diagnostics now agree with the Prolog decision: a structural type-shape unit contract is shown as qualifying, `kibi proof impact` compares against the Git HEAD baseline and exits 0 after a successful report, and mixed-role symbols fail the strict proof integrity gate.
+
+  - Mode-aware candidate evaluation in Prolog; receipt fallback uses `test_receipt_evidence(Context, TestId, Evidence)`.
+  - `proof impact` reads `HEAD:proof/baseline.json` with no worktree fallback; diagnostic exit 0.
+  - Strict proof workflow and baseline checker include canonical `symbol-traceability`.
+
+- f33a665: Proof failures now name the exact requirement, symbol, and why each `covered_by` candidate did not qualify, without changing what counts as proven. Agents can inspect a requirement with `kibi proof explain` and compare current proof state to the committed `proof/baseline.json` snapshot with `kibi proof impact`, instead of reverse-engineering Prolog or guessing from aggregate counts.
+
+  - Keep `kibi.requirement-proof.v3` and add additive production-symbol `explanations` plus TEST `testResolutions` on the same Proof.
+  - Ratchet `proof/baseline.json` to v2 with compact requirement fingerprints; aggregate counts stay the ratchet.
+  - Add `kibi proof explain` and `kibi proof impact` as Proof projections, mixed-role leftovers in `symbol-traceability`, and advisory `proof-contract-symbols`.
+  - Document the proof-regression workflow in `kibi-usage` 2.1.3.
+
+## 2.0.0
+
+### Major Changes
+
+- 812c201: Kibi's proof layer is now runner-neutral: any test runner, script, or harness can prove requirements, and Playwright is no longer built into the proof model.
+
+  - `kibi prove` replaces `kibi verify` as the single command to run configured proof producers and record evidence. Proof contracts (`kibi.proof-contract.v1`) declare explicit obligations (`symbol_id` + `target`) executed by a configured integration in `.kb/proof/integrations.json`; `kibi proof inspect` discovers test infrastructure deterministically; one producer run can satisfy many test contracts, and re-ingestion is idempotent.
+  - Evidence moves to the `kibi.proof-run.v1` artifact (typed environment, run-level outcome, factual attempt history with `native_case`/`aggregate_run` provenance) evaluated into `kibi.proof-receipt.v1` receipts bound to the live snapshot, contract hash, and effective execution fingerprint. Command proof is the universal fallback, so every project can prove requirements without a first-party framework adapter; strict first-attempt policy never upgrades unknown attempt history into passing evidence.
+  - Breaking removals: `kibi verify`, `kb_ingest_verification`, `kibi.playwright-run.v1`, `verification_contract`/`verification_receipts` entity fields (replaced by `proof_contract`/`proof_bindings`/`proof_receipts`), the `required_case_symbols`×`required_projects` Cartesian contract, and `retries` fields. Migrate by re-running `kibi prove` after bootstrap configures proof for your repository.
+
+  DRY: hard cutover to the proof-evidence protocol across CLI, MCP, runtime skills, Prolog proof evaluation, coverage/repair/report surfaces, agent skills, and repository self-proof (packed e2e steps now execute through `kibi prove --all`).
+
+### Patch Changes
+
+- b0271ac: Cursor now starts the bundled Kibi MCP server reliably when it launches plugin processes from a home directory or another unrelated working directory. Consumer workspaces with spaces continue to resolve their project-local `kibi-mcp` installation, while the portable Agent Plugin keeps its separate `npx --no-install` configuration.
+
+  - Fix `kibi-cursor` MCP launcher arguments to use Cursor's `${CURSOR_PLUGIN_ROOT}` expansion.
+  - Add source-install manifest regression coverage for consumer-local resolution from unrelated host directories.
+
+- b1682f1: Agents receive clearer guidance for repairing the actual supplied mutation request and preserving approved predicate bindings. The scoped additions retain the existing workflow while separating payload recovery from conditional relational modeling.
+
+  - Update `kibi-usage` to 2.1.2 in CLI/runtime sources and the generated Codex/Cursor distributions.
+  - Preserve the other three skills and all existing resource content.
+  - Retain production-adoption safeguards; development comparisons are not held-out evidence.
+
+- ee0dc49: Plugin hooks, the Cursor MCP launcher, and skill validation now expose the
+  same entry paths tests already spawn as processes. In-process coverage can
+  exercise stdin, CLI guards, and realpath failures instead of leaving those
+  lines invisible to Codecov.
+
+  - Export hook CLI helpers and Agent Plugin / launcher internals for tests.
+  - Use a namespace `fs` import in skill validation so realpath errors are testable.
+
+- 5999143: Agent-facing skill docs now use the current status field names, so agents following the freshness and E2E receipt workflows look for fields that actually exist in `kb_status` output instead of stale ones.
+
+  - Bundled `kibi-freshness` and `kibi-usage` skills (all agent mirrors) now reference `proofSnapshotChanges` and `proofSnapshot` (previously `verificationSnapshotChanges`/`verificationSnapshot` from the pre-proof-architecture status schema).
+  - The skillopt-eval harness reads `proofSnapshot*` status fields and its held-out eval prompts name the current fields, so "dirty editor path" evidence gathering works against live status output again.
+
+  Dry: completes the `verificationSnapshot*` → `proofSnapshot*` rename from the proof architecture change in the surfaces that earlier commit missed.
+
 ## 1.0.1
 
 ### Patch Changes

package/README.md

@@ -56,16 +56,19 @@ cp -r "$(npm root)/kibi-cursor" ~/.cursor/plugins/local/kibi-cursor
 ## MCP configuration
 
 The plugin bundles `mcp.json` with a thin launcher that locates and starts the
-`kibi-mcp` package installed in the opened project. The launcher runs from the
-consumer workspace and sets `KIBI_WORKSPACE` to that root; it never downloads,
-bundles, or falls back to a global Kibi runtime:
+`kibi-mcp` package installed in the opened project. The launcher starts the
+resolved child from the consumer workspace and sets `KIBI_WORKSPACE` to that
+root; it never downloads, bundles, or falls back to a global Kibi runtime:
 
 ```json
 {
   "mcpServers": {
     "kibi": {
       "command": "node",
-      "args": ["bin/launch-kibi-mcp.mjs", "${workspaceFolder}"]
+      "args": [
+        "${CURSOR_PLUGIN_ROOT}/bin/launch-kibi-mcp.mjs",
+        "${workspaceFolder}"
+      ]
     }
   }
 }
@@ -73,6 +76,9 @@ bundles, or falls back to a global Kibi runtime:
 
 Toggle the bundled MCP server from **Settings → Features → Model Context Protocol** after installing the plugin.
 
+Cursor expands `${CURSOR_PLUGIN_ROOT}` to the installed plugin directory and
+`${workspaceFolder}` to the opened workspace before starting the command.
+
 Manual MCP fallback (no plugin install required):
 
 ```json

package/agent-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "kibi",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Repo-local, per-branch, queryable knowledge base. Portable Agent Plugin packaging Kibi's Agent Skills and MCP server.",
   "author": { "name": "Kibi" },
   "homepage": "https://github.com/Looted/kibi/blob/develop/docs/install.md",

package/agent-plugin/skills/kibi-usage/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.1.1
+version: 2.1.3
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -75,6 +75,8 @@ check. Never fire `kb_upsert` calls in parallel; create or confirm endpoint
 entities before linking them. The canonical MCP names are `kb_search`,
 `kb_query`, `kb_upsert`, and `kb_check`.
 
+For a task that explicitly supplies a malformed concrete mutation payload, locate and read that public request artifact before choosing an entity, preserving its exact entity ID, type, requested changes, and every intended relationship and endpoint. Do not substitute a seeded or convenient entity for the requested target. Start with kb_search, then exact-filter those targets with kb_query, and run kb_validate_upsert on that same payload; validation is not completion. Correct only diagnosed pre-commit errors and revalidate the corrected payload. Once authorized, apply the identical corrected and authorized payload with kb_upsert. If it returns committed_with_repairs, treat the mutation as committed, follow only the required repair actions, and neither retry it nor trigger unrelated semantic backfill for a schema-only repair. Exact-read every changed entity and relationship endpoint with kb_query, then finish with an unfiltered kb_check followed by a final kb_status.
+
 ## Closeout fields
 
 End every task with these five independent fields:
@@ -131,6 +133,9 @@ safe normative claims; use `observation` or `meta` for bug/workaround notes and
 tests, symbol ownership, and fresh proof-bearing receipts before claiming proof.
 For an existing product KB that needs semantic backfill, read
 `resources/kb-improvement.md`, and `resources/proof.md` for the proof workflow.
+When a proof ratchet fails, follow Debugging proof regressions in
+`resources/proof.md`: use `kibi proof explain` and compare current proof state
+to committed `proof/baseline.json` with `kibi proof impact`.
 
 ## Predicate Ontology Decision Tree
 
@@ -147,6 +152,8 @@ grounding: run `logic-coverage` so each key binds to one ground fact.
 Relationship direction is fixed, and every `from` in a relationship batch
 must equal the upserted entity ID.
 
+For conditional relational claims, after the initial `kb_suggest_predicates` and before any `kb_upsert`—including one needed for a missing schema—call read-only `kb_model_requirement` to preview suitable scalar or typed-rule modeling. Treat the preview as advisory: do not apply an irrelevant result or create unrequested facts, and retain an approved ground-predicate plan when it captures the whole claim. Preserve supplied arity, ordered argument roles, polarity, bound values, and one claim key per actual assertion; never split arguments across clauses or schemas or alter values to force uniqueness.
+
 ## Symbol-First Traceability
 
 Represent implementation ownership with a `symbol` entity that has

package/agent-plugin/skills/kibi-usage/resources/proof.md

@@ -103,3 +103,48 @@ re-run `kibi prove` for the affected selection, then confirm `kb_status` and
 `kb_coverage` before handoff.
 
 Full reference: `docs/proving-requirements.md`.
+
+## Debugging proof regressions
+
+When a proof ratchet fails, diagnose first. Do not treat
+`proof/baseline.json` as the thing to edit.
+
+1. Do not refresh `proof/baseline.json` as the first fix.
+2. Identify the exact requirement and symbol responsible for the regression.
+3. Use Kibi proof diagnostics rather than reverse-engineering
+   `requirement_proof.pl`:
+
+   ```bash
+   kibi proof explain REQ-<id>
+   kibi proof explain SYM-<id>
+   kibi proof impact
+   ```
+
+   `kibi proof impact` compares the current Proof projection to
+   `HEAD:proof/baseline.json` (the committed ratchet snapshot, not the
+   working-tree file). It is diagnostic: fingerprint differences are reported
+   and the command exits 0 on successful evaluation. The strict ratchet remains
+   `scripts/check-proof-baseline.mjs`.
+4. For `missing_production_symbol_coverage`, inspect symbol role, owning
+   requirement, `covered_by`, candidate test scope, the requirement scenario
+   chain, and the current proof receipt. `kibi proof explain` prints those as
+   three labeled blocks so they cannot be confused:
+   `required_proofs` (TEST contract obligations), `executable_for` (test-code
+   identity), and `covered_by` (production coverage candidates with primary
+   plus optional secondary reasons).
+5. A behavioral production symbol requires qualifying behavioral/E2E evidence
+   under the current proof model.
+6. Unit coverage can satisfy structural/type-shape requirements only when the
+   symbol genuinely represents structural shape and the proof model allows it.
+7. `executable_for` identifies executable test code. Never use it on
+   production helpers merely to remove production coverage obligations.
+8. Do not trust TEST names. Resolve
+   `TEST -> proof_contract.required_proofs -> SYM -> source` and inspect what
+   the executable test actually exercises. Kibi does not infer “this TEST name
+   does not match that source file.”
+9. A passing proof producer does not automatically make every authored
+   `covered_by` relationship semantically correct.
+10. Prefer one meaningful E2E scenario covering multiple internal functions
+    plus focused unit tests for edge cases, rather than an E2E test per helper.
+11. Refresh the baseline only after a genuine intentional proof-state
+    improvement requires the ratchet snapshot to be updated.

package/bin/launch-kibi-mcp.d.mts

@@ -1,5 +1,23 @@
 export function parseWorkspaceFolderPaths(value: unknown): string[];
 
+export function nextAncestorDirectory(current: string): string | undefined;
+
+export function packageJsonForResolvedFile(startPath: string): {
+  packageJsonPath: string;
+  packageRoot: string;
+  packageJson: Record<string, unknown>;
+} | null;
+
+export function hasConsumerNodeModulesLink(
+  workspaceRoot: string,
+  packageRoot: string,
+): boolean;
+
+export function isProjectScopedPackage(
+  workspaceRoot: string,
+  packageRoot: string,
+): boolean;
+
 export function resolveProjectLocalMcp(workspaceRoot: string): {
   packageRoot: string;
   packageJsonPath: string;
@@ -7,12 +25,32 @@ export function resolveProjectLocalMcp(workspaceRoot: string): {
   binPath: string;
 };
 
+export function hasDeclaredProjectDependency(workspaceRoot: string): boolean;
+
 export function resolveWorkspaceRoot(
   explicitWorkspace?: string,
   options?: { cwd?: string; env?: NodeJS.ProcessEnv },
 ): string;
 
+export function signalExitCode(signal: NodeJS.Signals | string): number;
+
+export function isLaunchEntrypoint(
+  argv1: string | undefined,
+  moduleUrl: string,
+): boolean;
+
+export function runLaunchEntrypoint(
+  argv?: string[],
+  env?: NodeJS.ProcessEnv,
+): Promise<number>;
+
 export function launchKibiMcp(
   argv?: string[],
   env?: NodeJS.ProcessEnv,
+  spawnImpl?: typeof import("node:child_process").spawn,
 ): Promise<number>;
+
+export function runLaunchIfEntrypoint(
+  isEntrypoint?: boolean,
+  start?: () => Promise<number> | Promise<void>,
+): Promise<void>;

package/bin/launch-kibi-mcp.mjs

@@ -7,14 +7,17 @@
 /**
  * Launch the kibi-mcp package installed by the consumer project.
  *
- * Cursor starts plugin MCP commands with the plugin directory as their cwd.
- * This adapter deliberately knows nothing about the Kibi source tree: it only
- * resolves a consumer workspace, finds that workspace's kibi-mcp package, and
- * runs its declared bin with the consumer as both cwd and KIBI_WORKSPACE.
+ * Cursor resolves this command from the plugin-root manifest, but the process
+ * cwd is host-controlled and is not a reliable consumer workspace (it may be
+ * the plugin directory or another host directory). This adapter deliberately
+ * knows nothing about the Kibi source tree: it resolves the unrelated consumer
+ * workspace from Cursor's workspace-folder data or explicit environment,
+ * finds that workspace's kibi-mcp package, and runs its declared bin with the
+ * consumer as both cwd and KIBI_WORKSPACE.
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -29,12 +32,12 @@ const SIGNAL_EXIT_CODES = {
 };
 
 function readJson(path) {
-  return JSON.parse(readFileSync(path, "utf8"));
+  return JSON.parse(fs.readFileSync(path, "utf8"));
 }
 
 function isDirectory(path) {
   try {
-    return statSync(path).isDirectory();
+    return fs.statSync(path).isDirectory();
   } catch {
     return false;
   }
@@ -86,17 +89,22 @@ export function parseWorkspaceFolderPaths(value) {
     .filter(Boolean);
 }
 
-function packageJsonForResolvedFile(startPath) {
+export function nextAncestorDirectory(current) {
+  const parent = dirname(current);
+  return parent === current ? undefined : parent;
+}
+
+export function packageJsonForResolvedFile(startPath) {
   let current = resolve(startPath);
   try {
-    if (!statSync(current).isDirectory()) current = dirname(current);
+    if (!fs.statSync(current).isDirectory()) current = dirname(current);
   } catch {
     current = dirname(current);
   }
 
-  while (true) {
+  while (current !== undefined) {
     const packageJsonPath = join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
+    if (fs.existsSync(packageJsonPath)) {
       try {
         const packageJson = readJson(packageJsonPath);
         if (packageJson.name === PACKAGE_NAME) {
@@ -106,10 +114,9 @@ function packageJsonForResolvedFile(startPath) {
         // Keep walking if a parent package manifest is malformed.
       }
     }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
+    current = nextAncestorDirectory(current);
   }
+  return null;
 }
 
 function isWithinRoot(rootPath, candidatePath) {
@@ -120,10 +127,10 @@ function isWithinRoot(rootPath, candidatePath) {
   );
 }
 
-function hasConsumerNodeModulesLink(workspaceRoot, packageRoot) {
+export function hasConsumerNodeModulesLink(workspaceRoot, packageRoot) {
   try {
     const linkPath = join(workspaceRoot, "node_modules", PACKAGE_NAME);
-    const linkedRoot = realpathSync(linkPath);
+    const linkedRoot = fs.realpathSync(linkPath);
     return (
       isWithinRoot(linkedRoot, packageRoot) ||
       isWithinRoot(packageRoot, linkedRoot)
@@ -133,7 +140,7 @@ function hasConsumerNodeModulesLink(workspaceRoot, packageRoot) {
   }
 }
 
-function isProjectScopedPackage(workspaceRoot, packageRoot) {
+export function isProjectScopedPackage(workspaceRoot, packageRoot) {
   if (isWithinRoot(workspaceRoot, packageRoot)) return true;
 
   // pnpm can expose a package through a symlink whose realpath is outside the
@@ -197,7 +204,7 @@ export function resolveProjectLocalMcp(workspaceRoot) {
   }
 
   const binPath = resolve(packageInfo.packageRoot, binEntry);
-  if (!existsSync(binPath)) {
+  if (!fs.existsSync(binPath)) {
     throw new Error(
       `[KIBI-CURSOR] Project-local ${PACKAGE_NAME} declares a missing executable: ${binPath}. Reinstall the workspace dependency and reload Cursor.`,
     );
@@ -211,9 +218,9 @@ export function resolveProjectLocalMcp(workspaceRoot) {
   };
 }
 
-function hasDeclaredProjectDependency(workspaceRoot) {
+export function hasDeclaredProjectDependency(workspaceRoot) {
   const packageJsonPath = join(workspaceRoot, "package.json");
-  if (!existsSync(packageJsonPath)) return false;
+  if (!fs.existsSync(packageJsonPath)) return false;
   try {
     const packageJson = readJson(packageJsonPath);
     return [
@@ -235,8 +242,8 @@ function hasDeclaredProjectDependency(workspaceRoot) {
 
 function isDemonstrablyProjectWorkspace(workspaceRoot) {
   return (
-    existsSync(join(workspaceRoot, ".git")) ||
-    existsSync(join(workspaceRoot, ".kb")) ||
+    fs.existsSync(join(workspaceRoot, ".git")) ||
+    fs.existsSync(join(workspaceRoot, ".kb")) ||
     hasDeclaredProjectDependency(workspaceRoot)
   );
 }
@@ -311,12 +318,30 @@ export function resolveWorkspaceRoot(explicitWorkspace, options = {}) {
   );
 }
 
-function signalExitCode(signal) {
+export function signalExitCode(signal) {
   return SIGNAL_EXIT_CODES[signal] ?? 1;
 }
 
+export function isLaunchEntrypoint(argv1, moduleUrl) {
+  const entrypoint = argv1 ? resolve(argv1) : undefined;
+  return entrypoint === resolve(fileURLToPath(moduleUrl));
+}
+
+export async function runLaunchEntrypoint(
+  argv = process.argv.slice(2),
+  env = process.env,
+) {
+  const exitCode = await launchKibiMcp(argv, env);
+  process.exitCode = exitCode;
+  return exitCode;
+}
+
 /** Spawn the project-local MCP server and mirror its transport and exit state. */
-export function launchKibiMcp(argv = process.argv.slice(2), env = process.env) {
+export function launchKibiMcp(
+  argv = process.argv.slice(2),
+  env = process.env,
+  spawnImpl = spawn,
+) {
   const [explicitWorkspace, ...childArgs] = argv;
   let workspaceRoot;
   let projectLocal;
@@ -332,11 +357,15 @@ export function launchKibiMcp(argv = process.argv.slice(2), env = process.env) {
     return Promise.resolve(1);
   }
 
-  const child = spawn(process.execPath, [projectLocal.binPath, ...childArgs], {
-    cwd: workspaceRoot,
-    env: { ...env, KIBI_WORKSPACE: workspaceRoot },
-    stdio: ["inherit", "inherit", "inherit"],
-  });
+  const child = spawnImpl(
+    process.execPath,
+    [projectLocal.binPath, ...childArgs],
+    {
+      cwd: workspaceRoot,
+      env: { ...env, KIBI_WORKSPACE: workspaceRoot },
+      stdio: ["inherit", "inherit", "inherit"],
+    },
+  );
 
   return new Promise((resolveExit) => {
     let finished = false;
@@ -371,8 +400,12 @@ export function launchKibiMcp(argv = process.argv.slice(2), env = process.env) {
   });
 }
 
-const entrypoint = process.argv[1] ? resolve(process.argv[1]) : undefined;
-if (entrypoint === resolve(fileURLToPath(import.meta.url))) {
-  const exitCode = await launchKibiMcp(process.argv.slice(2));
-  process.exitCode = exitCode;
+export async function runLaunchIfEntrypoint(
+  isEntrypoint = isLaunchEntrypoint(process.argv[1], import.meta.url),
+  start = runLaunchEntrypoint,
+) {
+  if (!isEntrypoint) return;
+  await start();
 }
+
+await runLaunchIfEntrypoint();

package/dist/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "kibi-cursor",
   "displayName": "Kibi",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "Optional Cursor adapter for Kibi. Requires SWI-Prolog 9+ and project-local kibi-cli, kibi-mcp, and kibi-core before the bundled MCP server can start.",
   "license": "AGPL-3.0-or-later",
   "author": {

package/dist/bin/launch-kibi-mcp.d.mts

@@ -1,5 +1,23 @@
 export function parseWorkspaceFolderPaths(value: unknown): string[];
 
+export function nextAncestorDirectory(current: string): string | undefined;
+
+export function packageJsonForResolvedFile(startPath: string): {
+  packageJsonPath: string;
+  packageRoot: string;
+  packageJson: Record<string, unknown>;
+} | null;
+
+export function hasConsumerNodeModulesLink(
+  workspaceRoot: string,
+  packageRoot: string,
+): boolean;
+
+export function isProjectScopedPackage(
+  workspaceRoot: string,
+  packageRoot: string,
+): boolean;
+
 export function resolveProjectLocalMcp(workspaceRoot: string): {
   packageRoot: string;
   packageJsonPath: string;
@@ -7,12 +25,32 @@ export function resolveProjectLocalMcp(workspaceRoot: string): {
   binPath: string;
 };
 
+export function hasDeclaredProjectDependency(workspaceRoot: string): boolean;
+
 export function resolveWorkspaceRoot(
   explicitWorkspace?: string,
   options?: { cwd?: string; env?: NodeJS.ProcessEnv },
 ): string;
 
+export function signalExitCode(signal: NodeJS.Signals | string): number;
+
+export function isLaunchEntrypoint(
+  argv1: string | undefined,
+  moduleUrl: string,
+): boolean;
+
+export function runLaunchEntrypoint(
+  argv?: string[],
+  env?: NodeJS.ProcessEnv,
+): Promise<number>;
+
 export function launchKibiMcp(
   argv?: string[],
   env?: NodeJS.ProcessEnv,
+  spawnImpl?: typeof import("node:child_process").spawn,
 ): Promise<number>;
+
+export function runLaunchIfEntrypoint(
+  isEntrypoint?: boolean,
+  start?: () => Promise<number> | Promise<void>,
+): Promise<void>;