@herjarsa/omo-meta-governor 0.14.4 → 0.17.0

package/README.md

@@ -141,7 +141,8 @@ Enabled when `meta_governor.enabled: true` in config.
       "mode": "message",
       "minActionForMessage": "warn",
       "maxInterventionsPerSession": 3,
-      "respectDoneSignal": true
+      "respectDoneSignal": true,
+      "phaseAwareDoneSignal": true // v0.15.0: multi-phase plan support
     }
   }
 }
@@ -154,7 +155,172 @@ Enabled when `meta_governor.enabled: true` in config.
 | `mode` | `"message"` | How to inject: `"silent"`, `"message"`, or `"system"` |
 | `minActionForMessage` | `"warn"` | Minimum action: `"warn"`, `"escalate"`, or `"stop"` |
 | `maxInterventionsPerSession` | `3` | Hard cap on injections per session |
-| `respectDoneSignal` | `true` | Stop injecting after DONE + Oracle verified |
+| `respectDoneSignal` | `true` | Stop injecting after terminal signal + Oracle verified |
+| `phaseAwareDoneSignal` | `false` | **v0.15.0**: when `true`, only `<promise>PLAN-COMPLETE</promise>` latches intervention. DONE/PHASE-N-COMPLETE are per-phase hints. Recommended for multi-phase plans. |
+
+### Multi-phase plans (v0.15.0)
+
+For work plans with multiple phases (e.g. Sisyphus/Prometheus work plans),
+configure `phaseAwareDoneSignal: true` and emit `<promise>PLAN-COMPLETE</promise>`
+only when the **entire** plan is verified done by Oracle. The new markers:
+
+| Marker | Effect |
+|--------|--------|
+| `<promise>DONE</promise>` | Per-phase hint. Logged but does NOT latch intervention (when `phaseAwareDoneSignal: true`). |
+| `<promise>PHASE-N-COMPLETE</promise>` | Per-phase hint (e.g. `<promise>PHASE-1-COMPLETE</promise>`). Same as DONE — logged, does NOT latch. |
+| `<promise>PLAN-COMPLETE</promise>` | Terminal. Latches intervention when Oracle has verified. |
+
+**Migration**: existing v0.10.0–v0.14.x users keep working without changes (default
+`phaseAwareDoneSignal: false` preserves the legacy single-task behavior). Set the
+flag to `true` and switch your terminal marker to `PLAN-COMPLETE` to enable
+multi-phase governance.
+
+## v0.16.0 — Audit remediation: memory hygiene, dead code, tool coverage, CI
+
+v0.16.0 closes the 50+ findings from the multi-front audit at `.omo/ulw-research/20260727-000530/plan-audit-v0.15.0.md`. The release is **additive in behavior, no breaking API changes** for users — only internal cleanup, dead code removal, and CI hardening.
+
+### Highlights
+
+#### Memory hygiene (F1)
+
+- **`AuditStateCache`** (`src/audit-state-cache.ts`) — TTL+LRU bounded cache (100 entries, 1h TTL) replaces the bare `Map` that accumulated audit state without bounds. Stale sessions are evicted automatically.
+- **`TTLQueue`** (`src/ttl-queue.ts`) — TTL-based expiration for `pendingBotFeedback` and `pendingViolations` queues. Previously unbounded.
+- Removed dynamic `require("node:fs")` inside `shouldInjectPlanReminder` — replaced with static ESM imports (no more runtime module resolution failures).
+
+#### Dead code elimination (F2)
+
+- `takeAnyDecision()` — deprecated; removed from the active governance pipeline.
+- `systemInjection` — now awaited eagerly instead of fire-and-forget, eliminating a silent failure route.
+- `logToFile` in `graph-sync.ts` — wired to the real JSONL file logger (was a no-op stub).
+- Plugin version — derived from `package.json` at runtime instead of hardcoded "0.13.0" (closes the version-drift bug where `omo_health` reported stale versions).
+
+#### Tool bug fixes (F3)
+
+- **AFT checkpoint/undo**: args split on whitespace broke names with spaces. Rewrote arg construction with proper quoting.
+- **AFT subcommand**: now uses `options.projectDir` instead of `process.cwd()`.
+- **graphify binary override**: `omo_path` / `omo_explain` honored the `graphifyBin` option (was hardcoded).
+- **`as never` cast** on `setClient` → proper runtime guard that validates client shape.
+- **`session-bridge`**: replaced module-level `_client` with `AsyncLocalStorage` for per-request isolation. Concurrent sessions no longer race on the same client reference.
+
+#### Test coverage (F4)
+
+- 22 tests covering all 15 custom tools (`src/custom-tools.test.ts`). Previously the entire public tool surface had zero test coverage.
+- 12 tests for `decision-store` (previously untested).
+
+#### Type/token pipeline (F5)
+
+- `token-predictor` refactor: dead code (`delegate`/`switch-model`) removed; output is now informational-only as designed.
+- Type alignment across `types.ts`, `token-predictor.ts`, `orchestrator.ts`.
+
+#### CI matrix (F6)
+
+- `bun run typecheck` now runs on **macos-latest** and **windows-latest** (was Ubuntu-only).
+- Removed `package-lock.json` (bun project — canonical is `bun.lock`).
+- Secret redaction layer in `logToFile` (JWT, OpenAI keys, Bearer tokens, GitHub PATs, generic key:value patterns).
+- Implementation plan renamed `IMPLEMENTATION_PLAN.md` → `ARCHITECTURE.md`.
+
+#### Final refactors (F7)
+
+- Score formula documented (header doc with full formula spec).
+- **NaN guard** in `score()` — defaults to neutral continue when `iterationRatio` or `ambient.iteration/maxIterations` produce NaN.
+- `ACTION_SEVERITY` keyed by `DecisionHandlerOutput["action"]` union literal (was bare `Record<string, number>`).
+- `projectHasCodegraph` / `projectHasGraphify` IIFE booleans replaced with lookup-time calls to `graphRetrieval.hasCodegraphDir(cwd)`.
+- `extractConcepts` includes file basename for FTS lookup by tool/file name.
+- Backup graph-sync uses `triggerReindex` (was `triggerCodegraphSync`) — reindexes both codegraph AND graphify backends.
+
+### Test & build status
+
+- **495/495 tests pass** (up from 487 in v0.15.0/0.15.1).
+- `bun run typecheck` clean.
+- `bun build.ts` clean (0.34 MB dist).
+- `npm pack --dry-run` validated (no forbidden artifacts).
+
+### Migration
+
+No user action required. All changes are internal. The default `phaseAwareDoneSignal` is still `false` for backward compatibility; the v0.15.0 multi-phase behavior is preserved when explicitly enabled.
+
+### Deferred to v0.17.0
+
+- F5.1 — wiring `escalate` action to a real dispatcher (Oracle is recommended but not yet wired).
+- F5.4 — `maxLessonsPerSession` enforcement (config field exists but is not enforced).
+- F3.6 — Bridge tools lying about delivery (5 tools still return "dispatched" without polling). Recommend the user explicitly request this if delivery verification is critical.
+
+
+
+
+## v0.17.0 — Wire escalate to Oracle, enforce lesson cap, verify bridge delivery
+
+v0.17.0 closes the 3 deferred items from the v0.16.0 audit: **F5.1** (escalate → Oracle), **F5.4** (`maxLessonsPerSession` enforcement), and **F3.6** (bridge tool delivery verification).
+
+### Highlights
+
+#### F5.1 — Escalate action now fires Oracle (v0.17.0)
+
+When the scoring engine produces an `escalate` action with target `oracle`, the plugin's `tool.execute.after` hook now fires a `session.prompt()` instructing the LLM to invoke `task(subagent_type=oracle)`. The prompt includes the decision reasoning, evidence count, and a verification pass directive. New `buildEscalationPrompt()` function in `session-bridge.ts` is the pure prompt builder (testable in isolation). User-targeted escalations get a separate prompt asking the LLM to summarize for human input.
+
+```ts
+// Decision flow when score lands in escalate band:
+score ≤ -escalateThreshold (default -0.6)
+  → decision.action = "escalate"
+  → decision.shouldEscalateTo = "oracle" (or "user" for grave deviations)
+  → plugin fires session.prompt with buildEscalationPrompt(...)
+  → LLM invokes Oracle (or summarizes for user)
+  → Oracle verifies → oracleInvoked=true → governance continues
+```
+
+#### F5.4 — `maxLessonsPerSession` is now enforced
+
+The cap (default 20) was a config field that was never enforced. v0.17.0 adds:
+- `currentLessonCount` on `LearnFromOutcomeInput` and `MetaGovernorInput`
+- `lessonCount` tracked in per-session `AuditState`
+- `observeAndLearn()` short-circuits when `currentLessonCount >= maxLessonsPerSession`
+- The orchestrator increments `sessionState.lessonCount` after each successful save
+- **Cap semantics: inclusive** — when count equals cap, no more lessons are saved
+
+#### F3.6 — Bridge tool delivery verification
+
+The 5 bridge tools (`omo_remember`, `omo_recall_mcp`, `omo_rule`, `omo_history`, `omo_note`) previously returned "dispatched" after the `session.prompt()` was queued — without verifying the LLM actually called the MCP tool. v0.17.0 adds:
+
+- **New `PendingDeliveryRegistry` module** (`src/delivery-registry.ts`) — tracks pending dispatches per session with TTL-based cleanup.
+- **`tool.execute.after` hook** marks deliveries when a matching MCP tool call is observed.
+- **All 5 bridge tools** now report `deliveryStatus: "delivered" | "pending"` in their tool result and metadata, and briefly poll (1.5s) for fast deliveries.
+- When the LLM follows the prompt, the tool returns immediately with `"delivered"`. When it doesn't, the tool returns `"pending"` and the entry expires silently after 10s.
+
+```ts
+// Bridge tool result metadata now includes:
+{
+  tool: "omo_remember",
+  ok: true,
+  deliveryStatus: "delivered" | "pending",
+  messageID: "...",
+  durationMs: 1234,
+  contentLength: 256
+}
+```
+
+### Test & build status
+
+- **514/514 tests pass** (up from 495 in v0.16.0 — 5 + 4 + 10 new tests across F5.4, F5.1, F3.6).
+- `bun run typecheck` clean.
+- `bun build.ts` clean (0.34 MB dist).
+- `npm pack --dry-run` validated.
+
+### Migration
+
+No user action required. All changes are internal or additive:
+- `deliveryStatus` is an additive metadata field — existing consumers ignore it.
+- `maxLessonsPerSession` is now actually enforced — if you have sessions that previously saved more than 20 lessons (e.g. from before the cap was added), this may surprise you. Bump the cap in your config if needed.
+- `escalate` action now actively fires Oracle — this is the first version where Oracle is auto-invoked, not just manually invoked by the LLM.
+
+### Audit roadmap (status as of v0.17.0)
+
+| Release | Status | Scope |
+|---------|--------|-------|
+| v0.15.1 (F0) | ✅ Shipped | Hotfix self-dep + npm pack gate |
+| v0.16.0 (F1-F7) | ✅ Shipped | Memory hygiene, dead code, tool coverage, CI |
+| v0.17.0 (deferred) | ✅ Shipped | F5.1 escalate, F5.4 cap, F3.6 delivery verify |
+
+All audit findings are now closed. Future work focuses on new features and user-driven feedback.
 
 ## Auto-upgrade (v0.12.0)
 

package/dist/audit-state-cache.d.ts

@@ -0,0 +1,43 @@
+/**
+ * TTL-based + LRU-bounded cache for per-session audit state.
+ *
+ * v0.15.0: closed the C1/H16 audit findings — `auditSessions` was an
+ * unbounded Map that grew indefinitely. Replaced with a class that
+ *
+ *  1. Caps total entries (default 100, configurable).
+ *  2. Evicts the least-recently-accessed entry when the cap is hit.
+ *  3. TTLs each entry (default 1 hour, configurable). On read, expired
+ *     entries are dropped.
+ *
+ * The cache is intentionally synchronous (Map-backed) — the audit
+ * state mutations happen on the plugin's main thread between hooks
+ * and are not shared across the event loop, so no locking is needed.
+ *
+ * v0.16.0 also documents: Bun's runtime is single-threaded, so a read
+ * followed by an `await` cannot be interrupted by another write. This
+ * means we do NOT need per-session mutex for the audit state. See
+ * plugin.ts `// v0.16.0 concurrency model` comment block.
+ */
+export interface AuditStateCacheConfig {
+    /** Max number of entries. Default 100. */
+    readonly maxEntries?: number;
+    /** Time-to-live per entry in milliseconds. Default 3_600_000 (1h). */
+    readonly ttlMs?: number;
+    /** Optional clock injection for testing. Returns ms since epoch. */
+    readonly now?: () => number;
+}
+export declare class AuditStateCache<V> {
+    private readonly store;
+    private readonly maxEntries;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(config?: AuditStateCacheConfig);
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    set(key: string, value: V): void;
+    delete(key: string): boolean;
+    size(): number;
+    clear(): void;
+    /** Evict the entry with the oldest lastAccessAtMs. No-op if empty. */
+    private evictOldest;
+}

package/dist/config.d.ts

@@ -51,6 +51,8 @@ export interface MetaGovernorPluginConfig {
         maxInterventionsPerSession?: number;
         /** v0.10.0: stop injecting after <promise>DONE</promise> + Oracle verified. */
         respectDoneSignal?: boolean;
+        /** v0.15.0: split per-phase hint from terminal signal. See types.ts. */
+        phaseAwareDoneSignal?: boolean;
     };
     /** Sisyphus protocol enforcement config. */
     protocolEnforcement?: {

package/dist/custom-tools.d.ts

@@ -23,6 +23,29 @@ import type { SqliteBackend } from "./sqlite-backend";
 import type { GraphRetrieval } from "./graph-retrieval";
 import type { MetricsCollector } from "./metrics";
 import { type CodeGraphTools } from "./codegraph-tools";
+/**
+ * Module-level reference to the PendingDeliveryRegistry. The plugin
+ * factory sets this once at startup. Bridge tools call it via
+ * onDispatch and pollForDelivery.
+ */
+declare let pendingRegistryRef: {
+    register(input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+        ttlMs?: number;
+    }): string;
+    awaitDelivery(input: {
+        sessionID: string;
+        mcpTool: string;
+        timeoutMs?: number;
+    }): Promise<"delivered" | "expired">;
+} | null;
+/**
+ * Called by the plugin factory at startup to inject the delivery registry.
+ * Exposed as a setter so we don't need to thread it through every tool deps.
+ */
+export declare function setPendingDeliveryRegistry(registry: typeof pendingRegistryRef): void;
 export interface OmoSearchDeps {
     graphRetrieval: GraphRetrieval;
     cwd: string;
@@ -111,6 +134,14 @@ export declare function buildOmoImpactTool(deps: OmoImpactDeps): {
     }, context: ToolContext): Promise<ToolResult>;
 };
 export interface OmoRememberDeps {
+    /** Optional callback invoked after a successful prompt dispatch.
+     *  Used by the plugin to register the pending delivery in the registry
+     *  so the bridge tool can verify the LLM actually called the MCP tool. */
+    onDispatch?: (input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+    }) => void;
 }
 /**
  * Build the `omo_remember` tool. Persists a fact/observation/lesson to
@@ -122,18 +153,26 @@ export declare function buildOmoRememberTool(deps: OmoRememberDeps): {
         content: import("zod").ZodString;
         concepts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
         type: import("zod").ZodOptional<import("zod").ZodEnum<{
-            pattern: "pattern";
             fact: "fact";
             observation: "observation";
+            pattern: "pattern";
         }>>;
     };
     execute(args: {
         content: string;
         concepts?: string[] | undefined;
-        type?: "pattern" | "fact" | "observation" | undefined;
+        type?: "fact" | "observation" | "pattern" | undefined;
     }, context: ToolContext): Promise<ToolResult>;
 };
 export interface OmoRecallMcpDeps {
+    /** Optional callback invoked after a successful prompt dispatch.
+     *  Used by the plugin to register the pending delivery in the registry
+     *  so the bridge tool can verify the LLM actually called the MCP tool. */
+    onDispatch?: (input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+    }) => void;
 }
 /**
  * Build the `omo_recall_mcp` tool. Searches AgentMemory by sending a
@@ -155,6 +194,14 @@ export declare function buildOmoRecallMcpTool(deps: OmoRecallMcpDeps): {
     }, context: ToolContext): Promise<ToolResult>;
 };
 export interface OmoRuleDeps {
+    /** Optional callback invoked after a successful prompt dispatch.
+     *  Used by the plugin to register the pending delivery in the registry
+     *  so the bridge tool can verify the LLM actually called the MCP tool. */
+    onDispatch?: (input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+    }) => void;
 }
 /**
  * Build the `omo_rule` tool. Saves a durable rule to Magic Context that
@@ -165,20 +212,28 @@ export declare function buildOmoRuleTool(deps: OmoRuleDeps): {
     description: string;
     args: {
         category: import("zod").ZodEnum<{
-            PROJECT_RULES: "PROJECT_RULES";
             ARCHITECTURE: "ARCHITECTURE";
-            CONSTRAINTS: "CONSTRAINTS";
             CONFIG_VALUES: "CONFIG_VALUES";
+            CONSTRAINTS: "CONSTRAINTS";
             NAMING: "NAMING";
+            PROJECT_RULES: "PROJECT_RULES";
         }>;
         content: import("zod").ZodString;
     };
     execute(args: {
-        category: "PROJECT_RULES" | "ARCHITECTURE" | "CONSTRAINTS" | "CONFIG_VALUES" | "NAMING";
+        category: "ARCHITECTURE" | "CONFIG_VALUES" | "CONSTRAINTS" | "NAMING" | "PROJECT_RULES";
         content: string;
     }, context: ToolContext): Promise<ToolResult>;
 };
 export interface OmoHistoryDeps {
+    /** Optional callback invoked after a successful prompt dispatch.
+     *  Used by the plugin to register the pending delivery in the registry
+     *  so the bridge tool can verify the LLM actually called the MCP tool. */
+    onDispatch?: (input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+    }) => void;
 }
 /**
  * Build the `omo_history` tool. Searches git commit history and prior
@@ -189,16 +244,24 @@ export declare function buildOmoHistoryTool(deps: OmoHistoryDeps): {
     args: {
         query: import("zod").ZodString;
         sources: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-            message: "message";
             git_commit: "git_commit";
+            message: "message";
         }>>>;
     };
     execute(args: {
         query: string;
-        sources?: ("message" | "git_commit")[] | undefined;
+        sources?: ("git_commit" | "message")[] | undefined;
     }, context: ToolContext): Promise<ToolResult>;
 };
 export interface OmoNoteDeps {
+    /** Optional callback invoked after a successful prompt dispatch.
+     *  Used by the plugin to register the pending delivery in the registry
+     *  so the bridge tool can verify the LLM actually called the MCP tool. */
+    onDispatch?: (input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+    }) => void;
 }
 /**
  * Build the `omo_note` tool. Writes a session-scoped working note via
@@ -266,8 +329,7 @@ export declare function buildOmoOutlineTool(deps: OmoOutlineDeps): {
         target: string;
     }, context: ToolContext): Promise<ToolResult>;
 };
-export interface OmoCheckpointDeps {
-}
+export type OmoCheckpointDeps = Record<string, never>;
 /**
  * Build the `omo_checkpoint` tool. Creates a named AFT checkpoint so the
  * user can revert to a known good state. Uses `aft safety checkpoint --name <name>`.
@@ -281,8 +343,7 @@ export declare function buildOmoCheckpointTool(_deps: OmoCheckpointDeps): {
         name: string;
     }, context: ToolContext): Promise<ToolResult>;
 };
-export interface OmoUndoDeps {
-}
+export type OmoUndoDeps = Record<string, never>;
 /**
  * Build the `omo_undo` tool. Reverts tracked files to the most recent AFT
  * checkpoint. Uses `aft safety undo`.
@@ -292,3 +353,4 @@ export declare function buildOmoUndoTool(_deps: OmoUndoDeps): {
     args: {};
     execute(args: Record<string, never>, context: ToolContext): Promise<ToolResult>;
 };
+export {};

package/dist/decision-store.d.ts

@@ -25,9 +25,10 @@ export declare function takeDecision(sessionID: string): DecisionHandlerOutput |
  */
 export declare function hasDecision(sessionID: string): boolean;
 /**
- * Take any pending decision across all sessions.
- * Useful for hooks that do not receive a sessionID.
- * Returns the first pending decision found, or undefined if none.
+ * @deprecated v0.16.0: this function can leak decisions across sessions.
+ * Use takeDecision(sessionID) instead — the messages.transform hook now
+ * derives the sessionID from the last outgoing message (see plugin.ts).
+ * Will be removed in v0.18.0.
  */
 export declare function takeAnyDecision(): DecisionHandlerOutput | undefined;
 /**

package/dist/delivery-registry.d.ts

@@ -0,0 +1,83 @@
+/**
+ * v0.17.0 (F3.6): PendingDeliveryRegistry — track bridge tool dispatches
+ * and verify they were actually delivered by the LLM via the matching
+ * MCP tool call in `tool.execute.after`.
+ *
+ * Why this exists (v0.14.0 pivot):
+ * session-bridge uses `session.prompt()` to instruct the LLM to call an
+ * MCP tool (e.g. agentmemory_memory_save). The LLM may or may not follow
+ * the instruction. Previously, the bridge tool returned "dispatched" on
+ * `session.prompt()` success — but that just means the prompt was queued,
+ * not that the MCP tool was actually called. This registry gives us a
+ * way to verify delivery within a short window.
+ *
+ * Design:
+ * - Per-session pending entries (Map) — small, bounded, TTL-cleaned.
+ * - `register()` when a bridge tool dispatches a prompt.
+ * - `markDelivered()` when tool.execute.after sees a matching tool call.
+ * - `awaitDelivery()` is a brief async poll (~2-3s) used by bridge tools
+ *   to surface fast deliveries. Slow deliveries are still tracked.
+ */
+export interface PendingDelivery {
+    /** Unique id (randomUUID) so callers can correlate. */
+    readonly id: string;
+    readonly sessionID: string;
+    /** The MCP tool the bridge instructed the LLM to call. */
+    readonly mcpTool: string;
+    /** Hash of mcpArgs to match the eventual tool call. */
+    readonly mcpArgsHash: string;
+    /** When registered (ms since epoch). */
+    readonly registeredAt: number;
+    /** TTL in ms — after this, the entry is considered expired. */
+    readonly ttlMs: number;
+}
+export type DeliveryStatus = "pending" | "delivered" | "expired";
+export declare class PendingDeliveryRegistry {
+    private readonly entries;
+    /** When mcpArgs match is disabled (no mcpArgs available on observed call) */
+    private deliveredCount;
+    private expiredCount;
+    /**
+     * Register a pending delivery. Returns a random id for correlation.
+     */
+    register(input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs: Record<string, unknown>;
+        ttlMs?: number;
+    }): string;
+    /**
+     * Mark a pending delivery as delivered. Returns the matching id if
+     * found, or null if no pending entry matches.
+     */
+    markDelivered(input: {
+        sessionID: string;
+        mcpTool: string;
+        mcpArgs?: unknown;
+    }): string | null;
+    /**
+     * Brief async poll: wait for the matching delivery, up to `timeoutMs`.
+     * Resolves with the status when the delivery is verified or expires.
+     */
+    awaitDelivery(input: {
+        sessionID: string;
+        mcpTool: string;
+        timeoutMs?: number;
+    }): Promise<DeliveryStatus>;
+    /**
+     * Return current stats: pending + cumulative delivered + cumulative expired.
+     */
+    getStats(): {
+        pending: number;
+        delivered: number;
+        expired: number;
+    };
+    /**
+     * Clear all entries for a session. Useful on session end.
+     */
+    clearSession(sessionID: string): void;
+    /**
+     * Remove expired entries. Called internally on register/mark/await.
+     */
+    private cleanup;
+}

package/dist/graph-retrieval.d.ts

@@ -50,6 +50,8 @@ export interface InvokeOptions {
     graphifyBin?: string;
     /** Override timeout for this call. */
     timeoutMs?: number;
+    /** v0.16.0: project working directory. Defaults to process.cwd(). */
+    projectDir?: string;
 }
 /** Deterministic hash for a query string. Used as cache key suffix. */
 export declare function hashQuery(query: string): string;

package/dist/graph-sync.d.ts

@@ -129,6 +129,8 @@ export declare function isGraphifyHookInstalled(projectDir: string): Promise<boo
  * Best-effort: never throws, returns a structured result.
  */
 export declare function triggerCodegraphSync(projectDir: string): Promise<GraphSyncResult>;
+import type { LogLevel } from "./file-logger";
+export declare function logToFile(level: LogLevel, msg: string): Promise<void>;
 /**
  * Compare two semver strings. Returns true if `latest` is strictly greater
  * than `installed`. Handles X.Y.Z with optional pre-release suffix (-rc.1,