Consolidate duplicate patterns and simplify codebase (#1317)

* refactor(shared): unify binary downloader and session path storage

- Create binary-downloader.ts for common download/extract logic
- Create session-injected-paths.ts for unified path tracking
- Refactor comment-checker, ast-grep, grep downloaders to use shared util
- Consolidate directory injector types into shared module

* feat(shared): implement unified model resolution pipeline

- Create ModelResolutionPipeline for centralized model selection
- Refactor model-resolver to use pipeline
- Update delegate-task and config-handler to use unified logic
- Ensure consistent model resolution across all agent types

* refactor(agents): simplify agent utils and metadata management

- Extract helper functions for config merging and env context
- Register prompt metadata for all agents
- Simplify agent variant detection logic

* cleanup: inline utilities and remove unused exports

- Remove case-insensitive.ts (inline with native JS)
- Simplify opencode-version helpers
- Remove unused getModelLimit, createCompactionContextInjector exports
- Inline transcript entry creation in claude-code-hooks
- Update tests accordingly

---------

Co-authored-by: justsisyphus <justsisyphus@users.noreply.github.com>

src/shared/session-injected-paths.ts

@@ -0,0 +1,59 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+export interface InjectedPathsData {
+  sessionID: string;
+  injectedPaths: string[];
+  updatedAt: number;
+}
+
+export function createInjectedPathsStorage(storageDir: string) {
+  const getStoragePath = (sessionID: string): string =>
+    join(storageDir, `${sessionID}.json`);
+
+  const loadInjectedPaths = (sessionID: string): Set<string> => {
+    const filePath = getStoragePath(sessionID);
+    if (!existsSync(filePath)) return new Set();
+
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const data: InjectedPathsData = JSON.parse(content);
+      return new Set(data.injectedPaths);
+    } catch {
+      return new Set();
+    }
+  };
+
+  const saveInjectedPaths = (sessionID: string, paths: Set<string>): void => {
+    if (!existsSync(storageDir)) {
+      mkdirSync(storageDir, { recursive: true });
+    }
+
+    const data: InjectedPathsData = {
+      sessionID,
+      injectedPaths: [...paths],
+      updatedAt: Date.now(),
+    };
+
+    writeFileSync(getStoragePath(sessionID), JSON.stringify(data, null, 2));
+  };
+
+  const clearInjectedPaths = (sessionID: string): void => {
+    const filePath = getStoragePath(sessionID);
+    if (existsSync(filePath)) {
+      unlinkSync(filePath);
+    }
+  };
+
+  return {
+    loadInjectedPaths,
+    saveInjectedPaths,
+    clearInjectedPaths,
+  };
+}