@runeya/runeya 2.0.92 → 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";
 
@@ -2957,7 +2988,7 @@ async function getDockerStats(containerName) {
     execFile(
       "docker",
       ["stats", "--no-stream", "--format", "{{json .}}", containerName],
-      { timeout: 5e3 },
+      { timeout: 5e3, windowsHide: true },
       (err, stdout) => {
         if (err || !stdout.trim()) {
           resolve2(null);
@@ -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";
@@ -3283,6 +3314,7 @@ var TraefikManager = class {
       "traefik:v3"
     ];
     this.process = spawn("docker", args, {
+      windowsHide: true,
       shell: false,
       detached: false,
       stdio: ["ignore", "pipe", "pipe"]
@@ -3320,7 +3352,7 @@ var TraefikManager = class {
       this.debounceTimer = null;
     }
     await new Promise((resolve2) => {
-      execFile2("docker", ["rm", "-f", "runeya-traefik"], { timeout: 1e4 }, () => resolve2());
+      execFile2("docker", ["rm", "-f", "runeya-traefik"], { timeout: 1e4, windowsHide: true }, () => resolve2());
     });
     await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
@@ -3362,7 +3394,7 @@ var TraefikManager = class {
   }
   async getLogs(lines = 100) {
     return new Promise((resolve2) => {
-      execFile2("docker", ["logs", "--tail", String(lines), "runeya-traefik"], { timeout: 1e4 }, (err, stdout, stderr) => {
+      execFile2("docker", ["logs", "--tail", String(lines), "runeya-traefik"], { timeout: 1e4, windowsHide: true }, (err, stdout, stderr) => {
         if (err) {
           resolve2("");
           return;
@@ -3413,7 +3445,7 @@ var TraefikManager = class {
     let dockerAvailable = false;
     try {
       await new Promise((resolve2, reject) => {
-        execFile2("docker", ["info", "--format", "{{.ServerVersion}}"], { timeout: 5e3 }, (err) => {
+        execFile2("docker", ["info", "--format", "{{.ServerVersion}}"], { timeout: 5e3, windowsHide: true }, (err) => {
           if (err) reject(err instanceof Error ? err : new Error("docker info failed"));
           else resolve2();
         });
@@ -3433,7 +3465,7 @@ var TraefikManager = class {
     if (dockerAvailable) {
       try {
         const output = await new Promise((resolve2, reject) => {
-          execFile2("docker", ["inspect", "--format", "{{.State.Running}}", "runeya-traefik"], { timeout: 5e3 }, (err, stdout) => {
+          execFile2("docker", ["inspect", "--format", "{{.State.Running}}", "runeya-traefik"], { timeout: 5e3, windowsHide: true }, (err, stdout) => {
             if (err) reject(err instanceof Error ? err : new Error("docker inspect failed"));
             else resolve2(stdout.trim());
           });
@@ -3463,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;
@@ -3506,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 };
   })
@@ -3698,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);
 
@@ -4493,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` });
@@ -4506,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) => {
@@ -4606,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;
@@ -4638,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) => {
@@ -4668,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) => {
@@ -4741,15 +4773,15 @@ var healthRouter = router({
   /** Check which AI CLIs are available on this agent */
   checkCli: protectedProcedure.query(async () => {
     const [claudeOk, codexOk] = await Promise.all([
-      execFileAsync("claude", ["--version"], { timeout: 5e3, shell: false }).then(() => true).catch(() => false),
-      execFileAsync("codex", ["--version"], { timeout: 5e3, shell: false }).then(() => true).catch(() => false)
+      execFileAsync("claude", ["--version"], { timeout: 5e3, shell: false, windowsHide: true }).then(() => true).catch(() => false),
+      execFileAsync("codex", ["--version"], { timeout: 5e3, shell: false, windowsHide: true }).then(() => true).catch(() => false)
     ]);
     return { claudeAvailable: claudeOk, codexAvailable: codexOk };
   })
 });
 
 // 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
@@ -4842,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 };
@@ -4854,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) {
@@ -4926,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";
@@ -4966,6 +4998,7 @@ async function resolveSshHost(host) {
   if (!/^[a-zA-Z0-9._-]+$/.test(host)) return host;
   try {
     const { stdout } = await execFileAsync2("ssh", ["-G", host], {
+      windowsHide: true,
       timeout: 3e3,
       env: { PATH: process.env["PATH"] ?? "", HOME: process.env["HOME"] ?? "" }
     });
@@ -4993,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",
@@ -5032,7 +5065,7 @@ async function git(args, cwd, readOnly = false) {
   const env2 = gitSafeEnv();
   if (readOnly) env2["GIT_OPTIONAL_LOCKS"] = "0";
   try {
-    const result = execFileAsync3("git", args, { cwd, signal: ac.signal, env: env2 });
+    const result = execFileAsync3("git", args, { cwd, signal: ac.signal, env: env2, windowsHide: true });
     if (result.child) {
       activeGitProcesses.add(result.child);
       result.child.on("close", () => activeGitProcesses.delete(result.child));
@@ -5116,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]);
@@ -5141,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));
@@ -5163,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();
@@ -5220,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";
@@ -5231,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();
@@ -5243,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];
@@ -5251,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();
@@ -5295,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);
@@ -5361,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];
@@ -5383,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);
@@ -5408,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);
@@ -5421,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);
@@ -5435,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);
@@ -5458,7 +5491,7 @@ var gitRouter = router({
 });
 function runGitRaw(args, timeoutMs, extraEnv) {
   return new Promise((res) => {
-    const child = spawn3("git", args, { shell: false, stdio: "pipe", env: { ...process.env, ...extraEnv } });
+    const child = spawn3("git", args, { shell: false, stdio: "pipe", env: { ...process.env, ...extraEnv }, windowsHide: true });
     let out = "";
     child.stdout?.on("data", (d) => {
       out += d.toString();
@@ -5482,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
@@ -5629,6 +5662,7 @@ var AiSpawnManager = class {
     const { env: env2, args } = resolveSpawnEnvAndArgs(opts);
     const invocation = resolveCliInvocation(opts.cli, args);
     const proc = spawn4(invocation.command, invocation.args, {
+      windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
       env: env2,
@@ -5949,6 +5983,7 @@ var CodexAppServerManager = class extends EventEmitter10 {
   async doConnect() {
     const env2 = { ...process.env, ...this.extraEnv };
     this.proc = spawn6("codex", [...resolveMcpArgs(env2), "app-server"], {
+      windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
       env: env2
     });
@@ -6122,7 +6157,7 @@ function runCmd(cmd, args, stdin, timeoutMs = 5e3) {
       resolve2({ code, stderr });
     };
     try {
-      const child = spawn7(cmd, args, { stdio: ["pipe", "ignore", "pipe"] });
+      const child = spawn7(cmd, args, { stdio: ["pipe", "ignore", "pipe"], windowsHide: true });
       let stderr = "";
       child.stderr.on("data", (c) => {
         stderr += c.toString();
@@ -6197,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)) {
@@ -6227,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,
@@ -6274,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 };
   }),
@@ -6301,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 = [];
@@ -6354,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;
@@ -6380,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 [];
@@ -6452,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" });
     }
@@ -6484,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" });
@@ -6498,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" });
     }
@@ -6514,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
@@ -6538,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) {