kibi-cursor 2.0.0 → 2.1.0

package/dist/path-policy.js

@@ -1,3 +1,5 @@
+// implements REQ-cursor-kibi-plugin-v1
+import { extractExplicitPathFields as extractSharedExplicitPathFields, isKbPath, isDocumentationTrackedPath as isSharedDocumentationTrackedPath, isMeaningfulTrackedPath as isSharedMeaningfulTrackedPath, isSourceImpactRelevantPath as isSharedSourceImpactRelevantPath, normalizeWorkspacePath, } from "kibi-agent-core/path-policy";
 export function isFreshnessLane(lane) {
     return (lane === "requirements" ||
         lane === "scenarios" ||
@@ -9,200 +11,38 @@ export function isFreshnessLane(lane) {
         lane === "symbols.yaml" ||
         lane === "symbol-coordinates.yaml");
 }
-// implements REQ-cursor-kibi-plugin-v1
-const explicitPathKeys = new Set([
-    "absolute_path",
-    "file",
-    "file_path",
-    "filepath",
-    "new_path",
-    "old_path",
-    "path",
-    "paths",
-    "relative_path",
-    "target_path",
-]);
-const sourceExtensions = new Set([
-    ".c",
-    ".cc",
-    ".cpp",
-    ".cs",
-    ".css",
-    ".go",
-    ".h",
-    ".hpp",
-    ".html",
-    ".java",
-    ".js",
-    ".jsx",
-    ".kt",
-    ".lua",
-    ".mjs",
-    ".mts",
-    ".php",
-    ".pl",
-    ".py",
-    ".rb",
-    ".rs",
-    ".scala",
-    ".sh",
-    ".swift",
-    ".ts",
-    ".tsx",
-    ".vue",
-]);
-const documentationExtensions = new Set([".md", ".mdx", ".rst", ".txt"]);
-const CANONICAL_KB_KNOWLEDGE_LANES = new Set([
-    "requirements",
-    "scenarios",
-    "tests",
-    "facts",
-    "adr",
-    "flags",
-    "events",
-]);
-const CANONICAL_KB_KNOWLEDGE_FILES = new Set([
-    "symbols.yaml",
-    "symbol-coordinates.yaml",
-]);
-function isCanonicalKbKnowledgePath(segments) {
-    if (segments[0] !== ".kb") {
-        return false;
-    }
-    const lane = segments[1];
-    if (lane === undefined) {
-        return false;
-    }
-    return (CANONICAL_KB_KNOWLEDGE_FILES.has(lane) ||
-        CANONICAL_KB_KNOWLEDGE_LANES.has(lane));
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizePath(candidate) {
-    return candidate.trim().replaceAll("\\", "/");
-}
-function pathSegments(candidate) {
-    return normalizePath(candidate).split("/").filter(Boolean);
-}
-function collectPathValues(value, output) {
-    if (typeof value === "string") {
-        const normalized = normalizePath(value);
-        if (normalized.length > 0) {
-            output.push(normalized);
-        }
-        return;
-    }
-    if (!Array.isArray(value)) {
-        return;
-    }
-    for (const item of value) {
-        collectPathValues(item, output);
-    }
-}
-function visitExplicitPathFields(value, output) {
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            visitExplicitPathFields(item, output);
-        }
-        return;
-    }
-    if (!isRecord(value)) {
-        return;
-    }
-    for (const [key, child] of Object.entries(value)) {
-        if (explicitPathKeys.has(key.toLowerCase())) {
-            collectPathValues(child, output);
-        }
-        visitExplicitPathFields(child, output);
-    }
-}
 export function extractExplicitPathFields(input) {
-    const paths = [];
-    visitExplicitPathFields(input, paths);
-    return [...new Set(paths)];
+    return extractSharedExplicitPathFields(input);
 }
 export function isDirectKbPath(candidate) {
-    return pathSegments(candidate).includes(".kb");
+    return isKbPath(candidate);
 }
 export function isMeaningfulTrackedPath(candidate) {
-    const normalized = normalizePath(candidate);
-    const segments = pathSegments(normalized);
-    if (segments.includes("dist")) {
-        return false;
-    }
-    if (segments.includes(".kb")) {
-        return isCanonicalKbKnowledgePath(segments);
-    }
-    const basename = segments.at(-1) ?? "";
-    const extension = basename.includes(".")
-        ? `.${basename.split(".").at(-1) ?? ""}`
-        : "";
-    if (segments.includes("docs") || segments.includes("documentation")) {
-        return documentationExtensions.has(extension);
-    }
-    if (basename === "README.md") {
-        return true;
-    }
-    if (segments.includes("src") ||
-        segments.includes("tests") ||
-        segments.includes("test")) {
-        return (sourceExtensions.has(extension) || documentationExtensions.has(extension));
-    }
-    return false;
+    return isSharedMeaningfulTrackedPath(candidate);
 }
 /** Paths whose edits should trigger a KB freshness stop follow-up. */
 export function isKbFreshnessRelevantPath(candidate) {
-    const segments = pathSegments(normalizePath(candidate));
-    if (segments[0] === ".kb") {
-        const lane = segments[1];
-        if (isFreshnessLane(lane))
-            return true;
-    }
-    // Legacy layout during migration
-    if (segments.includes("documentation")) {
+    const segments = normalizeWorkspacePath(candidate).split("/").filter(Boolean);
+    if (segments[0] === ".kb" && isFreshnessLane(segments[1]))
+        return true;
+    if (segments.includes("documentation"))
         return true;
-    }
     return (segments[0] === "packages" &&
         segments[1] === "core" &&
         segments[2] === "src");
 }
 export function isSourceImpactRelevantPath(candidate) {
-    const normalized = normalizePath(candidate);
-    const segments = pathSegments(normalized);
-    if (segments.includes(".kb") ||
-        segments.includes("dist") ||
-        segments.includes("tests") ||
-        segments.includes("test") ||
-        segments.includes("docs") ||
-        segments.includes("documentation")) {
-        return false;
-    }
-    const basename = segments.at(-1) ?? "";
-    const extension = basename.includes(".")
-        ? `.${basename.split(".").at(-1) ?? ""}`
-        : "";
-    return segments.includes("src") && sourceExtensions.has(extension);
+    return isSharedSourceImpactRelevantPath(candidate);
 }
 export function isDocumentationTrackedPath(candidate) {
-    const normalized = normalizePath(candidate);
-    const segments = pathSegments(normalized);
-    const basename = segments.at(-1) ?? "";
-    const extension = basename.includes(".")
-        ? `.${basename.split(".").at(-1) ?? ""}`
-        : "";
-    return (segments.includes("docs") ||
-        segments.includes("documentation") ||
-        documentationExtensions.has(extension));
+    return isSharedDocumentationTrackedPath(candidate);
 }
 export function toRepoRelativePath(candidate, cwd) {
-    const normalized = normalizePath(candidate);
-    if (!cwd) {
+    const normalized = normalizeWorkspacePath(candidate);
+    if (!cwd)
         return normalized;
-    }
-    const cwdPrefix = `${normalizePath(cwd)}/`;
-    if (normalized.startsWith(cwdPrefix)) {
-        return normalized.slice(cwdPrefix.length);
-    }
-    return normalized;
+    const cwdPrefix = `${normalizeWorkspacePath(cwd)}/`;
+    return normalized.startsWith(cwdPrefix)
+        ? normalized.slice(cwdPrefix.length)
+        : normalized;
 }

package/dist/skills/.canon-hash.json

@@ -13,15 +13,15 @@
   "kibi-traceability/resources/operation-access.md": "39f7972ab7f4ae7479e78f7072bb50e8e6c4cdf4f857425f69d2522d37db437c",
   "kibi-traceability/resources/source-authoring.md": "408c6ee2bef1b84e0194c0538ef929c26a0a617e631b2234247388140dbbdd08",
   "kibi-traceability/resources/traceability.md": "38c290a0bc71bd1692e115f22694743946e2f69630e134acfd43cee5f613fb88",
-  "kibi-usage/SKILL.md": "47a76e74fa1439e3745afe4c883b9cb1383df7696b1a0d695c02fe4e34e3205d",
+  "kibi-usage/SKILL.md": "83567f8ead944457719e0254ad6bc1dbedda3a70d04266d2ff041a670336dcc6",
   "kibi-usage/resources/branch-lifecycle.md": "f1bf359e9826e83c548f3cd0287f8175a62456527b0132b06b3f9f74aa59b7d6",
-  "kibi-usage/resources/fact-lanes.md": "41b28023a57593009867ea0ebc8e9f3f05c3bd837144772d12844423f922e763",
+  "kibi-usage/resources/fact-lanes.md": "7ac928cc6b3d189eee6a9cda282918677d5a222cd7ba9b7f324e6553cd3adce8",
   "kibi-usage/resources/kb-improvement.md": "17e8b6cf6a0dd43b443a2bfd92e7205d099647a5f1c75fe85413a6cea63d86c6",
   "kibi-usage/resources/logic-ir.md": "151675d0ffa813cb9e271084102a3af42de369b8f9a0c64866af0cdc4d924063",
   "kibi-usage/resources/operation-access.md": "e8b4a3676892d2f7e2cfd708ec4ad1f41b6f296e1eb3a5ecc047f43322b4a92a",
-  "kibi-usage/resources/proof.md": "e1a44ea4bf342afebb0aaa7800221067a511f6607c687ac38db6392b7e3d9f9a",
-  "kibi-usage/resources/relationship-directions.md": "a357072d3370db9b7d80e505795f952909a68778cc18b1d089970de91e4fda46",
-  "kibi-usage/resources/source-authoring.md": "ac4f1a9b5785462f8c3530bdcdb82ad9a0ee1f4049454ae28bf4df09ff267ebd",
+  "kibi-usage/resources/proof.md": "7391046fbdeece4858b668360c60755f184af6dfedda9dbc67e2fa4574dbce7f",
+  "kibi-usage/resources/relationship-directions.md": "0fdd67032c2d15299f772845fc4f807eb9435b09507bd87a5911ab33db2f143d",
+  "kibi-usage/resources/source-authoring.md": "80978cea0614484292c7a70d511a3f50458f48ef976bf0675b8bb96abe9d3d36",
   "kibi-usage/resources/ui-requirements.md": "b7c31ab1affa3ab25ae5242d8fd8c4d546532d1cafc65d84088375317c1682cc",
-  "kibi-usage/resources/workflows.md": "776b97a794325e7012a230d2b9fc32fc89b2a51df45dfd8498cad49170bdc43d"
+  "kibi-usage/resources/workflows.md": "52cadc2b1e41af7d0c3129b721d81bb542fefb97113ba3a7c817f7ab7a1f787e"
 }

package/dist/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.2
+version: 2.2.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -59,7 +59,11 @@ mutability, and Prolog requirements of each operation.
 ## Safe workflow
 
 1. Always discover before you mutate: start with `kb_search`, then exact-filter with `kb_query`. Use
-   `kb_status` when branch or freshness confidence matters.
+   `kb_status` when branch or freshness confidence matters. `kb_search` ranks
+   lexically unless you pass `rankingMode: "intent-v1"`, `semanticFacets`, or
+   `sourceLocations`; use intent mode with grounded facets for conceptual
+   questions and before changing a source file, and keep lexical search for
+   literal identifiers. See `resources/workflows.md` for the mode recipe.
 2. Resolve genuine ambiguity with the human; use semantic advisor/modeling
    operations for deterministic interpretation and typed facts.
 3. Create endpoints before relationships and upsert small batches sequentially.
@@ -133,6 +137,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
 
@@ -157,7 +164,7 @@ Represent implementation ownership with a `symbol` entity that has
 `sourceFile`, `implements` to the requirement, and `covered_by` to the test.
 Prolog `symbol-coverage` also requires the test to `validates` the requirement
 (or the requirement `verified_by` the test). `covered_by` alone is not
-enough. Do not rely on legacy `// implements REQ-xxx` comments as the
+enough. Do not rely on legacy `// implements REQ-<area>-<behavior>` comments as the
 traceability record.
 
 ## Complete Logical Coverage

package/dist/skills/kibi-usage/resources/fact-lanes.md

@@ -55,6 +55,10 @@ relationship: { type: requires_predicate, from: REQ-EDITOR-DRAFT-AUTOSAVE, to: F
 
 The project-local schema endpoint must exist before this fact is linked. When ontology extension is explicitly authorized, define it first with `fact_kind: predicate_schema`, `predicate_name`, `predicate_arity`, and equally sized `argument_names` and `argument_types`. Without an authorized stable signature, record `review:ontology-gap` instead of inventing a schema.
 
+### Closed argument vocabularies
+
+A schema can close an argument with `argument_constants` (allowed values keyed by argument name) and map older spellings with `argument_aliases`. Reuse a declared constant; `kb_upsert` rejects any other value and names the constant to use for an alias. When a genuinely new value is needed, extend `argument_constants` on the schema first. To converge existing facts, declare aliases for their spellings and let `kibi migrate` rewrite them (`predicate_schema_alignment` actions). Close only arguments with a natural shared vocabulary, such as the governed component or a severity; forcing distinct obligations into a few constants makes different requirements share one ground term.
+
 ### Deny predicate
 
 Claim: “Suspended users must not publish articles.” When `permission_rule` fits, preserve its positive schema name and encode prohibition as polarity:

package/dist/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/dist/skills/kibi-usage/resources/relationship-directions.md

@@ -12,6 +12,7 @@
 | `constrains` | req -> fact(subject) | Requirement constrains a strict-lane domain fact |
 | `requires_property` | req -> fact(property_value) | Requirement requires a specific property value fact |
 | `supersedes` | new-req -> old-req | New requirement formally replaces an old requirement |
+| `restates` | req -> req | Requirement intentionally restates another current requirement (for example a product requirement echoed in a platform requirement); suppresses `domain-redundancy` for that pair without retiring either side |
 | `covered_by` | symbol -> test | Production symbol has test coverage evidence |
 
 ## Valid Payload Examples
@@ -20,32 +21,32 @@
 ```yaml
 relationships:
   - type: implements
-    from: SYM-001
-    to: REQ-001
+    from: SYM-operation-execute-check
+    to: REQ-cli-check
 ```
 
 ### specified_by
 ```yaml
 relationships:
   - type: specified_by
-    from: REQ-001
-    to: SCEN-001
+    from: REQ-mcp-search-discovery
+    to: SCEN-mcp-search-discovery
 ```
 
 ### verified_by
 ```yaml
 relationships:
   - type: verified_by
-    from: REQ-001
-    to: TEST-001
+    from: REQ-mcp-search-discovery
+    to: TEST-mcp-search-discovery
 ```
 
 ### validates
 ```yaml
 relationships:
   - type: validates
-    from: TEST-001
-    to: SCEN-001
+    from: TEST-mcp-search-discovery
+    to: SCEN-mcp-search-discovery
 ```
 
 ### executable_for
@@ -53,39 +54,56 @@ relationships:
 relationships:
   - type: executable_for
     from: SYM-test-login
-    to: TEST-001
+    to: TEST-mcp-search-discovery
 ```
 
 ### constrains
 ```yaml
 relationships:
   - type: constrains
-    from: REQ-019
-    to: FACT-USER-ROLE
+    from: REQ-cli-check
+    to: FACT-SUBJECT-KIBI-CHECK
 ```
 
 ### requires_property
 ```yaml
 relationships:
   - type: requires_property
-    from: REQ-019
-    to: FACT-LIMIT-3
+    from: REQ-cli-check
+    to: FACT-PROP-CHECK-FAILURE-EXIT-CODE
 ```
 
 ### supersedes
 ```yaml
 relationships:
   - type: supersedes
-    from: REQ-001-v2
-    to: REQ-001
+    from: REQ-opencode-kibi-briefing-v2
+    to: REQ-opencode-kibi-briefing-v1
 ```
 
+A `-v2` suffix is acceptable only for a direct superseding replacement like
+this one; otherwise name the new requirement by the behavior it governs.
+
+### restates
+```yaml
+# Illustrative: a product requirement echoes a platform requirement verbatim.
+relationships:
+  - type: restates
+    from: REQ-billing-invoice-retention
+    to: REQ-platform-record-retention
+```
+
+Use `restates` only when two current requirements deliberately ground the same
+logical term (same predicate, property tuple, or rule semantic key). It keeps
+both requirements current and tells `domain-redundancy` the duplication is
+intentional. If one requirement replaces the other, use `supersedes` instead.
+
 ### covered_by
 ```yaml
 relationships:
   - type: covered_by
-    from: SYM-handler
-    to: TEST-005
+    from: SYM-operation-execute-check
+    to: TEST-mcp-search-discovery
 ```
 
 ## Invalid Test-Fact Shortcuts

package/dist/skills/kibi-usage/resources/source-authoring.md

@@ -29,3 +29,39 @@ Cancellation follows the same rule: wait for the terminal journal state. A
 pre-commit rollback is retryable, a committed source with a failed derivative
 is repairable, and an indeterminate outcome is non-retryable until its recovery
 action resolves the journal.
+
+## Naming entities
+
+Name every entity by what it governs, the way you would name a source file.
+Never choose "the next number": parallel branches pick the same next number and
+collide even when they touch unrelated behavior.
+
+- Use `<TYPE>-<area>-<behavior>` in kebab-case, with the type prefix kept
+  uppercase: `REQ-cli-gc`, `SCEN-mcp-search-discovery`,
+  `TEST-mcp-search-discovery`, `ADR-capability-plugins-v1`,
+  `EVT-exact-branch-store-ensure`, and a flag named after its gate such as
+  `FLAG-scip-symbol-extraction`.
+- The filename stem equals the frontmatter `id`
+  (`.kb/requirements/REQ-cli-gc.md` has `id: REQ-cli-gc`). Always set `id`
+  explicitly; a missing `id` falls back to a path-and-title hash that changes
+  when the file is renamed.
+- Before creating an entity, `kb_search` the area. If an existing entity already
+  covers the behavior, update it, or create a replacement and link it with
+  `supersedes`. A `-v2` suffix is acceptable only for that direct superseding
+  replacement.
+- A name collision with another branch usually means the same work was done
+  twice. Reconcile the two entities; do not rename one of them to dodge the
+  collision.
+- The area prefix is for humans. Whether two requirements are about the same
+  thing is decided by their facts: a shared `subject_key` and identical
+  predicate or property signatures, which `domain-redundancy` and
+  `domain-contradictions` compare deterministically. Reuse existing subject keys
+  (dotted `component.aspect[.sub]`, lowercase snake segments such as
+  `kibi.cli.check.staged`) instead of deriving a subject from the requirement
+  ID.
+
+`entity-id-style` reports new purely numeric IDs (`REQ-123`) and IDs whose
+filename stem differs from `id` as non-blocking quality diagnostics. Legacy
+numbered entities created before the naming standard are grandfathered and are
+not renamed, because code comments such as `// implements REQ-003` still
+reference them.

package/dist/skills/kibi-usage/resources/workflows.md

@@ -33,11 +33,62 @@ surfaces are a release defect: require a new package version and label any
 project override temporary. This skill never selects a package manager or
 edits dependency configuration.
 
+## Choosing a discovery mode
+
+`kb_search` is not one behavior. It selects deterministic intent ranking when
+you pass `rankingMode: "intent-v1"`, `semanticFacets`, or `sourceLocations`,
+and legacy lexical ranking otherwise. Naming the tool is not enough; the inputs
+decide the path.
+
+- **Exact identity** — you already know the ID. Use `kb_query`, not search.
+- **Literal token** — a symbol, file, or error string that appears verbatim.
+  Use lexical `kb_search` and keep the query close to the literal text.
+- **Conceptual or behavioral** — "how does checkout handle a declined card".
+  Use intent mode and ground it in what you actually know:
+
+```json
+{
+  "query": "declined card during checkout",
+  "rankingMode": "intent-v1",
+  "semanticFacets": {
+    "actors": ["shopper"],
+    "actions": ["pay"],
+    "objects": ["card"],
+    "constraints": ["declined"]
+  }
+}
+```
+
+- **Before changing code** — pass the file you are about to edit as a source
+  location, so results are matched against source-linked symbols and return
+  source evidence:
+
+```json
+{
+  "query": "checkout total rounding",
+  "rankingMode": "intent-v1",
+  "sourceLocations": [{ "path": "src/checkout.ts", "symbol": "computeTotal" }]
+}
+```
+
+Supply facets only from the request, the code, or prior results. Inventing
+facets fabricates evidence and biases ranking. Intent mode abstains below
+`minScore` instead of returning weak matches; an abstention is an explicit
+no-answer, so widen the query or drop to lexical search rather than treating it
+as "nothing exists". There is no target percentage of intent-mode calls — a
+literal identifier lookup is still best served lexically.
+
+Results are summaries by default: identifying metadata, score, reasons, and a
+snippet. Read them to pick candidates, then `kb_query` those IDs for full
+bodies, or pass `fields: "full"` when you genuinely need every body. Extract
+the relevant existing constraints and decisions from the response before
+planning a behavior change; a search receipt is not comprehension.
+
 ## Discovery to Validation Sequence
 
 The canonical workflow for any KB operation follows this pattern:
 
-1. **Discover**: `kb_search` with focused probes
+1. **Discover**: `kb_search` with focused probes; pick the mode above
 2. **Confirm**: `kb_query` for exact IDs and state
 3. **Inspect**: `kb_status` when freshness matters
 4. **Decompose**: `kb_semantic_advisor` on the complete normative prose; verify or supply every atomic clause

package/dist/source-linked-requirements.d.ts

@@ -0,0 +1,16 @@
+type ManifestRow = {
+    sourceFile: string;
+    relationships: {
+        type: string;
+        target: string;
+    }[];
+};
+/**
+ * Resolve typed requirement ownership through the shared line-scanned index.
+ * Cursor stores the cache beside its hook state, so subsequent hook processes
+ * pay only two stats and a small JSON parse while the manifests are unchanged.
+ */
+export declare function getSourceLinkedRequirementIds(workspaceRoot: string, editedPath: string, cacheDir?: string): string[];
+/** Parse the canonical writer subset while retaining typed relationships. */
+export declare function parseSymbolsManifest(content: string): ManifestRow[];
+export {};

package/dist/source-linked-requirements.js

@@ -0,0 +1,55 @@
+// implements REQ-cursor-kibi-plugin-v1
+import path from "node:path";
+import { buildKnowledgeIndex, loadKnowledgeIndex, scanSymbolsManifest, } from "kibi-agent-core/knowledge-index";
+const MAX_LINKED_REQUIREMENTS = 3;
+const CURSOR_INDEX_OPTIONS = {
+    legacyLinksAsImplements: false,
+    cacheFileName: "cursor-knowledge-index.json",
+};
+function toManifestPath(workspaceRoot, filePath) {
+    const absolute = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(workspaceRoot, filePath);
+    return path.relative(workspaceRoot, absolute).split(path.sep).join("/");
+}
+/**
+ * Resolve typed requirement ownership through the shared line-scanned index.
+ * Cursor stores the cache beside its hook state, so subsequent hook processes
+ * pay only two stats and a small JSON parse while the manifests are unchanged.
+ */
+export function getSourceLinkedRequirementIds(workspaceRoot, editedPath, cacheDir) {
+    const relativePath = toManifestPath(workspaceRoot, editedPath);
+    const symbols = loadKnowledgeIndex(workspaceRoot, cacheDir, CURSOR_INDEX_OPTIONS).files[relativePath];
+    if (!symbols)
+        return [];
+    const ordered = [];
+    for (const symbol of symbols) {
+        for (const requirementId of symbol.implements) {
+            if (!ordered.includes(requirementId))
+                ordered.push(requirementId);
+        }
+    }
+    return ordered.slice(0, MAX_LINKED_REQUIREMENTS);
+}
+/** Parse the canonical writer subset while retaining typed relationships. */
+// implements REQ-cursor-kibi-plugin-v1
+export function parseSymbolsManifest(content) {
+    const index = buildKnowledgeIndex(scanSymbolsManifest(content), {}, CURSOR_INDEX_OPTIONS);
+    return Object.entries(index.files).flatMap(([sourceFile, symbols]) => symbols.map((symbol) => ({
+        sourceFile,
+        relationships: [
+            ...symbol.implements.map((target) => ({
+                type: "implements",
+                target,
+            })),
+            ...symbol.coveredBy.map((target) => ({
+                type: "covered_by",
+                target,
+            })),
+            ...symbol.executableFor.map((target) => ({
+                type: "executable_for",
+                target,
+            })),
+        ],
+    })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cursor",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Kibi Cursor plugin - thin adapter for Cursor MCP integration and editor hooks",
   "type": "module",
   "main": "dist/index.js",
@@ -53,6 +53,9 @@
       "optional": true
     }
   },
+  "dependencies": {
+    "kibi-agent-core": "^0.1.0"
+  },
   "devDependencies": {
     "@types/node": "latest",
     "typescript": "^5.7.0"