volute 0.30.1 → 0.32.0

package/templates/_base/.init/.local/hooks/pre-prompt/session-activity.ts

@@ -0,0 +1,40 @@
+// Cross-session activity — shows what happened in other sessions since last check.
+// Uses the daemon history API. Customize or remove this hook as you like.
+
+const input = await new Promise<string>((resolve) => {
+  let data = "";
+  process.stdin.on("data", (chunk) => {
+    data += chunk;
+  });
+  process.stdin.on("end", () => resolve(data));
+});
+
+const { VOLUTE_DAEMON_PORT, VOLUTE_DAEMON_TOKEN, VOLUTE_MIND } = process.env;
+if (!VOLUTE_DAEMON_PORT || !VOLUTE_DAEMON_TOKEN || !VOLUTE_MIND) {
+  console.log("{}");
+  process.exit(0);
+}
+
+let session = "";
+try {
+  session = JSON.parse(input).session ?? "";
+} catch {}
+
+try {
+  const res = await fetch(
+    `http://127.0.0.1:${VOLUTE_DAEMON_PORT}/api/minds/${VOLUTE_MIND}/history/cross-session?session=${encodeURIComponent(session)}`,
+    { headers: { Authorization: `Bearer ${VOLUTE_DAEMON_TOKEN}` } },
+  );
+  if (!res.ok) {
+    console.log("{}");
+    process.exit(0);
+  }
+  const { context } = (await res.json()) as { context: string | null };
+  if (context) {
+    console.log(JSON.stringify({ additionalContext: context }));
+  } else {
+    console.log("{}");
+  }
+} catch {
+  console.log("{}");
+}

package/templates/_base/.init/.local/hooks/startup-context.ts

@@ -0,0 +1,58 @@
+// Startup context hook — generates orientation context for new sessions.
+// Edit this script to customize what you see when your session starts.
+// Input: JSON on stdin with { "source": "startup" | "SessionStart" }
+// Output: JSON with hookSpecificOutput.additionalContext (for SessionStart hook)
+//         or plain text (for direct execution by pi template)
+
+import { readdirSync } from "node:fs";
+
+const input = await new Promise<string>((resolve) => {
+  let data = "";
+  process.stdin.on("data", (chunk: Buffer) => {
+    data += chunk;
+  });
+  process.stdin.on("end", () => resolve(data));
+});
+
+let source = "startup";
+try {
+  source = JSON.parse(input).source ?? "startup";
+} catch {}
+
+const parts: string[] = [`Session ${source} at ${new Date().toLocaleString()}.`];
+
+// Active sessions
+try {
+  const files = readdirSync(".mind/sessions").filter((f) => f.endsWith(".json"));
+  if (files.length > 0) {
+    const names = files.map((f) => f.replace(/\.json$/, "")).sort();
+    parts.push(`Active sessions: ${names.join(", ")}.`);
+  }
+} catch {}
+
+// Last journal entry
+try {
+  const entries = readdirSync("home/memory/journal").filter((f) => f.endsWith(".md"));
+  if (entries.length > 0) {
+    const latest = entries.sort().pop()!.replace(/\.md$/, "");
+    parts.push(`Last journal entry: ${latest}.`);
+  }
+} catch {}
+
+// Pending channel invites
+try {
+  const invites = readdirSync("home/inbox").filter((f) => f.endsWith(".md"));
+  if (invites.length > 0) {
+    parts.push(`Pending channel invites: ${invites.length} (check inbox/).`);
+  }
+} catch {}
+
+const context = parts.join(" ");
+console.log(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: context,
+    },
+  }),
+);

package/templates/_base/home/.config/routes.json

@@ -1,5 +1,5 @@
 {
-  "rules": [{ "channel": "volute:*", "isDM": false, "session": "group-${channel}" }],
+  "rules": [{ "channel": "*", "isDM": false, "session": "group-${channel}" }],
   "sessions": {
     "group-*": { "batch": { "debounce": 20, "maxWait": 120, "triggers": ["@{{name}}"] } }
   }

package/templates/_base/src/lib/auto-commit.ts

@@ -17,15 +17,19 @@ function exec(cmd: string, args: string[], cwd: string): Promise<{ code: number;
 // Serialize git operations to prevent concurrent commits from conflicting
 let pending = Promise.resolve();
 
+// Pending file changes accumulated across all sessions, flushed on turn end
+const pendingFiles = new Set<string>();
+const pendingSharedFiles = new Set<string>();
+
 /**
- * Commit a file change in the mind's home directory.
+ * Track a file change in the mind's home directory for batched commit.
  * Called by the PostToolUse hook when Edit or Write completes.
  *
- * Files under home/shared/ are committed to the shared worktree repo
- * with mind attribution. All other files go to the mind's own repo.
+ * Files under home/shared/ are tracked separately for the shared worktree repo.
+ * All other files go to the mind's own repo.
  */
-export function commitFileChange(filePath: string, cwd: string): void {
-  // Only commit files under the home directory
+export function trackFileChange(filePath: string, cwd: string): void {
+  // Only track files under the home directory
   const homeDir = resolve(cwd);
   const resolved = resolve(cwd, filePath);
   if (!resolved.startsWith(`${homeDir}/`) && resolved !== homeDir) return;
@@ -33,56 +37,91 @@ export function commitFileChange(filePath: string, cwd: string): void {
   const relativePath = resolved.slice(homeDir.length + 1);
   if (!relativePath) return;
 
-  // Check if this file is under the shared/ worktree
   const sharedPrefix = "shared/";
-  const isShared = relativePath.startsWith(sharedPrefix);
+  if (relativePath.startsWith(sharedPrefix)) {
+    pendingSharedFiles.add(relativePath);
+  } else {
+    pendingFiles.add(relativePath);
+  }
+}
 
-  pending = pending.then(async () => {
-    if (isShared) {
-      // Route to shared worktree
-      const sharedCwd = resolve(cwd, "shared");
-      const sharedRelative = relativePath.slice(sharedPrefix.length);
-      const mindName = process.env.VOLUTE_MIND ?? "unknown";
+/**
+ * Flush all pending file changes into batched commits.
+ * Called at the end of each turn. Produces up to two commits:
+ * one for the mind's own repo and one for the shared worktree.
+ */
+export function flushFileChanges(cwd?: string): Promise<void> {
+  const filesToCommit = [...pendingFiles];
+  const sharedToCommit = [...pendingSharedFiles];
+  pendingFiles.clear();
+  pendingSharedFiles.clear();
 
-      if ((await exec("git", gitArgs(["add", sharedRelative]), sharedCwd)).code !== 0) {
-        log("auto-commit", `git add failed for shared/${sharedRelative}`);
-        return;
-      }
-      if ((await exec("git", gitArgs(["diff", "--cached", "--quiet"]), sharedCwd)).code === 0)
-        return;
+  if (filesToCommit.length === 0 && sharedToCommit.length === 0) {
+    return pending.then(() => {});
+  }
+
+  const effectiveCwd = cwd ?? process.cwd();
 
-      const message = `Update ${sharedRelative}`;
-      const authorFlag = `${mindName} <${mindName}@volute>`;
-      if (
-        (await exec("git", gitArgs(["commit", "--author", authorFlag, "-m", message]), sharedCwd))
-          .code === 0
-      ) {
-        log("auto-commit", `[shared] ${message}`);
-      } else {
-        log("auto-commit", `[shared] commit failed for ${sharedRelative}`);
+  pending = pending.then(async () => {
+    // Commit mind's own files
+    if (filesToCommit.length > 0) {
+      for (const f of filesToCommit) {
+        if ((await exec("git", ["add", f], effectiveCwd)).code !== 0) {
+          log("auto-commit", `git add failed for ${f}`);
+        }
       }
-      // No auto-push for shared files — sharing is deliberate
-    } else {
-      // Existing behavior: commit to mind's own repo
-      if ((await exec("git", ["add", relativePath], cwd)).code !== 0) {
-        log("auto-commit", `git add failed for ${relativePath}`);
-        return;
+      if ((await exec("git", ["diff", "--cached", "--quiet"], effectiveCwd)).code !== 0) {
+        const names = filesToCommit.map((f) => f.replace(/^.*\//, "")).join(", ");
+        const message = `Update ${names}`;
+        if ((await exec("git", ["commit", "-m", message], effectiveCwd)).code === 0) {
+          log("auto-commit", message);
+          // Push if a remote is configured
+          const { stdout: remote } = await exec("git", ["remote"], effectiveCwd);
+          if (remote) {
+            const pushResult = await exec("git", ["push"], effectiveCwd);
+            if (pushResult.code !== 0) {
+              log("auto-commit", `git push failed`);
+            }
+          }
+        } else {
+          log("auto-commit", `commit failed for: ${names}`);
+        }
       }
-      if ((await exec("git", ["diff", "--cached", "--quiet"], cwd)).code === 0) return;
+    }
 
-      const message = `Update ${relativePath}`;
-      if ((await exec("git", ["commit", "-m", message], cwd)).code === 0) {
-        log("auto-commit", message);
-        // Push if a remote is configured
-        const { stdout: remote } = await exec("git", ["remote"], cwd);
-        if (remote) {
-          await exec("git", ["push"], cwd);
+    // Commit shared worktree files
+    if (sharedToCommit.length > 0) {
+      const sharedCwd = resolve(effectiveCwd, "shared");
+      const sharedPrefix = "shared/";
+      const mindName = process.env.VOLUTE_MIND ?? "unknown";
+
+      for (const f of sharedToCommit) {
+        const sharedRelative = f.slice(sharedPrefix.length);
+        if ((await exec("git", gitArgs(["add", sharedRelative]), sharedCwd)).code !== 0) {
+          log("auto-commit", `git add failed for shared/${sharedRelative}`);
+        }
+      }
+      if ((await exec("git", gitArgs(["diff", "--cached", "--quiet"]), sharedCwd)).code !== 0) {
+        const names = sharedToCommit
+          .map((f) => f.slice(sharedPrefix.length).replace(/^.*\//, ""))
+          .join(", ");
+        const message = `Update ${names}`;
+        const authorFlag = `${mindName} <${mindName}@volute>`;
+        if (
+          (await exec("git", gitArgs(["commit", "--author", authorFlag, "-m", message]), sharedCwd))
+            .code === 0
+        ) {
+          log("auto-commit", `[shared] ${message}`);
+        } else {
+          log("auto-commit", `[shared] commit failed`);
         }
       }
     }
   });
+
+  return pending.then(() => {});
 }
 
 export function waitForCommits(): Promise<void> {
-  return pending.then(() => {});
+  return flushFileChanges();
 }

package/templates/_base/src/lib/daemon-client.ts

@@ -1,12 +1,31 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
 const port = process.env.VOLUTE_DAEMON_PORT;
 const mind = process.env.VOLUTE_MIND;
 const token = process.env.VOLUTE_DAEMON_TOKEN;
 
+/** Read session from file (fallback for sandbox where env vars don't propagate). */
+function readSessionFile(): string | undefined {
+  const mindDir = process.env.VOLUTE_MIND_DIR;
+  if (!mindDir) return undefined;
+  try {
+    const p = resolve(mindDir, ".mind", "current-session");
+    if (existsSync(p)) return readFileSync(p, "utf-8").trim() || undefined;
+  } catch (err) {
+    console.warn(`[volute] failed to read session file: ${err}`);
+  }
+  return undefined;
+}
+
 function headers(): Record<string, string> {
   const h: Record<string, string> = { "Content-Type": "application/json" };
   if (token) h.Authorization = `Bearer ${token}`;
   // Origin header required for CSRF checks on mutation requests
   if (port) h.Origin = `http://127.0.0.1:${port}`;
+  // Tag requests with the current session for turn resolution
+  const session = process.env.VOLUTE_SESSION ?? readSessionFile();
+  if (session) h["X-Volute-Session"] = session;
   return h;
 }
 
@@ -39,7 +58,8 @@ export type EventType =
   | "session_start"
   | "done"
   | "inbound"
-  | "outbound";
+  | "outbound"
+  | "context";
 
 export type DaemonEvent = {
   type: EventType;
@@ -57,20 +77,27 @@ export async function daemonEmit(event: DaemonEvent): Promise<void> {
     }
     return;
   }
-  try {
-    const res = await fetch(
-      `http://127.0.0.1:${port}/api/minds/${encodeURIComponent(mind)}/events`,
-      {
-        method: "POST",
-        headers: headers(),
-        body: JSON.stringify(event),
-      },
-    );
-    if (!res.ok) {
+  const url = `http://127.0.0.1:${port}/api/minds/${encodeURIComponent(mind)}/events`;
+  const body = JSON.stringify(event);
+  // Critical events (done) get retries — if lost, turns stay stuck until daemon restart
+  const maxAttempts = event.type === "done" ? 3 : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const res = await fetch(url, { method: "POST", headers: headers(), body });
+      if (res.ok) return;
       console.error(`[volute] event emit failed: ${res.status}`);
+      // Don't retry client errors — they won't succeed on retry
+      if (res.status >= 400 && res.status < 500) return;
+      if (attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+      }
+    } catch (err) {
+      if (attempt >= maxAttempts) {
+        console.error(`[volute] event emit failed after ${maxAttempts} attempts:`, err);
+      } else {
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+      }
     }
-  } catch {
-    // Best-effort — don't let event emission failures break the mind
   }
 }
 
@@ -95,26 +122,3 @@ export async function daemonSendFile(
   }
   return (await res.json()) as { status: string; id?: string; destPath?: string };
 }
-
-export async function daemonSend(channel: string, text: string): Promise<void> {
-  if (!port || !mind) {
-    console.error("[volute] daemonSend: VOLUTE_DAEMON_PORT or VOLUTE_MIND not set");
-    return;
-  }
-  const res = await fetch(
-    `http://127.0.0.1:${port}/api/minds/${encodeURIComponent(mind)}/message`,
-    {
-      method: "POST",
-      headers: headers(),
-      body: JSON.stringify({
-        content: text,
-        channel,
-        sender: mind,
-      }),
-    },
-  );
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(`daemonSend failed (${res.status}): ${body}`);
-  }
-}

package/templates/_base/src/lib/format-prefix.ts

@@ -1,6 +1,7 @@
 import type { ChannelMeta, ParticipantProfile } from "./types.js";
 
 function derivePlatform(channel: string): string {
+  if (!channel.includes(":")) return "Volute";
   const name = channel.split(":")[0];
   return name.charAt(0).toUpperCase() + name.slice(1);
 }

package/templates/_base/src/lib/hook-loader.ts

@@ -0,0 +1,155 @@
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { log } from "./logger.js";
+
+export type HookResult = {
+  additionalContext?: string;
+  metadata?: Record<string, unknown>;
+  decision?: "block";
+};
+
+export type AggregatedResult = {
+  additionalContext?: string;
+  metadata: Record<string, unknown>;
+  blocked: boolean;
+};
+
+const DEFAULT_TIMEOUT = 5000;
+
+/**
+ * Discover hook scripts in `.local/hooks/<event>/`, sorted alphabetically.
+ */
+export function discoverHooks(hooksDir: string, event: string): string[] {
+  const dir = resolve(hooksDir, event);
+  if (!existsSync(dir)) return [];
+
+  try {
+    return readdirSync(dir)
+      .filter((f) => /\.(sh|ts|js)$/.test(f))
+      .sort()
+      .map((f) => join(dir, f));
+  } catch (err) {
+    log(
+      "hooks",
+      `failed to read hooks directory ${dir}: ${err instanceof Error ? err.message : err}`,
+    );
+    return [];
+  }
+}
+
+/**
+ * Select the runner command for a hook script based on its extension.
+ */
+function getRunner(scriptPath: string): { cmd: string; args: string[] } {
+  const ext = extname(scriptPath);
+  if (ext === ".ts") return { cmd: process.execPath, args: ["--import", "tsx", scriptPath] };
+  if (ext === ".js") return { cmd: "node", args: [scriptPath] };
+  return { cmd: "bash", args: [scriptPath] };
+}
+
+/**
+ * Execute a single hook script with JSON on stdin, parse JSON from stdout.
+ */
+export function executeHook(
+  scriptPath: string,
+  input: object,
+  timeout = DEFAULT_TIMEOUT,
+): Promise<HookResult> {
+  return new Promise((resolve) => {
+    const { cmd, args } = getRunner(scriptPath);
+    const child = spawn(cmd, args, {
+      timeout,
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: process.cwd(),
+      env: process.env,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (d: Buffer) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d: Buffer) => {
+      stderr += d.toString();
+    });
+
+    // Ignore stdin errors — child may exit before reading (EPIPE)
+    child.stdin.on("error", () => {});
+    child.stdin.write(JSON.stringify(input));
+    child.stdin.end();
+
+    let settled = false;
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (code !== 0) {
+        log("hooks", `hook ${scriptPath} exited with code ${code}: ${stderr.trim()}`);
+        resolve({});
+        return;
+      }
+
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        resolve({});
+        return;
+      }
+
+      try {
+        const parsed = JSON.parse(trimmed);
+        resolve({
+          additionalContext: parsed.additionalContext,
+          metadata: parsed.metadata,
+          decision: parsed.decision,
+        });
+      } catch {
+        log("hooks", `hook ${scriptPath} returned invalid JSON: ${trimmed.slice(0, 200)}`);
+        resolve({});
+      }
+    });
+
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      log("hooks", `hook ${scriptPath} failed to spawn: ${err.message}`);
+      resolve({});
+    });
+  });
+}
+
+/**
+ * Discover and run all hooks for an event, aggregating results.
+ */
+export async function runHooks(
+  hooksDir: string,
+  event: string,
+  input: object,
+  timeout = DEFAULT_TIMEOUT,
+): Promise<AggregatedResult> {
+  const scripts = discoverHooks(hooksDir, event);
+  if (scripts.length === 0) return { metadata: {}, blocked: false };
+
+  const contextParts: string[] = [];
+  const metadata: Record<string, unknown> = {};
+  let blocked = false;
+
+  for (const script of scripts) {
+    const result = await executeHook(script, input, timeout);
+    if (result.additionalContext) {
+      contextParts.push(result.additionalContext);
+    }
+    if (result.metadata) {
+      Object.assign(metadata, result.metadata);
+    }
+    if (result.decision === "block") {
+      blocked = true;
+    }
+  }
+
+  return {
+    additionalContext: contextParts.length > 0 ? contextParts.join("\n\n") : undefined,
+    metadata,
+    blocked,
+  };
+}

package/templates/_base/src/lib/router.ts

@@ -1,5 +1,7 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { formatPrefix, formatTypingSuffix } from "./format-prefix.js";
-import { log } from "./logger.js";
+import { log, warn } from "./logger.js";
 import {
   type BatchConfig,
   loadRoutingConfig,
@@ -273,6 +275,20 @@ export function createRouter(options: {
     const noop = () => {};
     const safeListener = listener ?? noop;
 
+    // Expose session to child processes (daemon-client reads this for X-Volute-Session)
+    process.env.VOLUTE_SESSION = session;
+    // Also write to file for sandbox environments where env vars don't propagate
+    try {
+      const mindDir = process.env.VOLUTE_MIND_DIR;
+      if (mindDir) {
+        const sessionFile = resolve(mindDir, ".mind", "current-session");
+        mkdirSync(resolve(mindDir, ".mind"), { recursive: true });
+        writeFileSync(sessionFile, session, "utf-8");
+      }
+    } catch (err) {
+      warn("router", `failed to write session file: ${err}`);
+    }
+
     // Apply formatting
     const formatted = applyPrefix(content, { ...meta, sessionName: session });
     const withTyping = appendTypingSuffix(formatted, meta.typing);

package/templates/_base/src/lib/startup.ts

@@ -30,16 +30,14 @@ export function loadConfig(): {
   compaction?: { maxContextTokens?: number };
   subagents?: Record<string, SubagentConfig>;
 } {
-  // Mind-own config lives in config.json; fall back to volute.json for older minds
-  for (const file of ["home/.config/config.json", "home/.config/volute.json"]) {
-    try {
-      return JSON.parse(readFileSync(resolve(file), "utf-8"));
-    } catch (err: any) {
-      if (err?.code === "ENOENT") continue;
-      log("startup", `failed to parse ${file}:`, err);
+  try {
+    return JSON.parse(readFileSync(resolve("home/.config/config.json"), "utf-8"));
+  } catch (err: any) {
+    if (err?.code !== "ENOENT") {
+      log("startup", "failed to parse config.json:", err);
     }
+    return {};
   }
-  return {};
 }
 
 function loadFile(path: string): string {
@@ -80,12 +78,19 @@ export function loadPackageInfo(): { name: string; version: string } {
 }
 
 export async function handleStartupContext(sendMessage: (content: string) => void): Promise<void> {
-  const scriptPath = resolve("home/.config/hooks/startup-context.sh");
-  if (!existsSync(scriptPath)) return;
+  // Prefer .ts, fall back to .sh for backwards compatibility
+  const tsPath = resolve("home/.local/hooks/startup-context.ts");
+  const shPath = resolve("home/.local/hooks/startup-context.sh");
+  const scriptPath = existsSync(tsPath) ? tsPath : existsSync(shPath) ? shPath : null;
+  if (!scriptPath) return;
+
+  const isTs = scriptPath.endsWith(".ts");
 
   try {
     const stdout = await new Promise<string>((resolve, reject) => {
-      const child = spawn("bash", [scriptPath], { timeout: 5000 });
+      const child = isTs
+        ? spawn(process.execPath, ["--import", "tsx", scriptPath], { timeout: 5000 })
+        : spawn("bash", [scriptPath], { timeout: 5000 });
       let out = "";
       child.stdout.on("data", (d: Buffer) => {
         out += d.toString();
@@ -112,7 +117,7 @@ export async function handleStartupContext(sendMessage: (content: string) => voi
       log("server", "sent startup context");
     }
   } catch (e) {
-    log("server", "failed to run startup-context.sh:", e);
+    log("server", "failed to run startup context hook:", e);
   }
 }
 

package/templates/_base/src/lib/transparency.ts

@@ -4,7 +4,7 @@ import type { DaemonEvent, EventType } from "./daemon-client.js";
 
 export type TransparencyPreset = "transparent" | "standard" | "private" | "silent";
 
-type FilterableEventType = Exclude<EventType, "inbound" | "outbound">;
+type FilterableEventType = Exclude<EventType, "inbound" | "outbound" | "context">;
 
 const PRESET_RULES: Record<
   TransparencyPreset,
@@ -53,7 +53,7 @@ const PRESET_RULES: Record<
 };
 
 // Communication records are always emitted (bypass transparency filtering)
-const ALWAYS_ALLOWED: ReadonlySet<string> = new Set(["inbound", "outbound"]);
+const ALWAYS_ALLOWED: ReadonlySet<string> = new Set(["inbound", "outbound", "context"]);
 
 export function loadTransparencyPreset(): TransparencyPreset {
   for (const file of ["home/.config/config.json", "home/.config/volute.json"]) {

package/templates/_base/src/lib/volute-server.ts

@@ -115,12 +115,9 @@ export function createVoluteServer(options: {
             channels: Record<string, any[]>;
           };
           router.dispatchBatch(batch, body.session ?? "main", body);
-        } else if (body.session) {
-          // Pre-routed by daemon delivery manager — dispatch directly
-          router.dispatch(body.content, body.session, body);
         } else {
-          // Legacy: local routing (for minds running with old daemon)
-          router.route(body.content, body);
+          // Pre-routed by daemon delivery manager — dispatch directly
+          router.dispatch(body.content, body.session ?? "main", body);
         }
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true }));

package/templates/claude/.init/.claude/settings.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.config/hooks/startup-context.sh"
+            "command": "node --import tsx \"$CLAUDE_PROJECT_DIR\"/.local/hooks/startup-context.ts"
           }
         ]
       }