@runeya/runeya 2.0.70 → 2.0.72

package/agent/index.js

@@ -60,7 +60,7 @@ var authMiddleware = t.middleware(({ ctx, next }) => {
 var protectedProcedure = t.procedure.use(authMiddleware);
 
 // src/trpc/routers/process.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 import { TRPCError as TRPCError2 } from "@trpc/server";
 
 // src/services/process-manager.ts
@@ -1721,6 +1721,49 @@ var KanbanCardRefSchema = z19.object({
   commentCount: z19.number().int().nonnegative().default(0)
 });
 
+// ../../packages/shared/src/schemas/cloud-api-key.schema.ts
+import { z as z20 } from "zod";
+var CloudApiScopeSchema = z20.enum(["kanban:read", "kanban:write", "kanban:comment"]);
+var CloudApiKeySecretSchema = z20.string().regex(/^rk_[0-9a-f]{64}$/);
+var CloudApiKeySchema = z20.object({
+  id: z20.string().max(128),
+  organizationId: z20.string().max(128),
+  name: z20.string().min(1).max(200),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10),
+  /**
+   * Les tableaux que la clé peut atteindre, ou `null` pour « tous ceux de
+   * l'organisation ».
+   *
+   * `null` et `[]` ne sont pas la même chose : la liste vide n'ouvre rien, et
+   * c'est délibéré — un tableau supprimé ne doit pas élargir une clé qui ne le
+   * nommait plus que lui.
+   */
+  boards: z20.array(z20.string().max(64)).max(200).nullable(),
+  createdAt: z20.string().max(64),
+  /** Dernier usage constaté, pour reconnaître une clé oubliée. */
+  lastUsedAt: z20.string().max(64).nullable(),
+  /** Qui l'a émise — une clé sans visage ne se révoque jamais sereinement. */
+  createdBy: z20.object({ id: z20.string().max(128), name: z20.string().max(200) }),
+  /** Les 4 derniers caractères du secret, pour reconnaître une clé dans une liste. */
+  keyPreview: z20.string().max(8)
+});
+var CreatedCloudApiKeySchema = z20.object({
+  key: CloudApiKeySchema,
+  secret: CloudApiKeySecretSchema
+});
+var CreateCloudApiKeyInput = z20.object({
+  organizationId: z20.string().min(1).max(128),
+  name: z20.string().min(1).max(200),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10),
+  boards: z20.array(z20.string().max(64)).max(200).nullable().default(null)
+});
+var UpdateCloudApiKeyInput = z20.object({
+  id: z20.string().min(1).max(128),
+  name: z20.string().min(1).max(200).optional(),
+  scopes: z20.array(CloudApiScopeSchema).min(1).max(10).optional(),
+  boards: z20.array(z20.string().max(64)).max(200).nullable().optional()
+});
+
 // ../../packages/shared/src/utils/crypto.ts
 import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
 
@@ -2897,7 +2940,7 @@ import { execa as execa3 } from "execa";
 import { homedir as homedir4 } from "os";
 
 // src/trpc/routers/config.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/services/traefik-manager.ts
 import { spawn, execFile as execFile2 } from "child_process";
@@ -3274,13 +3317,13 @@ function resolvePassthroughEnv() {
   return result;
 }
 var configRouter = router({
-  setPassthroughEnv: protectedProcedure.input(z20.object({
-    names: z20.array(
-      z20.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
+  setPassthroughEnv: protectedProcedure.input(z21.object({
+    names: z21.array(
+      z21.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
     ).max(100),
-    values: z20.record(
-      z20.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256),
-      z20.string().max(32768)
+    values: z21.record(
+      z21.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256),
+      z21.string().max(32768)
     ).refine((obj) => Object.keys(obj).length <= 100, "Too many values").optional()
   })).mutation(({ input }) => {
     passthroughEnvNames = input.names;
@@ -3317,7 +3360,7 @@ var configRouter = router({
   getTraefikFileTree: protectedProcedure.query(async () => {
     return traefikManager.getFileTree();
   }),
-  getTraefikLogs: protectedProcedure.input(z20.object({ lines: z20.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
+  getTraefikLogs: protectedProcedure.input(z21.object({ lines: z21.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
     const logs = await traefikManager.getLogs(input.lines);
     return { logs };
   })
@@ -3509,17 +3552,17 @@ var healthChecker = new HealthChecker();
 import killPort from "kill-port";
 
 // src/config/env.ts
-import { z as z21 } from "zod";
-var EnvSchema = z21.object({
-  RUNEYA_AGENT_PORT: z21.coerce.number().int().min(1).max(65535).default(4001),
-  RUNEYA_AGENT_HOST: z21.string().default("127.0.0.1"),
-  PASSPHRASE_OVERRIDE: z21.string().regex(/^[0-9a-f]+$/i, "Must be a hex string").optional(),
-  AGENT_ID: z21.string().optional(),
+import { z as z22 } from "zod";
+var EnvSchema = z22.object({
+  RUNEYA_AGENT_PORT: z22.coerce.number().int().min(1).max(65535).default(4001),
+  RUNEYA_AGENT_HOST: z22.string().default("127.0.0.1"),
+  PASSPHRASE_OVERRIDE: z22.string().regex(/^[0-9a-f]+$/i, "Must be a hex string").optional(),
+  AGENT_ID: z22.string().optional(),
   // Set by spawner or manually for remote agents
-  LOG_BUFFER_SIZE: z21.coerce.number().int().positive().default(LOG_BUFFER_SIZE),
-  METRICS_INTERVAL: z21.coerce.number().int().positive().default(METRICS_INTERVAL),
-  GRACE_PERIOD: z21.coerce.number().int().positive().default(GRACE_PERIOD),
-  HEALTH_WS_INTERVAL: z21.coerce.number().int().positive().default(HEALTH_WS_INTERVAL)
+  LOG_BUFFER_SIZE: z22.coerce.number().int().positive().default(LOG_BUFFER_SIZE),
+  METRICS_INTERVAL: z22.coerce.number().int().positive().default(METRICS_INTERVAL),
+  GRACE_PERIOD: z22.coerce.number().int().positive().default(GRACE_PERIOD),
+  HEALTH_WS_INTERVAL: z22.coerce.number().int().positive().default(HEALTH_WS_INTERVAL)
 });
 var env = EnvSchema.parse(process.env);
 
@@ -4294,7 +4337,7 @@ var processRouter = router({
     return processManager.listStatuses();
   }),
   /** Get a single process */
-  get: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).query(({ input }) => {
+  get: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).query(({ input }) => {
     const status = processManager.getStatus(input.id);
     if (!status) {
       throw new TRPCError2({ code: "NOT_FOUND", message: `Process ${input.id} not found` });
@@ -4307,78 +4350,78 @@ var processRouter = router({
     return { id };
   }),
   /** Undeploy: stop + remove */
-  undeploy: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(async ({ input }) => {
+  undeploy: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
     await processManager.undeploy(input.id);
     return { success: true };
   }),
   /** Update the service config for a deployed process */
-  updateConfig: protectedProcedure.input(z22.object({ serviceId: z22.string().max(128), config: ServiceConfigSchema })).mutation(({ input }) => {
+  updateConfig: protectedProcedure.input(z23.object({ serviceId: z23.string().max(128), config: ServiceConfigSchema })).mutation(({ input }) => {
     processManager.updateConfig(input.serviceId, input.config);
     return { success: true };
   }),
   /** Start a deployed process */
-  start: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(async ({ input }) => {
+  start: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
     console.log(`[agent] start service=${input.id}`);
     await processManager.start(input.id);
     return processManager.getStatus(input.id);
   }),
   /** Stop a running process */
-  stop: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(async ({ input }) => {
+  stop: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
     console.log(`[agent] stop service=${input.id}`);
     await processManager.stop(input.id);
     return processManager.getStatus(input.id);
   }),
   /** Restart a process */
-  restart: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(async ({ input }) => {
+  restart: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
     console.log(`[agent] restart service=${input.id}`);
     await processManager.restart(input.id);
     return processManager.getStatus(input.id);
   }),
   /** Get buffered logs for a process */
-  logs: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).query(({ input }) => {
+  logs: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).query(({ input }) => {
     const logs = processManager.getLogs(input.id);
     return logs;
   }),
   /** Clear buffered logs for a process */
-  clearLogBuffer: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(({ input }) => {
+  clearLogBuffer: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(({ input }) => {
     processManager.clearLogBuffer(input.id);
     return { success: true };
   }),
   /** Execute a shortcut command and stream output into the process log */
-  executeShortcut: protectedProcedure.input(z22.object({ id: z22.string().max(128), shortcut: ServiceShortcutSchema })).mutation(async ({ input }) => {
+  executeShortcut: protectedProcedure.input(z23.object({ id: z23.string().max(128), shortcut: ServiceShortcutSchema })).mutation(async ({ input }) => {
     const result = await processManager.executeShortcut(input.id, input.shortcut);
     return result;
   }),
   /** Cancel a running shortcut command */
-  cancelShortcut: protectedProcedure.input(z22.object({ id: z22.string().max(128), shortcutId: z22.string().max(128) })).mutation(({ input }) => {
+  cancelShortcut: protectedProcedure.input(z23.object({ id: z23.string().max(128), shortcutId: z23.string().max(128) })).mutation(({ input }) => {
     processManager.cancelShortcut(input.id, input.shortcutId);
     return { success: true };
   }),
   /** Cancel a running ad-hoc command */
-  cancelAdHocCommand: protectedProcedure.input(z22.object({ id: z22.string().max(128), commandId: z22.string().max(128).optional() })).mutation(({ input }) => {
+  cancelAdHocCommand: protectedProcedure.input(z23.object({ id: z23.string().max(128), commandId: z23.string().max(128).optional() })).mutation(({ input }) => {
     processManager.cancelAdHocCommand(input.id, input.commandId);
     return { success: true };
   }),
   /** Execute an ad-hoc command and stream output into the process log */
-  executeAdHocCommand: protectedProcedure.input(z22.object({
-    id: z22.string().max(128),
-    command: z22.string().min(1).max(4096),
-    cwd: z22.string().max(4096).optional(),
-    commandId: z22.string().max(128).optional()
+  executeAdHocCommand: protectedProcedure.input(z23.object({
+    id: z23.string().max(128),
+    command: z23.string().min(1).max(4096),
+    cwd: z23.string().max(4096).optional(),
+    commandId: z23.string().max(128).optional()
   })).mutation(async ({ input }) => {
     const result = await processManager.executeAdHocCommand(input.id, input.command, input.cwd, input.commandId);
     return result;
   }),
   /** List active log source types for a process */
-  logSources: protectedProcedure.input(z22.object({ processId: z22.string().max(128) })).query(({ input }) => {
+  logSources: protectedProcedure.input(z23.object({ processId: z23.string().max(128) })).query(({ input }) => {
     return processManager.getLogSourceTypes(input.processId);
   }),
   /** Get current metrics for a process */
-  metrics: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).query(async ({ input }) => {
+  metrics: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).query(async ({ input }) => {
     return processManager.getMetrics(input.id);
   }),
   /** Subscribe to real-time log stream (yields batches of ParsedLog[]) */
-  onLog: protectedProcedure.input(z22.object({ processId: z22.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onLog: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (batch) => {
@@ -4407,7 +4450,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time status changes */
-  onStatus: protectedProcedure.input(z22.object({ processId: z22.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onStatus: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     console.debug("[agent] onStatus subscription started", input?.processId ? `for process ${input.processId}` : "(all processes)");
     const queue = [];
     let resolve2 = null;
@@ -4439,7 +4482,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time health status changes */
-  onHealth: protectedProcedure.input(z22.object({ processId: z22.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onHealth: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (healthData) => {
@@ -4469,7 +4512,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time metrics */
-  onMetrics: protectedProcedure.input(z22.object({ processId: z22.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onMetrics: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (metrics) => {
@@ -4543,7 +4586,7 @@ var healthRouter = router({
 });
 
 // src/trpc/routers/terminal.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 import { TRPCError as TRPCError3 } from "@trpc/server";
 
 // src/services/terminal-manager.ts
@@ -4551,32 +4594,64 @@ import { EventEmitter as EventEmitter8 } from "events";
 import os from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 import * as pty from "@lydell/node-pty";
+var SCROLLBACK_LIMIT = 256 * 1024;
 var TerminalManager = class {
   sessions = /* @__PURE__ */ new Map();
-  create(cwd, cols, rows) {
+  create(cwd, cols, rows, title) {
     const sessionId = randomUUID4();
     const shell = process.env.SHELL ?? (os.platform() === "win32" ? "powershell.exe" : "/bin/bash");
+    const resolvedCwd = cwd ?? process.cwd();
+    const resolvedCols = cols ?? 80;
+    const resolvedRows = rows ?? 24;
     const term = pty.spawn(shell, [], {
       name: "xterm-256color",
-      cols: cols ?? 80,
-      rows: rows ?? 24,
-      cwd: cwd ?? process.cwd(),
+      cols: resolvedCols,
+      rows: resolvedRows,
+      cwd: resolvedCwd,
       env: process.env
     });
     const emitter = new EventEmitter8();
-    term.onData((data) => emitter.emit("data", data));
+    emitter.setMaxListeners(50);
+    const session = {
+      pty: term,
+      emitter,
+      scrollback: "",
+      info: {
+        sessionId,
+        title: title ?? "Terminal",
+        cwd: resolvedCwd,
+        cols: resolvedCols,
+        rows: resolvedRows,
+        createdAt: Date.now()
+      }
+    };
+    term.onData((data) => {
+      session.scrollback += data;
+      if (session.scrollback.length > SCROLLBACK_LIMIT) {
+        session.scrollback = session.scrollback.slice(-SCROLLBACK_LIMIT);
+      }
+      emitter.emit("data", data);
+    });
     term.onExit(() => {
       emitter.emit("exit");
       this.sessions.delete(sessionId);
     });
-    this.sessions.set(sessionId, { pty: term, emitter });
+    this.sessions.set(sessionId, session);
     return sessionId;
   }
   write(sessionId, data) {
     this.sessions.get(sessionId)?.pty.write(data);
   }
   resize(sessionId, cols, rows) {
-    this.sessions.get(sessionId)?.pty.resize(cols, rows);
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.pty.resize(cols, rows);
+    session.info.cols = cols;
+    session.info.rows = rows;
+  }
+  rename(sessionId, title) {
+    const session = this.sessions.get(sessionId);
+    if (session) session.info.title = title;
   }
   destroy(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -4588,6 +4663,13 @@ var TerminalManager = class {
       this.sessions.delete(sessionId);
     }
   }
+  /** Les sessions encore vivantes : de quoi retrouver ses onglets après un aller-retour. */
+  list() {
+    return [...this.sessions.values()].map((s) => s.info).sort((a, b) => a.createdAt - b.createdAt);
+  }
+  getScrollback(sessionId) {
+    return this.sessions.get(sessionId)?.scrollback ?? "";
+  }
   getEmitter(sessionId) {
     return this.sessions.get(sessionId)?.emitter ?? null;
   }
@@ -4597,35 +4679,47 @@ var terminalManager = new TerminalManager();
 // src/trpc/routers/terminal.ts
 var terminalRouter = router({
   /** Spawn a new PTY shell session, returns a sessionId */
-  create: protectedProcedure.input(z23.object({
-    cwd: z23.string().max(512).optional(),
-    cols: z23.number().int().min(1).max(512).optional(),
-    rows: z23.number().int().min(1).max(256).optional()
+  create: protectedProcedure.input(z24.object({
+    cwd: z24.string().max(512).optional(),
+    cols: z24.number().int().min(1).max(512).optional(),
+    rows: z24.number().int().min(1).max(256).optional(),
+    title: z24.string().max(128).optional()
   })).mutation(({ input }) => {
-    const sessionId = terminalManager.create(input.cwd, input.cols, input.rows);
+    const sessionId = terminalManager.create(input.cwd, input.cols, input.rows, input.title);
     return { sessionId };
   }),
+  /** Les sessions encore vivantes : un onglet fermé côté web se retrouve ici */
+  list: protectedProcedure.query(() => ({ sessions: terminalManager.list() })),
+  /** Renommer un onglet */
+  rename: protectedProcedure.input(z24.object({ sessionId: z24.string().max(128), title: z24.string().max(128) })).mutation(({ input }) => {
+    terminalManager.rename(input.sessionId, input.title);
+    return { ok: true };
+  }),
   /** Write data (keystrokes) to a PTY session */
-  write: protectedProcedure.input(z23.object({ sessionId: z23.string().max(128), data: z23.string().max(65536) })).mutation(({ input }) => {
+  write: protectedProcedure.input(z24.object({ sessionId: z24.string().max(128), data: z24.string().max(65536) })).mutation(({ input }) => {
     terminalManager.write(input.sessionId, input.data);
     return { ok: true };
   }),
   /** Resize a PTY session */
-  resize: protectedProcedure.input(z23.object({
-    sessionId: z23.string().max(128),
-    cols: z23.number().int().min(1).max(512),
-    rows: z23.number().int().min(1).max(256)
+  resize: protectedProcedure.input(z24.object({
+    sessionId: z24.string().max(128),
+    cols: z24.number().int().min(1).max(512),
+    rows: z24.number().int().min(1).max(256)
   })).mutation(({ input }) => {
     terminalManager.resize(input.sessionId, input.cols, input.rows);
     return { ok: true };
   }),
   /** Destroy a PTY session */
-  destroy: protectedProcedure.input(z23.object({ sessionId: z23.string().max(128) })).mutation(({ input }) => {
+  destroy: protectedProcedure.input(z24.object({ sessionId: z24.string().max(128) })).mutation(({ input }) => {
     terminalManager.destroy(input.sessionId);
     return { ok: true };
   }),
   /** Stream PTY output for a session (async generator subscription) */
-  onData: protectedProcedure.input(z23.object({ sessionId: z23.string().max(128) })).subscription(async function* ({ input }) {
+  onData: protectedProcedure.input(z24.object({
+    sessionId: z24.string().max(128),
+    /** Rejouer l'historique avant le flux : c'est ce qui rend l'onglet persistant. */
+    replay: z24.boolean().optional()
+  })).subscription(async function* ({ input }) {
     const emitter = terminalManager.getEmitter(input.sessionId);
     if (!emitter) {
       throw new TRPCError3({ code: "NOT_FOUND", message: `Terminal session ${input.sessionId} not found` });
@@ -4649,6 +4743,8 @@ var terminalRouter = router({
     };
     emitter.on("data", onData);
     emitter.on("exit", onExit);
+    const scrollback = input.replay ? terminalManager.getScrollback(input.sessionId) : "";
+    if (scrollback) yield scrollback;
     try {
       while (!done || queue.length > 0) {
         if (queue.length > 0) {
@@ -4667,7 +4763,7 @@ var terminalRouter = router({
 });
 
 // src/trpc/routers/git.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import { TRPCError as TRPCError4 } from "@trpc/server";
 import { execFile as execFile4, spawn as spawn3 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -4677,12 +4773,12 @@ import { join as join4, resolve as resolvePath } from "path";
 var execFileAsync2 = promisify2(execFile4);
 var GIT_TIMEOUT = 15e3;
 var DIFF_MAX_BYTES = 512 * 1024;
-var CWD_SCHEMA = z24.string().min(1).max(4096);
-var SAFE_PATH_SCHEMA = z24.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
+var CWD_SCHEMA = z25.string().min(1).max(4096);
+var SAFE_PATH_SCHEMA = z25.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
   message: "Path must be relative and not traverse up"
 });
-var REMOTE_SCHEMA = z24.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
-var BRANCH_SCHEMA = z24.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
+var REMOTE_SCHEMA = z25.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
+var BRANCH_SCHEMA = z25.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
 function gitSafeEnv() {
   const env2 = {
     GIT_TERMINAL_PROMPT: "0",
@@ -4800,10 +4896,10 @@ async function getGitStatus(cwd) {
 }
 var gitRouter = router({
   /** Check if a working directory exists and optionally verify its git remote */
-  checkCwd: protectedProcedure.input(z24.object({
+  checkCwd: protectedProcedure.input(z25.object({
     cwd: CWD_SCHEMA,
-    remote: z24.string().max(2048).optional(),
-    checkReachability: z24.boolean().optional()
+    remote: z25.string().max(2048).optional(),
+    checkReachability: z25.boolean().optional()
   })).query(async ({ input }) => {
     const resolvedCwd = expandEnvVar(input.cwd);
     const unresolvedVars = [...resolvedCwd.matchAll(/\$\{?(\w+)\}?/g)].map((m) => m[1]);
@@ -4824,8 +4920,8 @@ var gitRouter = router({
     return { exists, actualRemote, unreachable: false, resolvedCwd: absoluteCwd, unresolvedVars: [] };
   }),
   /** Clone a git repository into a target directory */
-  clone: protectedProcedure.input(z24.object({
-    remote: z24.string().min(1).max(2048),
+  clone: protectedProcedure.input(z25.object({
+    remote: z25.string().min(1).max(2048),
     cwd: CWD_SCHEMA
   })).mutation(async ({ input }) => {
     const absoluteCwd = resolvePath(expandEnvVar(input.cwd));
@@ -4846,13 +4942,13 @@ var gitRouter = router({
     return { success: true };
   }),
   /** Get full git status */
-  status: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  status: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     return getGitStatus(cwd);
   }),
   /** Watch .git/ for changes and stream updated status */
-  onStatusChange: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).subscription(async function* ({ input }) {
+  onStatusChange: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).subscription(async function* ({ input }) {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const gitDir = (await git(["rev-parse", "--git-dir"], cwd, true)).trim();
@@ -4903,7 +4999,7 @@ var gitRouter = router({
     }
   }),
   /** Get commit log */
-  log: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, limit: z24.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
+  log: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, limit: z25.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const format = "%H%h%an%ae%ai%s";
@@ -4914,7 +5010,7 @@ var gitRouter = router({
     });
   }),
   /** List local and remote branches */
-  branches: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  branches: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const current = (await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd, true)).trim();
@@ -4926,7 +5022,7 @@ var gitRouter = router({
     return { current, branches };
   }),
   /** Checkout a branch */
-  checkout: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, create: z24.boolean().default(false) })).mutation(async ({ input }) => {
+  checkout: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, create: z25.boolean().default(false) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const args = input.create ? ["checkout", "-b", input.branch] : ["checkout", input.branch];
@@ -4934,42 +5030,42 @@ var gitRouter = router({
     return { ok: true };
   }),
   /** Stage files */
-  stage: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, paths: z24.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  stage: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     await git(["add", "--", ...input.paths], cwd);
     return { ok: true };
   }),
   /** Stage all files */
-  stageAll: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
+  stageAll: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     await git(["add", "-A"], cwd);
     return { ok: true };
   }),
   /** Unstage files */
-  unstage: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, paths: z24.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  unstage: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     await git(["restore", "--staged", "--", ...input.paths], cwd);
     return { ok: true };
   }),
   /** Unstage all files */
-  unstageAll: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
+  unstageAll: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     await git(["reset", "--"], cwd);
     return { ok: true };
   }),
   /** Commit staged changes */
-  commit: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, message: z24.string().min(1).max(4096) })).mutation(async ({ input }) => {
+  commit: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, message: z25.string().min(1).max(4096) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["commit", "-m", input.message], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** Push to remote */
-  push: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z24.boolean().default(false) })).mutation(async ({ input }) => {
+  push: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z25.boolean().default(false) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd, true)).trim();
@@ -4978,25 +5074,25 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Pull from remote */
-  pull: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  pull: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["pull", input.remote], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** Fetch from remote */
-  fetch: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  fetch: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["fetch", input.remote], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** Get diff for a file or the whole index */
-  diff: protectedProcedure.input(z24.object({
+  diff: protectedProcedure.input(z25.object({
     cwd: CWD_SCHEMA,
-    path: z24.string().max(4096).optional(),
-    staged: z24.boolean().default(false),
-    untracked: z24.boolean().default(false)
+    path: z25.string().max(4096).optional(),
+    staged: z25.boolean().default(false),
+    untracked: z25.boolean().default(false)
   })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
@@ -5044,21 +5140,21 @@ var gitRouter = router({
     };
   }),
   /** Discard changes to working tree files */
-  discard: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, paths: z24.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  discard: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     await git(["restore", "--", ...input.paths], cwd);
     return { ok: true };
   }),
   /** Get staged diff (used by server for AI commit message generation) */
-  stagedDiff: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  stagedDiff: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const diff = await git(["diff", "--staged"], cwd, true);
     return { diff: diff.slice(0, 3e4) };
   }),
   /** Merge a branch into the current branch */
-  merge: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, noFf: z24.boolean().default(false) })).mutation(async ({ input }) => {
+  merge: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, noFf: z25.boolean().default(false) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const args = input.noFf ? ["merge", "--no-ff", input.branch] : ["merge", input.branch];
@@ -5066,14 +5162,14 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Rebase current branch onto another branch */
-  rebase: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
+  rebase: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["rebase", input.branch], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** List remotes */
-  remotes: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  remotes: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["remote", "-v"], cwd, true);
@@ -5091,7 +5187,7 @@ var gitRouter = router({
     return remotes;
   }),
   /** List stash entries */
-  stashList: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  stashList: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["stash", "list", "--format=%gd%s"], cwd, true);
@@ -5104,10 +5200,10 @@ var gitRouter = router({
     return entries;
   }),
   /** Stash current changes */
-  stashPush: protectedProcedure.input(z24.object({
+  stashPush: protectedProcedure.input(z25.object({
     cwd: CWD_SCHEMA,
-    message: z24.string().max(4096).optional(),
-    includeUntracked: z24.boolean().default(true)
+    message: z25.string().max(4096).optional(),
+    includeUntracked: z25.boolean().default(true)
   })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
@@ -5118,21 +5214,21 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Apply a stash entry and remove it from the list */
-  stashPop: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashPop: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["stash", "pop", `stash@{${input.index}}`], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** Apply a stash entry without removing it from the list */
-  stashApply: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashApply: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["stash", "apply", `stash@{${input.index}}`], cwd);
     return { ok: true, output: output.trim() };
   }),
   /** Drop a stash entry */
-  stashDrop: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashDrop: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["stash", "drop", `stash@{${input.index}}`], cwd);
@@ -5165,7 +5261,7 @@ function runGitRaw(args, timeoutMs, extraEnv) {
 }
 
 // src/trpc/routers/ai.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 import { TRPCError as TRPCError5 } from "@trpc/server";
 
 // src/services/ai-spawn-manager.ts
@@ -5880,23 +5976,23 @@ var MAX_CONTEXT_FILE_BYTES = 1e6;
 var MAX_CONTEXT_TOTAL_BYTES = 5e6;
 var aiRouter = router({
   /** Spawn an AI CLI process. Returns a spawnId for streaming. */
-  spawn: protectedProcedure.input(z25.object({
-    cli: z25.string().max(64),
-    args: z25.array(z25.string().max(5e5)),
-    env: z25.record(z25.string().max(256), z25.string().max(5e5)).optional(),
-    cwd: z25.string().max(4096).optional(),
-    stdinData: z25.string().max(1e7).optional(),
-    enableMcp: z25.boolean().optional(),
-    mcpApiBaseUrl: z25.string().max(512).optional(),
-    mcpApiToken: z25.string().max(8192).optional()
+  spawn: protectedProcedure.input(z26.object({
+    cli: z26.string().max(64),
+    args: z26.array(z26.string().max(5e5)),
+    env: z26.record(z26.string().max(256), z26.string().max(5e5)).optional(),
+    cwd: z26.string().max(4096).optional(),
+    stdinData: z26.string().max(1e7).optional(),
+    enableMcp: z26.boolean().optional(),
+    mcpApiBaseUrl: z26.string().max(512).optional(),
+    mcpApiToken: z26.string().max(8192).optional()
   })).mutation(({ input }) => {
     const spawnId = aiSpawnManager.spawn(input);
     return { spawnId };
   }),
   /** Stream stdout/stderr/exit chunks from offset. Reconnectable. */
-  stream: protectedProcedure.input(z25.object({
-    spawnId: z25.string().max(128),
-    fromOffset: z25.number().int().min(0).default(0)
+  stream: protectedProcedure.input(z26.object({
+    spawnId: z26.string().max(128),
+    fromOffset: z26.number().int().min(0).default(0)
   })).subscription(async function* ({ input }) {
     try {
       for await (const item of aiSpawnManager.stream(input.spawnId, input.fromOffset)) {
@@ -5910,39 +6006,39 @@ var aiRouter = router({
     }
   }),
   /** Spawn an AI CLI process in a PTY (interactive mode). Returns spawnId. */
-  spawnPty: protectedProcedure.input(z25.object({
-    cli: z25.string().max(64),
-    args: z25.array(z25.string().max(5e5)),
-    env: z25.record(z25.string().max(256), z25.string().max(5e5)).optional(),
-    cwd: z25.string().max(4096).optional(),
-    cols: z25.number().int().min(1).max(1e3).optional(),
-    rows: z25.number().int().min(1).max(1e3).optional(),
-    sessionId: z25.string().max(128).optional(),
-    enableMcp: z25.boolean().optional(),
-    mcpApiBaseUrl: z25.string().max(512).optional(),
-    mcpApiToken: z25.string().max(8192).optional()
+  spawnPty: protectedProcedure.input(z26.object({
+    cli: z26.string().max(64),
+    args: z26.array(z26.string().max(5e5)),
+    env: z26.record(z26.string().max(256), z26.string().max(5e5)).optional(),
+    cwd: z26.string().max(4096).optional(),
+    cols: z26.number().int().min(1).max(1e3).optional(),
+    rows: z26.number().int().min(1).max(1e3).optional(),
+    sessionId: z26.string().max(128).optional(),
+    enableMcp: z26.boolean().optional(),
+    mcpApiBaseUrl: z26.string().max(512).optional(),
+    mcpApiToken: z26.string().max(8192).optional()
   })).mutation(({ input }) => {
     const spawnId = aiSpawnManager.spawnPty(input);
     return { spawnId };
   }),
   /** Find a running PTY spawn by its logical sessionId (for re-attach). */
-  findPtyBySession: protectedProcedure.input(z25.object({ sessionId: z25.string().max(128) })).query(({ input }) => {
+  findPtyBySession: protectedProcedure.input(z26.object({ sessionId: z26.string().max(128) })).query(({ input }) => {
     return aiSpawnManager.findPtyBySessionId(input.sessionId);
   }),
   /** Write input to a PTY spawn (user keystrokes). */
-  writePty: protectedProcedure.input(z25.object({
-    spawnId: z25.string().max(128),
-    data: z25.string().max(1e6)
+  writePty: protectedProcedure.input(z26.object({
+    spawnId: z26.string().max(128),
+    data: z26.string().max(1e6)
   })).mutation(({ input }) => {
     const ok = aiSpawnManager.writePty(input.spawnId, input.data);
     return { ok };
   }),
   /** Write attached-context files for an AI session to a temp dir. Returns absolute paths. */
-  writeContextFiles: protectedProcedure.input(z25.object({
-    sessionId: z25.string().min(1).max(128),
-    files: z25.array(z25.object({
-      name: z25.string().min(1).max(256),
-      content: z25.string().max(MAX_CONTEXT_FILE_BYTES)
+  writeContextFiles: protectedProcedure.input(z26.object({
+    sessionId: z26.string().min(1).max(128),
+    files: z26.array(z26.object({
+      name: z26.string().min(1).max(256),
+      content: z26.string().max(MAX_CONTEXT_FILE_BYTES)
     })).min(1).max(MAX_CONTEXT_FILES)
   }).refine(
     (val) => val.files.reduce((sum, f) => sum + f.content.length, 0) <= MAX_CONTEXT_TOTAL_BYTES,
@@ -5957,25 +6053,25 @@ var aiRouter = router({
    * which clipboard method (if any) succeeded — caller decides whether to send
    * Ctrl+V (\x16) or inject `@<path>` into the PTY.
    */
-  pasteImage: protectedProcedure.input(z25.object({
-    sessionId: z25.string().max(128).optional(),
-    mimeType: z25.string().max(64),
-    base64: z25.string().max(15e6)
+  pasteImage: protectedProcedure.input(z26.object({
+    sessionId: z26.string().max(128).optional(),
+    mimeType: z26.string().max(64),
+    base64: z26.string().max(15e6)
   })).mutation(async ({ input }) => {
     const res = await savePastedImage(input.base64, input.mimeType, input.sessionId);
     return res;
   }),
   /** Resize a PTY spawn. */
-  resizePty: protectedProcedure.input(z25.object({
-    spawnId: z25.string().max(128),
-    cols: z25.number().int().min(1).max(1e3),
-    rows: z25.number().int().min(1).max(1e3)
+  resizePty: protectedProcedure.input(z26.object({
+    spawnId: z26.string().max(128),
+    cols: z26.number().int().min(1).max(1e3),
+    rows: z26.number().int().min(1).max(1e3)
   })).mutation(({ input }) => {
     const ok = aiSpawnManager.resizePty(input.spawnId, input.cols, input.rows);
     return { ok };
   }),
   /** Kill a running AI spawn. */
-  kill: protectedProcedure.input(z25.object({ spawnId: z25.string().max(128) })).mutation(({ input }) => {
+  kill: protectedProcedure.input(z26.object({ spawnId: z26.string().max(128) })).mutation(({ input }) => {
     const killed = aiSpawnManager.kill(input.spawnId);
     return { ok: killed };
   }),
@@ -5984,23 +6080,23 @@ var aiRouter = router({
     return aiSpawnManager.list();
   }),
   /** Acknowledge receipt of all data — agent can clean up after TTL. */
-  ack: protectedProcedure.input(z25.object({ spawnId: z25.string().max(128) })).mutation(({ input }) => {
+  ack: protectedProcedure.input(z26.object({ spawnId: z26.string().max(128) })).mutation(({ input }) => {
     const acked = aiSpawnManager.ack(input.spawnId);
     return { ok: acked };
   }),
   /** Forward a JSON-RPC request to the local codex app-server. */
-  codexRequest: protectedProcedure.input(z25.object({
-    method: z25.string().max(256),
-    params: z25.record(z25.string(), z25.unknown()).default({}),
-    env: z25.record(z25.string().max(256), z25.string().max(5e5)).optional()
+  codexRequest: protectedProcedure.input(z26.object({
+    method: z26.string().max(256),
+    params: z26.record(z26.string(), z26.unknown()).default({}),
+    env: z26.record(z26.string().max(256), z26.string().max(5e5)).optional()
   })).mutation(async ({ input }) => {
     await codexAppServerManager.ensureConnected(input.env);
     const result = await codexAppServerManager.sendRequest(input.method, input.params);
     return { result };
   }),
   /** Stream notifications from the codex app-server. Optionally filter by threadId. */
-  codexNotifications: protectedProcedure.input(z25.object({
-    threadId: z25.string().max(256).optional()
+  codexNotifications: protectedProcedure.input(z26.object({
+    threadId: z26.string().max(256).optional()
   }).default({})).subscription(async function* ({ input, signal }) {
     await codexAppServerManager.ensureConnected();
     const queue = [];
@@ -6037,13 +6133,13 @@ var aiRouter = router({
 });
 
 // src/trpc/routers/wiki.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 import { TRPCError as TRPCError6 } from "@trpc/server";
 import { readFile as readFile2, readdir, stat as stat2, realpath, writeFile as writeFile6, mkdir as mkdir6, rename as rename2, rm } from "fs/promises";
 import { dirname as dirname2 } from "path";
 import { resolve as resolvePath3, join as join5, relative, sep } from "path";
-var CWD_SCHEMA2 = z26.string().min(1).max(4096);
-var REL_PATH_SCHEMA = z26.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
+var CWD_SCHEMA2 = z27.string().min(1).max(4096);
+var REL_PATH_SCHEMA = z27.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
   message: "Path must be a relative path without traversal"
 });
 var MAX_FILES = 500;
@@ -6063,9 +6159,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "target",
   "out"
 ]);
-var RepoEntrySchema = z26.lazy(() => z26.union([
-  z26.object({ type: z26.literal("file"), name: z26.string(), path: z26.string() }),
-  z26.object({ type: z26.literal("dir"), name: z26.string(), path: z26.string(), children: z26.array(RepoEntrySchema) })
+var RepoEntrySchema = z27.lazy(() => z27.union([
+  z27.object({ type: z27.literal("file"), name: z27.string(), path: z27.string() }),
+  z27.object({ type: z27.literal("dir"), name: z27.string(), path: z27.string(), children: z27.array(RepoEntrySchema) })
 ]));
 async function walkMarkdown(root, dir, depth, counter) {
   if (depth > MAX_DEPTH || counter.n >= MAX_FILES) return [];
@@ -6135,13 +6231,13 @@ async function resolveRoot(cwd) {
   }
 }
 var wikiRouter = router({
-  listRepoMarkdown: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2 })).query(async ({ input }) => {
+  listRepoMarkdown: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2 })).query(async ({ input }) => {
     const root = await resolveRoot(input.cwd);
     const counter = { n: 0 };
     const entries = await walkMarkdown(root, root, 0, counter);
     return { root, entries, truncated: counter.n >= MAX_FILES };
   }),
-  readRepoMarkdown: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).query(async ({ input }) => {
+  readRepoMarkdown: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).query(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md sont autoris\xE9s" });
     }
@@ -6167,10 +6263,10 @@ var wikiRouter = router({
     const content = await readFile2(realTarget, "utf-8");
     return { path: input.path, content };
   }),
-  writeMarkdown: protectedProcedure.input(z26.object({
+  writeMarkdown: protectedProcedure.input(z27.object({
     cwd: CWD_SCHEMA2,
     path: REL_PATH_SCHEMA,
-    content: z26.string().max(5e6)
+    content: z27.string().max(5e6)
   })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
@@ -6181,7 +6277,7 @@ var wikiRouter = router({
     await writeFile6(target, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
-  createFile: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createFile: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -6197,13 +6293,13 @@ var wikiRouter = router({
     await writeFile6(target, "", "utf-8");
     return { path: input.path, ok: true };
   }),
-  createDir: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createDir: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const root = await resolveRoot(input.cwd);
     const target = await resolveSafePath(root, input.path, false);
     await mkdir6(target, { recursive: true });
     return { path: input.path, ok: true };
   }),
-  renamePath: protectedProcedure.input(z26.object({
+  renamePath: protectedProcedure.input(z27.object({
     cwd: CWD_SCHEMA2,
     fromPath: REL_PATH_SCHEMA,
     toPath: REL_PATH_SCHEMA
@@ -6221,14 +6317,14 @@ var wikiRouter = router({
     await rename2(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
-  ensureRoot: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2 })).mutation(async ({ input }) => {
+  ensureRoot: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2 })).mutation(async ({ input }) => {
     const expanded = expandEnvVar(input.cwd);
     const abs = resolvePath3(expanded);
     await mkdir6(abs, { recursive: true });
     const root = await realpath(abs);
     return { root, ok: true };
   }),
-  deletePath: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  deletePath: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const root = await resolveRoot(input.cwd);
     const target = await resolveSafePath(root, input.path, true);
     if (target === root) {