@syntax-syllogism/aloop 0.8.2 → 0.8.4

package/CHANGELOG.md

@@ -5,6 +5,15 @@ 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/).
 
+## [0.8.4] - 2026-09-20
+
+### Fixed
+
+- Nested repair baselines are now properly cleared when rerunning reviews
+- Resume commit checks are now correctly skipped during dry runs
+- Resume of existing commits now works correctly in read-only working directories
+- Model and engine flags are now handled correctly
+
 ## [0.8.0] - 2026-09-20
 
 ### Added

package/README.md

@@ -113,12 +113,12 @@ export default { publish: { backend: gitlabBackend({ transport: myMcpTransport }
 ### Bring your own engine
 
 Register an adapter under `adapters` when another CLI should run a phase. Its
-`command({ prompt, cwd, addDirs, readOnlyDirs, permissions, artifactOnly, agent })` function returns `{ command, args }`. For a read-only phase,
-`cwd` is always the run directory and `addDirs` contains only artifact roots;
-`readOnlyDirs` is an optional source-inspection input for adapters that can
-honor it. The runner supplies a permission level and restricts `addDirs`
-accordingly; the adapter must translate `permissions` into its own read-only
-or write-capable invocation flags. It may also provide `efforts`
+`command({ prompt, cwd, addDirs, permissions, artifactOnly, agent })` function
+returns `{ command, args }`. For a read-only phase, `cwd` is a disposable
+read-only source snapshot of the saved worktree and `addDirs` contains only
+writable artifact roots. The runner supplies a permission level and restricts
+`addDirs` accordingly; the adapter must translate `permissions` into its own
+read-only or write-capable invocation flags. It may also provide `efforts`
 validation and `createRenderer()` for streaming output. Custom adapter flags
 are vendor-specific and are not verified by aloop. See the [phase permission
 contract](docs/loop.md#phase-permissions) before enabling unattended runs.

package/bin/loop.mjs

@@ -32,6 +32,8 @@ export function parseLoopArgs(argv) {
       branch: { type: 'string', short: 'b' },
       'base-branch': { type: 'string' },
       engine: { type: 'string', short: 'e' },
+      model: { type: 'string', short: 'm' },
+      effort: { type: 'string' },
       'override-engine': { type: 'boolean' },
       config: { type: 'string' },
       phases: { type: 'string' },
@@ -79,6 +81,8 @@ export function parseLoopArgs(argv) {
     branch: values.branch,
     baseBranch: values['base-branch'],
     engine: values.engine,
+    model: values.model,
+    effort: values.effort,
     overrideEngine: values['override-engine'],
     config: values.config,
     phases: values.phases ? values.phases.split(',').map((phase) => phase.trim()).filter(Boolean) : undefined,
@@ -132,6 +136,8 @@ export function usage() {
     '  -b, --branch <name>     Branch to build on (default: <branchPrefix><name>)',
     '      --base-branch <branch>  Base to branch from and PR against (default: baseBranch config)',
     '  -e, --engine <name>     Default engine: claude | codex | agy | gemini',
+    '  -m, --model <name>      Model for the default engine (overrides config; switching engines without it uses the new engine default)',
+    '      --effort <level>    Reasoning effort for the default engine (overrides config; ignored by engines without effort)',
     '      --override-engine   With --resume and --engine, replace saved agent executables',
     '      --config <path>     Load loop configuration from this file (also overrides saved config on resume)',
     '      --phases a,b,c      Override the configured phase list',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syntax-syllogism/aloop",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "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

@@ -44,12 +44,23 @@ export function buildTaskContext({ task, taskFile }) {
   return '';
 }
 
-function overrideSavedEngines(agentSettings, engine, customAdapters) {
+function overrideSavedEngines(agentSettings, { engine, model, effort }, customAdapters) {
+  // Switching engine drops the saved model/effort: they are vendor-specific and
+  // meaningless to the new engine (see the --engine override above). --model and
+  // --effort set them explicitly for the new engine; without them each phase
+  // falls back to the target engine's default. validateAgent rejects an effort
+  // the target engine cannot honor.
+  const target = validateAgent(
+    { name: engine, ...(model ? { model } : {}), ...(effort ? { effort } : {}) },
+    customAdapters,
+  );
   const overrides = {};
   const overriddenSettings = Object.fromEntries(
     Object.entries(agentSettings).map(([phaseName, agent]) => {
-      if (agent.name === engine) return [phaseName, agent];
-      const overridden = validateAgent({ ...agent, name: engine }, customAdapters);
+      if (agent.name === target.name && agent.model === target.model && agent.effort === target.effort) {
+        return [phaseName, agent];
+      }
+      const overridden = { ...target };
       overrides[phaseName] = { from: agent, to: overridden };
       return [phaseName, overridden];
     }),
@@ -482,16 +493,16 @@ async function runAgent(phase, ctx, variables) {
   log(`  engine: ${agent.name}${agent.model ? `   model: ${agent.model}` : ''}${agent.effort ? `   effort: ${agent.effort}` : ''}   prompt: ${path}`);
   if (engineOverride) log(`  resumed override: ${describeAgent(engineOverride.from)} → ${describeAgent(engineOverride.to)}`);
 
-  // Every read-only agent starts in the driver-owned artifact directory. The
-  // source snapshot is disposable, so an adapter's writable added directories
-  // cannot reach the real worktree while the agent can still inspect a Git tree.
-  const agentCwd = artifactOnly ? ctx.state.dir : ctx.worktree;
+  // Read-only agents inspect the disposable source snapshot. Their writable
+  // added directories still point only at the run artifacts (and task file for
+  // review), so changing cwd cannot reach the real worktree.
+  const agentCwd = sourceSnapshot?.path ?? (artifactOnly ? ctx.state.dir : ctx.worktree);
   // Only the verdict phase's prompt is instructed to edit the task file (its
   // Code Review section), so only it is granted the external task-file repo as
   // 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 +550,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) {
@@ -607,7 +622,24 @@ export async function runLoop(options = {}) {
     ...(args.noWorktree ? { worktrees: false } : {}),
   }, args.config ? resolve(cwd, args.config) : undefined);
   if (args.engine && !args.overrideEngine) {
-    config.engines.default = validateAgent({ ...config.engines.default, name: args.engine }, config.adapters);
+    // A model/effort string is vendor-specific — `gpt-5.6-terra` means nothing
+    // to gemini — so switching to a different engine must not inherit the
+    // previous engine's model/effort. Carry them over only when the engine is
+    // unchanged; --model/--effort below can still set them explicitly.
+    const base = args.engine === config.engines.default.name
+      ? config.engines.default
+      : { name: args.engine };
+    config.engines.default = validateAgent({ ...base, name: args.engine }, config.adapters);
+  }
+  if ((args.model || args.effort) && !args.overrideEngine) {
+    config.engines.default = validateAgent(
+      {
+        ...config.engines.default,
+        ...(args.model ? { model: args.model } : {}),
+        ...(args.effort ? { effort: args.effort } : {}),
+      },
+      config.adapters,
+    );
   }
   if (args.overrideEngine && !args.resume) {
     throw new Error('--override-engine requires --resume.');
@@ -731,7 +763,11 @@ export async function runLoop(options = {}) {
     if (!savedAgentSettings) {
       throw new Error('--override-engine requires saved agent settings from an earlier run.');
     }
-    ({ agentSettings, overrides: engineOverrides } = overrideSavedEngines(savedAgentSettings, args.engine, config.adapters));
+    ({ agentSettings, overrides: engineOverrides } = overrideSavedEngines(
+      savedAgentSettings,
+      { engine: args.engine, model: args.model, effort: args.effort },
+      config.adapters,
+    ));
     if (Object.keys(engineOverrides).length > 0) {
       const engineOverride = {
         at: new Date().toISOString(),

package/src/runner.mjs

@@ -57,6 +57,19 @@ async function clearPendingRepair(phase, state) {
   await state.record({ pendingRepairs });
 }
 
+function requiresCommitBaseline(phase) {
+  return hasPostcondition(phase, 'head-advanced') || hasPostcondition(phase, 'head-advanced-or-rebuttal');
+}
+
+async function phaseHeadBefore(phase, ctx) {
+  if (ctx.dryRun) return null;
+  if (requiresCommitBaseline(phase)) {
+    return ctx.state.baselineFor(phase.name, () => ctx.git.revParse());
+  }
+  if (hasPostcondition(phase, 'head-unchanged')) return ctx.git.revParse();
+  return null;
+}
+
 async function invalidateGateCompletion(state, reviewedSha) {
   const gate = state.manifest.entries.findLast((entry) => entry.role === 'gate'
     && entry.status === 'completed'
@@ -65,25 +78,32 @@ async function invalidateGateCompletion(state, reviewedSha) {
   await state.record({ completed: state.data.completed.filter((name) => name !== gate.phase) });
 }
 
+function phaseAndRepairNames(phase) {
+  return [phase.name, ...(phase.repair ?? []).flatMap(phaseAndRepairNames)];
+}
+
 async function invalidateFollowingPhaseState(state, phases, phaseName) {
   const phaseIndex = phases.findIndex((phase) => phase.name === phaseName);
-  const followingNames = new Set(phases.slice(phaseIndex + 1).map((phase) => phase.name));
-  if (!followingNames.size) return;
+  if (phaseIndex < 0) return;
+  const invalidatedNames = new Set(phases.slice(phaseIndex).flatMap(phaseAndRepairNames));
 
-  const completed = state.data.completed.filter((name) => !followingNames.has(name));
+  const completed = state.data.completed.filter((name) => !invalidatedNames.has(name));
   const phaseState = Object.fromEntries(
-    Object.entries(state.data.phases ?? {}).filter(([name]) => !followingNames.has(name)),
+    Object.entries(state.data.phases ?? {}).filter(([name]) => !invalidatedNames.has(name)),
   );
   const pendingRepairs = Object.fromEntries(
-    Object.entries(state.data.pendingRepairs ?? {}).filter(([name]) => !followingNames.has(name)),
+    Object.entries(state.data.pendingRepairs ?? {}).filter(([name]) => !invalidatedNames.has(name)),
   );
   const rounds = Object.fromEntries(
-    Object.entries(state.data.rounds ?? {}).filter(([name]) => !followingNames.has(name)),
+    Object.entries(state.data.rounds ?? {}).filter(([name]) => !invalidatedNames.has(name)),
   );
   const reviewedShas = Object.fromEntries(
-    Object.entries(state.data.reviewedShas ?? {}).filter(([name]) => !followingNames.has(name)),
+    Object.entries(state.data.reviewedShas ?? {}).filter(([name]) => !invalidatedNames.has(name)),
+  );
+  const phaseBaselines = Object.fromEntries(
+    Object.entries(state.data.phaseBaselines ?? {}).filter(([name]) => !invalidatedNames.has(name)),
   );
-  await state.record({ completed, phases: phaseState, pendingRepairs, rounds, reviewedShas });
+  await state.record({ completed, phases: phaseState, pendingRepairs, rounds, reviewedShas, phaseBaselines });
 }
 
 async function runRepairs(phase, ctx, baseVariables, pending, operations, { retainCheckpoint = false } = {}) {
@@ -131,9 +151,35 @@ async function runRepairs(phase, ctx, baseVariables, pending, operations, { reta
         }));
       }
     } else {
-      const headBefore = !ctx.dryRun && (hasPostcondition(repair, 'head-advanced') || hasPostcondition(repair, 'head-advanced-or-rebuttal'))
-        ? await ctx.git.revParse()
-        : null;
+      const headBefore = await phaseHeadBefore(repair, ctx);
+      const forceNotedRepair = ctx.resume && ctx.note?.targetPhase === phase.name;
+      if (!ctx.dryRun && ctx.resume && requiresCommitBaseline(repair) && !forceNotedRepair) {
+        const stalledReason = await codePhasePostcondition(repair, ctx, {
+          hasFindings: pending.verdict?.blocking?.length > 0,
+          headBefore,
+          round: pending.round,
+        });
+        if (!stalledReason) {
+          const outputSha = await ctx.git.revParse();
+          const responsePath = join(ctx.state.dir, `response-round-${pending.round}.md`);
+          await recordManifest(ctx, manifestEntry(repair, ctx, {
+            inputSha: headBefore,
+            outputSha,
+            round: pending.round,
+            artifacts: [
+              ...(await fileExists(responsePath) ? [`response-round-${pending.round}.md`] : []),
+            ],
+            status: 'completed',
+          }));
+          await ctx.state.record({
+            pendingRepairs: {
+              ...ctx.state.data.pendingRepairs,
+              [phase.name]: { ...pending, nextRepair: index + 1 },
+            },
+          });
+          continue;
+        }
+      }
       const repairCtx = ctx.note?.targetPhase === phase.name
         ? { ...ctx, note: { ...ctx.note, repairPhase: repair.name } }
         : ctx;
@@ -616,8 +662,22 @@ export async function runPhases({
       await state.markComplete(phase.name, { rounds: result.rounds });
       continue;
     }
-    const headBefore = !ctx.dryRun && (hasPostcondition(phase, 'head-advanced') || hasPostcondition(phase, 'head-advanced-or-rebuttal') || hasPostcondition(phase, 'head-unchanged'))
-      ? await ctx.git.revParse() : null;
+    const headBefore = await phaseHeadBefore(phase, ctx);
+    if (!ctx.dryRun && args.resume && requiresCommitBaseline(phase) && !forceNotedPhase) {
+      const stalledReason = await codePhasePostcondition(phase, ctx, { headBefore });
+      if (!stalledReason) {
+        const outputSha = await ctx.git.revParse();
+        log(`  ${phase.name} already satisfies its commit postcondition; skipping agent on resume`);
+        await recordManifest(ctx, manifestEntry(phase, ctx, {
+          inputSha: headBefore,
+          outputSha,
+          status: 'completed',
+        }));
+        await state.markComplete(phase.name);
+        summary.phases.push({ name: phase.name, ok: true });
+        continue;
+      }
+    }
     const result = await withRetries(phase, () => runAgent(phase, ctx, variables));
     const stalledReason = await codePhasePostcondition(phase, ctx, { headBefore });
     if (stalledReason) {

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'));
@@ -172,6 +181,7 @@ export class RunState {
       completed: [],
       rounds: {},
       reviewedShas: {},
+      phaseBaselines: {},
       ...seed,
       schemaVersion: STATE_SCHEMA_VERSION,
     };
@@ -238,7 +248,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;
@@ -368,6 +387,14 @@ export class RunState {
     await this.save();
   }
 
+  async baselineFor(name, compute) {
+    const phaseBaselines = this.data.phaseBaselines ?? {};
+    if (phaseBaselines[name]) return phaseBaselines[name];
+    const baseline = await compute();
+    await this.record({ phaseBaselines: { ...phaseBaselines, [name]: baseline } });
+    return baseline;
+  }
+
   async record(patch) {
     Object.assign(this.data, patch);
     await this.save();

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;
 }
 
@@ -161,6 +167,7 @@ export interface RunData {
   completed: string[];
   rounds: Record<string, number>;
   reviewedShas: Record<string, string>;
+  phaseBaselines?: Record<string, string>;
   phases?: Record<string, Record<string, any>>;
   pendingRepairs?: Record<string, any>;
   [key: string]: any;
@@ -178,6 +185,7 @@ export interface RunState {
   verdictPath(round: number): string;
   isComplete(name: string): boolean;
   markComplete(name: string, details?: Record<string, unknown>): Promise<void>;
+  baselineFor(name: string, compute: () => Promise<string>): Promise<string>;
   record(patch: Record<string, unknown>): Promise<void>;
   saveManifest(manifest: Record<string, unknown>): Promise<void>;
 }