kibi-opencode 0.9.0 → 0.11.0

package/dist/scheduler.js

@@ -18,6 +18,7 @@ class WorktreeSyncScheduler {
     pending = null;
     trailing = null;
     lastFileEditedAt = 0;
+    flushWaiters = [];
     constructor(opts) {
         this.worktree = path.resolve(opts.worktree);
         this.config = opts.config;
@@ -32,7 +33,9 @@ class WorktreeSyncScheduler {
     scheduleSync(reason, filePath, checkRules) {
         if (!this.config.sync.enabled)
             return;
-        if (reason === "file.edited") {
+        // Treat file.created, file.edited, and file.deleted same relevance-wise
+        const isFileLifecycle = reason === "file.edited" || reason === "file.created" || reason === "file.deleted";
+        if (isFileLifecycle) {
             if (!filePath)
                 return;
             if (!shouldHandleFile(filePath, this.worktree))
@@ -71,11 +74,30 @@ class WorktreeSyncScheduler {
             this.scheduleSync(reason);
         }
     }
+    async flush() {
+        if (!this.config.sync.enabled)
+            return;
+        if (this.timer) {
+            this.clearTimeoutFn(this.timer);
+            this.timer = null;
+        }
+        this.flushPending();
+        if (this.isIdle()) {
+            return;
+        }
+        await new Promise((resolve) => {
+            this.flushWaiters.push(resolve);
+        });
+    }
     dispose() {
         if (this.timer) {
             this.clearTimeoutFn(this.timer);
             this.timer = null;
         }
+        const waiters = this.flushWaiters.splice(0);
+        for (const waiter of waiters) {
+            waiter();
+        }
     }
     isToolExecuteAfterEnabled() {
         if (this.explicitToolAfterHint)
@@ -106,9 +128,17 @@ class WorktreeSyncScheduler {
         let syncExitCode = 0;
         let checkExitCode;
         let checkRules;
+        let syncCommand;
+        let syncStdout;
+        let syncStderr;
+        let syncErrorMessage;
         try {
             const syncResult = await this.runSync(this.worktree);
             syncExitCode = syncResult.exitCode;
+            syncCommand = syncResult.syncCommand;
+            syncStdout = syncResult.syncStdout;
+            syncStderr = syncResult.syncStderr;
+            syncErrorMessage = syncResult.syncErrorMessage;
             // Run targeted checks if sync succeeded and rules specified
             if (syncExitCode === 0 &&
                 trigger.checkRules &&
@@ -127,11 +157,11 @@ class WorktreeSyncScheduler {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            logger.error(`sync.failed ${message}`);
             syncExitCode = 1;
+            syncErrorMessage = message;
         }
         finally {
-            this.emitCompletion(trigger, startedAt, syncExitCode, checkExitCode, checkRules);
+            this.emitCompletion(trigger, startedAt, syncExitCode, checkExitCode, checkRules, truncateSyncOutput(syncStdout), truncateSyncOutput(syncStderr), syncErrorMessage, syncCommand);
             this.inFlight = false;
             if (this.dirty) {
                 const trailing = this.trailing ?? { reason: "sync.trailing" };
@@ -147,9 +177,23 @@ class WorktreeSyncScheduler {
                         : {}),
                 });
             }
+            this.resolveFlushWaitersIfIdle();
+        }
+    }
+    isIdle() {
+        return !this.inFlight && !this.timer && !this.pending && !this.dirty && !this.trailing;
+    }
+    resolveFlushWaitersIfIdle() {
+        if (!this.isIdle())
+            return;
+        if (this.flushWaiters.length === 0)
+            return;
+        const waiters = this.flushWaiters.splice(0);
+        for (const waiter of waiters) {
+            waiter();
         }
     }
-    emitCompletion(trigger, startedAt, exitCode, checkExitCode, checkRules) {
+    emitCompletion(trigger, startedAt, exitCode, checkExitCode, checkRules, syncStdout, syncStderr, syncErrorMessage, syncCommand) {
         const durationMs = Math.max(0, this.now() - startedAt);
         const normalizedReason = trigger.reason.endsWith(".trailing")
             ? trigger.reason.slice(0, -".trailing".length)
@@ -164,6 +208,10 @@ class WorktreeSyncScheduler {
             ...(trigger.filePath !== undefined ? { filePath: trigger.filePath } : {}),
             ...(checkExitCode !== undefined ? { checkExitCode } : {}),
             ...(checkRules !== undefined ? { checkRules } : {}),
+            ...(syncStdout !== undefined ? { syncStdout } : {}),
+            ...(syncStderr !== undefined ? { syncStderr } : {}),
+            ...(syncErrorMessage !== undefined ? { syncErrorMessage } : {}),
+            ...(syncCommand !== undefined ? { syncCommand } : {}),
         };
         if (exitCode === 0) {
             logger.info(`sync.succeeded ${JSON.stringify(meta)}`);
@@ -177,11 +225,42 @@ class WorktreeSyncScheduler {
         this.onRunComplete?.(meta);
     }
 }
+const TRUNCATE_LIMIT = 4000;
+const TRUNCATE_SUFFIX = "\n...[truncated]";
+function truncateSyncOutput(value) {
+    if (!value)
+        return undefined;
+    if (value.length > TRUNCATE_LIMIT) {
+        return value.slice(0, TRUNCATE_LIMIT) + TRUNCATE_SUFFIX;
+    }
+    return value;
+}
 async function runKibiSync(worktree) {
     return new Promise((resolve) => {
-        exec("kibi sync", { cwd: worktree }, (error) => {
-            resolve({ exitCode: error ? (error.code ?? 1) : 0 });
-        });
+        try {
+            exec("kibi sync", { cwd: worktree }, (error, stdout, stderr) => {
+                if (error) {
+                    const truncatedOut = truncateSyncOutput(stdout || undefined);
+                    const truncatedErr = truncateSyncOutput(stderr || undefined);
+                    const signal = error.signal ? ` (signal: ${error.signal})` : "";
+                    const errorMessage = error.message ? `${error.message}${signal}` : signal || undefined;
+                    resolve({
+                        exitCode: error.code ?? 1,
+                        syncCommand: "kibi sync",
+                        ...(truncatedOut !== undefined ? { syncStdout: truncatedOut } : {}),
+                        ...(truncatedErr !== undefined ? { syncStderr: truncatedErr } : {}),
+                        ...(errorMessage ? { syncErrorMessage: errorMessage } : {}),
+                    });
+                }
+                else {
+                    resolve({ exitCode: 0, syncCommand: "kibi sync" });
+                }
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            resolve({ exitCode: 1, syncCommand: "kibi sync", syncErrorMessage: message });
+        }
     });
 }
 async function runKibiCheck(worktree, rules) {

package/dist/session-edit-state.d.ts

@@ -0,0 +1,25 @@
+export type EditEventKind = string;
+export interface SessionEditEntry {
+    /** Relative file path (relative to worktree root). */
+    filePath: string;
+    /** Hash of the file content at first sight (baseline). "<deleted>" sentinel if file was missing. */
+    baselineHash: string;
+    /** Current hash at last reconciliation. */
+    currentHash: string;
+    /** Timestamp (ms) of last reconciliation pass. */
+    lastReconciledAt: number;
+}
+export interface SessionEditState {
+    recordEventHint(filePath: string, kind: EditEventKind, timestamp?: number): void;
+    reconcilePath(filePath: string): void;
+    reconcileKnownPaths(): void;
+    getSessionEdits(): SessionEditEntry[];
+    getFocusEdit(): SessionEditEntry | null;
+    hasSessionEdits(): boolean;
+    forceEdit(filePath: string, kind?: EditEventKind, timestamp?: number): void;
+}
+export declare function createSessionEditState(opts: {
+    worktree: string;
+    /** Custom clock for testing. Defaults to Date.now. */
+    now?: () => number;
+}): SessionEditState;

package/dist/session-edit-state.js

@@ -0,0 +1,177 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const SENTINEL_HASH = "<deleted>";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export function createSessionEditState(opts) {
+    const worktree = opts.worktree;
+    const now = opts.now ?? Date.now;
+    // ---- Per-instance state (no module globals) ----
+    /**
+     * Tracked files keyed by relative path.
+     * Undefined baselineHash means we haven't taken a snapshot yet.
+     */
+    const tracked = new Map();
+    // ---- Internal helpers ----
+    function resolveToRelative(filePath) {
+        if (path.isAbsolute(filePath)) {
+            const rel = path.relative(worktree, filePath);
+            // Normalise away any leading ./ or ../ that escapes worktree
+            return rel.startsWith("..") ? filePath : rel;
+        }
+        return filePath;
+    }
+    function resolveToAbsolute(relPath) {
+        return path.join(worktree, relPath);
+    }
+    function hashContent(content) {
+        return crypto.createHash("sha256").update(content).digest("hex");
+    }
+    function hashFile(absPath) {
+        try {
+            const content = fs.readFileSync(absPath, "utf-8");
+            return hashContent(content);
+        }
+        catch {
+            return SENTINEL_HASH;
+        }
+    }
+    /**
+     * Take a baseline snapshot if we haven't yet.
+     * Returns the baseline hash.
+     */
+    function ensureBaseline(entry, relPath) {
+        if (entry.baselineHash !== undefined) {
+            return entry.baselineHash;
+        }
+        const abs = resolveToAbsolute(relPath);
+        const h = hashFile(abs);
+        entry.baselineHash = h;
+        return h;
+    }
+    // ---- Public API ----
+    function recordEventHint(filePath, kind, timestamp) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        entry.eventHints.push({ kind, timestamp: timestamp ?? now() });
+    }
+    function reconcilePath(filePath) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        // Lazy baseline snapshot
+        ensureBaseline(entry, rel);
+        // Current hash
+        const abs = resolveToAbsolute(rel);
+        const current = hashFile(abs);
+        entry.currentHash = current;
+        entry.lastReconciledAt = now();
+    }
+    function reconcileKnownPaths() {
+        for (const relPath of tracked.keys()) {
+            reconcilePath(relPath);
+        }
+    }
+    /**
+     * Return surviving session edits: files whose current hash differs from baseline.
+     * Sorted by lastReconciledAt ascending (oldest first).
+     */
+    function getSessionEdits() {
+        const results = [];
+        for (const [relPath, entry] of tracked) {
+            if (entry.baselineHash === undefined || entry.currentHash === undefined) {
+                // Not yet reconciled
+                continue;
+            }
+            if (entry.currentHash !== entry.baselineHash) {
+                results.push({
+                    filePath: relPath,
+                    baselineHash: entry.baselineHash,
+                    currentHash: entry.currentHash,
+                    lastReconciledAt: entry.lastReconciledAt,
+                });
+            }
+        }
+        results.sort((a, b) => a.lastReconciledAt - b.lastReconciledAt);
+        return results;
+    }
+    /**
+     * Focus edit = the last reconciled surviving edit (highest lastReconciledAt).
+     */
+    function getFocusEdit() {
+        const edits = getSessionEdits();
+        if (edits.length === 0)
+            return null;
+        // edits are sorted ascending by lastReconciledAt, so last = most recent
+        return edits[edits.length - 1];
+    }
+    function hasSessionEdits() {
+        for (const [, entry] of tracked) {
+            if (entry.baselineHash !== undefined &&
+                entry.currentHash !== undefined &&
+                entry.currentHash !== entry.baselineHash) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Force a file to be treated as a session edit without requiring a prior baseline.
+     * Used for eventless edits where the host signals a change via transform hook
+     * but no file.edited event was emitted to establish a pre-change baseline.
+     */
+    function forceEdit(filePath, kind, timestamp) {
+        const rel = resolveToRelative(filePath);
+        let entry = tracked.get(rel);
+        if (!entry) {
+            entry = {
+                baselineHash: undefined,
+                currentHash: undefined,
+                lastReconciledAt: 0,
+                eventHints: [],
+            };
+            tracked.set(rel, entry);
+        }
+        // Set a synthetic baseline that will never match real file content
+        if (entry.baselineHash === undefined) {
+            entry.baselineHash = hashContent(`__FORCED_BASELINE__${rel}`);
+        }
+        const abs = resolveToAbsolute(rel);
+        entry.currentHash = hashFile(abs);
+        entry.lastReconciledAt = timestamp ?? now();
+        if (kind) {
+            entry.eventHints.push({ kind, timestamp: timestamp ?? now() });
+        }
+    }
+    return {
+        recordEventHint,
+        reconcilePath,
+        reconcileKnownPaths,
+        getSessionEdits,
+        getFocusEdit,
+        hasSessionEdits,
+        forceEdit,
+    };
+}

package/dist/session-fingerprint.d.ts

@@ -0,0 +1,11 @@
+export interface SessionFingerprintInput {
+    sessionId?: string | undefined;
+    branch: string;
+    worktree: string;
+}
+export interface SessionBaselineState<Cursor> {
+    fingerprint: string | null;
+    cursor: Cursor | null;
+}
+export declare function buildSessionFingerprint(input: SessionFingerprintInput): string;
+export declare function syncSessionBaselineState<Cursor>(state: SessionBaselineState<Cursor>, input: SessionFingerprintInput, captureBaseline: () => Cursor | null): SessionBaselineState<Cursor>;

package/dist/session-fingerprint.js

@@ -0,0 +1,21 @@
+export function buildSessionFingerprint(
+// implements REQ-opencode-kibi-briefing-v6
+input) {
+    return [
+        input.sessionId?.trim() || "unknown",
+        input.branch,
+        input.worktree,
+    ].join("\0");
+}
+export function syncSessionBaselineState(
+// implements REQ-opencode-kibi-briefing-v6
+state, input, captureBaseline) {
+    const fingerprint = buildSessionFingerprint(input);
+    if (state.fingerprint === fingerprint) {
+        return state;
+    }
+    return {
+        fingerprint,
+        cursor: captureBaseline(),
+    };
+}

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

@@ -1,8 +1,7 @@
 /**
  * Resolve the configured symbols manifest path using loadKbSyncPaths(worktree),
  * read the YAML synchronously, and return up to 3 deduped REQ IDs linked to
- * the edited file path. Preference is given to relationships[type=implements].target
- * (in file order) then static links as a fallback, preserving file order.
+ * the edited file path via implements relationships.
  *
  * Supports both YAML formats: top-level array and { symbols: [...] } object.
  * This function is purely synchronous and makes no runtime KB queries.

package/dist/source-linked-guidance.js

@@ -1,179 +1,16 @@
 // implements REQ-opencode-smart-enforcement-v1
-import { existsSync, readFileSync } from "node:fs";
-import * as path from "node:path";
-import { loadKbSyncPaths } from "./file-filter.js";
+import { getFileLinkedTargetsByType } from "./file-entity-links.js";
 /**
  * Resolve the configured symbols manifest path using loadKbSyncPaths(worktree),
  * read the YAML synchronously, and return up to 3 deduped REQ IDs linked to
- * the edited file path. Preference is given to relationships[type=implements].target
- * (in file order) then static links as a fallback, preserving file order.
+ * the edited file path via implements relationships.
  *
  * Supports both YAML formats: top-level array and { symbols: [...] } object.
  * This function is purely synchronous and makes no runtime KB queries.
  */
 // implements REQ-opencode-smart-enforcement-v1
 export function getSourceLinkedRequirementIds(worktree, editedAbsolutePath) {
-    try {
-        const paths = loadKbSyncPaths(worktree);
-        const symbolsPathRaw = paths.symbols;
-        if (!symbolsPathRaw)
-            return [];
-        const symbolsPath = path.isAbsolute(symbolsPathRaw)
-            ? symbolsPathRaw
-            : path.join(worktree, symbolsPathRaw);
-        if (!existsSync(symbolsPath))
-            return [];
-        const content = readFileSync(symbolsPath, "utf8");
-        const symbols = parseSymbolsYaml(content);
-        const relEdited = path
-            .relative(worktree, editedAbsolutePath)
-            .split(path.sep)
-            .join("/");
-        const matchedRows = symbols.filter((s) => s.sourceFile === relEdited);
-        if (matchedRows.length === 0)
-            return [];
-        const seen = new Set();
-        const orderedIds = [];
-        // First pass: collect implements relationships in file order
-        for (const row of matchedRows) {
-            for (const r of row.relationships ?? []) {
-                if (r.type === "implements") {
-                    const id = r.target;
-                    if (!seen.has(id)) {
-                        seen.add(id);
-                        orderedIds.push(id);
-                        if (orderedIds.length >= 3)
-                            return orderedIds.slice(0, 3);
-                    }
-                }
-            }
-        }
-        // Second pass: fall back to static links, preserving file order
-        for (const row of matchedRows) {
-            for (const l of row.links ?? []) {
-                if (!seen.has(l)) {
-                    seen.add(l);
-                    orderedIds.push(l);
-                    if (orderedIds.length >= 3)
-                        return orderedIds.slice(0, 3);
-                }
-            }
-        }
-        return orderedIds.slice(0, 3);
-    }
-    catch {
-        return [];
-    }
-}
-// ── Lightweight YAML parser (symbols.yaml subset) ────────────────────
-//
-// Handles:
-//   symbols:
-//     - id: SYM-xxx
-//       sourceFile: path/to/file
-//       links:
-//         - REQ-xxx
-//       relationships:
-//         - type: implements
-//           target: REQ-xxx
-//
-// And bare array format (no wrapping `symbols:` key):
-//     - id: SYM-xxx
-//       ...
-function parseSymbolsYaml(content) {
-    const entries = [];
-    const lines = content.split("\n");
-    let current = null;
-    let section = "none";
-    let pendingRel = null;
-    function flushRel() {
-        if (pendingRel?.type && pendingRel.target && current?.relationships) {
-            current.relationships.push({
-                type: pendingRel.type,
-                target: pendingRel.target,
-            });
-        }
-        pendingRel = null;
-    }
-    function flushEntry() {
-        flushRel();
-        if (current?.id && current?.sourceFile) {
-            entries.push(current);
-        }
-        current = null;
-        section = "none";
-    }
-    for (const raw of lines) {
-        if (raw.trim().startsWith("#"))
-            continue;
-        // New entry: "  - id: ..."
-        const entryMatch = raw.match(/^\s+-\s+id:\s*(.+)$/);
-        if (entryMatch) {
-            flushEntry();
-            const entryId = entryMatch[1];
-            if (entryId === undefined)
-                continue;
-            current = { id: entryId.trim(), links: [], relationships: [] };
-            section = "none";
-            continue;
-        }
-        if (!current)
-            continue;
-        // sourceFile
-        const srcMatch = raw.match(/^\s+sourceFile:\s*(.+)$/);
-        if (srcMatch) {
-            const sourceFile = srcMatch[1];
-            if (sourceFile === undefined)
-                continue;
-            current.sourceFile = sourceFile.trim();
-            section = "none";
-            continue;
-        }
-        // links section header
-        if (/^\s+links:\s*$/.test(raw)) {
-            flushRel();
-            section = "links";
-            continue;
-        }
-        // relationships section header
-        if (/^\s+relationships:\s*$/.test(raw)) {
-            flushRel();
-            section = "relationships";
-            continue;
-        }
-        // Link item: "      - REQ-xxx"
-        if (section === "links") {
-            const linkMatch = raw.match(/^\s+-\s+(REQ-[A-Za-z0-9_-]+)\s*$/);
-            if (linkMatch) {
-                const linkId = linkMatch[1];
-                if (linkId !== undefined && current.links) {
-                    current.links.push(linkId);
-                }
-                continue;
-            }
-        }
-        // Relationship type: "      - type: implements"
-        if (section === "relationships") {
-            const relTypeMatch = raw.match(/^\s+-\s+type:\s*(.+)$/);
-            if (relTypeMatch) {
-                flushRel();
-                const relationType = relTypeMatch[1];
-                if (relationType === undefined)
-                    continue;
-                pendingRel = { type: relationType.trim() };
-                continue;
-            }
-            // Relationship target: "        target: REQ-..."
-            const relTargetMatch = raw.match(/^\s+target:\s*(.+)$/);
-            if (relTargetMatch && pendingRel) {
-                const target = relTargetMatch[1];
-                if (target === undefined)
-                    continue;
-                pendingRel.target = target.trim();
-                continue;
-            }
-        }
-    }
-    flushEntry();
-    return entries;
+    // Delegate to the shared file-entity-links resolver with implements-only filter.
+    // implements relationships always target REQ- IDs, so no additional filtering needed.
+    return getFileLinkedTargetsByType(worktree, editedAbsolutePath, ["implements"]).slice(0, 3);
 }

package/dist/startup-notifier.js

@@ -1,4 +1,4 @@
-import { hasLegacyToast, hasShowToast, sendToast, } from "./toast.js";
+import { sendToast, } from "./toast.js";
 // implements REQ-opencode-kibi-plugin-v1
 export function notifyStartup(client, cfg) {
     const message = "kibi-opencode started";
@@ -9,39 +9,50 @@ export function notifyStartup(client, cfg) {
         duration: 4000,
     };
     if (!cfg.suppressToast) {
-        if (hasShowToast(client)) {
-            void Promise.resolve(sendToast(client, toastPayload))
-                .then((result) => void Promise.resolve(client.app.log({
-                body: {
-                    service: "kibi-opencode",
-                    level: "info",
-                    message: "startup toast result",
-                    result: String(result),
-                    ...(cfg.directory ? { directory: cfg.directory } : {}),
-                },
-            })).catch((logErr) => {
-                console.error("[kibi-opencode] startup toast result log failed:", logErr);
-            }))
-                .catch((err) => {
-                console.error("[kibi-opencode] startup toast failed:", err);
-                void Promise.resolve(client.app.log({
+        void sendToast(client, toastPayload).then((result) => {
+            const base = {
+                service: "kibi-opencode",
+                ...(cfg.directory ? { directory: cfg.directory } : {}),
+            };
+            if (result.status === "delivered") {
+                void client.app.log({
                     body: {
-                        service: "kibi-opencode",
+                        ...base,
+                        level: "info",
+                        message: "startup toast delivered",
+                        transport: result.transport,
+                    },
+                }).catch(() => {
+                    // Advisory log failure stays silent
+                });
+            }
+            else if (result.status === "unavailable") {
+                void client.app.log({
+                    body: {
+                        ...base,
+                        level: "info",
+                        message: "startup toast unavailable",
+                        reason: result.reason,
+                    },
+                }).catch(() => {
+                    // Advisory log failure stays silent
+                });
+            }
+            else if (result.status === "failed") {
+                void client.app.log({
+                    body: {
+                        ...base,
                         level: "warn",
-                        message: "startup toast failed",
-                        error: String(err),
-                        ...(cfg.directory ? { directory: cfg.directory } : {}),
+                        message: "startup toast delivery failed",
+                        transport: result.transport,
+                        reason: result.reason,
+                        ...(result.error ? { error: result.error } : {}),
                     },
-                })).catch((logErr) => {
-                    console.error("[kibi-opencode] startup toast log failed:", logErr);
+                }).catch(() => {
+                    // Advisory log failure stays silent
                 });
-            });
-        }
-        else if (hasLegacyToast(client)) {
-            void Promise.resolve(sendToast(client, toastPayload)).catch((err) => {
-                console.error("[kibi-opencode] startup toast failed:", err);
-            });
-        }
+            }
+        });
     }
     void Promise.resolve(client.app.log({
         body: {
@@ -52,6 +63,6 @@ export function notifyStartup(client, cfg) {
             ...(cfg.directory ? { directory: cfg.directory } : {}),
         },
     })).catch((err) => {
-        console.error("[kibi-opencode] startup log failed:", err);
+        // Advisory log failure stays silent
     });
 }