@ai-dev-methodologies/rlp-desk 0.11.1 → 0.13.0

package/src/node/polling/signal-poller.mjs

@@ -3,6 +3,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
 
+import { autoDismissPrompts } from '../runner/prompt-dismisser.mjs';
+
 const execFileAsync = promisify(execFile);
 const SHELL_COMMANDS = new Set(['', 'zsh', 'bash', 'sh']);
 
@@ -13,6 +15,35 @@ export class TimeoutError extends Error {
   }
 }
 
+// v5.7 §4.17 (Node parity): default-No prompt detected while polling. Caller
+// must write a BLOCKED `infra_failure` sentinel and abort — never auto-Enter,
+// never wait silently for the human.
+export class PromptBlockedError extends Error {
+  constructor(message, info = {}) {
+    super(message);
+    this.name = 'PromptBlockedError';
+    this.paneId = info.paneId;
+    this.category = info.category ?? 'infra_failure';
+    this.reason = info.reason ?? message;
+  }
+}
+
+// v5.7 §4.22 (E2E real-claude-CLI finding): Worker process exited (back to
+// shell prompt) but no signal/done-claim file was written. fresh-context +
+// file-based architecture is broken — Leader has no way to know what Worker
+// did. zsh runner has `handle_worker_exit_claude` for this; Node leader did
+// not. Throw a specific error so the campaign loop can write BLOCKED with a
+// descriptive reason instead of silent iter-timeout.
+export class WorkerExitedError extends Error {
+  constructor(message, info = {}) {
+    super(message);
+    this.name = 'WorkerExitedError';
+    this.paneId = info.paneId;
+    this.category = info.category ?? 'infra_failure';
+    this.reason = info.reason ?? message;
+  }
+}
+
 async function defaultReadFile(filePath) {
   return fs.readFile(filePath, 'utf8');
 }
@@ -29,6 +60,28 @@ async function defaultGetPaneCommand(paneId) {
   return stdout.trim();
 }
 
+async function defaultCapturePane(paneId) {
+  // v5.7 §4.21 (E2E real-claude-CLI finding): claude v2.x trust prompt is
+  // ~30+ lines tall when the pane wraps narrowly. -S -10 missed the question
+  // header ("Quick safety check / Is this a project you trust?") so PROMPT_RE
+  // never matched and the unknown-prompt fast-fail BLOCKed instead of
+  // auto-dismissing. -50 covers the full prompt with margin for typical
+  // pane heights.
+  const { stdout } = await execFileAsync('tmux', [
+    'capture-pane',
+    '-t',
+    paneId,
+    '-p',
+    '-S',
+    '-50',
+  ]);
+  return stdout;
+}
+
+async function defaultSendKeys(paneId, key) {
+  await execFileAsync('tmux', ['send-keys', '-t', paneId, key]);
+}
+
 function isMissingFileError(error) {
   return error?.code === 'ENOENT';
 }
@@ -71,11 +124,61 @@ export async function pollForSignal(
     timeoutMs = 5000,
     readFile = defaultReadFile,
     getPaneCommand = defaultGetPaneCommand,
+    capturePane = defaultCapturePane,
+    sendKeys = defaultSendKeys,
+    log = () => {},
   } = {},
 ) {
   const deadline = Date.now() + timeoutMs;
+  let pendingBlock = null;
+  // v5.7 §4.22: track whether the worker process was ever observed running.
+  // Used to detect "worker started, did some work, then exited without
+  // writing signal/done-claim" — fresh-context architecture violation.
+  let seenWorkerRunning = false;
 
   while (!deadlineExceeded(deadline)) {
+    // v5.7 §4.13.b: auto-dismiss mid-execution permission prompts before
+    // checking the signal file. Without this, Worker hangs on TUI prompts
+    // even with --dangerously-skip-permissions (Bug 4).
+    // v5.7 §4.17 (Node parity): default-No prompts must NOT be auto-Entered;
+    // they raise a PromptBlockedError so the caller writes BLOCKED and aborts.
+    if (paneId) {
+      // v0.13.0: detect Claude Code self-modification permission prompts in
+      // pane stdout BEFORE attempting auto-dismiss. These cannot be dismissed
+      // by --dangerously-skip-permissions and would otherwise hang the worker
+      // for the full pollForSignal timeout.
+      try {
+        const paneContent = await capturePane(paneId);
+        const { detectPermissionPrompt } = await import('../runner/prompt-detector.mjs');
+        if (detectPermissionPrompt(paneContent)) {
+          throw new PromptBlockedError(
+            `Permission prompt detected on pane ${paneId} (Claude Code self-modification gate)`,
+            { paneId, category: 'permission_prompt', snippet: paneContent.split(/\r?\n/).slice(-10).join('\n') },
+          );
+        }
+      } catch (err) {
+        if (err instanceof PromptBlockedError) {
+          throw err;
+        }
+        // capture failure is non-fatal; fall through to auto-dismiss path.
+      }
+
+      await autoDismissPrompts(paneId, {
+        capturePane,
+        sendKeys,
+        log,
+        onDefaultNoBlock: (info) => {
+          pendingBlock = info;
+        },
+      }).catch(() => {});
+      if (pendingBlock) {
+        throw new PromptBlockedError(
+          `Default-No prompt on pane ${pendingBlock.paneId}: ${pendingBlock.reason}`,
+          pendingBlock,
+        );
+      }
+    }
+
     try {
       const rawContent = await readFile(signalFile);
       const parsed = JSON.parse(rawContent);
@@ -89,9 +192,42 @@ export async function pollForSignal(
       }
 
       return parsed;
-    } catch (error) {
-      if (!isMissingFileError(error) && !isJsonParseError(error)) {
-        throw error;
+    } catch (signalError) {
+      if (!isMissingFileError(signalError) && !isJsonParseError(signalError)) {
+        throw signalError;
+      }
+      // Signal file missing OR partial JSON. v5.7 §4.22: parity with zsh
+      // `handle_worker_exit_claude` — if Worker pane process is back to
+      // shell, the worker exited without writing artifacts. Stop polling
+      // immediately and surface a WorkerExitedError so the campaign loop
+      // can write BLOCKED with reason `worker_exited_without_artifacts`.
+      //
+      // IMPORTANT: only run the pane-exit check on ENOENT (signal file
+      // entirely missing). A SyntaxError means the file EXISTS but the
+      // Worker is mid-write (atomic-rename race) — checking pane state
+      // here would race against the imminent successful read. Skip the
+      // check; next iteration's read will succeed.
+      if (paneId && isMissingFileError(signalError)) {
+        try {
+          const currentCommand = await getPaneCommand(paneId);
+          if (SHELL_COMMANDS.has(currentCommand)) {
+            if (seenWorkerRunning) {
+              throw new WorkerExitedError(
+                `Worker pane ${paneId} exited (now '${currentCommand || 'shell'}') without writing signal at ${signalFile} — fresh-context contract violated`,
+                {
+                  paneId,
+                  category: 'infra_failure',
+                  reason: 'worker_exited_without_artifacts',
+                },
+              );
+            }
+          } else if (currentCommand) {
+            seenWorkerRunning = true;
+          }
+        } catch (commandError) {
+          if (commandError instanceof WorkerExitedError) throw commandError;
+          // Other tmux lookup errors: don't end the loop early.
+        }
       }
     }
 

package/src/node/reporting/campaign-reporting.mjs

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 
+import { resolveDeskRoot } from '../util/desk-root.mjs';
+
 const execFileAsync = promisify(execFile);
 const REQUIRED_ANALYTICS_FIELDS = [
   'iter',
@@ -596,7 +598,9 @@ export async function generateSVReport({
 
 export async function readStatus(slug, options = {}) {
   const rootDir = path.resolve(options.rootDir ?? process.cwd());
-  const statusFile = path.join(rootDir, '.claude', 'ralph-desk', 'logs', slug, 'runtime', 'status.json');
+  const env = options.env ?? process.env;
+  const deskRoot = resolveDeskRoot(rootDir, env);
+  const statusFile = path.join(deskRoot, 'logs', slug, 'runtime', 'status.json');
 
   if (!(await exists(statusFile))) {
     return `No active campaign for ${slug}.`;

package/src/node/run.mjs

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { initCampaign } from './init/campaign-initializer.mjs';
 import { readStatus } from './reporting/campaign-reporting.mjs';
 import { run as runCampaignMain } from './runner/campaign-main-loop.mjs';
+import { isClaudeEngine } from './cli/command-builder.mjs';
 
 const RUN_DEFAULTS = {
   mode: 'agent',
@@ -194,8 +195,9 @@ async function runInit(args, deps) {
 
   const slug = args[0];
   const objective = args.slice(1).join(' ').trim() || 'TBD - fill in the objective';
-  await deps.initCampaign(slug, objective, { rootDir: deps.cwd });
-  write(deps.stdout, `Initialized ${slug} in ${path.join(deps.cwd, '.claude', 'ralph-desk')}`);
+  const result = await deps.initCampaign(slug, objective, { rootDir: deps.cwd });
+  const deskRoot = result?.paths?.deskRoot ?? path.join(deps.cwd, '.rlp-desk');
+  write(deps.stdout, `Initialized ${slug} in ${deskRoot}`);
   return 0;
 }
 
@@ -221,6 +223,33 @@ async function runRunCommand(args, deps) {
 
   const slug = args[0];
   const options = parseRunOptions(args.slice(1), deps.cwd);
+
+  // v0.13.0: warn when Claude worker runs in tmux mode. Claude Code's
+  // hardcoded sensitive policy used to hang sentinel writes inside
+  // <project>/.claude/. After v0.13.0, sentinels live in
+  // <project>/.rlp-desk/, but if the user pinned RLP_DESK_RUNTIME_DIR
+  // back inside .claude/, the hang can return — surface the warning so
+  // they can switch to gpt-5.5:* or --mode agent quickly.
+  if (
+    !process.env.RLP_DESK_QUIET_WARNINGS
+    && process.env.NODE_ENV !== 'test'
+    && options.mode === 'tmux'
+    && isClaudeEngine(options.workerModel)
+  ) {
+    write(
+      deps.stderr,
+      'WARNING: Claude worker in tmux mode may hang on .claude/ sentinel writes.',
+    );
+    write(
+      deps.stderr,
+      'After v0.13.0, sentinels live in <project>/.rlp-desk/ which avoids this.',
+    );
+    write(
+      deps.stderr,
+      'If hang persists, switch to --worker-model gpt-5.5:high (codex) or --mode agent.',
+    );
+  }
+
   const result = await deps.runCampaign(slug, options);
   // governance §1f BLOCKED Surfacing: surface the blocked reason on stderr so
   // the operator (or wrapper script) does not have to grep memo files.