oh-my-opencode 4.2.1 → 4.2.3

package/dist/features/background-agent/parent-wake-notifier.d.ts

@@ -63,7 +63,7 @@ export declare class ParentWakeNotifier {
     private getParentWakeMessageFinish;
     private getParentWakeMessageCreatedAt;
     private parentWakePartIsWaitingOnTool;
-    private latestAssistantTurnIsWaitingOnTools;
+    private latestAssistantToolWaitState;
     private parentWakeMessageHasOutput;
     private parentWakeMessageContainsNotification;
     private isUserMessageInProgress;

package/dist/hooks/comment-checker/apply-patch-edits.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchEdit } from "./cli-runner";
+export declare function extractApplyPatchEdits(details: unknown, args?: Record<string, unknown>): ApplyPatchEdit[];

package/dist/hooks/comment-checker/hook.d.ts

@@ -11,6 +11,7 @@ export declare function createCommentCheckerHooks(config?: CommentCheckerConfig)
         tool: string;
         sessionID: string;
         callID: string;
+        args?: Record<string, unknown>;
     }, output: {
         title: string;
         output: string;

package/dist/hooks/comment-checker/initialization-gate.d.ts

@@ -1 +1,2 @@
 export declare function ensureCommentCheckerInitialization(initializer: () => void): void;
+export declare function _resetCommentCheckerInitializationForTesting(): void;

package/dist/hooks/directory-agents-injector/finder.d.ts

@@ -1,5 +1,7 @@
+import type { AgentsMdCache } from "@oh-my-opencode/rules-core";
 export declare function resolveFilePath(rootDirectory: string, path: string): string | null;
 export declare function findAgentsMdUp(input: {
-    startDir: string;
-    rootDir: string;
+    readonly startDir: string;
+    readonly rootDir: string;
+    readonly cache?: AgentsMdCache;
 }): Promise<string[]>;

package/dist/hooks/directory-agents-injector/injector.d.ts

@@ -1,10 +1,12 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { AgentsMdCache } from "@oh-my-opencode/rules-core";
 import type { createDynamicTruncator } from "../../shared/dynamic-truncator";
 type DynamicTruncator = ReturnType<typeof createDynamicTruncator>;
 export declare function processFilePathForAgentsInjection(input: {
     ctx: PluginInput;
     truncator: DynamicTruncator;
     sessionCaches: Map<string, Set<string>>;
+    agentsMdCache?: AgentsMdCache;
     filePath: string;
     sessionID: string;
     output: {

package/dist/hooks/rules-injector/injector.d.ts

@@ -1,10 +1,10 @@
 import { statSync } from "node:fs";
 import { homedir } from "node:os";
-import type { FindRuleFilesOptions } from "./rule-file-finder";
-import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
-import { saveInjectedRules } from "./storage";
 import type { SessionInjectedRulesCache } from "./cache";
+import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
+import type { FindRuleFilesOptions } from "./rule-file-finder";
 import type { RuleScanCache } from "./rule-scan-cache";
+import { saveInjectedRules } from "./storage";
 type ToolExecuteOutput = {
     title: string;
     output: string;
@@ -23,6 +23,9 @@ export interface ParsedRuleCacheStats {
 }
 export declare function clearParsedRuleCache(): void;
 export declare function getParsedRuleCacheStats(): ParsedRuleCacheStats;
+export interface TranscriptHydrationHook {
+    hydrateSession(sessionID: string): Promise<ReadonlySet<string>>;
+}
 export declare function createRuleInjectionProcessor(deps: {
     workspaceDirectory: string;
     truncator: DynamicTruncator;
@@ -37,6 +40,7 @@ export declare function createRuleInjectionProcessor(deps: {
     createContentHash?: typeof createContentHash;
     isDuplicateByContentHash?: typeof isDuplicateByContentHash;
     saveInjectedRules?: typeof saveInjectedRules;
+    transcriptHydration?: TranscriptHydrationHook;
 }): {
     processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
 };

package/dist/hooks/rules-injector/matcher.d.ts

@@ -1,26 +1,5 @@
-import type { RuleMetadata } from "./types";
-export interface MatchResult {
-    applies: boolean;
-    reason?: string;
-}
+export { createContentHash, getMatcherCacheStats, isDuplicateByContentHash, isDuplicateByRealPath, resetMatcherCache, shouldApplyRule, } from "@oh-my-opencode/rules-core";
+export type { MatchResult } from "@oh-my-opencode/rules-core";
 export interface MatcherCacheStats {
-    entries: number;
+    readonly entries: number;
 }
-export declare function resetMatcherCache(): void;
-export declare function getMatcherCacheStats(): MatcherCacheStats;
-/**
- * Check if a rule should apply to the current file based on metadata
- */
-export declare function shouldApplyRule(metadata: RuleMetadata, currentFilePath: string, projectRoot: string | null): MatchResult;
-/**
- * Check if realPath already exists in cache (symlink deduplication)
- */
-export declare function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean;
-/**
- * Create SHA-256 hash of content, truncated to 16 chars
- */
-export declare function createContentHash(content: string): string;
-/**
- * Check if content hash already exists in cache
- */
-export declare function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean;

package/dist/hooks/rules-injector/parser.d.ts

@@ -1,18 +1,2 @@
-import type { RuleMetadata } from "./types";
-export interface RuleFrontmatterResult {
-    metadata: RuleMetadata;
-    body: string;
-}
-/**
- * Parse YAML frontmatter from rule file content
- * Supports:
- * - Single string: globs: "**\/*.py"
- * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
- * - Multi-line array:
- *   globs:
- *     - "**\/*.py"
- *     - "src/**\/*.ts"
- * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
- * - Claude Code 'paths' field (alias for globs)
- */
-export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;
+export { parseRuleFrontmatter } from "@oh-my-opencode/rules-core";
+export type { RuleFrontmatterResult } from "@oh-my-opencode/rules-core";

package/dist/hooks/rules-injector/project-root-finder.d.ts

@@ -1,13 +1 @@
-export declare function clearProjectRootCache(): void;
-/**
- * Find project root by walking up from startPath.
- * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)
- *
- * Memoizes every directory visited during the walk so subsequent lookups for
- * any descendant path resolve in O(1) without re-running marker existsSync
- * probes.
- *
- * @param startPath - Starting path to search from (file or directory)
- * @returns Project root path or null if not found
- */
-export declare function findProjectRoot(startPath: string): string | null;
+export { clearProjectRootCache, findProjectRoot } from "@oh-my-opencode/rules-core";

package/dist/hooks/rules-injector/rule-distance.d.ts

@@ -1,10 +1 @@
-/**
- * Calculate directory distance between a rule file and current file.
- * Distance is based on common ancestor within project root.
- *
- * @param rulePath - Path to the rule file
- * @param currentFile - Path to the current file being edited
- * @param projectRoot - Project root for relative path calculation
- * @returns Distance (0 = same directory, higher = further)
- */
-export declare function calculateDistance(rulePath: string, currentFile: string, projectRoot: string | null): number;
+export { calculateDistance } from "@oh-my-opencode/rules-core";

package/dist/hooks/rules-injector/rule-file-finder.d.ts

@@ -1,6 +1,2 @@
-import type { RuleScanCache } from "./rule-scan-cache";
-import type { RuleFileCandidate } from "./types";
-export interface FindRuleFilesOptions {
-    skipClaudeUserRules?: boolean;
-}
-export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string, options?: FindRuleFilesOptions, cache?: RuleScanCache): RuleFileCandidate[];
+export { findRuleFiles } from "@oh-my-opencode/rules-core";
+export type { FindRuleFilesOptions } from "@oh-my-opencode/rules-core";

package/dist/hooks/rules-injector/rule-file-scanner.d.ts

@@ -1,14 +1,3 @@
-/**
- * Recursively find all rule files (*.md, *.mdc) in a directory
- *
- * @param dir - Directory to search
- * @param results - Array to accumulate results
- */
+import { safeRealpathSync } from "@oh-my-opencode/rules-core";
+export { safeRealpathSync };
 export declare function findRuleFilesRecursive(dir: string, results: string[]): void;
-/**
- * Resolve symlinks safely with fallback to original path
- *
- * @param filePath - Path to resolve
- * @returns Real path or original path if resolution fails
- */
-export declare function safeRealpathSync(filePath: string): string;

package/dist/hooks/rules-injector/rule-scan-cache.d.ts

@@ -1,13 +1,2 @@
-import type { RuleFileCandidate } from "./types";
-export type DirectoryScanEntry = {
-    path: string;
-    realPath: string;
-};
-export type RuleScanCache = {
-    get: (key: string) => RuleFileCandidate[] | undefined;
-    set: (key: string, value: RuleFileCandidate[]) => void;
-    getDirScan: (dir: string) => DirectoryScanEntry[] | undefined;
-    setDirScan: (dir: string, entries: DirectoryScanEntry[]) => void;
-    clear: () => void;
-};
-export declare function createRuleScanCache(): RuleScanCache;
+export { createRuleScanCache } from "@oh-my-opencode/rules-core";
+export type { DirectoryScanEntry, RuleScanCache } from "@oh-my-opencode/rules-core";

package/dist/hooks/rules-injector/transcript-hydration.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface TranscriptHydrationDeps {
+    readonly client: PluginInput["client"];
+}
+export interface TranscriptHydrationStore {
+    hydrateSession(sessionID: string): Promise<ReadonlySet<string>>;
+    getHydratedRelativePaths(sessionID: string): ReadonlySet<string>;
+    clearSession(sessionID: string): void;
+}
+/**
+ * Builds an in-memory store keyed by sessionID that lazily scans the session
+ * transcript for `[Rule: <relativePath>]` markers and exposes the set of
+ * already-injected rule relative paths. The store is consulted by the
+ * injector before emitting a rule so a process that lost its persisted cache
+ * file but whose model context still contains prior `[Rule: ...]` markers
+ * does not re-inject duplicates.
+ */
+export declare function createTranscriptHydrationStore(deps: TranscriptHydrationDeps): TranscriptHydrationStore;

package/dist/hooks/rules-injector/types.d.ts

@@ -1,54 +1,18 @@
-/**
- * Rule file metadata (Claude Code style frontmatter)
- * Supports both Claude Code format (globs, paths) and GitHub Copilot format (applyTo)
- * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
- * @see https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
- */
-export interface RuleMetadata {
-    description?: string;
-    globs?: string | string[];
-    alwaysApply?: boolean;
-}
-/**
- * Rule information with path context and content
- */
+import type { RuleFileCandidate, RuleMetadata } from "@oh-my-opencode/rules-core";
+export type { RuleFileCandidate, RuleMetadata };
 export interface RuleInfo {
-    /** Absolute path to the rule file */
     path: string;
-    /** Path relative to project root */
     relativePath: string;
-    /** Directory distance from target file (0 = same dir) */
     distance: number;
-    /** Rule file content (without frontmatter) */
     content: string;
-    /** SHA-256 hash of content for deduplication */
     contentHash: string;
-    /** Parsed frontmatter metadata */
     metadata: RuleMetadata;
-    /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
     matchReason: string;
-    /** Real path after symlink resolution (for duplicate detection) */
     realPath: string;
 }
-/**
- * Rule file candidate with discovery context
- */
-export interface RuleFileCandidate {
-    path: string;
-    realPath: string;
-    isGlobal: boolean;
-    distance: number;
-    /** Single-file rules (e.g., .github/copilot-instructions.md) always apply without frontmatter */
-    isSingleFile?: boolean;
-}
-/**
- * Session storage for injected rules tracking
- */
 export interface InjectedRulesData {
     sessionID: string;
-    /** Content hashes of already injected rules */
     injectedHashes: string[];
-    /** Real paths of already injected rules (for symlink deduplication) */
     injectedRealPaths: string[];
     updatedAt: number;
 }

package/dist/hooks/runtime-fallback/types.d.ts

@@ -61,6 +61,7 @@ export interface FallbackState {
     failedModels: Map<string, number>;
     attemptCount: number;
     pendingFallbackModel?: string;
+    pendingFallbackPromptMayHaveBeenAccepted?: boolean;
 }
 export interface FallbackResult {
     success: boolean;

package/dist/hooks/team-session-events/team-member-error-handler.d.ts

@@ -6,5 +6,18 @@ type HookInput = {
     };
 };
 export type HookImpl = (input: HookInput) => Promise<void>;
-export declare function createTeamMemberErrorHandler(config: TeamModeConfig): HookImpl;
+type TeamMemberErrorHandlerDeps = {
+    client?: {
+        session?: {
+            status?: () => Promise<unknown>;
+            messages?: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    settleMs?: number;
+};
+export declare function createTeamMemberErrorHandler(config: TeamModeConfig, deps?: TeamMemberErrorHandlerDeps): HookImpl;
 export {};

package/dist/hooks/unstable-agent-babysitter/unstable-agent-babysitter-hook.d.ts

@@ -13,27 +13,6 @@ type BabysitterContext = {
             }) => Promise<{
                 data?: unknown;
             } | unknown[]>;
-            prompt: (args: {
-                path: {
-                    id: string;
-                };
-                body: {
-                    parts: Array<{
-                        type: "text";
-                        text: string;
-                    }>;
-                    agent?: string;
-                    variant?: string;
-                    model?: {
-                        providerID: string;
-                        modelID: string;
-                    };
-                    tools?: Record<string, boolean>;
-                };
-                query?: {
-                    directory?: string;
-                };
-            }) => Promise<unknown>;
             promptAsync: (args: {
                 path: {
                     id: string;