orionfold-relay 0.15.3 → 0.15.5

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.3")) {
-    return "0.15.3";
+  if (semver.valid("0.15.5")) {
+    return "0.15.5";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
@@ -26016,7 +26049,13 @@ async function main() {
       RELAY_DATA_DIR: DATA_DIR,
       RELAY_LAUNCH_CWD: launchCwd2,
       PORT: String(actualPort),
-      ...opts.safeMode ? { RELAY_SAFE_MODE: "true" } : {}
+      ...opts.safeMode ? { RELAY_SAFE_MODE: "true" } : {},
+      // In dev mode, Next blocks cross-origin /_next/* dev-asset requests from
+      // the LAN client's IP, breaking the app over the network (issue #13).
+      // When the operator has opted into non-loopback binding, tell next.config
+      // to allow any dev origin. Mirrors the same trust decision as the warning
+      // above; harmless for the prebuilt `next start` path (no dev-origin gate).
+      ...isNonLoopbackHost(bindHost) ? { RELAY_ALLOW_LAN_ORIGINS: "true" } : {}
     }
   });
   if (opts.open !== false) {

package/next.config.mjs

@@ -1,8 +1,28 @@
+// When the operator opts into LAN binding (`--hostname` to a non-loopback host,
+// see bin/cli.ts), the CLI sets RELAY_ALLOW_LAN_ORIGINS=true. In dev mode Next
+// otherwise blocks cross-origin requests to /_next/* dev assets from the LAN
+// client's IP — which silently breaks the whole app over the network (issue
+// #13). The client IP is unknowable at config-load time (the bind host is
+// 0.0.0.0 = "all interfaces"), and Next's matcher explicitly rejects a bare
+// "*"/"**" catch-all, so we allow every RFC1918 private-network range instead.
+// This matches the "trusted network" assumption the --hostname warning already
+// states, while still blocking public origins. (Prod `next start` has no such
+// gate; this only affects the dev-mode npx path.)
+const RFC1918_DEV_ORIGINS = [
+  "10.*.*.*",
+  "192.168.*.*",
+  // 172.16.0.0/12 — Next's matcher globs per-octet, so enumerate 16–31.
+  ...Array.from({ length: 16 }, (_, i) => `172.${16 + i}.*.*`),
+];
+const allowLanDevOrigins = process.env.RELAY_ALLOW_LAN_ORIGINS === "true";
+
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   serverExternalPackages: ["better-sqlite3", "pdf-parse", "pdfjs-dist"],
   devIndicators: false,
-  allowedDevOrigins: ["127.0.0.1"],
+  allowedDevOrigins: allowLanDevOrigins
+    ? ["127.0.0.1", ...RFC1918_DEV_ORIGINS]
+    : ["127.0.0.1"],
   // The in-app kindle reader was removed; the book lives at ainative.business.
   // Redirect legacy /book links (and any chapter-anchored deep links) there.
   async redirects() {

package/package.json

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

package/src/app/layout.tsx

@@ -68,7 +68,13 @@ const CRITICAL_THEME_CSS = `
     --surface-2: oklch(0.16 0.02 250);
     --border: oklch(0.26 0.015 250);
   }
-  html { background: var(--background); font-size: 14px; }
+  /* Root rem base. Fixed 14px left the whole rem-based design tiny on high-res
+     4K displays (issue #4) — text stayed 14px regardless of viewport, forcing
+     browser zoom. This clamp holds a flat 14px through 1920px-wide viewports
+     (unchanged for existing laptop/desktop users) and only ramps up on QHD/4K:
+     ~16px at 2560px, capped at 18px from 3200px+. Type and spacing grow
+     proportionally (the design is rem-based) with no component changes. */
+  html { background: var(--background); font-size: clamp(14px, 0.35vw + 7.3px, 18px); }
 `.replace(/\s+/g, " ").trim();
 
 export default async function RootLayout({

package/src/components/instance/instance-section.tsx

@@ -187,7 +187,7 @@ export function InstanceSection() {
           Running on the main dev repo. Instance upgrade features are disabled.
           Set{" "}
           <code className="font-mono text-[11px] px-1 py-0.5 rounded bg-muted">
-            AINATIVE_INSTANCE_MODE=true
+            RELAY_INSTANCE_MODE=true
           </code>{" "}
           to test.
         </p>

package/src/components/settings/providers-runtimes-section.tsx

@@ -2,6 +2,7 @@
 
 import { useCallback, useEffect, useRef, useState } from "react";
 import {
+  AlertTriangle,
   ChevronDown,
   ChevronRight,
   Network,
@@ -286,6 +287,7 @@ function ProviderRow({
 export function ProvidersAndRuntimesSection() {
   const [data, setData] = useState<ProvidersPayload | null>(null);
   const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
   const [anthropicOpen, setAnthropicOpen] = useState(false);
   const [openAIOpen, setOpenAIOpen] = useState(false);
   const [openAILoginState, setOpenAILoginState] = useState<OpenAILoginState | null>(null);
@@ -298,8 +300,20 @@ export function ProvidersAndRuntimesSection() {
       if (res.ok) {
         const json = (await res.json()) as ProvidersPayload;
         setData(json);
+        setError(null);
         return json;
       }
+      // A non-OK response left the section spinning forever (issue #9): the
+      // render guard is `loading || !data`, so `data` staying null on error
+      // meant a permanent "Loading…" card with no visible failure. Surface it.
+      setError(`Failed to load provider configuration (HTTP ${res.status}).`);
+      return null;
+    } catch (err) {
+      setError(
+        err instanceof Error
+          ? `Failed to load provider configuration: ${err.message}`
+          : "Failed to load provider configuration.",
+      );
       return null;
     } finally {
       setLoading(false);
@@ -630,7 +644,7 @@ export function ProvidersAndRuntimesSection() {
 
   // ── Render ───────────────────────────────────────────────────────
 
-  if (loading || !data) {
+  if (loading) {
     return (
       <Card className="surface-card">
         <CardHeader>
@@ -644,6 +658,38 @@ export function ProvidersAndRuntimesSection() {
     );
   }
 
+  // Fetch finished but produced no data (non-OK response or thrown error).
+  // Show an actionable error with a retry instead of an endless spinner —
+  // the previous `loading || !data` guard silently hung here (issue #9).
+  if (!data) {
+    return (
+      <Card className="surface-card">
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <AlertTriangle className="h-5 w-5 text-destructive" />
+            Providers &amp; Runtimes
+          </CardTitle>
+          <CardDescription>
+            {error ?? "Failed to load provider configuration."}
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <button
+            type="button"
+            onClick={() => {
+              setLoading(true);
+              setError(null);
+              void fetchData();
+            }}
+            className="rounded-md border border-input bg-background px-3 py-1.5 text-sm font-medium hover:bg-accent hover:text-accent-foreground"
+          >
+            Retry
+          </button>
+        </CardContent>
+      </Card>
+    );
+  }
+
   const { providers, routingPreference, configuredProviderCount } = data;
   const openAIProvider: ProviderState = {
     ...providers.openai,

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();