orionfold-relay 0.15.2 → 0.15.4

package/dist/cli.js

@@ -9347,6 +9347,26 @@ var init_helpers2 = __esm({
 // src/lib/chat/tools/project-tools.ts
 import { z as z9 } from "zod";
 import { eq as eq21, and as and10, count } from "drizzle-orm";
+async function findSimilarProjects(candidateName) {
+  const candidateNameLower = candidateName.trim().toLowerCase();
+  if (!candidateNameLower) return [];
+  const existing = await db.select({
+    id: projects.id,
+    name: projects.name,
+    description: projects.description
+  }).from(projects);
+  const matches = [];
+  for (const row of existing) {
+    if (row.name.trim().toLowerCase() === candidateNameLower) {
+      matches.push({
+        id: row.id,
+        name: row.name,
+        reason: `Same name: "${row.name}"`
+      });
+    }
+  }
+  return matches;
+}
 function projectTools(ctx) {
   return [
     defineTool(
@@ -9380,10 +9400,23 @@ function projectTools(ctx) {
       {
         name: z9.string().min(1).max(100).describe("Project name"),
         description: z9.string().max(500).optional().describe("Project description"),
-        workingDirectory: z9.string().max(500).optional().describe("Absolute path to the project's working directory")
+        workingDirectory: z9.string().max(500).optional().describe("Absolute path to the project's working directory"),
+        force: z9.boolean().optional().describe(
+          "Set to true to create a project even when one with the same name already exists. Only use this when the user has explicitly confirmed they want a second same-named project. Default false \u2014 normally you should reuse the existing project returned by the near-duplicate check (its id) instead of creating a duplicate."
+        )
       },
       async (args) => {
         try {
+          if (!args.force) {
+            const similar = await findSimilarProjects(args.name);
+            if (similar.length > 0) {
+              return ok({
+                status: "similar-found",
+                message: "A project with this name already exists. Reuse it by its id for subsequent artifacts (profiles, tables, workflows), or pass force=true to create a separate same-named project.",
+                matches: similar
+              });
+            }
+          }
           const now = /* @__PURE__ */ new Date();
           const id = crypto.randomUUID();
           await db.insert(projects).values({
@@ -25202,8 +25235,8 @@ import { execFileSync as execFileSync3 } from "child_process";
 import yaml12 from "js-yaml";
 import semver from "semver";
 function relayCoreVersion() {
-  if (semver.valid("0.15.2")) {
-    return "0.15.2";
+  if (semver.valid("0.15.4")) {
+    return "0.15.4";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
@@ -25645,6 +25678,12 @@ function buildNextLaunchArgs({
 function buildSidecarUrl(port, host = SIDECAR_LOOPBACK_HOST) {
   return `http://${host}:${port}`;
 }
+function isNonLoopbackHost(host) {
+  const h = host.trim().toLowerCase();
+  if (h === "localhost" || h === "::1") return false;
+  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return false;
+  return true;
+}
 
 // bin/cli.ts
 init_ainative_paths();
@@ -25842,6 +25881,7 @@ Environment variables:
 
 Examples:
   node dist/cli.js --port 3210 --no-open
+  node dist/cli.js --hostname 0.0.0.0 --port 3000    # expose on the LAN (see warning)
   node dist/cli.js --data-dir ~/.relay-dogfood --port 3100
   node dist/cli.js plugin dry-run my-plugin    # print confinement policy
   node dist/cli.js pack add ./my-pack          # install a Relay pack (folder or git url)
@@ -25849,7 +25889,11 @@ Examples:
   node dist/cli.js pack remove my-pack         # uninstall a pack
 `;
 }
-program.name("relay").description("Orionfold Relay \u2014 a local-first, multi-agent orchestration runtime and builder scaffold for AI-native work.").version(pkg.version).addHelpText("after", getHelpText).option("-p, --port <number>", "port to start on", "3000").option("--data-dir <path>", "custom data directory (overrides RELAY_DATA_DIR)").option("--reset", "delete the local database before starting").option("--no-open", "don't auto-open browser").option("--safe-mode", "disable Kind-1 plugin MCP servers; Kind-5 primitives bundles still load");
+program.name("relay").description("Orionfold Relay \u2014 a local-first, multi-agent orchestration runtime and builder scaffold for AI-native work.").version(pkg.version).addHelpText("after", getHelpText).option("-p, --port <number>", "port to start on", "3000").option(
+  "--hostname <host>",
+  "host to bind to (default 127.0.0.1; use 0.0.0.0 to expose on the network)",
+  "127.0.0.1"
+).option("--data-dir <path>", "custom data directory (overrides RELAY_DATA_DIR)").option("--reset", "delete the local database before starting").option("--no-open", "don't auto-open browser").option("--safe-mode", "disable Kind-1 plugin MCP servers; Kind-5 primitives bundles still load");
 var firstArg = process.argv[2];
 var isPluginSubcommand = firstArg === "plugin";
 var isPackSubcommand = firstArg === "pack";
@@ -25979,11 +26023,18 @@ async function main() {
   }
   const nextEntrypoint = resolveNextEntrypoint(effectiveCwd);
   const isPrebuilt = existsSync12(join20(effectiveCwd, ".next", "BUILD_ID"));
+  const bindHost = opts.hostname || "127.0.0.1";
+  if (isNonLoopbackHost(bindHost)) {
+    console.warn(
+      `\u26A0 Binding to ${bindHost} \u2014 Relay will be reachable from other machines on the network. It is designed for local-first, single-user use and has no network authentication. Only do this on a trusted network, and put a reverse proxy with auth in front if exposing it more broadly.`
+    );
+  }
   const nextArgs = buildNextLaunchArgs({
     isPrebuilt,
-    port: actualPort
+    port: actualPort,
+    host: bindHost
   });
-  const sidecarUrl = buildSidecarUrl(actualPort);
+  const sidecarUrl = buildSidecarUrl(actualPort, bindHost);
   console.log(`Orionfold Relay ${pkg.version} \u2014 Community Edition`);
   console.log(`Data dir: ${DATA_DIR}`);
   console.log(`Mode: ${isPrebuilt ? "production" : "development"}`);
@@ -26002,10 +26053,11 @@ async function main() {
     }
   });
   if (opts.open !== false) {
+    const openUrl = isNonLoopbackHost(bindHost) ? buildSidecarUrl(actualPort, "127.0.0.1") : sidecarUrl;
     setTimeout(async () => {
       try {
         const open = (await import("open")).default;
-        await open(sidecarUrl);
+        await open(openUrl);
       } catch {
       }
     }, 3e3);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionfold-relay",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "Orionfold Relay — a local-first, multi-agent orchestration runtime and builder scaffold for AI-native work.",
   "keywords": [
     "ai",

package/src/lib/chat/engine.ts

@@ -672,9 +672,32 @@ export async function* sendMessage(
     const pendingScreenshotTools = new Set<string>(); // tool_use IDs for screenshot tools
     const screenshotAttachments: ScreenshotAttachment[] = [];
 
-    for await (const raw of response as AsyncIterable<
-      Record<string, unknown>
-    >) {
+    // Race the SDK iterator against the permission side-channel.
+    //
+    // The Agent SDK's canUseTool callback pauses the SDK indefinitely while a
+    // permission gate is pending (see docs: "Execution remains paused until
+    // your callback returns"). During that pause the SDK emits NO events, so a
+    // plain `for await` over the iterator parks — and any UI event a *second*
+    // concurrent gate pushes onto the side-channel would sit undrained until
+    // the 120s auto-deny fired. That was the "silent second gate" deadlock:
+    // the loop's only driver (SDK events) is exactly what the pending gate
+    // stalls.
+    //
+    // Instead we drive the iterator manually and race each `.next()` against a
+    // blocking `sideChannel.pull()`. When a side-channel event wins (a gate
+    // surfacing while the SDK is paused), we yield it immediately and loop
+    // again WITHOUT re-issuing `.next()` — the outstanding SDK promise is kept
+    // in `sdkNext` and only replaced once it resolves, so we never call
+    // `.next()` twice concurrently. This mirrors the codex-engine wake-signal
+    // loop, which never had this bug.
+    const sdkIterator = (response as AsyncIterable<Record<string, unknown>>)[
+      Symbol.asyncIterator
+    ]();
+    let sdkNext: Promise<IteratorResult<Record<string, unknown>>> | null =
+      sdkIterator.next();
+    let sdkDone = false;
+
+    while (!sdkDone) {
       if (signal?.aborted) break;
 
       // Signal that the model has connected and is processing
@@ -683,7 +706,35 @@ export async function* sendMessage(
         yield { type: "status", phase: "generating", message: "Generating response..." };
       }
 
-      // Drain any side-channel events (from canUseTool) before processing SDK event
+      // Race: whichever of the SDK event or a side-channel push resolves first.
+      // The SDK promise is persistent (never re-issued while pending); the pull
+      // is recreated each turn and resolves with `undefined` on channel close.
+      const winner = await Promise.race([
+        sdkNext.then((res) => ({ kind: "sdk" as const, res })),
+        sideChannel
+          .pull()
+          .then((event) => ({ kind: "side-channel" as const, event })),
+      ]);
+
+      // Side-channel won: the SDK is (likely) paused on a gate. Surface the
+      // event now and loop again — `sdkNext` stays pending, unresolved.
+      if (winner.kind === "side-channel") {
+        // `undefined` means the channel closed (turn ending); ignore it.
+        if (winner.event) yield winner.event;
+        continue;
+      }
+
+      // SDK event won: consume it and re-arm the iterator for the next turn.
+      const { res } = winner;
+      sdkNext = null;
+      if (res.done) {
+        sdkDone = true;
+        break;
+      }
+      const raw = res.value;
+      sdkNext = sdkIterator.next();
+
+      // Drain any side-channel events buffered alongside this SDK event.
       for (const sideEvent of sideChannel.drain()) {
         yield sideEvent;
       }

package/src/lib/chat/permission-bridge.ts

@@ -40,7 +40,7 @@ const pendingRequests = new Map<string, PendingRequest>();
  */
 export class AsyncQueue<T> {
   private buffer: T[] = [];
-  private waiters: Array<(value: T) => void> = [];
+  private waiters: Array<(value: T | undefined) => void> = [];
   private closed = false;
 
   push(item: T) {
@@ -60,12 +60,35 @@ export class AsyncQueue<T> {
     return items;
   }
 
-  /** Close the queue — any pending waiters will reject */
+  /**
+   * Block until the next item is available, then resolve with it.
+   *
+   * This is the wake-signal the Claude chat engine races against the SDK
+   * iterator: when `canUseTool` pauses the SDK (no more SDK events until a
+   * gate resolves), a pull() that began awaiting before the next
+   * `emitSideChannelEvent` still resolves the moment that event is pushed —
+   * so a second permission gate surfaces immediately instead of stalling
+   * until the 120s auto-deny. Resolves with `undefined` (not a rejection)
+   * when the queue closes, so a losing race branch never throws.
+   */
+  pull(): Promise<T | undefined> {
+    if (this.buffer.length > 0) {
+      return Promise.resolve(this.buffer.shift());
+    }
+    if (this.closed) {
+      return Promise.resolve(undefined);
+    }
+    return new Promise<T | undefined>((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+
+  /** Close the queue — any pending waiters resolve with the `undefined` sentinel */
   close() {
     this.closed = true;
     this.buffer = [];
     for (const waiter of this.waiters) {
-      // Resolve with a sentinel — callers check isClosed()
+      waiter(undefined);
     }
     this.waiters = [];
   }

package/src/lib/chat/system-prompt.ts

@@ -128,6 +128,7 @@ Be proactive with tools. If the user asks about project status, use list_tasks t
 - For workflows, valid patterns are: sequence, parallel, checkpoint, planner-executor, swarm, loop.
 - **Delay steps** (sequence pattern only): a step with \`delayDuration\` (format: Nm|Nh|Nd|Nw, bounds 1m..30d) pauses the workflow between task steps. Format examples: "30m", "2h", "3d", "1w". Delay steps must have NO profile or prompt — they are pure waits. Use them for outreach sequences, drip campaigns, cooling periods, staged rollouts. A paused workflow resumes automatically when its scheduled time arrives, or immediately when the user clicks "Resume Now".
 - **enrich_table idempotency:** \`enrich_table\` skips rows where the target column already has a non-empty value. If the user wants to overwrite existing values, explain that force re-enrichment is not supported in v1 — they must manually clear the target column first (e.g. via update_row) before re-running.
+- **create_project dedup / reuse:** When composing an app for a named client, reuse an existing project instead of creating a duplicate. \`create_project\` performs its own exact-name check and will return \`{status: "similar-found", matches: [...]}\` instead of inserting when a same-named project already exists — when that happens, use the returned project \`id\` for every subsequent artifact (profiles, tables, workflows, schedules) rather than retrying \`create_project\`. Only pass \`force: true\` when the user has explicitly confirmed they want a second same-named project.
 - **create_workflow dedup:** Before calling \`create_workflow\`, call \`list_workflows\` (filtered by the current project) to check whether a similar workflow already exists. If the user asks to "redesign", "redo", or "update" an existing workflow, call \`update_workflow\` on the matching row instead of creating a new one. \`create_workflow\` performs its own near-duplicate check and will return \`{status: "similar-found", matches: [...]}\` instead of inserting when it finds one — when that happens, surface the matches to the user and confirm intent. Only pass \`force: true\` to \`create_workflow\` when the user has explicitly confirmed they want a second workflow alongside a similar one (e.g., "v2", "alternate approach").
 - When a working directory is specified, always create files relative to it. Never assume the git root is the working directory — they may differ in worktree environments.
 

package/src/lib/chat/tools/project-tools.ts

@@ -7,6 +7,54 @@ import { ok, err, type ToolContext } from "./helpers";
 
 const VALID_PROJECT_STATUSES = ["active", "paused", "completed"] as const;
 
+export interface SimilarProjectMatch {
+  id: string;
+  name: string;
+  reason: string;
+}
+
+/**
+ * Find existing projects that duplicate a candidate by name.
+ *
+ * Projects are top-level (not scoped like workflows), so this scans all of
+ * them. Unlike workflow dedup, there is no fuzzy step-text signal to compare —
+ * a project is just a name + description — so this is an exact, case- and
+ * whitespace-insensitive name match only. That precisely targets the observed
+ * compose bug: a long chat truncates the earlier `create_project` call out of
+ * the sliding-window context, so the model re-creates the same named client
+ * ("Northstar CRE") instead of reusing it. Fuzzy matching would add
+ * false-positive risk with no evidence it is needed (engineering principle #6).
+ *
+ * Used by `create_project` to warn the model before blindly inserting; bypass
+ * with `force: true` when the user genuinely wants a second same-named project.
+ */
+export async function findSimilarProjects(
+  candidateName: string
+): Promise<SimilarProjectMatch[]> {
+  const candidateNameLower = candidateName.trim().toLowerCase();
+  if (!candidateNameLower) return [];
+
+  const existing = await db
+    .select({
+      id: projects.id,
+      name: projects.name,
+      description: projects.description,
+    })
+    .from(projects);
+
+  const matches: SimilarProjectMatch[] = [];
+  for (const row of existing) {
+    if (row.name.trim().toLowerCase() === candidateNameLower) {
+      matches.push({
+        id: row.id,
+        name: row.name,
+        reason: `Same name: "${row.name}"`,
+      });
+    }
+  }
+  return matches;
+}
+
 export function projectTools(ctx: ToolContext) {
   return [
     defineTool(
@@ -57,9 +105,32 @@ export function projectTools(ctx: ToolContext) {
           .max(500)
           .optional()
           .describe("Absolute path to the project's working directory"),
+        force: z
+          .boolean()
+          .optional()
+          .describe(
+            "Set to true to create a project even when one with the same name already exists. Only use this when the user has explicitly confirmed they want a second same-named project. Default false — normally you should reuse the existing project returned by the near-duplicate check (its id) instead of creating a duplicate."
+          ),
       },
       async (args) => {
         try {
+          // Dedup guard: in a long compose conversation the sliding-window
+          // context can evict the earlier create_project call, so the model
+          // re-creates the same named client instead of reusing it. Check for
+          // an existing same-named project before inserting; pass force=true to
+          // bypass. Mirrors the create_workflow near-duplicate pattern.
+          if (!args.force) {
+            const similar = await findSimilarProjects(args.name);
+            if (similar.length > 0) {
+              return ok({
+                status: "similar-found",
+                message:
+                  "A project with this name already exists. Reuse it by its id for subsequent artifacts (profiles, tables, workflows), or pass force=true to create a separate same-named project.",
+                matches: similar,
+              });
+            }
+          }
+
           const now = new Date();
           const id = crypto.randomUUID();
 

package/src/lib/desktop/sidecar-launch.ts

@@ -83,3 +83,21 @@ export function buildNextLaunchArgs({
 export function buildSidecarUrl(port: number, host = SIDECAR_LOOPBACK_HOST): string {
   return `http://${host}:${port}`;
 }
+
+/**
+ * True when `host` is NOT a loopback address — i.e. binding to it exposes the
+ * server beyond the local machine. Relay is local-first with light auth, so the
+ * CLI warns before binding to such a host (`--hostname 0.0.0.0`, a LAN IP, a
+ * hostname, etc.). This is an advisory gate, not access control, so it errs
+ * toward warning: anything not provably loopback returns true.
+ *
+ * Loopback = `localhost`, IPv6 `::1`, or any `127.0.0.0/8` address (Linux lets
+ * you bind e.g. `127.0.0.5`). `0.0.0.0` / `::` are INADDR_ANY ("all
+ * interfaces") — the most exposing choice — and are treated as non-loopback.
+ */
+export function isNonLoopbackHost(host: string): boolean {
+  const h = host.trim().toLowerCase();
+  if (h === "localhost" || h === "::1") return false;
+  if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return false;
+  return true;
+}