@syntax-syllogism/aloop 0.8.2 → 0.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syntax-syllogism/aloop",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Syntax & Syllogism agentic loop runner.",
   "type": "module",
   "exports": {

package/src/adapters.mjs

@@ -413,16 +413,26 @@ const geminiAdapter = {
     // until the process exits, so a multi-minute phase is indistinguishable from
     // a hang. stream-json emits an event per step, which `createRenderer` turns
     // back into readable lines — same reasoning as the claude adapter above.
+    //
+    // The prompt goes on stdin, not `--prompt`. Gemini's Windows launcher is a
+    // `.cmd`/`.ps1` shim, so on Git Bash aloop runs it through `cmd.exe /c`
+    // (see command.mjs windowsSpawnSpec). cmd.exe caps the whole command line at
+    // ~8191 chars and mangles newlines and metacharacters (`% ! & | < >`), so a
+    // real review prompt — work item plus instructions — arrives truncated or
+    // garbled and Gemini "ignores" it. stdin is a pipe cmd.exe never parses, so
+    // the prompt survives intact. `-p ""` still selects headless mode; Gemini
+    // documents `--prompt` as "appended to input on stdin", so an empty flag
+    // leaves the stdin prompt as the whole prompt.
     const canWrite = permissionLevel(permissions) === PERMISSIONS.WRITE_WORKTREE || artifactOnly;
     const args = [
-      '--prompt', prompt,
+      '--prompt', '',
       '--approval-mode', canWrite ? 'yolo' : 'plan',
       '--skip-trust',
       '--output-format', 'stream-json',
     ];
     if (agent.model) args.push('--model', agent.model);
     for (const dir of addDirs) args.push('--include-directories', dir);
-    return { command: 'gemini', args };
+    return { command: 'gemini', args, input: prompt };
   },
   createRenderer: () => createJsonlRenderer(renderGeminiEvent),
 };

package/src/pipeline.mjs

@@ -491,7 +491,7 @@ async function runAgent(phase, ctx, variables) {
   // writable. Every other artifact-only phase — pr-description included — gets
   // just its own run directory; it has no business touching the task file repo.
   const artifactOnlyDirs = phase.role === 'verdict' ? ctx.artifactDirs : [ctx.state.dir];
-  const { command, args } = adapter.command({
+  const { command, args, input } = adapter.command({
     prompt,
     cwd: agentCwd,
     addDirs: worktreeWrite ? ctx.addDirs : [...artifactOnlyDirs, ...(sourceSnapshot ? [sourceSnapshot.path] : [])],
@@ -539,6 +539,10 @@ async function runAgent(phase, ctx, variables) {
       env: execution.env,
       timeoutMs: ctx.config.timeoutMs,
       activeProcessPath: ctx.activeProcessPath,
+      // Adapters that carry the prompt on stdin (gemini, to dodge the cmd.exe
+      // command-line limit on Windows) return it as `input`; a hermetic wrapper
+      // forwards stdin to the sandboxed process unchanged.
+      input,
       onOutput: (text, stream) => emit(stream === 'stderr' ? text : renderer.write(text)),
     });
   } catch (error) {

package/src/state.mjs

@@ -37,6 +37,15 @@ function isActiveProcessAlive(activeProcess) {
   return isProcessGroupAlive(activeProcess?.processGroupId) || isProcessAlive(activeProcess?.pid);
 }
 
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function readActiveProcess(dir) {
   try {
     return JSON.parse(await readFile(join(dir, 'active-command.json'), 'utf8'));
@@ -238,7 +247,16 @@ export class RunState {
         await publishLock(path, lockToken, contents);
         return lockToken;
       } catch (error) {
-        if (!['EEXIST', 'ENOTEMPTY'].includes(error.code)) throw error;
+        // POSIX rejects a rename onto the existing (non-empty) lock directory
+        // with EEXIST/ENOTEMPTY — the signal that the lock is already held.
+        // Windows rejects the same rename with EPERM (sometimes EACCES)
+        // instead, so without this a `--resume` that finds any prior lock dir
+        // crashes with "EPERM: operation not permitted, rename". Treat those as
+        // contention too, but only when the lock path is actually present, so a
+        // genuine permission failure still surfaces instead of spinning here.
+        const contended = ['EEXIST', 'ENOTEMPTY'].includes(error.code)
+          || (['EPERM', 'EACCES'].includes(error.code) && await pathExists(path));
+        if (!contended) throw error;
       }
 
       let existing;

package/src/types.d.ts

@@ -70,6 +70,12 @@ export interface AdapterCommandOptions {
 export interface AdapterCommand {
   command: string;
   args: string[];
+  /**
+   * Optional stdin for the command. Adapters use it to carry the prompt off the
+   * argument vector (gemini does, to dodge the cmd.exe command-line limit on
+   * Windows) rather than passing it as an argv element.
+   */
+  input?: string;
   [key: string]: unknown;
 }