orionfold-relay 0.15.3 → 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.3")) {
-    return "0.15.3";
+  if (semver.valid("0.15.4")) {
+    return "0.15.4";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionfold-relay",
-  "version": "0.15.3",
+  "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();