@runeya/runeya 2.0.93 → 2.0.94

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 z23 } from "zod";
+import { z as z24 } from "zod";
 import { TRPCError as TRPCError2 } from "@trpc/server";
 
 // src/services/process-manager.ts
@@ -1148,6 +1148,37 @@ var UpdateCloudApiKeyInput = z20.object({
   boards: z20.array(z20.string().max(64)).max(200).nullable().optional()
 });
 
+// ../../packages/shared/src/schemas/changelog.schema.ts
+import { z as z21 } from "zod";
+var ChangelogSurfaceSchema = z21.enum(["app", "cloud"]);
+var ChangelogChangeKindSchema = z21.enum(["feature", "improvement", "fix", "breaking"]);
+var ChangelogTextSchema = z21.object({
+  fr: z21.string().min(1).max(500),
+  en: z21.string().min(1).max(500)
+});
+var ChangelogChangeSchema = z21.object({
+  kind: ChangelogChangeKindSchema,
+  text: ChangelogTextSchema
+});
+var ChangelogDraftSchema = ChangelogChangeSchema.extend({
+  date: z21.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  title: ChangelogTextSchema.optional()
+});
+var ChangelogReleaseSchema = z21.object({
+  surface: ChangelogSurfaceSchema,
+  /** `1.4.2` pour l'app (version npm publiée), `2026-09-03` — ou `2026-09-03.2` — pour le cloud. */
+  version: z21.string().min(1).max(32).regex(/^[0-9][0-9.-]*$/),
+  /** Date de publication, `YYYY-MM-DD`. */
+  date: z21.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  /** Facultatif : une version peut s'annoncer par son seul numéro. */
+  title: ChangelogTextSchema.optional(),
+  /** Une version sans changement n'a rien à annoncer : elle n'a pas sa place ici. */
+  changes: z21.array(ChangelogChangeSchema).min(1).max(50)
+});
+var ChangelogIndexItemSchema = ChangelogReleaseSchema.omit({ changes: true }).extend({
+  changeCount: z21.number().int().nonnegative()
+});
+
 // ../../packages/shared/src/utils/crypto.ts
 import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
 
@@ -3086,7 +3117,7 @@ import { execa as execa3 } from "execa";
 import { homedir as homedir4 } from "os";
 
 // src/trpc/routers/config.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/services/traefik-manager.ts
 import { spawn, execFile as execFile2 } from "child_process";
@@ -3464,13 +3495,13 @@ function resolvePassthroughEnv() {
   return result;
 }
 var configRouter = router({
-  setPassthroughEnv: protectedProcedure.input(z21.object({
-    names: z21.array(
-      z21.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
+  setPassthroughEnv: protectedProcedure.input(z22.object({
+    names: z22.array(
+      z22.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256)
     ).max(100),
-    values: z21.record(
-      z21.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256),
-      z21.string().max(32768)
+    values: z22.record(
+      z22.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(256),
+      z22.string().max(32768)
     ).refine((obj) => Object.keys(obj).length <= 100, "Too many values").optional()
   })).mutation(({ input }) => {
     passthroughEnvNames = input.names;
@@ -3507,7 +3538,7 @@ var configRouter = router({
   getTraefikFileTree: protectedProcedure.query(async () => {
     return traefikManager.getFileTree();
   }),
-  getTraefikLogs: protectedProcedure.input(z21.object({ lines: z21.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
+  getTraefikLogs: protectedProcedure.input(z22.object({ lines: z22.number().int().min(1).max(500).default(100) })).query(async ({ input }) => {
     const logs = await traefikManager.getLogs(input.lines);
     return { logs };
   })
@@ -3699,17 +3730,17 @@ var healthChecker = new HealthChecker();
 import killPort from "kill-port";
 
 // src/config/env.ts
-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(),
+import { z as z23 } from "zod";
+var EnvSchema = z23.object({
+  RUNEYA_AGENT_PORT: z23.coerce.number().int().min(1).max(65535).default(4001),
+  RUNEYA_AGENT_HOST: z23.string().default("127.0.0.1"),
+  PASSPHRASE_OVERRIDE: z23.string().regex(/^[0-9a-f]+$/i, "Must be a hex string").optional(),
+  AGENT_ID: z23.string().optional(),
   // Set by spawner or manually for remote agents
-  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)
+  LOG_BUFFER_SIZE: z23.coerce.number().int().positive().default(LOG_BUFFER_SIZE),
+  METRICS_INTERVAL: z23.coerce.number().int().positive().default(METRICS_INTERVAL),
+  GRACE_PERIOD: z23.coerce.number().int().positive().default(GRACE_PERIOD),
+  HEALTH_WS_INTERVAL: z23.coerce.number().int().positive().default(HEALTH_WS_INTERVAL)
 });
 var env = EnvSchema.parse(process.env);
 
@@ -4494,7 +4525,7 @@ var processRouter = router({
     return processManager.listStatuses();
   }),
   /** Get a single process */
-  get: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).query(({ input }) => {
+  get: protectedProcedure.input(z24.object({ id: z24.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` });
@@ -4507,78 +4538,78 @@ var processRouter = router({
     return { id };
   }),
   /** Undeploy: stop + remove */
-  undeploy: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
+  undeploy: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ serviceId: z23.string().max(128), config: ServiceConfigSchema })).mutation(({ input }) => {
+  updateConfig: protectedProcedure.input(z24.object({ serviceId: z24.string().max(128), config: ServiceConfigSchema })).mutation(({ input }) => {
     processManager.updateConfig(input.serviceId, input.config);
     return { success: true };
   }),
   /** Start a deployed process */
-  start: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
+  start: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
+  stop: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ id: z23.string().max(128) })).mutation(async ({ input }) => {
+  restart: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ id: z23.string().max(128) })).query(({ input }) => {
+  logs: protectedProcedure.input(z24.object({ id: z24.string().max(128) })).query(({ input }) => {
     const logs = processManager.getLogs(input.id);
     return logs;
   }),
   /** Clear buffered logs for a process */
-  clearLogBuffer: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).mutation(({ input }) => {
+  clearLogBuffer: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ id: z23.string().max(128), shortcut: ServiceShortcutSchema })).mutation(async ({ input }) => {
+  executeShortcut: protectedProcedure.input(z24.object({ id: z24.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(z23.object({ id: z23.string().max(128), shortcutId: z23.string().max(128) })).mutation(({ input }) => {
+  cancelShortcut: protectedProcedure.input(z24.object({ id: z24.string().max(128), shortcutId: z24.string().max(128) })).mutation(({ input }) => {
     processManager.cancelShortcut(input.id, input.shortcutId);
     return { success: true };
   }),
   /** Cancel a running ad-hoc command */
-  cancelAdHocCommand: protectedProcedure.input(z23.object({ id: z23.string().max(128), commandId: z23.string().max(128).optional() })).mutation(({ input }) => {
+  cancelAdHocCommand: protectedProcedure.input(z24.object({ id: z24.string().max(128), commandId: z24.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(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()
+  executeAdHocCommand: protectedProcedure.input(z24.object({
+    id: z24.string().max(128),
+    command: z24.string().min(1).max(4096),
+    cwd: z24.string().max(4096).optional(),
+    commandId: z24.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(z23.object({ processId: z23.string().max(128) })).query(({ input }) => {
+  logSources: protectedProcedure.input(z24.object({ processId: z24.string().max(128) })).query(({ input }) => {
     return processManager.getLogSourceTypes(input.processId);
   }),
   /** Get current metrics for a process */
-  metrics: protectedProcedure.input(z23.object({ id: z23.string().max(128) })).query(async ({ input }) => {
+  metrics: protectedProcedure.input(z24.object({ id: z24.string().max(128) })).query(async ({ input }) => {
     return processManager.getMetrics(input.id);
   }),
   /** Subscribe to real-time log stream (yields batches of ParsedLog[]) */
-  onLog: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onLog: protectedProcedure.input(z24.object({ processId: z24.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (batch) => {
@@ -4607,7 +4638,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time status changes */
-  onStatus: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onStatus: protectedProcedure.input(z24.object({ processId: z24.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;
@@ -4639,7 +4670,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time health status changes */
-  onHealth: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onHealth: protectedProcedure.input(z24.object({ processId: z24.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (healthData) => {
@@ -4669,7 +4700,7 @@ var processRouter = router({
     }
   }),
   /** Subscribe to real-time metrics */
-  onMetrics: protectedProcedure.input(z23.object({ processId: z23.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
+  onMetrics: protectedProcedure.input(z24.object({ processId: z24.string().max(128).optional() }).optional()).subscription(async function* ({ input }) {
     const queue = [];
     let resolve2 = null;
     const handler = (metrics) => {
@@ -4750,7 +4781,7 @@ var healthRouter = router({
 });
 
 // src/trpc/routers/terminal.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import { TRPCError as TRPCError3 } from "@trpc/server";
 
 // src/services/terminal-manager.ts
@@ -4843,11 +4874,11 @@ var terminalManager = new TerminalManager();
 // src/trpc/routers/terminal.ts
 var terminalRouter = router({
   /** Spawn a new PTY shell session, returns a sessionId */
-  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()
+  create: protectedProcedure.input(z25.object({
+    cwd: z25.string().max(512).optional(),
+    cols: z25.number().int().min(1).max(512).optional(),
+    rows: z25.number().int().min(1).max(256).optional(),
+    title: z25.string().max(128).optional()
   })).mutation(({ input }) => {
     const sessionId = terminalManager.create(input.cwd, input.cols, input.rows, input.title);
     return { sessionId };
@@ -4855,34 +4886,34 @@ var terminalRouter = router({
   /** 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 }) => {
+  rename: protectedProcedure.input(z25.object({ sessionId: z25.string().max(128), title: z25.string().max(128) })).mutation(({ input }) => {
     terminalManager.rename(input.sessionId, input.title);
     return { ok: true };
   }),
   /** Write data (keystrokes) to a PTY session */
-  write: protectedProcedure.input(z24.object({ sessionId: z24.string().max(128), data: z24.string().max(65536) })).mutation(({ input }) => {
+  write: protectedProcedure.input(z25.object({ sessionId: z25.string().max(128), data: z25.string().max(65536) })).mutation(({ input }) => {
     terminalManager.write(input.sessionId, input.data);
     return { ok: true };
   }),
   /** Resize a PTY session */
-  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)
+  resize: protectedProcedure.input(z25.object({
+    sessionId: z25.string().max(128),
+    cols: z25.number().int().min(1).max(512),
+    rows: z25.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(z24.object({ sessionId: z24.string().max(128) })).mutation(({ input }) => {
+  destroy: protectedProcedure.input(z25.object({ sessionId: z25.string().max(128) })).mutation(({ input }) => {
     terminalManager.destroy(input.sessionId);
     return { ok: true };
   }),
   /** Stream PTY output for a session (async generator subscription) */
-  onData: protectedProcedure.input(z24.object({
-    sessionId: z24.string().max(128),
+  onData: protectedProcedure.input(z25.object({
+    sessionId: z25.string().max(128),
     /** Rejouer l'historique avant le flux : c'est ce qui rend l'onglet persistant. */
-    replay: z24.boolean().optional()
+    replay: z25.boolean().optional()
   })).subscription(async function* ({ input }) {
     const emitter = terminalManager.getEmitter(input.sessionId);
     if (!emitter) {
@@ -4927,7 +4958,7 @@ var terminalRouter = router({
 });
 
 // src/trpc/routers/git.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 import { TRPCError as TRPCError4 } from "@trpc/server";
 import { execFile as execFile5, spawn as spawn3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -4995,12 +5026,12 @@ async function sameGitRemote(a, b, resolveHost = resolveSshHost) {
 var execFileAsync3 = promisify3(execFile5);
 var GIT_TIMEOUT = 15e3;
 var DIFF_MAX_BYTES = 512 * 1024;
-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("../"), {
+var CWD_SCHEMA = z26.string().min(1).max(4096);
+var SAFE_PATH_SCHEMA = z26.string().min(1).max(4096).refine((p) => !p.startsWith("/") && !p.includes("../"), {
   message: "Path must be relative and not traverse up"
 });
-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._\-/]+$/);
+var REMOTE_SCHEMA = z26.string().min(1).max(128).regex(/^[a-zA-Z0-9_\-.]+$/);
+var BRANCH_SCHEMA = z26.string().min(1).max(256).regex(/^[a-zA-Z0-9._\-/]+$/);
 function gitSafeEnv() {
   const env2 = {
     GIT_TERMINAL_PROMPT: "0",
@@ -5118,10 +5149,10 @@ async function getGitStatus(cwd) {
 }
 var gitRouter = router({
   /** Check if a working directory exists and optionally verify its git remote */
-  checkCwd: protectedProcedure.input(z25.object({
+  checkCwd: protectedProcedure.input(z26.object({
     cwd: CWD_SCHEMA,
-    remote: z25.string().max(2048).optional(),
-    checkReachability: z25.boolean().optional()
+    remote: z26.string().max(2048).optional(),
+    checkReachability: z26.boolean().optional()
   })).query(async ({ input }) => {
     const resolvedCwd = expandEnvVar(input.cwd);
     const unresolvedVars = [...resolvedCwd.matchAll(/\$\{?(\w+)\}?/g)].map((m) => m[1]);
@@ -5143,8 +5174,8 @@ var gitRouter = router({
     return { exists, actualRemote, remoteMatches, unreachable: false, resolvedCwd: absoluteCwd, unresolvedVars: [] };
   }),
   /** Clone a git repository into a target directory */
-  clone: protectedProcedure.input(z25.object({
-    remote: z25.string().min(1).max(2048),
+  clone: protectedProcedure.input(z26.object({
+    remote: z26.string().min(1).max(2048),
     cwd: CWD_SCHEMA
   })).mutation(async ({ input }) => {
     const absoluteCwd = resolvePath(expandEnvVar(input.cwd));
@@ -5165,13 +5196,13 @@ var gitRouter = router({
     return { success: true };
   }),
   /** Get full git status */
-  status: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  status: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA })).subscription(async function* ({ input }) {
+  onStatusChange: protectedProcedure.input(z26.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();
@@ -5222,7 +5253,7 @@ var gitRouter = router({
     }
   }),
   /** Get commit log */
-  log: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, limit: z25.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
+  log: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, limit: z26.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";
@@ -5233,7 +5264,7 @@ var gitRouter = router({
     });
   }),
   /** List local and remote branches */
-  branches: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  branches: protectedProcedure.input(z26.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();
@@ -5245,7 +5276,7 @@ var gitRouter = router({
     return { current, branches };
   }),
   /** Checkout a branch */
-  checkout: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, create: z25.boolean().default(false) })).mutation(async ({ input }) => {
+  checkout: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, create: z26.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];
@@ -5253,42 +5284,42 @@ var gitRouter = router({
     return { ok: true };
   }),
   /** Stage files */
-  stage: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  stage: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, paths: z26.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(z25.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
+  stageAll: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  unstage: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, paths: z26.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(z25.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
+  unstageAll: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA, message: z25.string().min(1).max(4096) })).mutation(async ({ input }) => {
+  commit: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, message: z26.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(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z25.boolean().default(false) })).mutation(async ({ input }) => {
+  push: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z26.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();
@@ -5297,25 +5328,25 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Pull from remote */
-  pull: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  pull: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+  fetch: protectedProcedure.input(z26.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(z25.object({
+  diff: protectedProcedure.input(z26.object({
     cwd: CWD_SCHEMA,
-    path: z25.string().max(4096).optional(),
-    staged: z25.boolean().default(false),
-    untracked: z25.boolean().default(false)
+    path: z26.string().max(4096).optional(),
+    staged: z26.boolean().default(false),
+    untracked: z26.boolean().default(false)
   })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
@@ -5363,21 +5394,21 @@ var gitRouter = router({
     };
   }),
   /** Discard changes to working tree files */
-  discard: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, paths: z25.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+  discard: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, paths: z26.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(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  stagedDiff: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, noFf: z25.boolean().default(false) })).mutation(async ({ input }) => {
+  merge: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA, noFf: z26.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];
@@ -5385,14 +5416,14 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Rebase current branch onto another branch */
-  rebase: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
+  rebase: protectedProcedure.input(z26.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(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  remotes: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
     const output = await git(["remote", "-v"], cwd, true);
@@ -5410,7 +5441,7 @@ var gitRouter = router({
     return remotes;
   }),
   /** List stash entries */
-  stashList: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+  stashList: protectedProcedure.input(z26.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);
@@ -5423,10 +5454,10 @@ var gitRouter = router({
     return entries;
   }),
   /** Stash current changes */
-  stashPush: protectedProcedure.input(z25.object({
+  stashPush: protectedProcedure.input(z26.object({
     cwd: CWD_SCHEMA,
-    message: z25.string().max(4096).optional(),
-    includeUntracked: z25.boolean().default(true)
+    message: z26.string().max(4096).optional(),
+    includeUntracked: z26.boolean().default(true)
   })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
     await assertGitRepo(cwd);
@@ -5437,21 +5468,21 @@ var gitRouter = router({
     return { ok: true, output: output.trim() };
   }),
   /** Apply a stash entry and remove it from the list */
-  stashPop: protectedProcedure.input(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashPop: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, index: z26.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(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashApply: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, index: z26.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(z25.object({ cwd: CWD_SCHEMA, index: z25.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+  stashDrop: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA, index: z26.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);
@@ -5484,7 +5515,7 @@ function runGitRaw(args, timeoutMs, extraEnv) {
 }
 
 // src/trpc/routers/ai.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 import { TRPCError as TRPCError5 } from "@trpc/server";
 
 // src/services/ai-spawn-manager.ts
@@ -6201,23 +6232,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(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()
+  spawn: protectedProcedure.input(z27.object({
+    cli: z27.string().max(64),
+    args: z27.array(z27.string().max(5e5)),
+    env: z27.record(z27.string().max(256), z27.string().max(5e5)).optional(),
+    cwd: z27.string().max(4096).optional(),
+    stdinData: z27.string().max(1e7).optional(),
+    enableMcp: z27.boolean().optional(),
+    mcpApiBaseUrl: z27.string().max(512).optional(),
+    mcpApiToken: z27.string().max(8192).optional()
   })).mutation(({ input }) => {
     const spawnId = aiSpawnManager.spawn(input);
     return { spawnId };
   }),
   /** Stream stdout/stderr/exit chunks from offset. Reconnectable. */
-  stream: protectedProcedure.input(z26.object({
-    spawnId: z26.string().max(128),
-    fromOffset: z26.number().int().min(0).default(0)
+  stream: protectedProcedure.input(z27.object({
+    spawnId: z27.string().max(128),
+    fromOffset: z27.number().int().min(0).default(0)
   })).subscription(async function* ({ input }) {
     try {
       for await (const item of aiSpawnManager.stream(input.spawnId, input.fromOffset)) {
@@ -6231,39 +6262,39 @@ var aiRouter = router({
     }
   }),
   /** Spawn an AI CLI process in a PTY (interactive mode). Returns spawnId. */
-  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()
+  spawnPty: protectedProcedure.input(z27.object({
+    cli: z27.string().max(64),
+    args: z27.array(z27.string().max(5e5)),
+    env: z27.record(z27.string().max(256), z27.string().max(5e5)).optional(),
+    cwd: z27.string().max(4096).optional(),
+    cols: z27.number().int().min(1).max(1e3).optional(),
+    rows: z27.number().int().min(1).max(1e3).optional(),
+    sessionId: z27.string().max(128).optional(),
+    enableMcp: z27.boolean().optional(),
+    mcpApiBaseUrl: z27.string().max(512).optional(),
+    mcpApiToken: z27.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(z26.object({ sessionId: z26.string().max(128) })).query(({ input }) => {
+  findPtyBySession: protectedProcedure.input(z27.object({ sessionId: z27.string().max(128) })).query(({ input }) => {
     return aiSpawnManager.findPtyBySessionId(input.sessionId);
   }),
   /** Write input to a PTY spawn (user keystrokes). */
-  writePty: protectedProcedure.input(z26.object({
-    spawnId: z26.string().max(128),
-    data: z26.string().max(1e6)
+  writePty: protectedProcedure.input(z27.object({
+    spawnId: z27.string().max(128),
+    data: z27.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(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)
+  writeContextFiles: protectedProcedure.input(z27.object({
+    sessionId: z27.string().min(1).max(128),
+    files: z27.array(z27.object({
+      name: z27.string().min(1).max(256),
+      content: z27.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,
@@ -6278,25 +6309,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(z26.object({
-    sessionId: z26.string().max(128).optional(),
-    mimeType: z26.string().max(64),
-    base64: z26.string().max(15e6)
+  pasteImage: protectedProcedure.input(z27.object({
+    sessionId: z27.string().max(128).optional(),
+    mimeType: z27.string().max(64),
+    base64: z27.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(z26.object({
-    spawnId: z26.string().max(128),
-    cols: z26.number().int().min(1).max(1e3),
-    rows: z26.number().int().min(1).max(1e3)
+  resizePty: protectedProcedure.input(z27.object({
+    spawnId: z27.string().max(128),
+    cols: z27.number().int().min(1).max(1e3),
+    rows: z27.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(z26.object({ spawnId: z26.string().max(128) })).mutation(({ input }) => {
+  kill: protectedProcedure.input(z27.object({ spawnId: z27.string().max(128) })).mutation(({ input }) => {
     const killed = aiSpawnManager.kill(input.spawnId);
     return { ok: killed };
   }),
@@ -6305,23 +6336,23 @@ var aiRouter = router({
     return aiSpawnManager.list();
   }),
   /** Acknowledge receipt of all data — agent can clean up after TTL. */
-  ack: protectedProcedure.input(z26.object({ spawnId: z26.string().max(128) })).mutation(({ input }) => {
+  ack: protectedProcedure.input(z27.object({ spawnId: z27.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(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()
+  codexRequest: protectedProcedure.input(z27.object({
+    method: z27.string().max(256),
+    params: z27.record(z27.string(), z27.unknown()).default({}),
+    env: z27.record(z27.string().max(256), z27.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(z26.object({
-    threadId: z26.string().max(256).optional()
+  codexNotifications: protectedProcedure.input(z27.object({
+    threadId: z27.string().max(256).optional()
   }).default({})).subscription(async function* ({ input, signal }) {
     await codexAppServerManager.ensureConnected();
     const queue = [];
@@ -6358,13 +6389,13 @@ var aiRouter = router({
 });
 
 // src/trpc/routers/wiki.ts
-import { z as z27 } from "zod";
+import { z as z28 } 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 = 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("/"), {
+var CWD_SCHEMA2 = z28.string().min(1).max(4096);
+var REL_PATH_SCHEMA = z28.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;
@@ -6384,9 +6415,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "target",
   "out"
 ]);
-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) })
+var RepoEntrySchema = z28.lazy(() => z28.union([
+  z28.object({ type: z28.literal("file"), name: z28.string(), path: z28.string() }),
+  z28.object({ type: z28.literal("dir"), name: z28.string(), path: z28.string(), children: z28.array(RepoEntrySchema) })
 ]));
 async function walkMarkdown(root, dir, depth, counter) {
   if (depth > MAX_DEPTH || counter.n >= MAX_FILES) return [];
@@ -6456,13 +6487,13 @@ async function resolveRoot(cwd) {
   }
 }
 var wikiRouter = router({
-  listRepoMarkdown: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2 })).query(async ({ input }) => {
+  listRepoMarkdown: protectedProcedure.input(z28.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(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).query(async ({ input }) => {
+  readRepoMarkdown: protectedProcedure.input(z28.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" });
     }
@@ -6488,10 +6519,10 @@ var wikiRouter = router({
     const content = await readFile2(realTarget, "utf-8");
     return { path: input.path, content };
   }),
-  writeMarkdown: protectedProcedure.input(z27.object({
+  writeMarkdown: protectedProcedure.input(z28.object({
     cwd: CWD_SCHEMA2,
     path: REL_PATH_SCHEMA,
-    content: z27.string().max(5e6)
+    content: z28.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" });
@@ -6502,7 +6533,7 @@ var wikiRouter = router({
     await writeFile6(target, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
-  createFile: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createFile: protectedProcedure.input(z28.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" });
     }
@@ -6518,13 +6549,13 @@ var wikiRouter = router({
     await writeFile6(target, "", "utf-8");
     return { path: input.path, ok: true };
   }),
-  createDir: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createDir: protectedProcedure.input(z28.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(z27.object({
+  renamePath: protectedProcedure.input(z28.object({
     cwd: CWD_SCHEMA2,
     fromPath: REL_PATH_SCHEMA,
     toPath: REL_PATH_SCHEMA
@@ -6542,14 +6573,14 @@ var wikiRouter = router({
     await rename2(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
-  ensureRoot: protectedProcedure.input(z27.object({ cwd: CWD_SCHEMA2 })).mutation(async ({ input }) => {
+  ensureRoot: protectedProcedure.input(z28.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(z27.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  deletePath: protectedProcedure.input(z28.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) {