@syntax-syllogism/aloop 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ 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/).
 
+## [Unreleased]
+
+### Added
+
+- **Gemini engine.** `gemini` joins `claude`, `codex`, and `agy` as a built-in
+  engine. Any phase can run on the Gemini CLI via `engines.*.name = 'gemini'` or
+  `--engine gemini`. Headless phases run with `--approval-mode` (`plan` when
+  read-only, `yolo` when writing), `--skip-trust` so a fresh worktree is
+  trusted, and `--output-format stream-json` so long phases stay watchable.
+  Gemini has no reasoning-effort flag, so a configured `effort` is ignored for
+  it.
+
+## [0.7.0] - 2026-09-18
+
+### Added
+
+- Gemini is now available as a built-in engine
+
 ## [0.6.0] - 2026-09-14
 
 ### Added
@@ -183,6 +201,12 @@ History from before the standalone extraction (changesets format), preserved for
   - Prompts ship with the package and are overridable per phase from
     `.loop/prompts/` in the consuming project.
 
+## [0.6.2] - 2026-09-16
+
+### Fixed
+
+- Resolve Windows executables to correct on-disk casing
+
 ## [0.5.2] - 2026-09-13
 
 ### Changed

package/README.md

@@ -85,9 +85,10 @@ export default {
 };
 ```
 
-Supported built-in engines are `claude`, `codex`, and `agy`. The corresponding
-CLI must already be installed and authenticated. Engine descriptors may include
-an engine-specific `model` and `effort`. `--config` selects a configuration
+Supported built-in engines are `claude`, `codex`, `agy`, and `gemini`. The
+corresponding CLI must already be installed and authenticated. Engine
+descriptors may include an engine-specific `model` and `effort` (Gemini has no
+effort tier, so a configured `effort` is ignored for it). `--config` selects a configuration
 file outside the current repository; command-line phase and round options take
 precedence.
 

package/bin/loop.mjs

@@ -115,7 +115,7 @@ export function usage() {
     '  -n, --name <slug>       Explicit run identity/slug',
     '  -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',
+    '  -e, --engine <name>     Default engine: claude | codex | agy | gemini',
     '      --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.6.1",
+  "version": "0.7.0",
   "description": "Syntax & Syllogism agentic loop runner.",
   "type": "module",
   "exports": {
@@ -31,6 +31,7 @@
     "claude",
     "codex",
     "antigravity",
+    "gemini",
     "opencode",
     "cli"
   ],

package/src/adapters.mjs

@@ -71,6 +71,24 @@ function summarizeAgyParams(params) {
   return '';
 }
 
+/**
+ * Summarize a Gemini tool call's parameters.
+ *
+ * Gemini's built-in tools use the descriptive keys the shared summarizer already
+ * knows (`command`, `file_path`, `path`, `pattern`, `url`, …); an MCP tool may
+ * use anything, so fall back to the first string value — robust to tools this
+ * list has never seen, the same shape as `summarizeAgyParams`.
+ */
+function summarizeGeminiParams(params) {
+  if (!params || typeof params !== 'object') return '';
+  const known = summarizeToolInput(params);
+  if (known) return known;
+  for (const value of Object.values(params)) {
+    if (typeof value === 'string' && value.trim()) return condense(value);
+  }
+  return '';
+}
+
 function cliVersion(command) {
   return async () => {
     const cwd = await mkdtemp(join(tmpdir(), 'aloop-version-'));
@@ -163,6 +181,63 @@ export function renderAgyEvent(event) {
   return '';
 }
 
+/**
+ * Turn one Gemini stream-json event into the line a watching human wants.
+ *
+ * Gemini tags each event with `type` (like Claude, unlike agy's `event`). The
+ * headless stream emits `init` (session), `message` (user/assistant turns —
+ * assistant text streams as deltas), `tool_use` (a tool the model invoked, with
+ * `tool_name`/`parameters`), `tool_result` (its outcome, `status` success|error
+ * with an `error.message`), `error` (non-fatal warnings and system errors), and
+ * `result` (final status, token counts under `stats`). Tool activity and tool
+ * or system failures are surfaced so a long phase stays watchable; a successful
+ * tool result is not — its full output would bury the log, exactly as the
+ * claude and agy renderers omit theirs. An unrecognized shape renders as nothing
+ * rather than raw JSON, so the enormous init payload and any event a future
+ * release adds stay out of the log.
+ */
+export function renderGeminiEvent(event) {
+  if (event.type === 'init') {
+    const id = String(event.session_id ?? '').slice(0, 8);
+    const model = event.model;
+    return `  · session ${id}${model ? ` model ${model}` : ''}\n`;
+  }
+  if (event.type === 'message') {
+    // Assistant text arrives as deltas; stream them through verbatim. The user
+    // turn is the prompt aloop already wrote, so echoing it back is noise.
+    if (event.role !== 'assistant' || typeof event.content !== 'string') return '';
+    return event.content;
+  }
+  if (event.type === 'tool_use') {
+    const detail = summarizeGeminiParams(event.parameters);
+    return `  → ${event.tool_name ?? 'tool'}${detail ? ` ${detail}` : ''}\n`;
+  }
+  if (event.type === 'tool_result') {
+    // Only failures are worth a line; a successful result's `output` is the
+    // tool's full stdout and belongs in the phase's files, not the run log.
+    if (event.status !== 'error') return '';
+    const message = event.error?.message ?? event.output ?? 'tool call failed';
+    return `  ✗ ${condense(String(message), 160)}\n`;
+  }
+  if (event.type === 'error') {
+    // Non-fatal warnings and system errors — a warning is marked, not dropped,
+    // so a stall or a blocked turn is visible while the phase runs.
+    const mark = event.severity === 'warning' ? '⚠' : '✗';
+    return `  ${mark} ${condense(String(event.message ?? 'error'), 160)}\n`;
+  }
+  if (event.type === 'result') {
+    const stats = event.stats ?? {};
+    const calls = stats.tool_calls ? ` ${stats.tool_calls} tool call${stats.tool_calls === 1 ? '' : 's'}` : '';
+    const seconds = stats.duration_ms ? ` ${Math.round(stats.duration_ms / 1000)}s` : '';
+    if (event.status && event.status !== 'success') {
+      const why = event.error?.message ? `: ${condense(String(event.error.message), 160)}` : '';
+      return `  ✗ ${String(event.status).toLowerCase()}${why}${calls}${seconds}\n`;
+    }
+    return `  ✓ done${calls}${seconds}\n`;
+  }
+  return '';
+}
+
 /**
  * Line-buffer a JSONL stream and render each complete event.
  *
@@ -175,7 +250,9 @@ export function createJsonlRenderer(renderEvent) {
   let usage = null;
   const recordUsage = (event) => {
     if (!event || typeof event !== 'object') return;
-    const source = event.usage ?? event.result?.usage ?? event;
+    // Gemini reports token counts under `stats` rather than `usage`; check it
+    // before falling back to the event itself so its totals are not lost.
+    const source = event.usage ?? event.result?.usage ?? event.stats ?? event.result?.stats ?? event;
     if (!source || typeof source !== 'object') return;
     const tokenValues = [
       source.tokens,
@@ -305,7 +382,43 @@ const agyAdapter = {
   createRenderer: () => createJsonlRenderer(renderAgyEvent),
 };
 
-const adapters = { claude: claudeAdapter, codex: codexAdapter, agy: agyAdapter };
+const geminiAdapter = {
+  name: 'gemini',
+  version: cliVersion('gemini'),
+  // Gemini CLI exposes no reasoning-effort flag, so this adapter declares no
+  // `efforts`: a configured effort is simply not passed through (see docs).
+  command({ prompt, addDirs, permissions, artifactOnly = false, agent = {} }) {
+    // `yolo`, not `plan`/`auto_edit`: in headless `--prompt` mode Gemini cannot
+    // interactively approve the shell tools a worktree-writing phase needs to
+    // build, test, and commit. `plan` is read-only and `auto_edit` auto-approves
+    // only edit tools, so either one auto-denies the first shell call and the
+    // phase "completes" instantly with an empty log. `yolo` auto-approves every
+    // tool — Gemini's equivalent of the claude adapter's `--permission-mode
+    // auto` and agy's `--dangerously-skip-permissions`.
+    //
+    // `--skip-trust`: a fresh worktree is an untrusted folder, and Gemini
+    // refuses to run headlessly in one (it prints a trust warning and does
+    // nothing). This trusts the workspace for this one invocation only.
+    //
+    // stream-json, not the default `text`: text output withholds every byte
+    // 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.
+    const canWrite = permissionLevel(permissions) === PERMISSIONS.WRITE_WORKTREE || artifactOnly;
+    const args = [
+      '--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 };
+  },
+  createRenderer: () => createJsonlRenderer(renderGeminiEvent),
+};
+
+const adapters = { claude: claudeAdapter, codex: codexAdapter, agy: agyAdapter, gemini: geminiAdapter };
 
 function validateConfiguredAdapter(name, adapter) {
   if (!adapter || typeof adapter !== 'object' || Array.isArray(adapter) || typeof adapter.command !== 'function') {

package/src/command.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
 import { win32 as windowsPath } from 'node:path';
 
 export function signalProcessGroup(pid, signal, {
@@ -63,7 +63,10 @@ function environmentValue(env, name) {
   return key ? env[key] : undefined;
 }
 
-export function resolveWindowsExecutable(command, env = process.env, { fileExists = existsSync } = {}) {
+export function resolveWindowsExecutable(command, env = process.env, {
+  fileExists = existsSync,
+  realPath = realpathSync.native,
+} = {}) {
   const pathEntries = (environmentValue(env, 'PATH') ?? '').split(';').filter(Boolean);
   const pathExtensions = (environmentValue(env, 'PATHEXT') ?? WINDOWS_EXECUTABLE_EXTENSIONS.join(';'))
     .split(';')
@@ -76,7 +79,18 @@ export function resolveWindowsExecutable(command, env = process.env, { fileExist
   for (const base of bases) {
     for (const extension of extensions) {
       const candidate = `${base}${extension}`;
-      if (fileExists(candidate)) return candidate;
+      // Candidates are assembled from PATHEXT, which is upper-cased by convention
+      // (".EXE"), while the file on disk is usually "git.exe". existsSync matches
+      // case-insensitively, so a match here would otherwise be handed to spawn with
+      // the wrong casing — which fails with ENOENT under Git Bash / MSYS. Canonicalize
+      // to the real on-disk path so spawn receives the name that actually exists.
+      if (fileExists(candidate)) {
+        try {
+          return realPath(candidate);
+        } catch {
+          return candidate;
+        }
+      }
     }
   }
   return null;