cueloop 0.1.0-alpha.96 → 0.1.0-alpha.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.96",
+  "version": "0.1.0-alpha.98",
   "description": "Terminal review surface for coding agents: annotate plans and diffs, return a message, send structured feedback back",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -30,11 +30,11 @@
     "build:binary": "bun build --compile --minify --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.96",
-    "@cueloop/client": "0.1.0-alpha.96",
-    "@cueloop/daemon": "0.1.0-alpha.96",
-    "@cueloop/extension-api": "0.1.0-alpha.96",
-    "@cueloop/schema": "0.1.0-alpha.96",
+    "@cueloop/adapters": "0.1.0-alpha.98",
+    "@cueloop/client": "0.1.0-alpha.98",
+    "@cueloop/daemon": "0.1.0-alpha.98",
+    "@cueloop/extension-api": "0.1.0-alpha.98",
+    "@cueloop/schema": "0.1.0-alpha.98",
     "@modelcontextprotocol/server": "2.0.0",
     "@valibot/to-json-schema": "1.8.0",
     "valibot": "^1.5.0"

package/src/agent-harness.ts

@@ -0,0 +1,17 @@
+import { createFxHarness } from "@cueloop/adapters/fx/harness";
+import { loadConfig } from "@cueloop/client/config";
+import type { AgentHarnessAdapter } from "@cueloop/schema";
+
+/** Select a locally installed harness; unsupported providers fail before a daemon starts. */
+export function configuredAgentHarness(): AgentHarnessAdapter | undefined {
+  const id = process.env.CUELOOP_AGENT_HARNESS ?? "fx";
+
+  if (id !== "fx") throw new Error(`Thread agent harness is not installed: ${id}`);
+
+  return createFxHarness({ command: [process.env.CUELOOP_FX_EXECUTABLE ?? "fx", "acp"] });
+}
+
+/** Resolve the experimental Thread agent flag from user and workspace TOML. */
+export function threadAgentEnabled(repoRoot: string): boolean {
+  return loadConfig({ repoRoot }).experimental.threadAgent;
+}

package/src/codex-delivery-worker-command.test.ts

@@ -61,8 +61,14 @@ test("a Codex reply is delivered without an MCP transport", async () => {
 
   try {
     await client.sessionSendMessage(opened.threadId, "approved", "Continue after MCP exit.");
-    while (!existsSync(join(home, "delivered.txt")) && Date.now() < deadline) await Bun.sleep(20);
-    expect(readFileSync(join(home, "delivered.txt"), "utf8")).toContain("Continue after MCP exit.");
+    const deliveryPath = join(home, "delivered.txt");
+    const delivered = () =>
+      existsSync(deliveryPath) &&
+      readFileSync(deliveryPath, "utf8").includes("Continue after MCP exit.");
+
+    // Shell redirection creates the file before printf writes the delivered message.
+    while (!delivered() && Date.now() < deadline) await Bun.sleep(20);
+    expect(delivered()).toBe(true);
   } finally {
     client.close();
   }

package/src/daemon-command.ts

@@ -0,0 +1,38 @@
+/** Compose the local daemon with its installed harness adapters at the CLI boundary. */
+export async function daemonCommand(argv: string[]): Promise<number> {
+  const { DaemonServer } = await import("@cueloop/daemon");
+  // Explicit foreground never idle-exits; --autostart (a re-exec from the client)
+  // takes the normal idle-exit, matching the source main.ts entry.
+  const envIdle = process.env.CUELOOP_IDLE_EXIT_MS;
+  let idleExitMs: number | undefined = 0;
+
+  if (argv.includes("--autostart")) idleExitMs = envIdle ? Number(envIdle) : undefined;
+  const { configuredAgentHarness, threadAgentEnabled } = await import("./agent-harness");
+  const server = new DaemonServer({
+    idleExitMs,
+    threadAgent: {
+      enabled: true,
+      enabledForThread: (thread) => threadAgentEnabled(thread.workspace.repoRoot),
+      adapter: configuredAgentHarness(),
+    },
+  });
+  const path = server.start();
+
+  if (path === null) {
+    console.error("a cueloop daemon already owns this home - nothing to do");
+
+    return 1;
+  }
+  console.log(`cueloop daemon (foreground) on ${path}`);
+  const stop = () => {
+    server.stop();
+    process.exit(0);
+  };
+
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  process.once("exit", () => server.stop());
+  await new Promise(() => {}); // run until signalled
+
+  return 0;
+}

package/src/dev-command.ts

@@ -1,3 +1,4 @@
+import { threadAgentEnabled } from "./agent-harness";
 /**
  * `cueloop dev`: open the TUI against an isolated dev home seeded once with a
  * plan and a diff under this repo's project plus a standalone reply thread, so
@@ -97,16 +98,23 @@ async function refreshDevSeed(client: DaemonClient, home: string): Promise<void>
 
 /** `cueloop dev`: seed an isolated dev home (refreshing a stale seed), then open the TUI on it. */
 export async function devCommand(): Promise<number> {
-  const home = (process.env.CUELOOP_HOME ??= join(homedir(), ".cueloop-dev"));
+  const home = (process.env.CUELOOP_HOME ??= threadAgentEnabled(process.cwd())
+    ? join(process.cwd(), ".cueloop-dev")
+    : join(homedir(), ".cueloop-dev"));
 
+  let sessionId: string | undefined;
   const client = await DaemonClient.connect({ autostart: true });
   try {
     await refreshDevSeed(client, home);
+    if (threadAgentEnabled(process.cwd()))
+      sessionId = (await client.sessionList()).find(
+        (thread) => thread.artifact.meta.title === "Read the repository",
+      )?.id;
   } finally {
     client.close();
   }
 
   const { runClient } = await import("@cueloop/client");
 
-  return runClient({});
+  return runClient({ sessionId });
 }

package/src/main.ts

@@ -26,31 +26,12 @@ import { DaemonClient, DaemonClientError } from "@cueloop/daemon/client";
 import type { DiffFileContents, Thread, ThreadSurfaceOpenStatus } from "@cueloop/schema";
 import { openReview } from "@cueloop/daemon/thread-review";
 
+// The CLI owns adapter composition; the daemon package still starts independently.
+process.env.CUELOOP_DAEMON_ENTRY = import.meta.path;
+
 const argv = process.argv.slice(2);
 const cmd = argv[0];
 
-async function daemonCommand(argv: string[]): Promise<number> {
-  const { DaemonServer } = await import("@cueloop/daemon");
-  // Explicit foreground never idle-exits; --autostart (a re-exec from the client)
-  // takes the normal idle-exit, matching the source main.ts entry.
-  const envIdle = process.env.CUELOOP_IDLE_EXIT_MS;
-  let idleExitMs: number | undefined = 0;
-
-  if (argv.includes("--autostart")) idleExitMs = envIdle ? Number(envIdle) : undefined;
-  const server = new DaemonServer({ idleExitMs });
-  const path = server.start();
-
-  if (path === null) {
-    console.error("a cueloop daemon already owns this home - nothing to do");
-
-    return 1;
-  }
-  console.log(`cueloop daemon (foreground) on ${path}`);
-  await new Promise(() => {}); // run until signalled
-
-  return 0;
-}
-
 async function serveEntry(rest: string[]): Promise<number> {
   const { positional, flags } = parseArgs(rest);
   const port = stringFlag(flags, "port");
@@ -103,7 +84,7 @@ interface CommandHandlers {
 
 const commandHandlers: CommandHandlers = {
   session: (rest) => sessionCommand(rest),
-  daemon: (rest) => daemonCommand(rest),
+  daemon: async (rest) => (await import("./daemon-command")).daemonCommand(rest),
   stop: async () => (await import("./daemon-control")).stopCommand(),
   restart: async () => (await import("./daemon-control")).restartCommand(),
   plan: (rest) => planCommand(rest),