@chorus-aidlc/chorus 0.14.6 → 0.15.0

package/cli/directory-discovery.mjs

@@ -0,0 +1,184 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+export const DIRECTORY_ERROR_CODES = Object.freeze([
+  "HOST_OFFLINE",
+  "TIMEOUT",
+  "INVALID_PATH",
+  "OUTSIDE_ROOT",
+  "NOT_DIRECTORY",
+  "ACCESS_DENIED",
+  "STALE_TARGET",
+  "LIMIT_EXCEEDED",
+  "INTERNAL_ERROR",
+]);
+
+export class DirectoryDiscoveryError extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.name = "DirectoryDiscoveryError";
+    this.code = code;
+  }
+}
+
+function expandHome(value, home, pathApi) {
+  if (value === "~") return home;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return pathApi.join(home, value.slice(2));
+  }
+  return value;
+}
+
+export function isPathWithin(root, candidate, pathApi = path) {
+  const relative = pathApi.relative(pathApi.resolve(root), pathApi.resolve(candidate));
+  return relative === "" || (!relative.startsWith("..") && !pathApi.isAbsolute(relative));
+}
+
+function cursorIndex(cursor) {
+  if (cursor == null || cursor === "") return 0;
+  try {
+    const parsed = Number(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (Number.isSafeInteger(parsed) && parsed >= 0) return parsed;
+  } catch {}
+  throw new DirectoryDiscoveryError("INVALID_PATH", "Invalid directory cursor");
+}
+
+function fsError(err) {
+  if (err?.code === "EACCES" || err?.code === "EPERM") return "ACCESS_DENIED";
+  if (err?.code === "ENOTDIR") return "NOT_DIRECTORY";
+  if (err?.code === "ENOENT") return "INVALID_PATH";
+  return "INTERNAL_ERROR";
+}
+
+async function resolveRoots(roots, fsApi, pathApi) {
+  try {
+    return await Promise.all(roots.map(async (root) => ({
+      lexical: root,
+      real: await fsApi.realpath(root),
+    })));
+  } catch (err) {
+    throw new DirectoryDiscoveryError(fsError(err));
+  }
+}
+
+async function assertCanonicalWithin(candidate, roots, fsApi, pathApi) {
+  const lexicalRoot = roots.find((root) =>
+    isPathWithin(root.lexical, candidate, pathApi));
+  if (!lexicalRoot) throw new DirectoryDiscoveryError("OUTSIDE_ROOT");
+
+  let realCandidate;
+  try {
+    realCandidate = await fsApi.realpath(candidate);
+  } catch (err) {
+    throw new DirectoryDiscoveryError(fsError(err));
+  }
+  const relative = pathApi.relative(lexicalRoot.lexical, pathApi.resolve(candidate));
+  const expected = pathApi.resolve(lexicalRoot.real, relative);
+  if (realCandidate !== expected || !isPathWithin(lexicalRoot.real, realCandidate, pathApi)) {
+    throw new DirectoryDiscoveryError("OUTSIDE_ROOT");
+  }
+  return realCandidate;
+}
+
+/**
+ * Complete one path segment. Results intentionally contain only `{name,path}`.
+ */
+export async function discoverDirectories(options) {
+  const pathApi = options.pathApi ?? path;
+  const fsApi = options.fsApi ?? fs;
+  const home = options.home ?? homedir();
+  const maxScan = options.maxScan ?? 10_000;
+  const maxResults = options.maxResults ?? 1_000;
+  const maxLimit = options.maxLimit ?? 100;
+  const timeoutMs = options.timeoutMs ?? 2_000;
+  const limit = options.limit ?? 50;
+  if (!Number.isInteger(limit) || limit < 1 || limit > maxLimit) {
+    throw new DirectoryDiscoveryError("LIMIT_EXCEEDED");
+  }
+  if (typeof options.prefix !== "string" || !options.prefix.trim()) {
+    throw new DirectoryDiscoveryError("INVALID_PATH");
+  }
+  const expanded = expandHome(options.prefix.trim(), home, pathApi);
+  if (!pathApi.isAbsolute(expanded)) throw new DirectoryDiscoveryError("INVALID_PATH");
+  const normalized = pathApi.normalize(expanded);
+  const parent = normalized.endsWith(pathApi.sep)
+    ? normalized
+    : pathApi.dirname(normalized);
+  const namePrefix = normalized.endsWith(pathApi.sep) ? "" : pathApi.basename(normalized);
+  const lexicalRoots = (options.browseRoots ?? []).map((root) => pathApi.resolve(root));
+  if (!lexicalRoots.some((root) => isPathWithin(root, parent, pathApi))) {
+    throw new DirectoryDiscoveryError("OUTSIDE_ROOT");
+  }
+
+  const scan = async () => {
+    const roots = await resolveRoots(lexicalRoots, fsApi, pathApi);
+    let parentStat;
+    try {
+      parentStat = await fsApi.lstat(parent);
+      await fsApi.access(parent);
+    } catch (err) {
+      throw new DirectoryDiscoveryError(fsError(err));
+    }
+    if (parentStat.isSymbolicLink()) throw new DirectoryDiscoveryError("OUTSIDE_ROOT");
+    if (!parentStat.isDirectory()) throw new DirectoryDiscoveryError("NOT_DIRECTORY");
+    await assertCanonicalWithin(parent, roots, fsApi, pathApi);
+
+    let entries;
+    try {
+      entries = await fsApi.readdir(parent, { withFileTypes: true });
+    } catch (err) {
+      throw new DirectoryDiscoveryError(fsError(err));
+    }
+    if (entries.length > maxScan) throw new DirectoryDiscoveryError("LIMIT_EXCEEDED");
+    const matches = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || !entry.name.startsWith(namePrefix)) continue;
+      const candidate = pathApi.resolve(parent, entry.name);
+      if (!roots.some((root) => isPathWithin(root.lexical, candidate, pathApi))) continue;
+      try {
+        const stat = await fsApi.lstat(candidate);
+        if (stat.isSymbolicLink() || !stat.isDirectory()) continue;
+        await fsApi.access(candidate);
+        await assertCanonicalWithin(candidate, roots, fsApi, pathApi);
+      } catch {
+        continue;
+      }
+      matches.push({ name: entry.name, path: candidate });
+      if (matches.length > maxResults) throw new DirectoryDiscoveryError("LIMIT_EXCEEDED");
+    }
+    matches.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }) || a.name.localeCompare(b.name));
+    const start = cursorIndex(options.cursor);
+    const items = matches.slice(start, start + limit);
+    const next = start + items.length;
+    return {
+      items,
+      nextCursor: next < matches.length
+        ? Buffer.from(String(next), "utf8").toString("base64url")
+        : null,
+    };
+  };
+
+  let timer;
+  try {
+    return await Promise.race([
+      scan(),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new DirectoryDiscoveryError("TIMEOUT")), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function validateDirectory(options) {
+  const result = await discoverDirectories({
+    ...options,
+    prefix: options.cwd.endsWith(options.pathApi?.sep ?? path.sep)
+      ? options.cwd
+      : `${options.cwd}${options.pathApi?.sep ?? path.sep}`,
+    limit: 1,
+  });
+  return { valid: true, normalizedPath: (options.pathApi ?? path).normalize(options.cwd), ...result };
+}

package/cli/event-router.mjs

@@ -105,7 +105,8 @@ export class EventRouter {
     const targetConnectionUuid =
       typeof event.targetConnectionUuid === "string" ? event.targetConnectionUuid : null;
     const suppressWake = event.suppressWake === true;
-    this.#fetchAndRoute(event.notificationUuid, { targetConnectionUuid, suppressWake }).catch(
+    const runtimeCwd = typeof event.runtimeCwd === "string" ? event.runtimeCwd : null;
+    this.#fetchAndRoute(event.notificationUuid, { targetConnectionUuid, suppressWake, runtimeCwd }).catch(
       (err) => {
         this.logger.error(`[Chorus] failed to route notification ${event.notificationUuid}: ${err}`);
       }
@@ -209,7 +210,8 @@ export class EventRouter {
       );
     }
 
-    await this.#resolveAndEnqueue(n, notificationUuid);
+    const routed = transport.runtimeCwd ? { ...n, runtimeCwd: transport.runtimeCwd } : n;
+    await this.#resolveAndEnqueue(routed, notificationUuid);
   }
 
   /**
@@ -244,6 +246,7 @@ export class EventRouter {
       entityType,
       entityUuid,
       ...(resumedFrom ? { resumedFrom } : {}),
+      ...(typeof target?.runtimeCwd === "string" ? { runtimeCwd: target.runtimeCwd } : {}),
     };
     this.#resolveAndEnqueue(n, `resume:${entityType}:${entityUuid}`).catch((err) => {
       this.logger.error(`[Chorus] failed to dispatch resume for ${entityType}:${entityUuid}: ${err}`);
@@ -319,6 +322,7 @@ export class EventRouter {
         sessionId,
         directIdeaUuid,
         trigger: pending.trigger,
+        runtimeCwd: typeof pending.runtimeCwd === "string" ? pending.runtimeCwd : null,
       }).catch((err) => {
         this.logger.error(
           `[Chorus] failed to re-dispatch autonomous pending turn ${turnUuid}: ${err}`
@@ -367,6 +371,7 @@ export class EventRouter {
       entityType: directIdeaUuid ? "idea" : "daemon_session",
       entityUuid: directIdeaUuid ? directIdeaUuid : sessionId,
       instructionText: instruction,
+      ...(typeof pending.runtimeCwd === "string" ? { runtimeCwd: pending.runtimeCwd } : {}),
     };
     const key = directIdeaUuid ? `idea:${directIdeaUuid}` : `entity:daemon_session:${sessionId}`;
     const attribution = { key, rootIdeaUuid: directIdeaUuid, directIdeaUuid };
@@ -407,7 +412,7 @@ export class EventRouter {
    * @param {{ turnUuid: string, sessionId: string, directIdeaUuid: string|null, trigger: string }} pending
    */
   async #redispatchAutonomousTurn(pending) {
-    const { turnUuid, sessionId, directIdeaUuid, trigger } = pending;
+    const { turnUuid, sessionId, directIdeaUuid, trigger, runtimeCwd } = pending;
     let result;
     try {
       result = await this.mcp.callTool("chorus_get_notifications", {
@@ -488,7 +493,10 @@ export class EventRouter {
     this.logger.info(
       `[Chorus] autonomous pending turn ${turnUuid} (${trigger}): waking from re-read notification ${match.uuid}`
     );
-    await this.#resolveAndEnqueue(match, match.uuid);
+    await this.#resolveAndEnqueue(
+      runtimeCwd ? { ...match, runtimeCwd } : match,
+      match.uuid,
+    );
   }
 
   /**

package/cli/turn-reporter.mjs

@@ -4,7 +4,8 @@
 // persistent conversation; the server creates that turn (status `pending`) at the
 // notification chokepoint, and the daemon advances it:
 //   • on spawn      → pending → running
-//   • on subprocess exit → running → ended (clean) | interrupted (user/crash/shutdown)
+//   • on subprocess exit/validation → running → ended (clean) |
+//     interrupted (user/crash/shutdown/invalid_path)
 //
 // The daemon does NOT know the server-side turn uuid. It identifies the turn the SAME
 // way the transcript ingest does — by the session BUSINESS KEY (`sessionId` = the
@@ -30,7 +31,12 @@ const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
 export const TURN_STATUSES = new Set(["pending", "running", "ended", "interrupted"]);
 
 /** Interrupt reasons a DAEMON may report (`offline` is server-reconcile-only). */
-export const TURN_INTERRUPT_REASONS = new Set(["user", "crash", "shutdown"]);
+export const TURN_INTERRUPT_REASONS = new Set([
+  "user",
+  "crash",
+  "shutdown",
+  "invalid_path",
+]);
 
 /**
  * Build an `advanceTurn(params)` function the waker invokes on a wake's spawn (→
@@ -46,7 +52,7 @@ export const TURN_INTERRUPT_REASONS = new Set(["user", "crash", "shutdown"]);
  *   logger?: { info(m:string):void, warn(m:string):void, error(m:string):void },
  *   fetchImpl?: typeof fetch,             Injectable for tests.
  * }} opts
- * @returns {(params: { sessionId: string, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown"|null, transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null }) => Promise<void>}
+ * @returns {(params: { sessionId: string, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown"|"invalid_path"|null, transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null }) => Promise<void>}
  */
 export function createTurnReporter(opts) {
   const logger = opts.logger ?? NOOP_LOGGER;
@@ -69,6 +75,7 @@ export function createTurnReporter(opts) {
     interruptedReason,
     transcriptRelayError,
     usage,
+    backendSessionId,
   }) {
     if (typeof sessionId !== "string" || !sessionId || !TURN_STATUSES.has(status)) {
       logger.warn(
@@ -103,6 +110,7 @@ export function createTurnReporter(opts) {
       // Per-turn token usage (daemon-token-usage): the client spreads it into the body
       // only on a terminal edge. No validation here — usage is an opaque nested object.
       usage,
+      backendSessionId,
     });
   };
 }

package/cli/waker.mjs

@@ -30,6 +30,7 @@ export class Waker {
    *   lineage: { resolve: (event: any) => Promise<{ rootIdeaUuid: string|null, directIdeaUuid: string|null }> },
    *   spawner: { wake: (params: any) => Promise<{ sessionId: string, exitCode: number|null, isNew: boolean }> },
    *   cwd?: string,  The connection/session-bound working directory this Waker serves; resolveCwd() is the single source the probe + spawn + resume use. `undefined` ⇒ the process default cwd (HARD-1 / single-path).
+   *   validateRuntimeCwd?: (cwd: string) => Promise<{normalizedPath?: string}>,
    *   hooks?: import("./upload-hooks.mjs").UploadHooks,
    *   logger?: { info(m:string):void, warn(m:string):void, error(m:string):void },
    *   writeMcpConfigFn?: typeof writeMcpConfig,
@@ -38,7 +39,7 @@ export class Waker {
    *     Injectable interrupt reporter (子3). Called when a wake's subprocess exits in
    *     an interrupted (user) or crashed (non-zero, no interrupt flag) state. Defaults
    *     to a no-op that logs — the daemon wires the REST reporter (interrupt-reporter.mjs).
-   *   advanceTurn?: (params: { sessionId: string, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown", transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null }) => Promise<void>,
+   *   advanceTurn?: (params: { sessionId: string, backendSessionId?: string|null, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown", transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null }) => Promise<void>,
    *     Injectable turn-lifecycle reporter (子1 — daemon-session-conversation). Called
    *     on spawn (→ running) and on subprocess exit (→ ended on a clean exit, or
    *     → interrupted with the classified reason otherwise) to advance the server-side
@@ -67,6 +68,7 @@ export class Waker {
     // so resolveCwd() is the SINGLE place the process-default fallback is applied
     // (Module Contract 1 — one cwd source of truth, no scattered process.cwd()).
     this.cwd = opts.cwd;
+    this.validateRuntimeCwd = opts.validateRuntimeCwd;
     this.hooks = opts.hooks;
     this.logger = opts.logger ?? NOOP_LOGGER;
     this.writeMcpConfigFn = opts.writeMcpConfigFn ?? writeMcpConfig;
@@ -145,8 +147,8 @@ export class Waker {
    * wake path reads `process.cwd()`.
    * @returns {string}
    */
-  resolveCwd() {
-    return this.cwd ?? process.cwd();
+  resolveCwd(runtimeCwd) {
+    return runtimeCwd ?? this.cwd ?? process.cwd();
   }
 
   /**
@@ -340,6 +342,11 @@ export class Waker {
     // duration. `Date.now()` is fine here (runtime metric, not a resume seed).
     const startMs = Date.now();
     const target = entity ? `${entity.entityType}:${entity.entityUuid}` : key;
+    const sessionId = directIdeaUuid ?? notification.entityUuid ?? null;
+    const requestedRuntimeCwd =
+      typeof notification?.runtimeCwd === "string" && notification.runtimeCwd
+        ? notification.runtimeCwd
+        : null;
     try {
       const prompt = buildPrompt(notification);
       if (!prompt) {
@@ -377,12 +384,21 @@ export class Waker {
       // Decide new-vs-resume by probing the on-disk transcript in the SAME cwd we
       // spawn in. The spawner re-validates the id is a lowercase UUID before
       // spawning, so a garbage id surfaces visibly rather than misanchoring.
-      const sessionId = directIdeaUuid ?? notification.entityUuid ?? null;
       // Resolve the connection/session-bound cwd ONCE for this wake (Module Contract
       // 1). The transcript probe and the spawn below BOTH use this same value, so a
       // session's repeated wakes/probes always land the same cwd (NFR-3) — and a
       // multi-path daemon's other Wakers (other cwds) never bleed in.
-      const cwd = this.resolveCwd();
+      let cwd = this.resolveCwd(requestedRuntimeCwd);
+      if (requestedRuntimeCwd) {
+        if (!this.validateRuntimeCwd) {
+          throw new Error("Directed runtime cwd cannot be validated by this daemon");
+        }
+        const validation = await this.validateRuntimeCwd(requestedRuntimeCwd);
+        if (!validation?.normalizedPath) {
+          throw new Error("Directed runtime cwd validation returned no normalized path");
+        }
+        cwd = validation.normalizedPath;
+      }
       const isNew = sessionId ? this.isNewSessionFn(sessionId, cwd) : true;
 
       // Spawners declare whether the shared transcript probe is authoritative
@@ -524,10 +540,10 @@ export class Waker {
           // A clean exit with a KNOWN relay drop is the exact #444 signature: the reply
           // ran but its transcript never landed. Annotate the (still-clean) `ended` turn.
           // `turnUsage` rides the same terminal advance (daemon-token-usage).
-          await this.#advanceTurn(sessionId, "ended", entity, null, transcriptRelayError, turnUsage);
+          await this.#advanceTurn(sessionId, "ended", entity, null, transcriptRelayError, turnUsage, result?.backendSessionId);
         } else {
           const reason = wasInterrupting ? "user" : this.shuttingDown ? "shutdown" : "crash";
-          await this.#advanceTurn(sessionId, "interrupted", entity, reason, transcriptRelayError, turnUsage);
+          await this.#advanceTurn(sessionId, "interrupted", entity, reason, transcriptRelayError, turnUsage, result?.backendSessionId);
         }
       }
 
@@ -566,6 +582,16 @@ export class Waker {
       }
     } catch (err) {
       this.logger.warn(`[Chorus] wake failed for ${key}: ${err}`);
+      if (sessionId && requestedRuntimeCwd && typeof err?.code === "string") {
+        await this.#advanceTurn(sessionId, "running", entity);
+        await this.#advanceTurn(
+          sessionId,
+          "interrupted",
+          entity,
+          "invalid_path",
+          `${err.code}: ${err.message ?? "Runtime cwd validation failed"}`,
+        );
+      }
     } finally {
       // Wake finished (cleanly or not): the resource leaves the active set. Drop
       // it and emit a fresh snapshot so the server ends its running/queued row.
@@ -622,7 +648,7 @@ export class Waker {
    * @param {import("./upload-hooks.mjs").TokenUsage|null} [usage]  Per-turn token usage
    *   (daemon-token-usage); forwarded only on a terminal edge, mirroring transcriptRelayError.
    */
-  async #advanceTurn(sessionId, status, entity, interruptedReason = null, transcriptRelayError = null, usage = null) {
+  async #advanceTurn(sessionId, status, entity, interruptedReason = null, transcriptRelayError = null, usage = null, backendSessionId = null) {
     try {
       await this.advanceTurn({
         sessionId,
@@ -632,6 +658,7 @@ export class Waker {
         ...(status === "interrupted" && interruptedReason ? { interruptedReason } : {}),
         ...(transcriptRelayError ? { transcriptRelayError } : {}),
         ...(usage ? { usage } : {}),
+        ...(backendSessionId ? { backendSessionId } : {}),
       });
     } catch (err) {
       this.logger.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chorus-aidlc/chorus",
-  "version": "0.14.6",
+  "version": "0.15.0",
   "description": "The Agent Harness for AI-Human Collaboration — session lifecycle, task state, sub-agent orchestration, observability, and failure recovery",
   "homepage": "https://github.com/Chorus-AIDLC/Chorus",
   "repository": {

package/prisma/migrations/20260731093000_add_daemon_backend_session_id/migration.sql

@@ -0,0 +1 @@
+ALTER TABLE "DaemonSession" ADD COLUMN "backendSessionId" TEXT;

package/prisma/migrations/20260801113000_add_project_agent_cwd_discovery/migration.sql

@@ -0,0 +1,50 @@
+CREATE TABLE "ProjectAgentCwdPreference" (
+  "id" SERIAL NOT NULL,
+  "uuid" TEXT NOT NULL,
+  "companyUuid" TEXT NOT NULL,
+  "userUuid" TEXT NOT NULL,
+  "projectUuid" TEXT NOT NULL,
+  "agentUuid" TEXT NOT NULL,
+  "host" TEXT NOT NULL,
+  "cwd" TEXT NOT NULL,
+  "anchorAgentInstanceUuid" TEXT,
+  "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" TIMESTAMP(3) NOT NULL,
+  CONSTRAINT "ProjectAgentCwdPreference_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "DaemonDirectoryRequest" (
+  "id" SERIAL NOT NULL,
+  "uuid" TEXT NOT NULL,
+  "companyUuid" TEXT NOT NULL,
+  "callerUserUuid" TEXT NOT NULL,
+  "agentUuid" TEXT NOT NULL,
+  "targetConnectionUuid" TEXT NOT NULL,
+  "operation" TEXT NOT NULL,
+  "prefix" TEXT,
+  "cwd" TEXT,
+  "cursor" TEXT,
+  "limit" INTEGER NOT NULL,
+  "status" TEXT NOT NULL DEFAULT 'pending',
+  "result" JSONB,
+  "errorCode" TEXT,
+  "deadlineAt" TIMESTAMP(3) NOT NULL,
+  "completedAt" TIMESTAMP(3),
+  "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updatedAt" TIMESTAMP(3) NOT NULL,
+  CONSTRAINT "DaemonDirectoryRequest_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX "ProjectAgentCwdPreference_uuid_key" ON "ProjectAgentCwdPreference"("uuid");
+CREATE UNIQUE INDEX "ProjectAgentCwdPreference_userUuid_projectUuid_agentUuid_key" ON "ProjectAgentCwdPreference"("userUuid", "projectUuid", "agentUuid");
+CREATE INDEX "ProjectAgentCwdPreference_companyUuid_projectUuid_idx" ON "ProjectAgentCwdPreference"("companyUuid", "projectUuid");
+CREATE INDEX "ProjectAgentCwdPreference_projectUuid_idx" ON "ProjectAgentCwdPreference"("projectUuid");
+CREATE INDEX "ProjectAgentCwdPreference_agentUuid_idx" ON "ProjectAgentCwdPreference"("agentUuid");
+CREATE INDEX "ProjectAgentCwdPreference_anchorAgentInstanceUuid_idx" ON "ProjectAgentCwdPreference"("anchorAgentInstanceUuid");
+CREATE UNIQUE INDEX "DaemonDirectoryRequest_uuid_key" ON "DaemonDirectoryRequest"("uuid");
+CREATE INDEX "DaemonDirectoryRequest_companyUuid_callerUserUuid_createdAt_idx" ON "DaemonDirectoryRequest"("companyUuid", "callerUserUuid", "createdAt");
+CREATE INDEX "DaemonDirectoryRequest_callerUserUuid_idx" ON "DaemonDirectoryRequest"("callerUserUuid");
+CREATE INDEX "DaemonDirectoryRequest_agentUuid_idx" ON "DaemonDirectoryRequest"("agentUuid");
+CREATE INDEX "DaemonDirectoryRequest_targetConnectionUuid_status_idx" ON "DaemonDirectoryRequest"("targetConnectionUuid", "status");
+CREATE INDEX "DaemonDirectoryRequest_deadlineAt_idx" ON "DaemonDirectoryRequest"("deadlineAt");
+ALTER TABLE "DaemonSession" ADD COLUMN "runtimeCwd" TEXT;

package/prisma/migrations/20260802140000_add_assignment_runtime_cwd_snapshot/migration.sql

@@ -0,0 +1,7 @@
+ALTER TABLE "Idea" ADD COLUMN "cwdSource" TEXT;
+ALTER TABLE "Idea" ADD COLUMN "cwdHost" TEXT;
+ALTER TABLE "Idea" ADD COLUMN "runtimeCwd" TEXT;
+
+ALTER TABLE "Task" ADD COLUMN "cwdSource" TEXT;
+ALTER TABLE "Task" ADD COLUMN "cwdHost" TEXT;
+ALTER TABLE "Task" ADD COLUMN "runtimeCwd" TEXT;