@syntax-syllogism/aloop 0.8.3 → 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.3",
+  "version": "0.8.4",
   "description": "Syntax & Syllogism agentic loop runner.",
   "type": "module",
   "exports": {

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,10 +493,10 @@ 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
@@ -611,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.');
@@ -735,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

@@ -181,6 +181,7 @@ export class RunState {
       completed: [],
       rounds: {},
       reviewedShas: {},
+      phaseBaselines: {},
       ...seed,
       schemaVersion: STATE_SCHEMA_VERSION,
     };
@@ -386,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

@@ -167,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;
@@ -184,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>;
 }