kibi-cursor 2.10.0 → 2.11.0

package/dist/bin/launch-kibi-mcp.mjs

@@ -180,7 +180,8 @@ export function resolveProjectLocalMcp(workspaceRoot) {
   if (!packageInfo) {
     throw new Error(
       `[KIBI-CURSOR] No project-local ${PACKAGE_NAME} package was found for ${root}. ` +
-        `Install it in that workspace (for example: npm install --save-dev ${PACKAGE_NAME}) and reload Cursor.`,
+        `Install it in that workspace (for example: npm install --save-dev ${PACKAGE_NAME}) and reload Cursor. ` +
+        `The plugin launcher does not use a global ${PACKAGE_NAME}; to use one, add the manual MCP entry from the kibi-cursor README instead.`,
     );
   }
 

package/dist/hook-runner.js

@@ -4,8 +4,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { captureReminder, claimCaptureReminder, claimSignoffReminder, confirmFirmEdits, firmEditNotice, firmRequirementsTouched, hasDecisionFlag, holdRuleNote, isRequirementUpsert, markDecisionFlag, recordRequest, settleFirmRequirements, settledFirmRequirements, signoffReminder, takeRuleNote, } from "kibi-agent-core/decision-guard";
-import { appendHookUsageRows, editTraces, hookTelemetryEnabled, kbUsageTrace, readPackageVersion, } from "kibi-agent-core/hook-usage-log";
+import { appendHookUsage, appendHookUsageRows, editTraces, finishHookTelemetry, hookTracesWanted, kbUsageTrace, readPackageVersion, } from "kibi-agent-core/hook-usage-log";
 import { stampKibiWorkspace } from "kibi-agent-core/kb-mcp-tools";
+import { classifyPath } from "kibi-agent-core/path-policy";
 import { createEntitySummarizer, editFocus, fileKnowledgeSnippet, implementedRequirementIds, } from "kibi-agent-core/snippets";
 import { preEditGuidance, readGuidance, writeGuidance } from "./guidance.js";
 import { parseHookInput, parseStdinJson, readStdin } from "./hook-input.js";
@@ -54,7 +55,8 @@ function firmNotice(workspaceRoot, linked, focus, session, env) {
     return firmEditNotice(symbol ? `${symbol.title} in ${linked.relativePath}` : linked.relativePath, ids.map(summarize));
 }
 function packageVersion() {
-    // dist/hook-runner.js sits one level below the package root. Each hook
+    // bin/hook-runner.mjs and dist/hook-runner.js sit one level below the
+    // package root. Each hook
     // event is its own process, so the version is read at most once per event.
     return readPackageVersion(path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json"));
 }
@@ -68,7 +70,7 @@ function recordToolTelemetry(input, workspaceRoot, stateDir, startedAt, env) {
     // rationale: appendHookUsageRows applies the same opt-in; this guard only
     // skips reading the index when telemetry is off.
     // Stryker disable next-line ConditionalExpression
-    if (!hookTelemetryEnabled(env))
+    if (!hookTracesWanted(env))
         return;
     const kbUsage = kbUsageTrace(input.toolName, input.toolInput);
     if (!kbUsage && !isKnownEditableTool(input.toolName))
@@ -166,157 +168,100 @@ export async function runHook(rawInput, environment = {}) {
         stateDir,
         sessionId: input.conversationId,
     };
-    switch (input.event) {
-        case "sessionStart":
-            if (!kibiReady) {
-                const advisory = interfaceAdvisory(initialState.mcpState, workspaceTrusted);
-                return {
-                    additional_context: advisory
-                        ? `${BOOTSTRAP_REMINDER}\n${advisory}`
-                        : BOOTSTRAP_REMINDER,
-                };
-            }
-            {
-                const advisory = interfaceAdvisory(initialState.mcpState, workspaceTrusted);
-                return advisory ? { additional_context: advisory } : emptyResult();
-            }
-        case "preToolUse": {
-            // Name the agent's workspace on every Kibi MCP call so the launcher
-            // answers from it, also for agents working in a git worktree. The
-            // per-call cwd wins over workspace_roots, which can be the window's
-            // folders rather than the agent's checkout.
-            const stamped = stampKibiWorkspace(input.toolName, input.toolInput, kibiWorkspaceFor(input.cwd ?? input.workspaceRoots?.[0]));
-            if (stamped) {
-                return { updated_input: stamped };
-            }
-            const explicitPaths = extractExplicitPathFields(input.toolInput);
-            const hasDirectKbEdit = isEditLikeTool(input.toolName) && explicitPaths.some(isDirectKbPath);
-            if (hasDirectKbEdit) {
-                return {
-                    permission: "allow",
-                    agent_message: DIRECT_KB_EDIT_WARNING,
-                };
-            }
-            const primaryPath = resolvePrimaryPath(input);
-            if (!primaryPath || !kibiReady || !isKnownEditableTool(input.toolName)) {
-                return emptyResult();
-            }
-            const relativePath = toRepoRelativePath(primaryPath, cwd);
-            const state = loadHookState(stateDir);
-            const linked = getSourceLinkedSymbols(cwd, primaryPath, stateDir);
-            const focus = editFocus(path.resolve(cwd, primaryPath), input.toolInput);
-            const ruleNote = takeRuleNote(session);
-            const notice = firmNotice(cwd, linked, focus, session, environment.env ?? process.env);
-            const guidance = hasGuidedPath(state, "pre-edit", relativePath)
-                ? undefined
-                : preEditGuidance(primaryPath, {
-                    cwd,
-                    hasKibi: kibiReady,
-                    mcpState: state.mcpState,
-                    workspaceTrusted,
-                    // A file that implements requirements always gets the shared
-                    // snippet, so the bare linked-requirement wording is never needed.
-                    knowledge: knowledgeFor(cwd, linked, "edit", focus),
-                });
-            if (guidance) {
-                rememberGuidedPath(stateDir, "pre-edit", relativePath);
-            }
-            const parts = [ruleNote, notice, guidance].filter((part) => part !== undefined);
-            return parts.length > 0
-                ? { permission: "allow", agent_message: parts.join("\n\n") }
-                : emptyResult();
-        }
-        // implements REQ-agent-hosts-decision-guard
-        case "beforeSubmitPrompt": {
-            // Cursor's prompt hook cannot add context: the request's rule note
-            // waits for the next pre-edit message.
-            if (kibiReady && input.prompt) {
-                const rule = recordRequest(session, input.prompt);
-                if (rule !== undefined)
-                    holdRuleNote(session, rule);
-            }
-            return { continue: true };
-        }
-        case "beforeReadFile": {
-            const primaryPath = resolvePrimaryPath(input);
-            if (!primaryPath || !kibiReady) {
-                return { permission: "allow" };
-            }
-            const relativePath = toRepoRelativePath(primaryPath, cwd);
-            const state = loadHookState(stateDir);
-            if (hasGuidedPath(state, "read", relativePath)) {
-                return { permission: "allow" };
-            }
-            const guidance = readGuidance(primaryPath, {
-                cwd,
-                hasKibi: kibiReady,
-                mcpState: state.mcpState,
-                workspaceTrusted,
-                knowledge: knowledgeFor(cwd, getSourceLinkedSymbols(cwd, primaryPath, stateDir), 
-                // rationale: the snippet only special-cases "edit", so any other
-                // surface literal renders the same read snippet.
-                // Stryker disable next-line StringLiteral
-                "read"),
-            });
-            if (!guidance) {
-                return { permission: "allow" };
-            }
-            rememberGuidedPath(stateDir, "read", relativePath);
-            return {
-                permission: "allow",
-                agent_message: guidance,
-            };
-        }
-        case "postToolUse": {
-            if (kibiReady) {
-                try {
-                    recordToolTelemetry(input, cwd, stateDir, startedAt, environment.env);
+    const trace = {};
+    try {
+        switch (input.event) {
+            case "sessionStart":
+                trace.action = "session_start";
+                if (!kibiReady) {
+                    const advisory = interfaceAdvisory(initialState.mcpState, workspaceTrusted);
+                    return {
+                        additional_context: advisory
+                            ? `${BOOTSTRAP_REMINDER}\n${advisory}`
+                            : BOOTSTRAP_REMINDER,
+                    };
                 }
-                catch {
-                    // Telemetry is best effort and must never change the hook's output.
+                {
+                    const advisory = interfaceAdvisory(initialState.mcpState, workspaceTrusted);
+                    return advisory ? { additional_context: advisory } : emptyResult();
                 }
-            }
-            const kbToolCall = extractKbMcpToolCall(input.toolName, input.toolInput);
-            if (kbToolCall) {
-                recordKbMcpTool(stateDir, kbToolCall.toolName, {
-                    impactCheckRun: kbToolCall.impactCheckRun,
-                    sourceFiles: kbToolCall.sourceFiles,
-                });
-            }
-            if (isPlanDeliveryTool(input.toolName)) {
-                recordPlanDelivered(stateDir);
-            }
-            const explicitPaths = extractExplicitPathFields(input.toolInput);
-            if (isKnownEditableTool(input.toolName)) {
-                const dirtyPaths = explicitPaths
-                    .map((candidate) => toRepoRelativePath(candidate, cwd))
-                    .filter((candidate) => isMeaningfulTrackedPath(candidate) ||
-                    isKbFreshnessRelevantPath(candidate));
-                if (dirtyPaths.length > 0) {
-                    addDirtyPaths(stateDir, dirtyPaths);
+            case "preToolUse": {
+                // Name the agent's workspace on every Kibi MCP call so the launcher
+                // answers from it, also for agents working in a git worktree. The
+                // per-call cwd wins over workspace_roots, which can be the window's
+                // folders rather than the agent's checkout.
+                const stamped = stampKibiWorkspace(input.toolName, input.toolInput, kibiWorkspaceFor(input.cwd ?? input.workspaceRoots?.[0]));
+                if (stamped) {
+                    return { updated_input: stamped };
                 }
-                if (dirtyPaths.some(isSourceImpactRelevantPath)) {
-                    markDecisionFlag(session, "source-edited");
+                const explicitPaths = extractExplicitPathFields(input.toolInput);
+                const hasDirectKbEdit = isEditLikeTool(input.toolName) && explicitPaths.some(isDirectKbPath);
+                if (hasDirectKbEdit) {
+                    trace.action = "kb_direct_note";
+                    trace.pathKind = "kb";
+                    return {
+                        permission: "allow",
+                        agent_message: DIRECT_KB_EDIT_WARNING,
+                    };
                 }
-            }
-            if (kbToolCall?.toolName === "kb_upsert" ||
-                kbUsageTrace(input.toolName, input.toolInput)?.kbOperation ===
-                    "kb_upsert") {
-                markDecisionFlag(session, "kb-recorded");
-                // implements REQ-kibi-signoff-views
-                if (isRequirementUpsert(input.toolInput)) {
-                    markDecisionFlag(session, "requirement-recorded");
+                const primaryPath = resolvePrimaryPath(input);
+                if (!primaryPath ||
+                    !kibiReady ||
+                    !isKnownEditableTool(input.toolName)) {
+                    return emptyResult();
                 }
+                const relativePath = toRepoRelativePath(primaryPath, cwd);
+                const state = loadHookState(stateDir);
+                const linked = getSourceLinkedSymbols(cwd, primaryPath, stateDir);
+                trace.pathKind = classifyPath(relativePath);
+                trace.requirementIds = implementedRequirementIds(linked.symbols);
+                const focus = editFocus(path.resolve(cwd, primaryPath), input.toolInput);
+                const ruleNote = takeRuleNote(session);
+                const notice = firmNotice(cwd, linked, focus, session, environment.env ?? process.env);
+                const guidance = hasGuidedPath(state, "pre-edit", relativePath)
+                    ? undefined
+                    : preEditGuidance(primaryPath, {
+                        cwd,
+                        hasKibi: kibiReady,
+                        mcpState: state.mcpState,
+                        workspaceTrusted,
+                        // A file that implements requirements always gets the shared
+                        // snippet, so the bare linked-requirement wording is never needed.
+                        knowledge: knowledgeFor(cwd, linked, "edit", focus),
+                    });
+                if (guidance) {
+                    rememberGuidedPath(stateDir, "pre-edit", relativePath);
+                }
+                const parts = [ruleNote, notice, guidance].filter((part) => part !== undefined);
+                trace.action = parts.length > 0 ? "edit_snippet" : "edit_silent";
+                return parts.length > 0
+                    ? { permission: "allow", agent_message: parts.join("\n\n") }
+                    : emptyResult();
             }
-            const primaryPath = resolvePrimaryPath(input);
-            if (!primaryPath || !kibiReady) {
-                return emptyResult();
+            // implements REQ-agent-hosts-decision-guard
+            case "beforeSubmitPrompt": {
+                // Cursor's prompt hook cannot add context: the request's rule note
+                // waits for the next pre-edit message.
+                if (kibiReady && input.prompt) {
+                    const rule = recordRequest(session, input.prompt);
+                    if (rule !== undefined)
+                        holdRuleNote(session, rule);
+                    trace.action =
+                        rule === undefined ? "prompt_silent" : "prompt_rule_note";
+                }
+                return { continue: true };
             }
-            const relativePath = toRepoRelativePath(primaryPath, cwd);
-            const state = loadHookState(stateDir);
-            if (isReadLikeTool(input.toolName)) {
+            case "beforeReadFile": {
+                const primaryPath = resolvePrimaryPath(input);
+                if (!primaryPath || !kibiReady) {
+                    return { permission: "allow" };
+                }
+                const relativePath = toRepoRelativePath(primaryPath, cwd);
+                trace.pathKind = classifyPath(relativePath);
+                trace.action = "read_silent";
+                const state = loadHookState(stateDir);
                 if (hasGuidedPath(state, "read", relativePath)) {
-                    return emptyResult();
+                    return { permission: "allow" };
                 }
                 const guidance = readGuidance(primaryPath, {
                     cwd,
@@ -324,77 +269,177 @@ export async function runHook(rawInput, environment = {}) {
                     mcpState: state.mcpState,
                     workspaceTrusted,
                     knowledge: knowledgeFor(cwd, getSourceLinkedSymbols(cwd, primaryPath, stateDir), 
-                    // rationale: as above, only "edit" changes the snippet.
+                    // rationale: the snippet only special-cases "edit", so any other
+                    // surface literal renders the same read snippet.
                     // Stryker disable next-line StringLiteral
                     "read"),
                 });
                 if (!guidance) {
-                    return emptyResult();
+                    return { permission: "allow" };
                 }
                 rememberGuidedPath(stateDir, "read", relativePath);
-                return { additional_context: guidance };
+                trace.action = "read_snippet";
+                return {
+                    permission: "allow",
+                    agent_message: guidance,
+                };
             }
-            if (isEditLikeTool(input.toolName)) {
-                // rationale: the runner only ever passes "read" or "write"; an empty
-                // kind selects the same write bucket.
-                // Stryker disable StringLiteral
-                if (hasGuidedPath(state, "write", relativePath)) {
-                    return emptyResult();
+            case "postToolUse": {
+                if (kibiReady) {
+                    try {
+                        recordToolTelemetry(input, cwd, stateDir, startedAt, environment.env);
+                    }
+                    catch {
+                        // Telemetry is best effort and must never change the hook's output.
+                    }
                 }
-                // Stryker restore
-                const guidance = writeGuidance(primaryPath, {
-                    cwd,
-                    hasKibi: kibiReady,
-                    mcpState: state.mcpState,
-                    workspaceTrusted,
-                });
-                if (!guidance) {
+                const kbToolCall = extractKbMcpToolCall(input.toolName, input.toolInput);
+                if (kbToolCall) {
+                    recordKbMcpTool(stateDir, kbToolCall.toolName, {
+                        impactCheckRun: kbToolCall.impactCheckRun,
+                        sourceFiles: kbToolCall.sourceFiles,
+                    });
+                }
+                if (isPlanDeliveryTool(input.toolName)) {
+                    recordPlanDelivered(stateDir);
+                }
+                const explicitPaths = extractExplicitPathFields(input.toolInput);
+                if (isKnownEditableTool(input.toolName)) {
+                    const dirtyPaths = explicitPaths
+                        .map((candidate) => toRepoRelativePath(candidate, cwd))
+                        .filter((candidate) => isMeaningfulTrackedPath(candidate) ||
+                        isKbFreshnessRelevantPath(candidate));
+                    if (dirtyPaths.length > 0) {
+                        addDirtyPaths(stateDir, dirtyPaths);
+                    }
+                    if (dirtyPaths.some(isSourceImpactRelevantPath)) {
+                        markDecisionFlag(session, "source-edited");
+                    }
+                }
+                if (kbToolCall?.toolName === "kb_upsert" ||
+                    kbUsageTrace(input.toolName, input.toolInput)?.kbOperation ===
+                        "kb_upsert") {
+                    markDecisionFlag(session, "kb-recorded");
+                    // implements REQ-kibi-signoff-views
+                    if (isRequirementUpsert(input.toolInput)) {
+                        markDecisionFlag(session, "requirement-recorded");
+                    }
+                }
+                const primaryPath = resolvePrimaryPath(input);
+                if (!primaryPath || !kibiReady) {
                     return emptyResult();
                 }
-                // rationale: same bucket equivalence as the lookup above.
-                // Stryker disable StringLiteral
-                rememberGuidedPath(stateDir, "write", relativePath);
-                // Stryker restore
-                return { additional_context: guidance };
+                const relativePath = toRepoRelativePath(primaryPath, cwd);
+                const state = loadHookState(stateDir);
+                if (isReadLikeTool(input.toolName)) {
+                    if (hasGuidedPath(state, "read", relativePath)) {
+                        return emptyResult();
+                    }
+                    const guidance = readGuidance(primaryPath, {
+                        cwd,
+                        hasKibi: kibiReady,
+                        mcpState: state.mcpState,
+                        workspaceTrusted,
+                        knowledge: knowledgeFor(cwd, getSourceLinkedSymbols(cwd, primaryPath, stateDir), 
+                        // rationale: as above, only "edit" changes the snippet.
+                        // Stryker disable next-line StringLiteral
+                        "read"),
+                    });
+                    if (!guidance) {
+                        return emptyResult();
+                    }
+                    rememberGuidedPath(stateDir, "read", relativePath);
+                    return { additional_context: guidance };
+                }
+                if (isEditLikeTool(input.toolName)) {
+                    // rationale: the runner only ever passes "read" or "write"; an empty
+                    // kind selects the same write bucket.
+                    // Stryker disable StringLiteral
+                    if (hasGuidedPath(state, "write", relativePath)) {
+                        return emptyResult();
+                    }
+                    // Stryker restore
+                    const guidance = writeGuidance(primaryPath, {
+                        cwd,
+                        hasKibi: kibiReady,
+                        mcpState: state.mcpState,
+                        workspaceTrusted,
+                    });
+                    if (!guidance) {
+                        return emptyResult();
+                    }
+                    // rationale: same bucket equivalence as the lookup above.
+                    // Stryker disable StringLiteral
+                    rememberGuidedPath(stateDir, "write", relativePath);
+                    // Stryker restore
+                    return { additional_context: guidance };
+                }
+                return emptyResult();
             }
-            return emptyResult();
-        }
-        case "stop": {
-            const state = loadHookState(stateDir);
-            const shouldClearSession = state.dirtyPaths.length > 0 || state.kbCheckRun || state.planDelivered;
-            if (input.status === "aborted" || input.status === "error") {
+            case "stop": {
+                const state = loadHookState(stateDir);
+                const shouldClearSession = state.dirtyPaths.length > 0 ||
+                    state.kbCheckRun ||
+                    state.planDelivered;
+                if (input.status === "aborted" || input.status === "error") {
+                    if (shouldClearSession) {
+                        clearSessionHookState(stateDir);
+                    }
+                    return emptyResult();
+                }
+                // implements REQ-agent-hosts-decision-guard
+                // Source changed and nothing was recorded: the follow-up asks for the
+                // decision to be recorded, once per conversation.
+                const capture = claimCaptureReminder(session)
+                    ? captureReminder(hasDecisionFlag(session, "rule-prompt"))
+                    : undefined;
+                // implements REQ-kibi-signoff-views
+                // Requirements were written without a signoff view since: ask once.
+                // A recorded requirement also counts as recorded knowledge, so this
+                // never coincides with the capture request above.
+                const signoff = claimSignoffReminder(session, cwd)
+                    ? signoffReminder()
+                    : undefined;
+                const reminder = stopFollowupMessage(state);
+                const followupMessage = [capture, signoff, reminder]
+                    .filter((part) => part !== undefined)
+                    .join("\n");
+                if (followupMessage) {
+                    trace.action = capture
+                        ? "stop_capture_reminder"
+                        : signoff
+                            ? "stop_signoff_reminder"
+                            : "stop_reminder";
+                    clearSessionHookState(stateDir);
+                    return { followup_message: followupMessage };
+                }
                 if (shouldClearSession) {
                     clearSessionHookState(stateDir);
                 }
                 return emptyResult();
             }
-            // implements REQ-agent-hosts-decision-guard
-            // Source changed and nothing was recorded: the follow-up asks for the
-            // decision to be recorded, once per conversation.
-            const capture = claimCaptureReminder(session)
-                ? captureReminder(hasDecisionFlag(session, "rule-prompt"))
-                : undefined;
-            // implements REQ-kibi-signoff-views
-            // Requirements were written without a signoff view since: ask once.
-            // A recorded requirement also counts as recorded knowledge, so this
-            // never coincides with the capture request above.
-            const signoff = claimSignoffReminder(session, cwd)
-                ? signoffReminder()
-                : undefined;
-            const followupMessage = [capture, signoff, stopFollowupMessage(state)]
-                .filter((part) => part !== undefined)
-                .join("\n");
-            if (followupMessage) {
-                clearSessionHookState(stateDir);
-                return { followup_message: followupMessage };
-            }
-            if (shouldClearSession) {
-                clearSessionHookState(stateDir);
-            }
-            return emptyResult();
+            default:
+                return emptyResult();
+        }
+    }
+    finally {
+        if (kibiReady) {
+            appendHookUsage({
+                host: "cursor",
+                packageVersion: packageVersion(),
+                workspaceRoot: cwd,
+                event: input.event,
+                sessionId: input.conversationId,
+                hostTool: input.toolName,
+                trace,
+                startedAt,
+            }, environment.env ?? process.env);
         }
-        default:
-            return emptyResult();
+        await finishHookTelemetry({
+            event: input.event,
+            workspaceRoot: kibiReady ? cwd : undefined,
+            sessionId: input.conversationId,
+        }, environment.env ?? process.env);
     }
 }
 export async function main() {

package/dist/hooks/hooks.json

@@ -3,32 +3,32 @@
   "hooks": {
     "sessionStart": [
       {
-        "command": "node dist/hook-runner.js"
+        "command": "node bin/hook-runner.mjs"
       }
     ],
     "beforeSubmitPrompt": [
       {
-        "command": "node dist/hook-runner.js"
+        "command": "node bin/hook-runner.mjs"
       }
     ],
     "preToolUse": [
       {
-        "command": "node dist/hook-runner.js"
+        "command": "node bin/hook-runner.mjs"
       }
     ],
     "postToolUse": [
       {
-        "command": "node dist/hook-runner.js"
+        "command": "node bin/hook-runner.mjs"
       }
     ],
     "beforeReadFile": [
       {
-        "command": "node dist/hook-runner.js"
+        "command": "node bin/hook-runner.mjs"
       }
     ],
     "stop": [
       {
-        "command": "node dist/hook-runner.js",
+        "command": "node bin/hook-runner.mjs",
         "loop_limit": 1
       }
     ]

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

@@ -4,11 +4,11 @@
   "kibi-bootstrap/resources/branch-lifecycle.md": "c854264ce888439140883a3fc636db5e522f020dd27b30a5c1ecc4105b64ed13",
   "kibi-bootstrap/resources/operation-access.md": "b5a6a59e72d800c376e7fad79132897623c32a0ce152a1e8d73f9628b444db51",
   "kibi-bootstrap/resources/source-authoring.md": "bf296e62f69474e01797d6cb9469bf624551dca834dd188abb6e705bd96fa586",
-  "kibi-commit-review/SKILL.md": "cd3a0d5ed5e2e7562995180e440dce1aa1607d3d072d3400e966e988725ed399",
+  "kibi-commit-review/SKILL.md": "bec768ad3e4cd4e782e9e13360b69bcd40a0964b305909818115d7f9e8d282d9",
   "kibi-commit-review/resources/staged-gate.md": "37f750f327bb9202c1f30989763f4f1205b906cf672318ca50887d7984bc3e08",
-  "kibi-decisions/SKILL.md": "02685fa50f093025782986bfe009940e934c3a64d47858920815e7eb66b0c523",
+  "kibi-decisions/SKILL.md": "d91f784410251095e9d881bce751728cc4596858a518fb24f5e5d38c940bab50",
   "kibi-decisions/resources/decision-records.md": "b201e619c48daf6ebe5989991a96f6c0573adb6c37abf814b9d34b7a1cd423c6",
-  "kibi-decisions/resources/signoff-views.md": "123da13a3f2b30b5672044a1284626e218d3088411f84f2692746f95e06c1393",
+  "kibi-decisions/resources/signoff-views.md": "84eb2b7123e54047205b84af6fbf60c910ebcaaf98023e5812f3de9b65a4871c",
   "kibi-freshness/SKILL.md": "b5c4f24bebdb5b4e0d04c2fa1176fc33ace35334b0c0b6ca943d6f445dc9b69e",
   "kibi-freshness/resources/branch-lifecycle.md": "ebc01b19fe3dca8df5fc0175978963f6f1204f71f7c805cb2a5fb1b277ac78e4",
   "kibi-freshness/resources/operation-access.md": "4e1db9294ee540cd29b8b3a2532a81e7894d5b4228b39e99ba48b37212f489f3",
@@ -18,13 +18,14 @@
   "kibi-traceability/resources/operation-access.md": "39f7972ab7f4ae7479e78f7072bb50e8e6c4cdf4f857425f69d2522d37db437c",
   "kibi-traceability/resources/source-authoring.md": "408c6ee2bef1b84e0194c0538ef929c26a0a617e631b2234247388140dbbdd08",
   "kibi-traceability/resources/traceability.md": "38c290a0bc71bd1692e115f22694743946e2f69630e134acfd43cee5f613fb88",
-  "kibi-usage/SKILL.md": "d5c2e9e2e643f51f068a4e586002976d28125001c33e791e70994efdbbc8130f",
+  "kibi-usage/SKILL.md": "91639d49eae60a83b01017de1843ce49575db231f3f9cb1b0270c57a20462a88",
   "kibi-usage/resources/branch-lifecycle.md": "f1bf359e9826e83c548f3cd0287f8175a62456527b0132b06b3f9f74aa59b7d6",
   "kibi-usage/resources/fact-lanes.md": "7d487ffb794f6a7c32afabc7756a265a258b072ca83510ddb40d275863d44648",
   "kibi-usage/resources/kb-improvement.md": "a8408fce27342bdce6415a6718599e53fe00bb33aa1fd3dc42353ec6f61adcd7",
   "kibi-usage/resources/logic-ir.md": "0e8ce8aad07433ab4803ec169149ff6c4e1cf8cf010af18fa6fd67862d9be807",
   "kibi-usage/resources/operation-access.md": "eb455796c066787ffd3fae8db0db1d3e87a84265a57f06ae61e30103cd6aed66",
-  "kibi-usage/resources/proof.md": "65797125425f457dd6291e034e4174166bc0b62a2c269d136877c6f8de676bf0",
+  "kibi-usage/resources/prolog-proofs.md": "b630f1edf32c4d14dbd096deb15c370f6ce05dede8aa9cda4fbf294d8668f164",
+  "kibi-usage/resources/proof.md": "fe5c0ed8117ec724f925c29a95345e2f7b9969a413a3ba56eece23273f91346e",
   "kibi-usage/resources/relationship-directions.md": "0fdd67032c2d15299f772845fc4f807eb9435b09507bd87a5911ab33db2f143d",
   "kibi-usage/resources/source-authoring.md": "cad93f1e0ae08a676f2de7492f9227677880302327e74d159618fea86ca50abe",
   "kibi-usage/resources/ui-requirements.md": "f99c2a9a73bbb7bd92ce1f231db3056d544588be149a5b0d3f7cc6f28bc9eee9",

package/dist/skills/kibi-commit-review/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-commit-review
 name: kibi-commit-review
 description: "Use when kibi check --staged or the Kibi pre-commit hook blocks a commit (kibi_impact_evidence_missing, symbols_manifest_stale, symbol_granularity_violation, symbol-coverage, kibi check-generated drift, Staged impact review failed), or when preparing a commit or pull-request impact review. Covers reading the per-file Detail lines, authoring .kb/symbols.yaml symbol entries through kb_upsert, staging the tracked Kibi evidence with git add (symbol coordinates are derived and never staged), kb_prepare_impact_review for a staged or diff scope, the kibi signoff requirements summary to show before a commit, and how merge commits and migration renames are judged."
-version: 1.3.0
+version: 1.4.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -91,7 +91,11 @@ apps); never attach the `.html` as a file, which chat apps show as raw source;
 past 15 requirements the Markdown stops and only the page lists them all.
 Host details: `kibi-decisions`, `resources/signoff-views.md`. `--no-proof` skips the proof lookup, which reads coverage and is slow
 on a large knowledge base. The summary is not an approval: never set
-`approved_by` or `origin.ref` from it.
+`approved_by` or `origin.ref` from it. Show it before you open or merge the
+pull request. When the person answers, record their answer in the same
+change (their name in `approved_by`, their words in `origin.ref` or
+`approval_ref`) and push it to the same pull request; never move a signoff,
+firmness or waiver approval into a separate pull request.
 
 ## Impact reviews
 

package/dist/skills/kibi-decisions/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-decisions
 name: kibi-decisions
 description: "Use when the person states a rule or decision (must, never, always, from now on, we decided), when a Kibi hook asks to confirm or warns about an edit to code that implements a firm requirement, when the Stop hook says source files changed but nothing was recorded, when kb_check quotes requirement_statement_unverified, or when a request conflicts with a recorded requirement or ADR. Covers reading firmness and origin, recording a person's rule as firm with origin.ref, superseding with a Why this changed section, the kb_compile_intent unresolved/reviewCandidates/conflictReviews loop, asking before overriding a firm rule, and putting decisions to the person as one numbered kibi signoff --questions view."
-version: 1.4.0
+version: 1.5.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -115,7 +115,12 @@ again until none is open, then record each rule with their words in
 `origin.ref`. Fields and outputs: `resources/signoff-views.md`.
 
 Never invent words for `origin.ref`, never set `approved_by` yourself, and
-mark your own picks `default` and guesses `exploratory`. Payload shapes,
+mark your own picks `default` and guesses `exploratory`. Once the person has
+answered, recording their answer (their name in `approved_by` or a
+`*_waiver_approved_by` field, their words in `origin.ref` or `approval_ref`)
+is yours to do: put it on the branch of the change it approves and push it to
+that pull request, never to a separate one. Ask before you open or merge the
+pull request, so the answer lands in it. Payload shapes,
 refusal messages and the `kb_compile_intent` review loop are in
 `resources/decision-records.md`.