kibi-opencode 0.13.0 → 0.15.0

package/dist/prompt.d.ts

@@ -7,6 +7,7 @@ import type { PathKind } from "./path-kind.js";
 import type { RepoPosture } from "./repo-posture.js";
 import type { RiskClass } from "./risk-classifier.js";
 import type { WorkspaceHealth } from "./workspace-health.js";
+import type { KbFreshnessEvaluation } from "./kb-freshness-state.js";
 declare const SENTINEL = "<!-- kibi-opencode -->";
 export declare function buildAutoBriefingGuidance(autoBriefResult: BriefingRuntimeResult | undefined, completionReminder: boolean): string | null;
 export interface PromptContext {
@@ -47,6 +48,16 @@ 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;
+    };
+    /** KB freshness evaluation from evidence store */
+    kbFreshness?: KbFreshnessEvaluation;
+    /** Paths changed for freshness evaluation (capped at 5) */
+    freshnessChangedPaths?: string[];
 }
 export declare function postureGuidance(posture: RepoPosture, capability?: InitKibiCommandCapability): string | null;
 /**

package/dist/prompt.js

@@ -110,7 +110,29 @@ function buildBootstrapRequiredBody(capability = getInitKibiCommandCapability())
     const commandBullet = capability.supported
         ? "- When the Kibi OpenCode plugin is active and native injection is supported, use `/init-kibi` as the canonical short alias; `/kibi:init-kibi:mcp` remains the namespaced MCP fallback."
         : "- This host does not support native `/init-kibi` injection. Kibi must fail closed and does not register a fake native alias; use `/kibi:init-kibi:mcp` instead.";
-    return `This repository does not appear to have Kibi initialized. Agents should:\n${commandBullet}\n- The workflow uses \`kb_autopilot_generate\` for read-only synthesis; always preview and get approval before writes.\n- Ask the user/operator to run setup or repair outside this session if bootstrap is insufficient.\n\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\`.`;
+    return `This repository does not appear to have Kibi initialized. Agents should:\n${commandBullet}\n- The workflow uses \`kb_autopilot_generate\` for read-only synthesis; always preview and get approval before writes.\n- Ask the user/operator to run setup or repair outside this session if bootstrap is insufficient.\n- For comprehensive Kibi usage guidance, use \`kb_skills_load\` with skill id \`kibi-usage\`.\n\nUse public MCP tools only: \`kb_autopilot_generate\`, \`kb_search\`, \`kb_query\`, \`kb_status\`, \`kb_find_gaps\`, \`kb_coverage\`, \`kb_graph\`, \`kb_upsert\`, \`kb_delete\`, \`kb_check\`, \`kb_skills_load\`.`;
+}
+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 = {
@@ -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;
@@ -215,6 +240,7 @@ ${buildBootstrapRequiredBody(capability)}`;
             context.cache &&
             context.workspaceRoot &&
             context.branch &&
+            !context.kbFreshness?.requiresEvidence &&
             riskClass) {
             const focusEdit = getFocusEdit(context);
             const key = {
@@ -430,6 +456,26 @@ The Kibi workspace is in a maintenance-degraded state. Guidance remains advisory
         posture !== "root_partial") {
         finalBlock = `${finalBlock}\n- Kibi impact evidence is required before completion/commit: run \`kb_check\` before completing this task.`;
     }
+    // Prepend KB freshness block when evidence is required
+    if (context.kbFreshness?.requiresEvidence) {
+        const changedListing = context.freshnessChangedPaths?.length
+            ? `Changed: ${context.freshnessChangedPaths.slice(0, 5).map(p => `\`${p}\``).join(", ")}`
+            : null;
+        const freshnessLines = [
+            "🧠 **Kibi freshness required**",
+            changedListing,
+            `State: ${context.kbFreshness.state}. ${context.kbFreshness.reason}`,
+            ...(context.kbFreshness.missingEvidence.length > 0
+                ? [`Missing: ${context.kbFreshness.missingEvidence.join(", ")}`]
+                : []),
+            "Resolution:",
+            "- **KB updated**: run `kb_search` for discovery, then `kb_upsert`/`kb_delete` for mutations, then `kb_check`.",
+            "- **No KB impact**: include a no-impact rationale in your final report after source-linked discovery via `kb_search`/`kb_query(sourceFile=...)` and `kb_check`.",
+        ].filter(Boolean).join("\n");
+        finalBlock = finalBlock
+            ? `${freshnessLines}\n\n${finalBlock}`
+            : freshnessLines;
+    }
     // Return: sentinel + one targeted block (or just sentinel if no block)
     return finalBlock
         ? `${SENTINEL}\n\n${finalBlock}`
@@ -506,7 +552,13 @@ Dogfood note for this repo: OpenCode here uses local built \`kibi-mcp\` and \`ki
 6. **Validate**: Run kb_check after KB mutations to catch violations early.
 7. **Before completion/commit**: Kibi impact evidence is required before completion/commit. If extraction output changes, refresh documentation/symbols.yaml and do not revert that update as scope creep.
 
-**Public Kibi tools only:** kb_autopilot_generate, kb_search, kb_query, kb_status, kb_find_gaps, kb_coverage, kb_graph, kb_upsert, kb_delete, kb_check.\n\nDo not invoke Kibi CLI commands directly from the agent.\n\n${buildInitKibiBootstrapReference(capability)}`;
+**Public Kibi tools only:** kb_autopilot_generate, kb_search, kb_query, kb_status, kb_find_gaps, kb_coverage, kb_graph, kb_upsert, kb_delete, kb_check, kb_skills_load.
+
+For comprehensive Kibi usage guidance (relationships, fact lanes, workflows), use \`kb_skills_load\` with skill id \`kibi-usage\`.
+
+Do not invoke Kibi CLI commands directly from the agent.
+
+${buildInitKibiBootstrapReference(capability)}`;
 }
 /**
  * Build prompt with contextual guidance based on posture, risk class, and cache state.

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/startup-notifier.d.ts

@@ -6,8 +6,14 @@ export type StartupNotifierClient = ToastCapableClient & {
     };
 };
 export type StartupNotifierConfig = {
-    version?: string;
+    versions?: {
+        opencode?: string;
+        mcp?: string;
+        cli?: string;
+        core?: string;
+    };
     suppressToast?: boolean;
     directory?: string;
+    versionMetadataSource?: string;
 };
 export declare function notifyStartup(client: StartupNotifierClient, cfg: StartupNotifierConfig): void;

package/dist/startup-notifier.js

@@ -1,10 +1,30 @@
 import { sendToast, } from "./toast.js";
+const VERSION_ORDER = ["opencode", "mcp", "cli", "core"];
 // implements REQ-opencode-kibi-plugin-v1
 export function notifyStartup(client, cfg) {
     const message = "kibi-opencode started";
-    const displayMessage = cfg.version
-        ? `${message} (v${cfg.version})`
+    // Build toast message from known versions in order
+    const versionParts = [];
+    if (cfg.versions) {
+        for (const key of VERSION_ORDER) {
+            const val = cfg.versions[key];
+            if (val !== undefined) {
+                versionParts.push(`${key} v${val}`);
+            }
+        }
+    }
+    const displayMessage = versionParts.length > 0
+        ? `${message} (${versionParts.join(", ")})`
         : message;
+    // Compute unknown versions (keys from VERSION_ORDER not present in cfg.versions)
+    const unknownVersions = [];
+    if (cfg.versions) {
+        for (const key of VERSION_ORDER) {
+            if (cfg.versions[key] === undefined) {
+                unknownVersions.push(key);
+            }
+        }
+    }
     const toastPayload = {
         variant: "success",
         title: "Kibi OpenCode",
@@ -18,31 +38,36 @@ export function notifyStartup(client, cfg) {
                 ...(cfg.directory ? { directory: cfg.directory } : {}),
             };
             if (result.status === "delivered") {
-                void client.app.log({
+                void client.app
+                    .log({
                     body: {
                         ...base,
                         level: "info",
                         message: "startup toast delivered",
                         transport: result.transport,
                     },
-                }).catch(() => {
+                })
+                    .catch(() => {
                     // Advisory log failure stays silent
                 });
             }
             else if (result.status === "unavailable") {
-                void client.app.log({
+                void client.app
+                    .log({
                     body: {
                         ...base,
                         level: "info",
                         message: "startup toast unavailable",
                         reason: result.reason,
                     },
-                }).catch(() => {
+                })
+                    .catch(() => {
                     // Advisory log failure stays silent
                 });
             }
             else if (result.status === "failed") {
-                void client.app.log({
+                void client.app
+                    .log({
                     body: {
                         ...base,
                         level: "warn",
@@ -51,21 +76,30 @@ export function notifyStartup(client, cfg) {
                         reason: result.reason,
                         ...(result.error ? { error: result.error } : {}),
                     },
-                }).catch(() => {
+                })
+                    .catch(() => {
                     // Advisory log failure stays silent
                 });
             }
         });
     }
-    void Promise.resolve(client.app.log({
-        body: {
-            service: "kibi-opencode",
-            level: "info",
-            message,
-            ...(cfg.version ? { version: cfg.version } : {}),
-            ...(cfg.directory ? { directory: cfg.directory } : {}),
-        },
-    })).catch((err) => {
+    // Structured startup log
+    const logBody = {
+        service: "kibi-opencode",
+        level: "info",
+        message,
+    };
+    if (cfg.versions && Object.keys(cfg.versions).length > 0) {
+        logBody.versions = cfg.versions;
+        logBody.unknownVersions = unknownVersions;
+    }
+    if (cfg.versionMetadataSource) {
+        logBody.versionMetadataSource = cfg.versionMetadataSource;
+    }
+    if (cfg.directory) {
+        logBody.directory = cfg.directory;
+    }
+    void Promise.resolve(client.app.log({ body: logBody })).catch(() => {
         // Advisory log failure stays silent
     });
 }

package/dist/version-metadata.d.ts

@@ -0,0 +1,13 @@
+export interface KibiPackageVersions {
+    opencode: string;
+    mcp: string;
+    cli: string;
+    core: string;
+    source: "generated-dist" | "workspace-packages" | "unknown";
+    missing: string[];
+}
+export interface ReadKibiPackageVersionsOptions {
+    baseUrl?: string | URL;
+    readFileSync?: (path: string | URL, encoding: "utf-8") => string;
+}
+export declare function readKibiPackageVersions(options?: ReadKibiPackageVersionsOptions): KibiPackageVersions;

package/dist/version-metadata.js

@@ -0,0 +1,78 @@
+import { readFileSync as fsReadFileSync } from "node:fs";
+// implements REQ-opencode-toast-package-versions-v1
+export function readKibiPackageVersions(options) {
+    const baseUrl = options?.baseUrl ?? import.meta.url;
+    const readFs = options?.readFileSync ?? fsReadFileSync;
+    // Tier 1: generated dist JSON (build-time artifact)
+    try {
+        const distUrl = new URL("./version-metadata.json", baseUrl);
+        const raw = readFs(distUrl, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.opencode === "string" &&
+            typeof parsed.mcp === "string" &&
+            typeof parsed.cli === "string" &&
+            typeof parsed.core === "string") {
+            return {
+                opencode: parsed.opencode,
+                mcp: parsed.mcp,
+                cli: parsed.cli,
+                core: parsed.core,
+                source: "generated-dist",
+                missing: [],
+            };
+        }
+    }
+    catch {
+        // fall through
+    }
+    // Tier 2: workspace package.json files
+    try {
+        const entries = [
+            ["opencode", "../package.json"],
+            ["mcp", "../../mcp/package.json"],
+            ["cli", "../../cli/package.json"],
+            ["core", "../../core/package.json"],
+        ];
+        const versions = {};
+        const missing = [];
+        for (const [name, relPath] of entries) {
+            try {
+                const pkgUrl = new URL(relPath, baseUrl);
+                const raw = readFs(pkgUrl, "utf-8");
+                const pkg = JSON.parse(raw);
+                versions[name] =
+                    typeof pkg.version === "string" ? pkg.version : "unknown";
+                if (typeof pkg.version !== "string") {
+                    missing.push(name);
+                }
+            }
+            catch {
+                versions[name] = "unknown";
+                missing.push(name);
+            }
+        }
+        // Only claim workspace-packages if at least one resolved
+        if (Object.values(versions).some((v) => v !== "unknown")) {
+            return {
+                opencode: versions.opencode ?? "unknown",
+                mcp: versions.mcp ?? "unknown",
+                cli: versions.cli ?? "unknown",
+                core: versions.core ?? "unknown",
+                source: "workspace-packages",
+                missing: missing.length > 0 ? missing : [],
+            };
+        }
+    }
+    catch {
+        // fall through
+    }
+    // Tier 3: all unknown — never throws
+    return {
+        opencode: "unknown",
+        mcp: "unknown",
+        cli: "unknown",
+        core: "unknown",
+        source: "unknown",
+        missing: ["opencode", "mcp", "cli", "core"],
+    };
+}

package/dist/version-metadata.json

@@ -0,0 +1 @@
+{"opencode":"0.15.0","mcp":"0.14.2","cli":"0.11.1","core":"0.5.3"}

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.13.0",
+  "version": "0.15.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -52,7 +52,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && bun run scripts/build-tui.ts && tsc -p tsconfig.tui-types.json",
+    "build": "tsc -p tsconfig.json && bun run scripts/generate-version-metadata.ts && bun run scripts/build-tui.ts && tsc -p tsconfig.tui-types.json",
     "build:tui": "bun run scripts/build-tui.ts && tsc -p tsconfig.tui-types.json",
     "dev": "tsc -p tsconfig.json --watch",
     "clean": "rm -rf dist",
@@ -62,10 +62,10 @@
     "@opencode-ai/plugin": "^1.4.7",
     "@opentui/core": "^0.1.99",
     "@opentui/solid": "^0.1.99",
-    "kibi-cli": "^0.11.0"
+    "kibi-cli": "^0.11.1"
   },
   "devDependencies": {
     "@types/node": "latest",
     "typescript": "^5.0.0"
   }
-}
+}