kibi-opencode 0.10.0 → 0.12.0

package/dist/tui.d.ts

@@ -0,0 +1,8 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const tui: TuiPlugin;
+export { tui };
+declare const _default: {
+    readonly id: "kibi-opencode";
+    readonly tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,413 @@
+// @bun
+// src/idle-brief-reader.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/idle-brief-paths.ts
+import * as path from "path";
+import { loadBriefConfig } from "kibi-cli/brief-config";
+function resolveBriefsDir(workspaceRoot) {
+  return path.join(workspaceRoot, ".kb", "briefs");
+}
+
+// src/idle-brief-store.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isCitation(value) {
+  return isRecord(value) && typeof value.id === "string";
+}
+function isStatement(value) {
+  return isRecord(value) && typeof value.statement === "string" && isStringArray(value.citationIds);
+}
+function isValidationViolation(value) {
+  return isRecord(value) && typeof value.rule === "string" && typeof value.entityId === "string" && typeof value.description === "string";
+}
+function isValidationDiagnostic(value) {
+  return isRecord(value) && typeof value.category === "string" && typeof value.severity === "string" && typeof value.message === "string";
+}
+function isAuditCursor(value) {
+  return isRecord(value) && typeof value.lastTimestamp === "string" && typeof value.lastOperation === "string" && typeof value.entryCount === "number" && typeof value.fileSize === "number";
+}
+function isValidation(value) {
+  return isRecord(value) && Array.isArray(value.violations) && value.violations.every(isValidationViolation) && typeof value.count === "number" && Array.isArray(value.diagnostics) && value.diagnostics.every(isValidationDiagnostic);
+}
+function isBriefingBase(value) {
+  return isRecord(value) && typeof value.tldr === "string" && typeof value.promptBlock === "string" && Array.isArray(value.citations) && value.citations.every(isCitation) && (value.constraints === undefined || Array.isArray(value.constraints) && value.constraints.every(isStatement)) && (value.regressionRisks === undefined || Array.isArray(value.regressionRisks) && value.regressionRisks.every(isStatement)) && (value.missingEvidence === undefined || Array.isArray(value.missingEvidence) && value.missingEvidence.every(isStatement));
+}
+function isBriefingV2(value) {
+  return isBriefingBase(value) && isStringArray(value.changeNarrative) && (value.deliveryReasons === undefined || isDeliveryReasons(value.deliveryReasons));
+}
+function isReasonItem(value) {
+  return isRecord(value) && typeof value.kind === "string" && typeof value.text === "string" && isStringArray(value.entityIds) && (value.citationIds === undefined || isStringArray(value.citationIds)) && (value.severity === undefined || value.severity === "info" || value.severity === "warning" || value.severity === "error");
+}
+function isDeliveryReasons(value) {
+  return isRecord(value) && value.version === 1 && isRecord(value.toast) && typeof value.toast.title === "string" && typeof value.toast.summary === "string" && typeof value.toast.whyItMatters === "string" && Array.isArray(value.items) && value.items.every(isReasonItem);
+}
+function isChangeItem(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.type === "string";
+}
+function isIdleBriefEnvelope(value) {
+  if (!isRecord(value))
+    return false;
+  const hasBaseFields = (value.schemaVersion === "1.0" || value.schemaVersion === "2.0") && typeof value.briefId === "string" && (value.type === "success" || value.type === "warning") && typeof value.sessionId === "string" && typeof value.branch === "string" && typeof value.createdAt === "string" && typeof value.unread === "boolean" && isAuditCursor(value.auditCursor) && typeof value.summary === "string" && isValidation(value.validation) && typeof value.contentHash === "string";
+  if (!hasBaseFields)
+    return false;
+  if (value.schemaVersion === "1.0") {
+    return isRecord(value.counts) && typeof value.counts.requirementsAdded === "number" && typeof value.counts.relationshipsAdded === "number" && typeof value.counts.entitiesDeleted === "number" && isBriefingBase(value.briefing);
+  }
+  return isRecord(value.counts) && typeof value.counts.entitiesAdded === "number" && typeof value.counts.entitiesModified === "number" && typeof value.counts.entitiesRemoved === "number" && typeof value.counts.relationshipsChanged === "number" && isRecord(value.changes) && isRecord(value.changes.entities) && Array.isArray(value.changes.entities.added) && value.changes.entities.added.every(isChangeItem) && Array.isArray(value.changes.entities.modified) && value.changes.entities.modified.every(isChangeItem) && Array.isArray(value.changes.entities.removed) && value.changes.entities.removed.every(isChangeItem) && isRecord(value.changes.relationships) && typeof value.changes.relationships.changed === "number" && isBriefingV2(value.briefing);
+}
+
+// src/idle-brief-reader.ts
+var BRIEF_FILENAME_RE = /^(\d+)_brief\.json$/;
+var TUI_SEEN_FILE = ".tui-seen.json";
+function resolveTuiSeenPath(workspaceRoot) {
+  return path2.join(resolveBriefsDir(workspaceRoot), TUI_SEEN_FILE);
+}
+function markBriefTuiSeen(workspaceRoot, branch, contentHash) {
+  const briefsDir = resolveBriefsDir(workspaceRoot);
+  fs.mkdirSync(briefsDir, { recursive: true });
+  const seenPath = resolveTuiSeenPath(workspaceRoot);
+  let parsed = {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(seenPath, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      parsed = raw;
+    }
+  } catch {}
+  const existing = Array.isArray(parsed[branch]) ? parsed[branch] : [];
+  const next = [contentHash, ...existing.filter((entry) => entry !== contentHash)].slice(0, 100);
+  parsed[branch] = next;
+  const tempPath = `${seenPath}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(parsed, null, 2), "utf-8");
+  fs.renameSync(tempPath, seenPath);
+}
+function extractTimestamp(filename) {
+  const match = filename.match(BRIEF_FILENAME_RE);
+  if (!match)
+    return null;
+  return Number(match[1]);
+}
+function scanBriefs(workspaceRoot, branch, filterUnread) {
+  const briefsDir = resolveBriefsDir(workspaceRoot);
+  if (!fs.existsSync(briefsDir)) {
+    return null;
+  }
+  const files = fs.readdirSync(briefsDir);
+  const candidates = [];
+  for (const file of files) {
+    if (file.endsWith(".tmp"))
+      continue;
+    const timestamp = extractTimestamp(file);
+    if (timestamp === null)
+      continue;
+    const filePath = path2.join(briefsDir, file);
+    let envelope;
+    try {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!isIdleBriefEnvelope(parsed)) {
+        continue;
+      }
+      envelope = parsed;
+    } catch {
+      continue;
+    }
+    if (envelope.branch === branch && (envelope.schemaVersion === "1.0" || envelope.schemaVersion === "2.0") && (!filterUnread || envelope.unread === true)) {
+      candidates.push({ timestamp, envelope, filePath });
+    }
+  }
+  if (candidates.length === 0) {
+    return null;
+  }
+  candidates.sort((a, b) => b.timestamp - a.timestamp);
+  const latest = candidates[0];
+  if (!latest) {
+    return null;
+  }
+  return {
+    envelope: latest.envelope,
+    filePath: latest.filePath
+  };
+}
+function selectLatestPersistedBrief(workspaceRoot, branch) {
+  return scanBriefs(workspaceRoot, branch, false);
+}
+function markBriefRead(workspaceRoot, briefPath) {
+  const briefsDir = resolveBriefsDir(workspaceRoot);
+  const resolvedBriefPath = path2.resolve(briefPath);
+  const resolvedBriefsDir = path2.resolve(briefsDir);
+  if (!resolvedBriefPath.startsWith(resolvedBriefsDir + path2.sep)) {
+    throw new Error(`Invalid brief path: ${briefPath} is not inside ${briefsDir}`);
+  }
+  const raw = fs.readFileSync(briefPath, "utf-8");
+  const brief = JSON.parse(raw);
+  brief.unread = false;
+  const tempPath = `${briefPath}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(brief, null, 2), "utf-8");
+  fs.renameSync(tempPath, briefPath);
+}
+
+// src/tui.tsx
+import { loadBriefConfig as loadBriefConfig2 } from "kibi-cli/brief-config";
+
+// src/brief-delivery-reasons.ts
+function toastSummary(items) {
+  const first = items[0]?.text?.trim() ?? "";
+  const second = items[1]?.text?.trim() ?? "";
+  if (first && second)
+    return `${first}, ${second}`;
+  return first || second || undefined;
+}
+function toastWhy(items) {
+  if (items.some((i) => i.kind === "conflict_detected"))
+    return "There is a knowledge conflict to resolve before using the brief.";
+  if (items.some((i) => i.kind === "validation_issue"))
+    return "Validation issues need attention before the update is treated as settled.";
+  const hasEntities = items.some((i) => i.kind === "entity_added" || i.kind === "entity_modified" || i.kind === "entity_removed");
+  const hasRelationships = items.some((i) => i.kind === "relationship_changed");
+  if (hasEntities && hasRelationships)
+    return "Requirements and facts were updated.";
+  if (hasEntities)
+    return "Entities were updated.";
+  if (hasRelationships)
+    return "Relationships were updated.";
+  return;
+}
+function isOperationalByEntityIds(item) {
+  if (item.entityIds.length === 0)
+    return false;
+  return item.entityIds.every((id) => {
+    const dashIdx = id.indexOf("-");
+    if (dashIdx < 0)
+      return false;
+    const name = id.slice(dashIdx + 1);
+    return /\.[a-zA-Z0-9]+$/.test(name);
+  });
+}
+function isOperationalItem(item, allItems) {
+  if (item.kind === "relationship_changed") {
+    const entityItems = allItems.filter((i) => i.kind === "entity_added" || i.kind === "entity_modified" || i.kind === "entity_removed");
+    return entityItems.length > 0 && entityItems.every(isOperationalByEntityIds);
+  }
+  return isOperationalByEntityIds(item);
+}
+function renderToastSummary(reasons) {
+  const domainItems = reasons.items.filter((i) => !isOperationalItem(i, reasons.items));
+  if (domainItems.length === 0) {
+    return;
+  }
+  return {
+    title: "Kibi Knowledge Update",
+    summary: toastSummary(domainItems) ?? "",
+    whyItMatters: toastWhy(domainItems) ?? ""
+  };
+}
+
+// src/tui-brief-view-model.ts
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return;
+}
+function isOperationalByEntityIds2(item) {
+  if (item.entityIds.length === 0)
+    return false;
+  return item.entityIds.every((id) => {
+    const dashIdx = id.indexOf("-");
+    if (dashIdx < 0)
+      return false;
+    return /\.[a-zA-Z0-9]+$/.test(id.slice(dashIdx + 1));
+  });
+}
+function isOperationalDeliveryItem(item, allItems) {
+  if (item.kind === "relationship_changed") {
+    const entityItems = allItems.filter((i) => i.kind === "entity_added" || i.kind === "entity_modified" || i.kind === "entity_removed");
+    return entityItems.length > 0 && entityItems.every(isOperationalByEntityIds2);
+  }
+  return isOperationalByEntityIds2(item);
+}
+function deriveWhatChanged(envelope) {
+  const briefing = envelope.briefing;
+  const deliveryReasons = briefing.deliveryReasons;
+  if (deliveryReasons?.items?.length) {
+    const domainItems = deliveryReasons.items.filter((item) => !isOperationalDeliveryItem(item, deliveryReasons.items));
+    if (domainItems.length > 0) {
+      return domainItems.map((item) => item.text);
+    }
+  }
+  if (envelope.schemaVersion === "2.0") {
+    const narrative = envelope.briefing.changeNarrative.map((line) => line.trim()).filter(Boolean).filter((line) => !line.includes(".sisyphus/"));
+    if (narrative.length > 0) {
+      return narrative.slice(0, 2);
+    }
+    const fallbackEntity = envelope.changes.entities.modified[0] ?? envelope.changes.entities.added[0];
+    if (fallbackEntity) {
+      const action = envelope.changes.entities.modified[0] ? "Modified" : "Added";
+      return [
+        `${action} ${fallbackEntity.id}: ${fallbackEntity.title ?? "Untitled"}`
+      ];
+    }
+  }
+  const fallback = firstNonEmpty(envelope.summary, envelope.briefing.tldr);
+  return fallback ? [fallback] : [];
+}
+function buildTuiBriefViewModel(envelope) {
+  const briefing = envelope.briefing;
+  const deliveryReasons = briefing.deliveryReasons;
+  let title = firstNonEmpty(envelope.summary, envelope.briefing.tldr);
+  if (deliveryReasons?.items?.length) {
+    const filteredToast = renderToastSummary(deliveryReasons);
+    if (filteredToast) {
+      title = filteredToast.summary;
+    }
+  } else if (envelope.schemaVersion === "2.0" && envelope.briefing.changeNarrative.length > 0) {
+    title = envelope.briefing.changeNarrative[0]?.trim() ?? title;
+  }
+  const base = {
+    briefId: envelope.briefId,
+    schemaVersion: envelope.schemaVersion,
+    branch: envelope.branch,
+    createdAt: envelope.createdAt,
+    type: envelope.type,
+    unread: envelope.unread,
+    contentHash: envelope.contentHash,
+    title: title ?? "Kibi Brief",
+    whatChanged: deriveWhatChanged(envelope),
+    whyItMatters: deliveryReasons?.items?.length ? renderToastSummary(deliveryReasons)?.whyItMatters || undefined : undefined,
+    knowledgeImpact: {
+      citations: envelope.briefing.citations,
+      constraints: envelope.briefing.constraints ?? [],
+      regressionRisks: envelope.briefing.regressionRisks ?? []
+    },
+    interpretationNote: {
+      validationCount: envelope.validation.count,
+      missingEvidence: envelope.briefing.missingEvidence ?? []
+    }
+  };
+  if (envelope.schemaVersion === "2.0") {
+    return {
+      ...base,
+      counts: {
+        schemaVersion: "2.0",
+        entitiesAdded: envelope.counts.entitiesAdded,
+        entitiesModified: envelope.counts.entitiesModified,
+        entitiesRemoved: envelope.counts.entitiesRemoved,
+        relationshipsChanged: envelope.counts.relationshipsChanged
+      }
+    };
+  }
+  return {
+    ...base,
+    counts: {
+      schemaVersion: "1.0",
+      requirementsAdded: envelope.counts.requirementsAdded,
+      relationshipsAdded: envelope.counts.relationshipsAdded,
+      entitiesDeleted: envelope.counts.entitiesDeleted
+    }
+  };
+}
+
+// src/tui.tsx
+var tui = async (api, _options, _meta) => {
+  let currentContentHash = null;
+  api.route.register([
+    {
+      name: "kibi.brief",
+      render: () => {
+        const workspace = api.state.path.worktree || "";
+        const branch = api.state.vcs?.branch || "main";
+        const brief = selectLatestPersistedBrief(workspace, branch);
+        if (!brief) {
+          currentContentHash = null;
+          return /* @__PURE__ */ h("box", {
+            flexDirection: "column",
+            gap: 1,
+            padding: 1
+          }, /* @__PURE__ */ h("text", {
+            fg: api.theme.current.error
+          }, "No meaningful KB update"), /* @__PURE__ */ h("text", null, "There is no latest persisted brief for this branch."));
+        }
+        const { envelope } = brief;
+        const isNewContent = envelope.contentHash !== currentContentHash;
+        currentContentHash = envelope.contentHash;
+        if (isNewContent && envelope.unread) {
+          markBriefTuiSeen(workspace, branch, envelope.contentHash);
+          try {
+            const config = loadBriefConfig2(workspace);
+            if (!config.channels.vscode) {
+              markBriefRead(workspace, brief.filePath);
+            }
+          } catch {}
+        }
+        const viewModel = buildTuiBriefViewModel(envelope);
+        return /* @__PURE__ */ h("scrollbox", {
+          flexDirection: "column",
+          gap: 1,
+          padding: 1
+        }, /* @__PURE__ */ h("text", {
+          fg: api.theme.current.accent
+        }, /* @__PURE__ */ h("strong", null, viewModel.title)), /* @__PURE__ */ h("box", {
+          flexDirection: "column"
+        }, /* @__PURE__ */ h("text", null, /* @__PURE__ */ h("strong", null, "What changed:")), /* @__PURE__ */ h("text", null, viewModel.whatChanged.map((line) => `- ${line}`).join(`
+`))), /* @__PURE__ */ h("box", {
+          flexDirection: "column"
+        }, /* @__PURE__ */ h("text", null, /* @__PURE__ */ h("strong", null, "Why it matters:")), /* @__PURE__ */ h("text", null, viewModel.whyItMatters)), (viewModel.knowledgeImpact.citations.length > 0 || viewModel.knowledgeImpact.constraints.length > 0 || viewModel.knowledgeImpact.regressionRisks.length > 0) && /* @__PURE__ */ h("box", {
+          flexDirection: "column"
+        }, /* @__PURE__ */ h("text", null, /* @__PURE__ */ h("strong", null, "Project knowledge impact:")), viewModel.knowledgeImpact.citations.length > 0 && /* @__PURE__ */ h("text", null, viewModel.knowledgeImpact.citations.map((citation) => `- ${citation.id}${citation.title ? `: ${citation.title}` : ""}`).join(`
+`)), viewModel.knowledgeImpact.constraints.length > 0 && /* @__PURE__ */ h("text", null, viewModel.knowledgeImpact.constraints.map((constraint) => `- ${constraint.statement}`).join(`
+`)), viewModel.knowledgeImpact.regressionRisks.length > 0 && /* @__PURE__ */ h("text", null, viewModel.knowledgeImpact.regressionRisks.map((risk) => `- ${risk.statement}`).join(`
+`))), (viewModel.interpretationNote.validationCount > 0 || viewModel.interpretationNote.missingEvidence.length > 0) && /* @__PURE__ */ h("box", {
+          flexDirection: "column"
+        }, /* @__PURE__ */ h("text", {
+          fg: api.theme.current.warning
+        }, /* @__PURE__ */ h("strong", null, "Interpretation note:")), viewModel.interpretationNote.validationCount > 0 && /* @__PURE__ */ h("text", null, "Validation checks reported unresolved items: ", viewModel.interpretationNote.validationCount, " issue(s)."), viewModel.interpretationNote.missingEvidence.length > 0 && /* @__PURE__ */ h("text", null, viewModel.interpretationNote.missingEvidence.map((item) => `- ${item.statement}`).join(`
+`))));
+      }
+    }
+  ]);
+  if (api.command?.register) {
+    api.command.register(() => [
+      {
+        title: "Kibi: Open Latest Brief",
+        value: "kibi.open_latest_brief",
+        description: "Opens the latest persisted brief for the current workspace and branch",
+        onSelect: () => {
+          api.route.navigate("kibi.brief");
+        }
+      },
+      {
+        title: "Kibi: Open Latest Brief",
+        value: "kibi-brief",
+        description: "Opens the latest persisted brief for the current workspace and branch",
+        onSelect: () => {
+          api.route.navigate("kibi.brief");
+        }
+      },
+      {
+        title: "Kibi: Refresh Brief",
+        value: "kibi.refresh_brief",
+        description: "Re-reads the latest persisted brief and refreshes the view",
+        onSelect: () => {
+          api.route.navigate("kibi.brief");
+        }
+      }
+    ]);
+  }
+};
+var tui_default = {
+  id: "kibi-opencode",
+  tui
+};
+export {
+  tui,
+  tui_default as default
+};

package/dist/tui.jsx

@@ -0,0 +1,120 @@
+import { selectLatestPersistedBrief, markBriefTuiSeen, markBriefRead } from "./idle-brief-reader.js";
+import { loadBriefConfig } from "kibi-cli/brief-config";
+import { buildTuiBriefViewModel } from "./tui-brief-view-model.js";
+const tui = async (api, _options, _meta) => {
+    // State: track the currently displayed contentHash for in-place refresh detection
+    let currentContentHash = null;
+    api.route.register([
+        {
+            name: "kibi.brief",
+            render: () => {
+                const workspace = api.state.path.worktree || "";
+                const branch = api.state.vcs?.branch || "main";
+                const brief = selectLatestPersistedBrief(workspace, branch);
+                if (!brief) {
+                    currentContentHash = null;
+                    return (<box flexDirection="column" gap={1} padding={1}>
+              <text fg={api.theme.current.error}>No meaningful KB update</text>
+              <text>There is no latest persisted brief for this branch.</text>
+            </box>);
+                }
+                const { envelope } = brief;
+                const isNewContent = envelope.contentHash !== currentContentHash;
+                currentContentHash = envelope.contentHash;
+                // Mark as TUI-seen when this is a new (previously unseen) brief and it's unread
+                if (isNewContent && envelope.unread) {
+                    markBriefTuiSeen(workspace, branch, envelope.contentHash);
+                    // When VSCode channel is disabled, TUI is the sole delivery channel —
+                    // viewing the brief here should also mark it as fully read
+                    try {
+                        const config = loadBriefConfig(workspace);
+                        if (!config.channels.vscode) {
+                            markBriefRead(workspace, brief.filePath);
+                        }
+                    }
+                    catch {
+                        // Gracefully handle config load or markBriefRead failures
+                    }
+                }
+                const viewModel = buildTuiBriefViewModel(envelope);
+                return (<scrollbox flexDirection="column" gap={1} padding={1}>
+            <text fg={api.theme.current.accent}><strong>{viewModel.title}</strong></text>
+            
+            <box flexDirection="column">
+              <text><strong>What changed:</strong></text>
+              <text>{viewModel.whatChanged.map((line) => `- ${line}`).join("\n")}</text>
+            </box>
+
+            <box flexDirection="column">
+              <text><strong>Why it matters:</strong></text>
+              <text>{viewModel.whyItMatters}</text>
+            </box>
+
+            {(viewModel.knowledgeImpact.citations.length > 0 || viewModel.knowledgeImpact.constraints.length > 0 || viewModel.knowledgeImpact.regressionRisks.length > 0) && (<box flexDirection="column">
+                <text><strong>Project knowledge impact:</strong></text>
+                {viewModel.knowledgeImpact.citations.length > 0 && (<text>
+                    {viewModel.knowledgeImpact.citations
+                                .map((citation) => `- ${citation.id}${citation.title ? `: ${citation.title}` : ""}`)
+                                .join("\n")}
+                  </text>)}
+                {viewModel.knowledgeImpact.constraints.length > 0 && (<text>
+                    {viewModel.knowledgeImpact.constraints
+                                .map((constraint) => `- ${constraint.statement}`)
+                                .join("\n")}
+                  </text>)}
+                {viewModel.knowledgeImpact.regressionRisks.length > 0 && (<text>
+                    {viewModel.knowledgeImpact.regressionRisks
+                                .map((risk) => `- ${risk.statement}`)
+                                .join("\n")}
+                  </text>)}
+              </box>)}
+
+            {(viewModel.interpretationNote.validationCount > 0 || viewModel.interpretationNote.missingEvidence.length > 0) && (<box flexDirection="column">
+                <text fg={api.theme.current.warning}><strong>Interpretation note:</strong></text>
+                {viewModel.interpretationNote.validationCount > 0 && (<text>Validation checks reported unresolved items: {viewModel.interpretationNote.validationCount} issue(s).</text>)}
+                {viewModel.interpretationNote.missingEvidence.length > 0 && (<text>
+                    {viewModel.interpretationNote.missingEvidence
+                                .map((item) => `- ${item.statement}`)
+                                .join("\n")}
+                  </text>)}
+              </box>)}
+          </scrollbox>);
+            },
+        },
+    ]);
+    if (api.command?.register) {
+        api.command.register(() => [
+            {
+                title: "Kibi: Open Latest Brief",
+                value: "kibi.open_latest_brief",
+                description: "Opens the latest persisted brief for the current workspace and branch",
+                // implements REQ-opencode-kibi-briefing-v6
+                onSelect: () => {
+                    api.route.navigate("kibi.brief");
+                },
+            },
+            {
+                title: "Kibi: Open Latest Brief",
+                value: "kibi-brief",
+                description: "Opens the latest persisted brief for the current workspace and branch",
+                // implements REQ-opencode-kibi-briefing-v6
+                onSelect: () => {
+                    api.route.navigate("kibi.brief");
+                },
+            },
+            {
+                title: "Kibi: Refresh Brief",
+                value: "kibi.refresh_brief",
+                description: "Re-reads the latest persisted brief and refreshes the view",
+                onSelect: () => {
+                    api.route.navigate("kibi.brief");
+                },
+            },
+        ]);
+    }
+};
+export { tui };
+export default {
+    id: "kibi-opencode",
+    tui,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-opencode",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Kibi OpenCode plugin - thin adapter to integrate Kibi with OpenCode sessions",
   "type": "module",
   "main": "dist/index.js",
@@ -30,6 +30,11 @@
       "types": "./dist/file-filter.d.ts",
       "import": "./dist/file-filter.js",
       "default": "./dist/file-filter.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js",
+      "default": "./dist/tui.js"
     }
   },
   "files": [
@@ -47,14 +52,17 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && 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",
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.2.26",
-    "kibi-cli": "^0.7.0"
+    "@opencode-ai/plugin": "^1.4.7",
+    "@opentui/core": "^0.1.99",
+    "@opentui/solid": "^0.1.99",
+    "kibi-cli": "^0.10.0"
   },
   "devDependencies": {
     "@types/node": "latest",