kibi-opencode 0.12.1 → 0.14.0

package/dist/prompt.d.ts

@@ -47,6 +47,12 @@ export interface PromptContext {
         lifecycleReminder: string | null;
         e2eReminder: string | null;
     };
+    /** Hard-mode checkpoint block that must take prompt priority over advisory guidance. */
+    hardGateBlock?: {
+        shownPaths: string[];
+        remainingCount: number;
+        reason?: string;
+    };
 }
 export declare function postureGuidance(posture: RepoPosture, capability?: InitKibiCommandCapability): string | null;
 /**

package/dist/prompt.js

@@ -112,6 +112,28 @@ function buildBootstrapRequiredBody(capability = getInitKibiCommandCapability())
         : "- 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\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\`.`;
 }
+function buildHardGateBlock(block) {
+    const pathLines = block.shownPaths.map((path) => `- \`${path}\``);
+    if (block.remainingCount > 0) {
+        pathLines.push(`- +${block.remainingCount} more dirty files`);
+    }
+    const reasonLine = block.reason ? `Reason: ${block.reason}.` : null;
+    return [
+        "🛑 Kibi hard gate blocked",
+        "STOP implementation until this authoritative Kibi checkpoint is satisfied.",
+        reasonLine,
+        "Affected files:",
+        ...pathLines,
+        "MCP-only recovery steps:",
+        "- 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.",
+        "- Run `kb_upsert` for required traceability, relationship, or fact updates.",
+        "- Run `kb_check` before continuing.",
+    ]
+        .filter((line) => line !== null)
+        .join("\n");
+}
 // ── Guidance blocks by risk class ──────────────────────────────────────
 const GUIDANCE_BY_RISK = {
     safe_docs_only: null,
@@ -171,6 +193,9 @@ Root .kb/config.json exists but some configured KB targets are missing. Guidance
  * Build prompt guidance block based on posture, risk class, and cache state.
  */
 function buildContextualGuidance(context, capability = getInitKibiCommandCapability()) {
+    if (context.hardGateBlock) {
+        return `${SENTINEL}\n\n${buildHardGateBlock(context.hardGateBlock)}`;
+    }
     const posture = context.posture ?? "root_active";
     const riskClass = context.riskClass;
     const readyAutoBriefingAvailable = context.autoBriefResult?.showManualCue === false;

package/dist/smart-enforcement.d.ts

@@ -5,14 +5,16 @@ import type { RepoPosture } from "./repo-posture.js";
  * - "strict": plugin may escalate targeted checks, completion reminders, and
  *   structured logging. Hooks/checks remain the hard enforcement boundary
  *   regardless of mode.
+ * - "hard": authoritative root-KB postures may hard-block through durable
+ *   hook/check boundaries, even when maintenance guidance is degraded.
  */
-export type EffectiveMode = "advisory" | "strict";
+export type EffectiveMode = "advisory" | "strict" | "hard";
 /**
  * Inputs required to determine the effective smart-enforcement mode.
  */
 export interface ModeInputs {
     /** Configured smart-enforcement mode. */
-    mode: "advisory" | "strict";
+    mode: "advisory" | "strict" | "hard";
     /** When true, strict mode only activates for authoritative root KB postures. */
     requireRootKbForStrict: boolean;
     /** Current repository posture from detectPosture(). */
@@ -37,5 +39,7 @@ export declare function isStrictEligible(inputs: ModeInputs): boolean;
  * - strict config + requireRootKbForStrict=false → strict may apply to all
  *   postures (but hooks/checks remain hard gate regardless)
  * - maintenance-degraded → advisory regardless of config
+ * - hard config → hard only for authoritative root-KB postures, even when
+ *   maintenance is degraded; non-authoritative postures stay advisory
  */
 export declare function computeEffectiveMode(inputs: ModeInputs): EffectiveMode;

package/dist/smart-enforcement.js

@@ -30,9 +30,15 @@ export function isStrictEligible(inputs) {
  * - strict config + requireRootKbForStrict=false → strict may apply to all
  *   postures (but hooks/checks remain hard gate regardless)
  * - maintenance-degraded → advisory regardless of config
+ * - hard config → hard only for authoritative root-KB postures, even when
+ *   maintenance is degraded; non-authoritative postures stay advisory
  */
+// implements REQ-opencode-worktree-hard-enforcement-v1
 export function computeEffectiveMode(inputs) {
-    // implements REQ-opencode-smart-enforcement-v1
+    // implements REQ-opencode-smart-enforcement-v1, REQ-opencode-worktree-hard-enforcement-v1
+    if (inputs.mode === "hard") {
+        return STRICT_ELIGIBLE_POSTURES.has(inputs.posture) ? "hard" : "advisory";
+    }
     // Maintenance-degraded always forces advisory
     if (inputs.maintenanceDegraded) {
         return "advisory";

package/dist/utils/brief-marker.d.ts

@@ -0,0 +1,19 @@
+export interface PendingBriefMarkerIssue {
+    filePath: string;
+    reason: "parse" | "schema" | "delete";
+}
+export interface PendingBriefMarkersResult {
+    entityIds: string[];
+    relationships: Array<{
+        from: string;
+        to: string;
+        type: string;
+    }>;
+    markerPaths: string[];
+    issues: PendingBriefMarkerIssue[];
+}
+export declare function loadPendingBriefMarkers(workspaceRoot: string, branch: string): PendingBriefMarkersResult;
+export declare function deletePendingBriefMarkers(markerPaths: string[]): Promise<{
+    deletedCount: number;
+    issues: PendingBriefMarkerIssue[];
+}>;

package/dist/utils/brief-marker.js

@@ -0,0 +1,101 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+// implements REQ-opencode-kibi-briefing-v2
+export function loadPendingBriefMarkers(workspaceRoot, branch) {
+    const pendingDir = path.join(workspaceRoot, ".kb", "briefs", "pending");
+    if (!fs.existsSync(pendingDir)) {
+        return { entityIds: [], relationships: [], markerPaths: [], issues: [] };
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir, { withFileTypes: true });
+    }
+    catch {
+        return { entityIds: [], relationships: [], markerPaths: [], issues: [] };
+    }
+    const issues = [];
+    const markerPaths = [];
+    const entityIds = [];
+    const seenEntityIds = new Set();
+    const relationshipMap = new Map();
+    for (const entry of entries
+        .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".json"))
+        .sort((a, b) => a.name.localeCompare(b.name))) {
+        const filePath = path.join(pendingDir, entry.name);
+        let payload;
+        try {
+            payload = parsePendingBriefMarker(JSON.parse(fs.readFileSync(filePath, "utf8")));
+        }
+        catch (error) {
+            issues.push({
+                filePath,
+                reason: error instanceof SyntaxError ? "parse" : "schema",
+            });
+            continue;
+        }
+        if (payload.branch !== branch) {
+            continue;
+        }
+        markerPaths.push(filePath);
+        for (const entityId of payload.entityIds) {
+            if (seenEntityIds.has(entityId)) {
+                continue;
+            }
+            seenEntityIds.add(entityId);
+            entityIds.push(entityId);
+        }
+        for (const relationship of payload.relationships) {
+            relationshipMap.set(`${relationship.type}\u0000${relationship.from}\u0000${relationship.to}`, relationship);
+        }
+    }
+    return {
+        entityIds,
+        relationships: [...relationshipMap.values()],
+        markerPaths,
+        issues,
+    };
+}
+// implements REQ-opencode-kibi-briefing-v2
+export async function deletePendingBriefMarkers(markerPaths) {
+    let deletedCount = 0;
+    const issues = [];
+    for (const markerPath of markerPaths) {
+        try {
+            const existedBeforeDelete = fs.existsSync(markerPath);
+            await fs.promises.rm(markerPath, { force: true });
+            if (existedBeforeDelete && !fs.existsSync(markerPath)) {
+                deletedCount += 1;
+            }
+        }
+        catch {
+            issues.push({ filePath: markerPath, reason: "delete" });
+        }
+    }
+    return { deletedCount, issues };
+}
+function parsePendingBriefMarker(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Invalid marker payload");
+    }
+    const record = value;
+    const branch = typeof record.branch === "string" ? record.branch.trim() : "";
+    const entityIds = Array.isArray(record.entityIds)
+        ? record.entityIds.filter((item) => typeof item === "string" && item.length > 0)
+        : null;
+    const relationships = Array.isArray(record.relationships)
+        ? record.relationships
+            .filter((item) => !!item &&
+            typeof item === "object" &&
+            typeof item.from === "string" &&
+            typeof item.to === "string" &&
+            typeof item.type === "string" &&
+            item.from.length > 0 &&
+            item.to.length > 0 &&
+            item.type.length > 0)
+            .map((item) => ({ from: item.from, to: item.to, type: item.type }))
+        : [];
+    if (!branch || !entityIds) {
+        throw new Error("Invalid marker schema");
+    }
+    return { branch, entityIds, relationships };
+}

package/dist/work-context-resolver.d.ts

@@ -0,0 +1,21 @@
+import { type RepoPosture } from "./repo-posture.js";
+export interface ResolveWorkContextInput {
+    inputDirectory: string;
+    inputWorktree: string;
+    filePath?: string;
+    sessionId?: string;
+    agentIdentity?: string;
+}
+export interface WorkContext {
+    worktreeRoot: string;
+    kibiAuthorityRoot: string;
+    branch: string;
+    repoRelativePath: string;
+    posture: RepoPosture;
+    isAuthoritative: boolean;
+    isLinkedWorktree: boolean;
+    sessionId: string | undefined;
+    agentIdentity: string;
+}
+declare const resolveWorkContext: (input: ResolveWorkContextInput) => WorkContext;
+export { resolveWorkContext };

package/dist/work-context-resolver.js

@@ -0,0 +1,197 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
+import { detectPosture } from "./repo-posture.js";
+function safeStat(path) {
+    try {
+        return statSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+function readFirstLine(path) {
+    try {
+        const [firstLine] = readFileSync(path, "utf8").split(/\r?\n/, 1);
+        const trimmed = firstLine?.trim();
+        return trimmed && trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readLinkedGitDir(worktreeRoot, gitFilePath) {
+    const firstLine = readFirstLine(gitFilePath);
+    if (!firstLine?.startsWith("gitdir:")) {
+        return null;
+    }
+    const rawGitDir = firstLine.slice("gitdir:".length).trim();
+    if (rawGitDir.length === 0) {
+        return null;
+    }
+    return isAbsolute(rawGitDir)
+        ? resolve(rawGitDir)
+        : resolve(worktreeRoot, rawGitDir);
+}
+function readCommonGitDir(gitDir) {
+    const rawCommonDir = readFirstLine(join(gitDir, "commondir"));
+    if (!rawCommonDir) {
+        return gitDir;
+    }
+    return isAbsolute(rawCommonDir)
+        ? resolve(rawCommonDir)
+        : resolve(gitDir, rawCommonDir);
+}
+function directorySearchStart(candidatePath) {
+    const resolved = resolve(candidatePath);
+    const stats = safeStat(resolved);
+    return stats?.isDirectory() ? resolved : dirname(resolved);
+}
+function findGitMetadata(candidatePath) {
+    let current = directorySearchStart(candidatePath);
+    while (true) {
+        const dotGitPath = join(current, ".git");
+        const dotGitStats = safeStat(dotGitPath);
+        if (dotGitStats?.isFile()) {
+            const gitDir = readLinkedGitDir(current, dotGitPath);
+            if (gitDir) {
+                return {
+                    worktreeRoot: current,
+                    gitDir,
+                    commonGitDir: readCommonGitDir(gitDir),
+                    isLinkedWorktree: true,
+                };
+            }
+        }
+        if (dotGitStats?.isDirectory()) {
+            return {
+                worktreeRoot: current,
+                gitDir: dotGitPath,
+                commonGitDir: dotGitPath,
+                isLinkedWorktree: false,
+            };
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function hasRootKbConfig(root) {
+    return existsSync(join(root, ".kb", "config.json"));
+}
+function uniqueResolved(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const path of paths) {
+        if (!path) {
+            continue;
+        }
+        const resolved = resolve(path);
+        if (seen.has(resolved)) {
+            continue;
+        }
+        seen.add(resolved);
+        result.push(resolved);
+    }
+    return result;
+}
+function authorityRootFromCommonGitDir(commonGitDir) {
+    return basename(commonGitDir) === ".git" ? dirname(commonGitDir) : null;
+}
+function authorityRootFromLinkedGitDir(gitDir) {
+    const normalizedGitDir = resolve(gitDir);
+    const marker = `${sep}.git${sep}worktrees${sep}`;
+    const markerIndex = normalizedGitDir.indexOf(marker);
+    if (markerIndex < 0) {
+        return null;
+    }
+    return normalizedGitDir.slice(0, markerIndex);
+}
+function ancestorKbRoots(start) {
+    const roots = [];
+    let current = resolve(start);
+    while (true) {
+        if (hasRootKbConfig(current)) {
+            roots.push(current);
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return roots;
+        }
+        current = parent;
+    }
+}
+function resolveAuthorityRoot(git, inputDirectory) {
+    if (!git.isLinkedWorktree) {
+        return git.worktreeRoot;
+    }
+    const candidates = uniqueResolved([
+        authorityRootFromCommonGitDir(git.commonGitDir),
+        authorityRootFromLinkedGitDir(git.gitDir),
+        ...ancestorKbRoots(git.worktreeRoot),
+        inputDirectory,
+        git.worktreeRoot,
+    ]);
+    return (candidates.find((candidate) => hasRootKbConfig(candidate)) ??
+        candidates[0] ??
+        git.worktreeRoot);
+}
+function resolveBranch(git) {
+    if (!git) {
+        return "unknown";
+    }
+    const head = readFirstLine(join(git.gitDir, "HEAD"));
+    if (!head) {
+        return "unknown";
+    }
+    if (!head.startsWith("ref:")) {
+        return "HEAD";
+    }
+    const ref = head.slice("ref:".length).trim();
+    if (!ref.startsWith("refs/heads/")) {
+        return "HEAD";
+    }
+    const branch = ref.slice("refs/heads/".length);
+    return branch === "master" ? "main" : branch;
+}
+function normalizeRepoRelativePath(fromRoot, targetPath) {
+    const rawRelativePath = relative(fromRoot, targetPath);
+    if (rawRelativePath.length === 0) {
+        return ".";
+    }
+    return rawRelativePath.split(sep).join("/");
+}
+function authoritativeForPosture(posture) {
+    return posture === "root_active" || posture === "hybrid_root_plus_vendored";
+}
+// implements REQ-opencode-worktree-hard-enforcement-v1
+const resolveWorkContext = function resolveWorkContext(input) {
+    const declaredWorktreeRoot = resolve(input.inputWorktree || input.inputDirectory);
+    const declaredDirectory = resolve(input.inputDirectory || input.inputWorktree);
+    const absoluteFilePath = input.filePath
+        ? isAbsolute(input.filePath)
+            ? resolve(input.filePath)
+            : resolve(declaredWorktreeRoot, input.filePath)
+        : undefined;
+    const git = (absoluteFilePath ? findGitMetadata(absoluteFilePath) : null) ??
+        findGitMetadata(declaredWorktreeRoot);
+    const worktreeRoot = git?.worktreeRoot ?? declaredWorktreeRoot;
+    const kibiAuthorityRoot = git
+        ? resolveAuthorityRoot(git, declaredDirectory)
+        : declaredWorktreeRoot;
+    const posture = detectPosture(kibiAuthorityRoot).state;
+    const repoRelativePath = normalizeRepoRelativePath(worktreeRoot, absoluteFilePath ?? worktreeRoot);
+    return {
+        worktreeRoot,
+        kibiAuthorityRoot,
+        branch: resolveBranch(git),
+        repoRelativePath,
+        posture,
+        isAuthoritative: authoritativeForPosture(posture),
+        isLinkedWorktree: git?.isLinkedWorktree ?? false,
+        sessionId: input.sessionId,
+        agentIdentity: input.agentIdentity ?? "unknown",
+    };
+};
+export { resolveWorkContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -62,7 +62,7 @@
     "@opencode-ai/plugin": "^1.4.7",
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
-    "kibi-cli": "^0.10.1"
+    "kibi-cli": "^0.11.0"
   },
   "devDependencies": {
     "@types/node": "latest",