@lawrence369/loop-cli 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-03-10
+
+### Fixed
+
+- Shared plan async/sync contract mismatch: all plan functions now properly awaited
+- Shared plan field name drift: `reviewerScore`/`reviewerApproved` → `score`/`approved`
+- Agent launcher IPC socket path: `daemon.sock` → `loop.sock` to match daemon
+- Agent launcher IPC message format: aligned to UPPERCASE types + nested `data` object
+- Daemon start/stop/status: real background daemon with PID file and IPC-based status
+- Placeholder IPC handlers (LAUNCH_AGENT, RESUME_AGENTS, LAUNCH_GROUP, STOP_GROUP) now return explicit "not implemented" errors
+- README: config field names, default values, and command list aligned with actual CLI
+- CLI version string now matches package.json
+
+### Added
+
+- Multi-turn manual mode: readline-based follow-up prompting between PTY sessions
+- Daemon entry script for proper background process management
+- 33 new regression tests (315 total across 26 test files)
+
+## [0.1.2] - 2026-03-10
+
+### Fixed
+
+- Fix `posix_spawnp failed` crash: `@clack/prompts` placeholder text was leaking as actual CLI arguments
+- Add try-catch around PTY spawn with clear error message when engine CLI is not found
+- Add automatic fallback to non-interactive `engine.run()` when PTY spawn fails
+
 ## [0.1.0] - 2026-03-10
 
 ### Added

package/README.md

@@ -60,15 +60,17 @@ loop [task]              # Run iteration loop (interactive if no task)
 loop daemon start        # Start background daemon
 loop daemon stop         # Stop daemon
 loop daemon status       # Check daemon status
-loop bus tail            # Stream event bus
-loop bus stats           # Show bus statistics
+loop bus send <message>  # Send a message on the event bus
+loop bus check <id>      # Check for pending bus messages
+loop bus status          # Show event bus status
 loop chat                # Open real-time dashboard
 loop plan show           # Show current iteration plan
 loop plan clear          # Clear plan
-loop ctx add             # Add architectural decision
+loop ctx add <title>     # Add architectural decision
 loop ctx list            # List decisions
+loop ctx resolve <id>    # Resolve a decision
 loop skills list         # List available skills
-loop skills show <name>  # Show skill content
+loop skills add <name>   # Add a new skill
 ```
 
 ## Options
@@ -77,12 +79,12 @@ loop skills show <name>  # Show skill content
 |------|-------------|
 | `-e, --executor <engine>` | Executor engine: `claude` \| `gemini` \| `codex` |
 | `-r, --reviewer <engine>` | Reviewer engine: `claude` \| `gemini` \| `codex` |
-| `-n, --iterations <num>` | Max iterations (default: 5) |
+| `-n, --iterations <num>` | Max iterations (default: 3) |
 | `-d, --dir <path>` | Working directory |
 | `-v, --verbose` | Stream real-time output |
 | `--auto` | Auto mode — skip manual conversation |
 | `--pass <args...>` | Pass native flags to executor CLI |
-| `--threshold <num>` | Approval score threshold, 1-10 (default: 8) |
+| `--threshold <num>` | Approval score threshold, 1-10 (default: 9) |
 
 ## How It Works
 
@@ -104,12 +106,15 @@ Create `.loop/config.json` in your project:
 
 ```json
 {
-  "executor": "claude",
-  "reviewer": "gemini",
-  "maxIterations": 5,
-  "threshold": 8,
-  "verbose": false,
-  "auto": false
+  "defaultExecutor": "claude",
+  "defaultReviewer": "gemini",
+  "maxIterations": 3,
+  "threshold": 9,
+  "mode": "manual",
+  "launchMode": "auto",
+  "autoResume": false,
+  "skillsDir": ".loop/skills",
+  "verbose": false
 }
 ```
 

package/dist/agent/launcher.js

@@ -29,7 +29,7 @@ function runDir(projectRoot) {
     return path.join(loopDir(projectRoot), "run");
 }
 function daemonSocketPath(projectRoot) {
-    return path.join(runDir(projectRoot), "daemon.sock");
+    return path.join(runDir(projectRoot), "loop.sock");
 }
 function connectSocket(sockPath) {
     return new Promise((resolve, reject) => {
@@ -99,12 +99,13 @@ async function registerWithDaemon(projectRoot, agentType, subscriberId, nickname
                 catch {
                     continue;
                 }
-                if (payload.type === "register_ok" && typeof payload.subscriberId === "string") {
+                const responseData = payload.data;
+                if (payload.success === true && responseData?.subscriber_id) {
                     if (settled)
                         return;
                     settled = true;
                     cleanup();
-                    resolve(payload.subscriberId);
+                    resolve(String(responseData.subscriber_id));
                     return;
                 }
                 if (payload.type === "error") {
@@ -118,10 +119,8 @@ async function registerWithDaemon(projectRoot, agentType, subscriberId, nickname
             }
         });
         const req = {
-            type: "register_agent",
-            agentType,
-            nickname,
-            parentPid: process.pid,
+            type: "REGISTER_AGENT",
+            data: { agent_type: agentType, nickname, pid: process.pid },
         };
         client.write(JSON.stringify(req) + "\n");
     });
@@ -197,8 +196,8 @@ export class AgentLauncher {
                 if (!client)
                     return;
                 client.write(JSON.stringify({
-                    type: "agent_ready",
-                    subscriberId,
+                    type: "AGENT_READY",
+                    data: { subscriber_id: subscriberId },
                 }) + "\n");
                 client.end();
             }).catch(() => {

package/dist/agent/pty-session.js

@@ -76,13 +76,20 @@ export class PtySession extends EventEmitter {
         const rows = opts?.rows ?? process.stdout.rows ?? 24;
         this._engine = opts?.engine;
         this._promptPattern = DEFAULT_PROMPT_PATTERN;
-        this._pty = pty.spawn(command, args, {
-            name: "xterm-256color",
-            cols,
-            rows,
-            cwd,
-            env: { ...process.env, ...(opts?.env ?? {}) },
-        });
+        try {
+            this._pty = pty.spawn(command, args, {
+                name: "xterm-256color",
+                cols,
+                rows,
+                cwd,
+                env: { ...process.env, ...(opts?.env ?? {}) },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to spawn PTY for "${command}": ${msg}\n` +
+                `Ensure "${command}" is installed and available in your PATH.`);
+        }
         // ── PTY data handler ──────────────────────────────────────────────
         this._pty.onData((data) => {
             if (!this._alive)

package/dist/core/conversation.js

@@ -4,6 +4,7 @@
  * Ported from iterloop's conversation.ts. Runs an interactive PTY session
  * with idle detection, mode toggling, and user-controlled continuation.
  */
+import * as readline from "node:readline";
 import { dim, formatBytes, brandColor } from "../ui/colors.js";
 // ── Idle detection constants ─────────────────────────
 /** Time to wait after detecting idle prompt before auto-proceeding (ms) */
@@ -109,14 +110,38 @@ async function runPtySession(engine, initialPrompt, opts) {
     // Set up renderer before spawning the PTY so the first frame is not missed
     const renderer = new PtyRenderer(engine.name, engine.label);
     renderer.start();
-    // Create PTY session via engine.interactive()
-    const session = engine.interactive({
-        cwd: opts.cwd,
-        passthroughArgs: opts.passthroughArgs,
-        onData(data) {
-            renderer.write(data);
-        },
-    });
+    // Create PTY session via engine.interactive(), with fallback to engine.run()
+    let session;
+    try {
+        session = engine.interactive({
+            cwd: opts.cwd,
+            passthroughArgs: opts.passthroughArgs,
+            onData(data) {
+                renderer.write(data);
+            },
+        });
+    }
+    catch (err) {
+        // PTY spawn failed — fall back to non-interactive engine.run()
+        const msg = err instanceof Error ? err.message : String(err);
+        renderer.stop({ elapsed: "0.0s", bytes: "0 B" });
+        console.log(dim(`  PTY spawn failed: ${msg}`));
+        console.log(dim(`  Falling back to non-interactive mode...\n`));
+        const start = Date.now();
+        const output = await engine.run(initialPrompt, {
+            cwd: opts.cwd,
+            verbose: opts.verbose,
+            passthroughArgs: opts.passthroughArgs,
+            onData(chunk) {
+                process.stdout.write(chunk);
+            },
+        });
+        return {
+            output,
+            bytes: Buffer.byteLength(output),
+            durationMs: Date.now() - start,
+        };
+    }
     return new Promise((resolve, reject) => {
         let done = false;
         let idleTimer = null;
@@ -252,6 +277,35 @@ async function runPtySession(engine, initialPrompt, opts) {
         });
     });
 }
+// ── User prompt helper (readline-based) ──────────────
+/**
+ * Prompt the user for a follow-up message using Node's readline module.
+ * Returns the trimmed user input, or `null` on Ctrl+D / EOF / empty input / "/done".
+ */
+function promptUser() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(dim("  Follow-up (empty or /done to submit): "), (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (trimmed === "" || trimmed === "/done") {
+                resolve(null);
+            }
+            else {
+                resolve(trimmed);
+            }
+        });
+        // Handle Ctrl+D (EOF) — readline emits 'close' without calling the callback
+        rl.on("close", () => {
+            // If the question callback already resolved, this is a no-op.
+            // If Ctrl+D was pressed, resolve with null to signal "submit".
+            resolve(null);
+        });
+    });
+}
 // ── Main conversation loop ───────────────────────────
 /**
  * Run a multi-turn conversation with an AI engine.
@@ -268,22 +322,53 @@ export async function runConversation(opts) {
         console.log(dim("  Ctrl+D to submit for review, double Ctrl+C to abort\n"));
     }
     // Run first interactive PTY session
-    const { output, bytes, durationMs } = await runPtySession(engine, initialPrompt, { cwd, verbose, mode, passthroughArgs });
-    // Auto mode: done, submit to reviewer
+    let currentPrompt = initialPrompt;
+    let accumulatedOutput = "";
+    let totalBytes = 0;
+    let totalDurationMs = 0;
+    const firstResult = await runPtySession(engine, currentPrompt, {
+        cwd,
+        verbose,
+        mode,
+        passthroughArgs,
+    });
+    accumulatedOutput += firstResult.output;
+    totalBytes += firstResult.bytes;
+    totalDurationMs += firstResult.durationMs;
+    // Auto mode (or switched to auto during first session): done, submit to reviewer
     if (mode.current === "auto") {
         return {
-            finalOutput: output,
-            duration_ms: durationMs,
-            bytes_received: bytes,
+            finalOutput: accumulatedOutput,
+            duration_ms: totalDurationMs,
+            bytes_received: totalBytes,
         };
     }
-    // Manual mode: the user can continue interacting or submit
-    // For now, return the first session output. Full multi-turn manual flow
-    // (promptUser loop) is handled at a higher layer.
+    // Manual mode: multi-turn loop — prompt user after each PTY session
+    while (mode.current === "manual") {
+        console.log(dim(`  Session complete. Accumulated ${formatBytes(totalBytes)} over ${(totalDurationMs / 1000).toFixed(1)}s.`));
+        const followUp = await promptUser();
+        // null means user wants to submit (empty input, /done, or Ctrl+D)
+        if (followUp === null) {
+            break;
+        }
+        // Run another PTY session with the follow-up prompt
+        currentPrompt = followUp;
+        const result = await runPtySession(engine, currentPrompt, {
+            cwd,
+            verbose,
+            mode,
+            passthroughArgs,
+        });
+        accumulatedOutput += "\n" + result.output;
+        totalBytes += result.bytes;
+        totalDurationMs += result.durationMs;
+        // If the mode was switched to auto during the session (via Shift+Tab),
+        // the while condition will handle it — no explicit break needed.
+    }
     return {
-        finalOutput: output,
-        duration_ms: durationMs,
-        bytes_received: bytes,
+        finalOutput: accumulatedOutput,
+        duration_ms: totalDurationMs,
+        bytes_received: totalBytes,
     };
 }
 //# sourceMappingURL=conversation.js.map

package/dist/core/loop.js

@@ -12,10 +12,10 @@ import { createExecutorMessage, parseReviewerOutput, formatForReviewer, } from "
 import { evaluateReview } from "./scoring.js";
 import { bold, dim, success, warn, brandColor } from "../ui/colors.js";
 const NO_OP_PLAN = {
-    initSharedPlan: () => { },
-    updateSharedPlan: () => { },
-    getExecutorContext: () => "",
-    getReviewerContext: () => "",
+    initSharedPlan: async () => { },
+    updateSharedPlan: async () => { },
+    getExecutorContext: async () => "",
+    getReviewerContext: async () => "",
 };
 // Lazy-loaded promise — awaited before first use in runLoop()
 let _planModulePromise = null;
@@ -67,7 +67,7 @@ export async function runLoop(options) {
     };
     // Load shared plan module (awaited — no race condition)
     const plan = await loadPlanModule();
-    plan.initSharedPlan(cwd, task);
+    await plan.initSharedPlan(cwd, task);
     let executorOutput = "";
     let reviewerFeedback = "";
     for (let i = 1; i <= maxIterations; i++) {
@@ -78,7 +78,7 @@ export async function runLoop(options) {
             initialPrompt = task;
         }
         else {
-            const executorContext = plan.getExecutorContext(cwd);
+            const executorContext = await plan.getExecutorContext(cwd);
             initialPrompt = [
                 "Please revise your previous work based on the following review feedback.",
                 "",
@@ -119,7 +119,7 @@ export async function runLoop(options) {
         });
         history.push(executorMsg);
         // ── Reviewer ──
-        const reviewerContext = plan.getReviewerContext(cwd);
+        const reviewerContext = await plan.getReviewerContext(cwd);
         const reviewPrompt = [
             "You are a code review expert. Please review the following task completion.",
             "",
@@ -169,14 +169,14 @@ export async function runLoop(options) {
         // Evaluate review using scoring module
         const scoringResult = evaluateReview(reviewerMsg.review, scoringConfig);
         // Update shared plan with iteration data
-        plan.updateSharedPlan(cwd, {
+        await plan.updateSharedPlan(cwd, {
             iteration: i,
             timestamp: new Date().toISOString(),
             executor: executor.name,
             reviewer: reviewer.name,
             executorSummary: executorOutput.slice(0, 500),
-            reviewerScore: reviewerMsg.review?.score ?? 0,
-            reviewerApproved: scoringResult.approved,
+            score: reviewerMsg.review?.score ?? 0,
+            approved: scoringResult.approved,
             reviewerFeedback: reviewerFeedback.slice(0, 500),
         }, executorMsg.output.files_changed);
         // ── Check approval ──

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, join, dirname } from "node:path";
 import { bold, red, yellow, green } from "./ui/colors.js";
 import { ENGINE_NAMES } from "./config/schema.js";
 import { loadConfig } from "./config/index.js";
@@ -12,12 +12,14 @@ import { SkillRegistry } from "./skills/registry.js";
 import { runLoop } from "./core/loop.js";
 import { createEngine } from "./core/engine.js";
 import { EventBus } from "./bus/event-bus.js";
-import { OrchestratorDaemon } from "./orchestrator/daemon.js";
+import { daemonize, readPidFile, isProcessAlive, removePidFile, } from "./utils/process.js";
+import { createConnection } from "node:net";
+import { fileURLToPath } from "node:url";
 const program = new Command();
 program
     .name("loop")
     .description("Iterative multi-engine AI orchestration CLI — Claude, Gemini, Codex")
-    .version("0.1.0")
+    .version("0.2.0")
     .argument("[task]", "Task description (omit to enter interactive mode)")
     .option("-e, --executor <engine>", "Executor engine: claude | gemini | codex")
     .option("-r, --reviewer <engine>", "Reviewer engine: claude | gemini | codex")
@@ -124,10 +126,22 @@ daemon
     .action(async () => {
     try {
         const cwd = process.cwd();
-        const mgr = new OrchestratorDaemon(cwd);
+        const runDirPath = join(cwd, ".loop", "run");
+        const pidPath = join(runDirPath, "loop-daemon.pid");
+        const logPath = join(runDirPath, "loop-daemon.log");
+        // Check if already running
+        const existingPid = readPidFile(pidPath);
+        if (existingPid !== null && isProcessAlive(existingPid)) {
+            console.log(yellow(`  Daemon already running (pid=${existingPid})`));
+            return;
+        }
+        // Resolve daemon entry script relative to this compiled module
+        const thisFile = fileURLToPath(import.meta.url);
+        const thisDir = dirname(thisFile);
+        const entryScript = join(thisDir, "orchestrator", "daemon-entry.js");
         console.log(bold("  Starting daemon..."));
-        await mgr.start();
-        console.log(green("  Daemon started (pid=" + process.pid + ")"));
+        const pid = daemonize(entryScript, [], logPath);
+        console.log(green(`  Daemon started (pid=${pid})`));
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -141,13 +155,17 @@ daemon
     .action(async () => {
     try {
         const cwd = process.cwd();
-        const mgr = new OrchestratorDaemon(cwd);
-        if (!mgr.isRunning()) {
+        const pidPath = join(cwd, ".loop", "run", "loop-daemon.pid");
+        const pid = readPidFile(pidPath);
+        if (pid === null || !isProcessAlive(pid)) {
             console.log(yellow("  Daemon is not running."));
+            removePidFile(pidPath);
             return;
         }
-        await mgr.stop();
-        console.log(green("  Daemon stopped."));
+        process.kill(pid, "SIGTERM");
+        console.log(green(`  Daemon stopped (pid=${pid}).`));
+        // Clean up PID file after kill
+        removePidFile(pidPath);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -161,17 +179,53 @@ daemon
     .action(async () => {
     try {
         const cwd = process.cwd();
-        const mgr = new OrchestratorDaemon(cwd);
-        if (!mgr.isRunning()) {
+        const pidPath = join(cwd, ".loop", "run", "loop-daemon.pid");
+        const socketPath = join(cwd, ".loop", "run", "loop.sock");
+        const pid = readPidFile(pidPath);
+        if (pid === null || !isProcessAlive(pid)) {
             console.log(yellow("  Daemon is not running."));
             return;
         }
-        const status = await mgr.getStatus();
+        // Connect to the daemon's IPC socket and request STATUS
+        const status = await new Promise((resolvePromise, rejectPromise) => {
+            const client = createConnection(socketPath, () => {
+                client.write(JSON.stringify({ type: "STATUS", data: {} }) + "\n");
+            });
+            let buffer = "";
+            const timeout = setTimeout(() => {
+                client.destroy();
+                rejectPromise(new Error("Timed out waiting for daemon status"));
+            }, 5_000);
+            client.on("data", (data) => {
+                buffer += data.toString("utf8");
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const payload = JSON.parse(line);
+                        clearTimeout(timeout);
+                        client.end();
+                        resolvePromise(payload);
+                        return;
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                }
+            });
+            client.on("error", (err) => {
+                clearTimeout(timeout);
+                rejectPromise(err);
+            });
+        });
+        const statusData = (status.data ?? {});
         console.log(bold("  Daemon status:"));
-        console.log(`  PID:       ${status.pid}`);
-        console.log(`  Uptime:    ${status.uptime}s`);
-        console.log(`  Agents:    ${status.agents}`);
-        console.log(`  Events:    ${status.busEvents}`);
+        console.log(`  PID:       ${statusData.pid ?? pid}`);
+        console.log(`  Uptime:    ${statusData.uptime ?? "?"}s`);
+        console.log(`  Agents:    ${statusData.agents ?? 0}`);
+        console.log(`  Events:    ${statusData.busEvents ?? 0}`);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/orchestrator/daemon-entry.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Daemon entry point — spawned as a detached background process by
+ * `loop daemon start`.  Creates an OrchestratorDaemon and starts it.
+ * The IPC server keeps the process alive.
+ */
+export {};
+//# sourceMappingURL=daemon-entry.d.ts.map

package/dist/orchestrator/daemon-entry.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Daemon entry point — spawned as a detached background process by
+ * `loop daemon start`.  Creates an OrchestratorDaemon and starts it.
+ * The IPC server keeps the process alive.
+ */
+import { OrchestratorDaemon } from "./daemon.js";
+const projectRoot = process.cwd();
+const daemon = new OrchestratorDaemon(projectRoot);
+daemon.start().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`daemon-entry: failed to start: ${message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=daemon-entry.js.map

package/dist/orchestrator/daemon.js

@@ -211,11 +211,10 @@ export class OrchestratorDaemon {
                     };
                 }
                 case "LAUNCH_AGENT": {
-                    // Placeholder - actual agent launching is handled by the agent launcher
                     return {
-                        success: true,
+                        success: false,
                         type: "LAUNCH_AGENT",
-                        data: { message: "Agent launch request received" },
+                        error: "Not implemented",
                     };
                 }
                 case "CLOSE_AGENT": {
@@ -229,23 +228,23 @@ export class OrchestratorDaemon {
                 }
                 case "RESUME_AGENTS": {
                     return {
-                        success: true,
+                        success: false,
                         type: "RESUME_AGENTS",
-                        data: { message: "Resume request received" },
+                        error: "Not implemented",
                     };
                 }
                 case "LAUNCH_GROUP": {
                     return {
-                        success: true,
+                        success: false,
                         type: "LAUNCH_GROUP",
-                        data: { message: "Group launch request received" },
+                        error: "Not implemented",
                     };
                 }
                 case "STOP_GROUP": {
                     return {
-                        success: true,
+                        success: false,
                         type: "STOP_GROUP",
-                        data: { message: "Group stop request received" },
+                        error: "Not implemented",
                     };
                 }
                 default: {

package/dist/ui/interactive.js

@@ -93,17 +93,20 @@ export async function interactive() {
         return null;
     }
     // Native CLI flags (optional)
+    const PASS_ARGS_PLACEHOLDER = "e.g., --model claude-sonnet-4-20250514";
     const passArgsInput = await p.text({
         message: "Native CLI flags for executor (optional)",
-        placeholder: "e.g., --model claude-sonnet-4-20250514",
+        placeholder: PASS_ARGS_PLACEHOLDER,
         defaultValue: "",
     });
     if (p.isCancel(passArgsInput)) {
         p.cancel("Cancelled.");
         return null;
     }
-    const passthroughArgs = passArgsInput.trim()
-        ? passArgsInput.split(/\s+/).filter(Boolean)
+    // Guard against @clack/prompts returning placeholder text as the value
+    const rawPassArgs = typeof passArgsInput === "string" ? passArgsInput : "";
+    const passthroughArgs = rawPassArgs.trim() && rawPassArgs.trim() !== PASS_ARGS_PLACEHOLDER
+        ? rawPassArgs.split(/\s+/).filter(Boolean)
         : [];
     // Task
     const task = await p.text({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawrence369/loop-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Iterative Multi-Engine AI Orchestration",
   "type": "module",
   "main": "./dist/index.js",