@yegor256/jinka 0.0.5 → 0.0.6

package/bin/jinka.js

@@ -4,18 +4,21 @@
 
 import { Command, Option, InvalidArgumentError } from 'commander';
 import { readFile } from 'node:fs/promises';
-import { resolve, join, dirname } from 'node:path';
+import { resolve, join, dirname, parse } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { Jinka } from '../src/jinka.js';
 import { Wishes } from '../src/wishes.js';
 import { Agent } from '../src/agent.js';
 import { Claude } from '../src/claude.js';
+import { Codex } from '../src/codex.js';
+import { Genie } from '../src/genie.js';
 import { Disk } from '../src/disk.js';
 import { Tty } from '../src/tty.js';
 import { Log } from '../src/log.js';
 import { Status } from '../src/status.js';
 import { Quota } from '../src/quota.js';
+import { Rollouts } from '../src/rollouts.js';
 import { Meters } from '../src/meters.js';
 import { Freeze } from '../src/freeze.js';
 import { Frozen } from '../src/frozen.js';
@@ -27,6 +30,8 @@ import { Legend } from '../src/legend.js';
 import { Tokens } from '../src/tokens.js';
 import { Crew } from '../src/crew.js';
 import { Jobs } from '../src/jobs.js';
+import { Summary } from '../src/summary.js';
+import { Summarized } from '../src/summarized.js';
 
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -63,29 +68,42 @@ const program = new Command()
   .addOption(new Option('--logs <dir>', 'directory where the output of every agent run is saved').default(join(homedir(), '.jinka', 'logs'), '~/.jinka/logs'))
   .addOption(new Option('--memory <dir>', 'directory where agents keep what they learn about repositories between runs').default(join(homedir(), '.jinka', 'memory'), '~/.jinka/memory'))
   .addOption(new Option('--skill <dir>', 'directory with the plugin of skills that the agent loads').default(join(root, 'plugin'), 'skills bundled with jinka'))
-  .option('--agent <cmd>', 'agent executable to run', 'claude')
+  .addOption(new Option('--engine <name>', 'kind of agent to run, guessed from the name of the agent executable when not given').choices(['claude', 'codex']))
+  .addOption(new Option('--agent <cmd>', 'agent executable to run').default('', 'the name of the engine'))
   .option('--interval <ms>', 'how often the wishes directory is scanned', positive, 5000)
   .option('--pause <ms>', 'how long a capitalized wish that was there at startup waits after a success before it runs again', positive, 60000)
   .addOption(new Option('--model <name>', 'model passed to the agent').default('', 'agent default'))
+  .addOption(new Option('--effort <level>', 'reasoning effort passed to the agent, such as low, medium, high, xhigh, or max').default('', 'agent default'))
   .option('--throttle <percent>', 'how much of the agent quota, in percent, must be left in every window before a new job starts', percent, 15)
   .addOption(new Option('--limit <n>', 'how many jobs start before jinka waits for them to finish and quits').argParser(positive).default(Infinity, 'unlimited'))
   .parse();
 const values = program.opts();
 const dir = resolve(values.wishes);
+const engine = values.engine ?? (parse(values.agent).name === 'codex' ? 'codex' : 'claude');
+const agent = values.agent === '' ? engine : values.agent;
 const tokens = new Tokens();
 const quota = new Quota();
 const crew = new Crew(values.threads, limit, { warn: (text) => screen.notice().warn(text) });
-const jobs = new Jobs(new Claude(new Agent(values.agent, values.model), resolve(values.skill), new Disk(dir, resolve(values.logs), resolve(values.memory), crew), new Meters([tokens, quota])));
-const freeze = new Freeze(crew, { warn: (text) => screen.notice().warn(text) }, () => process.exit(0));
-const screen = process.stdout.isTTY
-  ? new Tty(
-    process.stdout,
-    crew,
-    new Status(pkg.version, Date.now(), jobs, values.agent, values.model, tokens, quota),
-    new Legend(freeze)
-  )
-  : new Log(process.stdout);
+const jobs = new Jobs(new Genie(new (engine === 'codex' ? Codex : Claude)(new Agent(agent), values.model, values.effort, resolve(values.skill)), new Disk(dir, resolve(values.logs), resolve(values.memory), crew), new Meters([tokens, engine === 'codex' ? new Rollouts(quota, join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'sessions')) : quota])));
+const freeze = new Freeze(crew, { warn: (text) => screen.notice().warn(text) }, () => quit(0));
+const start = Date.now();
+const screen = new Summarized(
+  process.stdout.isTTY
+    ? new Tty(
+      process.stdout,
+      crew,
+      new Status(start, jobs, agent, values.model, tokens, quota),
+      new Legend(freeze, pkg.version)
+    )
+    : new Log(process.stdout),
+  new Summary(start, pkg.version, jobs, { agent, model: values.model, effort: values.effort, wishes: dir }),
+  process.stdout
+);
 process.on('exit', () => screen.close());
+const quit = (code) => {
+  screen.close();
+  process.stdout.write('', () => process.stderr.write('', () => process.exit(code)));
+};
 const controller = new AbortController();
 const interrupt = () => {
   if (controller.signal.aborted) {
@@ -103,9 +121,9 @@ try {
     screen,
     crew
   ).run(controller.signal);
-  process.exit(130);
+  quit(130);
 } catch (e) {
   screen.close();
   console.error(e.message);
-  process.exit(1);
+  quit(1);
 }

package/package.json

@@ -6,7 +6,7 @@
   "dependencies": {
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",
-    "slice-ansi": "^9.0.0"
+    "slice-ansi": "^10.0.0"
   },
   "description": "Simple command line orchestrator of coding agents",
   "devDependencies": {
@@ -35,5 +35,5 @@
     "test": "c8 --check-coverage --lines 80 mocha"
   },
   "type": "module",
-  "version": "0.0.5"
+  "version": "0.0.6"
 }

package/plugin/skills/accept-pull-request/SKILL.md

@@ -31,7 +31,7 @@ Use a merge commit when the repository allows it.
 Fall back to the merge method the repository allows otherwise.
 Keep the head branch, since its author owns it.
 
-Always post your decision to the PR, explain why you decided to merge.
+Post your decision to the issue, explain why you decided to merge.
 Write like a human maintainer, short and specific.
 Open with substance, never with praise or boilerplate.
 Keep prose free of emoji and of `Generated with` footers.

package/src/agent.js

@@ -4,22 +4,12 @@
 import spawn from 'cross-spawn';
 
 export class Agent {
-  constructor(command, model) {
+  constructor(command) {
     this.command = command;
-    this.model = model;
   }
   start(args, signal) {
     const windows = process.platform === 'win32';
-    const child = spawn(
-      this.command,
-      [
-        '-p', '--output-format', 'stream-json', '--verbose',
-        ...args,
-        '--dangerously-skip-permissions',
-        ...(this.model === '' ? [] : ['--model', this.model])
-      ],
-      windows ? { stdio: 'pipe' } : { signal, stdio: 'pipe' }
-    );
+    const child = spawn(this.command, args, windows ? { stdio: 'pipe' } : { signal, stdio: 'pipe' });
     if (windows) {
       signal.addEventListener(
         'abort',

package/src/claude.js

@@ -1,56 +1,27 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-import { createInterface } from 'node:readline';
-import { Event } from './event.js';
-import { Tokens } from './tokens.js';
-import { Model } from './model.js';
-
 export class Claude {
-  constructor(agent, plugin, disk, meter) {
+  constructor(agent, model, effort, plugin) {
     this.agent = agent;
+    this.model = model;
+    this.effort = effort;
     this.plugin = plugin;
-    this.disk = disk;
-    this.meter = meter;
   }
-  async run(wish, row, signal) {
-    const prompt = [
-      'Make this wish come true, working on your own without asking any questions:',
-      '',
-      await wish.text(),
-      '',
-      ...this.disk.lines(wish),
-      'When you finish, end with a single plain sentence that says what you did.',
-      'On the next line, write the full URL of the GitHub issue or pull request you worked on, if there was one.'
-    ].join('\n');
-    const log = await this.disk.log(wish);
-    const child = this.agent.start(['--plugin-dir', this.plugin, ...this.disk.args()], signal);
-    child.stdin.on('error', () => {});
-    child.stdin.end(prompt);
-    child.stdout.pipe(log, { end: false });
-    child.stderr.pipe(log, { end: false });
-    let summary = '';
-    let link = '';
-    const usage = new Tokens();
-    const model = new Model();
-    createInterface({ input: child.stdout }).on('line', (line) => {
-      this.meter.add(line);
-      usage.add(line);
-      model.add(line);
-      summary = new Event(line).summary() || summary;
-      link = new Event(line).link() || link;
-      const text = new Event(line).text();
-      if (text !== '') {
-        row.show(text);
-      }
-    });
-    return new Promise((resolve, reject) => {
-      child.on('error', (e) => {
-        if (!signal.aborted) {
-          reject(new Error(`Cannot start the agent "${child.spawnfile}": ${e.message}`));
-        }
-      });
-      child.on('close', (code) => log.end(() => resolve({ code: code ?? 1, summary, link, tokens: usage.text(), model: model.text() })));
-    });
+  start(args, signal) {
+    return this.agent.start(
+      [
+        '-p', '--output-format', 'stream-json', '--verbose',
+        '--plugin-dir', this.plugin,
+        ...args,
+        '--dangerously-skip-permissions',
+        ...(this.model === '' ? [] : ['--model', this.model]),
+        ...(this.effort === '' ? [] : ['--effort', this.effort])
+      ],
+      signal
+    );
+  }
+  lines() {
+    return [];
   }
 }

package/src/codex.js

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { join } from 'node:path';
+
+export class Codex {
+  constructor(agent, model, effort, plugin) {
+    this.agent = agent;
+    this.model = model;
+    this.effort = effort;
+    this.plugin = plugin;
+  }
+  start(args, signal) {
+    return this.agent.start(
+      [
+        'exec', '--json',
+        '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check',
+        ...args,
+        ...(this.model === '' ? [] : ['--model', this.model]),
+        ...(this.effort === '' ? [] : ['--config', `model_reasoning_effort=${this.effort}`]),
+        '-'
+      ],
+      signal
+    );
+  }
+  lines() {
+    return [
+      `Your skills live in the directory ${join(this.plugin, 'skills')}, one skill per subdirectory, each described in its SKILL.md file.`,
+      'Before you start, read the descriptions of these skills, and whenever a skill fits your work, read its SKILL.md file and follow it.'
+    ];
+  }
+}

package/src/disk.js

@@ -19,7 +19,10 @@ export class Disk {
       `If this wish is an atomic job that involves no other jobs, make it come true yourself;`,
       `otherwise, do not do it yourself, but split it into smaller wishes`,
       `and write each of them as a separate Markdown file in the directory ${join(this.wishes, dirname(wish.name()))}.`,
-      `Your memory lives in the directory ${this.memory}, keep there what the skills tell you to keep.`,
+      `Always start the name of every new wish file with a small English letter, never with a capital one.`,
+      `In every Git repository you touch, do all your work inside a separate Git worktree, never in the main directory of the repository, so that other wishes running at the same time do not see your changes.`,
+      `Never spend time waiting while doing a wish, neither sleeping nor polling for a build, a review, a merge, or anything else;`,
+      `if something must happen first, write a new wish that waits for it and finishes the job, and then complete the current wish right away.`,      `Your memory lives in the directory ${this.memory}, keep there what the skills tell you to keep.`,
       `Jinka runs ${this.crew.size()} threads right now, so up to ${this.crew.size()} wishes run at once.`
     ];
   }

package/src/duration.js

@@ -9,6 +9,21 @@ export class Duration {
     const seconds = Math.floor(this.millis / 1000);
     return [Math.floor(seconds / 60), seconds % 60].map((p) => String(p).padStart(2, '0')).join(':');
   }
+  clock() {
+    const minutes = Math.floor(this.millis / 60_000);
+    if (minutes < 1000) {
+      return this.minutes().padStart(6);
+    }
+    if (minutes < 6000) {
+      return `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}m`;
+    }
+    return `${Math.floor(minutes / 60)}h`.padStart(6);
+  }
+  phrase() {
+    const seconds = Math.floor(this.millis / 1000);
+    const [count, unit] = seconds < 60 ? [seconds, 'second'] : [Math.floor(seconds / 60), 'minute'];
+    return `${count} ${unit}${count === 1 ? '' : 's'}`;
+  }
   hours() {
     const seconds = Math.floor(this.millis / 1000);
     return [Math.floor(seconds / 3600), Math.floor(seconds / 60) % 60, seconds % 60].map((p) => String(p).padStart(2, '0')).join(':');

package/src/event.js

@@ -1,11 +1,10 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-import { styleText } from 'node:util';
-
 export class Event {
-  constructor(line) {
+  constructor(line, count) {
     this.line = line;
+    this.count = count;
   }
   text() {
     try {
@@ -16,16 +15,14 @@ export class Event {
   }
   summary() {
     try {
-      const json = JSON.parse(this.line);
-      return json.type === 'result' ? this.#first(String(json.result ?? '')) : '';
+      return this.#first(this.#final(JSON.parse(this.line)));
     } catch {
       return '';
     }
   }
   link() {
     try {
-      const json = JSON.parse(this.line);
-      return json.type === 'result' ? (String(json.result ?? '').match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+/) ?? [''])[0] : '';
+      return (this.#final(JSON.parse(this.line)).match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+/) ?? [''])[0];
     } catch {
       return '';
     }
@@ -37,6 +34,27 @@ export class Event {
     if (json.type === 'result') {
       return this.#first(String(json.result ?? json.subtype ?? ''));
     }
+    if (json.type === 'item.completed' && json.item?.type === 'agent_message') {
+      return this.#first(String(json.item.text ?? ''));
+    }
+    if (json.type === 'item.started' && json.item?.type === 'command_execution') {
+      return this.#program(String(json.item.command ?? ''));
+    }
+    if (json.type === 'item.completed' && json.item?.type === 'file_change') {
+      return `editing ${(json.item.changes ?? []).map((c) => c.path).join(', ')}`;
+    }
+    if (json.type === 'turn.failed') {
+      return this.#first(String(json.error?.message ?? ''));
+    }
+    return '';
+  }
+  #final(json) {
+    if (json.type === 'result') {
+      return String(json.result ?? '');
+    }
+    if (json.type === 'item.completed' && json.item?.type === 'agent_message') {
+      return String(json.item.text ?? '');
+    }
     return '';
   }
   #part(part) {
@@ -49,17 +67,21 @@ export class Event {
       if (phrase !== undefined) {
         return this.#first(phrase);
       }
-      return styleText(
-        'gray',
+      if (part.name === 'Bash' && input.command !== undefined) {
+        return this.#program(String(input.command));
+      }
+      return `\x1b[38;2;0;204;204m${
         [part.name, input.command ?? input.file_path ?? input.pattern ?? input.url ?? input.query ?? input.skill ?? input.description]
           .filter((p) => p !== undefined)
           .map((p) => this.#first(String(p)))
-          .join(': '),
-        { validateStream: false }
-      );
+          .join(': ')
+      }\x1b[39m`;
     }
     return '';
   }
+  #program(command) {
+    return `\x1b[38;2;0;204;204m${command.trim().split(/\s+/)[0].split('/').at(-1)}\x1b[39m (${this.count} lines)`;
+  }
   #plain(name, input) {
     const phrases = {
       Bash: () => input.description,

package/src/genie.js

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { createInterface } from 'node:readline';
+import { Event } from './event.js';
+import { Tokens } from './tokens.js';
+import { Model } from './model.js';
+
+export class Genie {
+  constructor(engine, disk, meter) {
+    this.engine = engine;
+    this.disk = disk;
+    this.meter = meter;
+  }
+  async run(wish, row, signal) {
+    const prompt = [
+      'Make this wish come true, working on your own without asking any questions:',
+      '',
+      await wish.text(),
+      '',
+      ...this.disk.lines(wish),
+      ...this.engine.lines(),
+      'When you finish, end with a single plain sentence that says what you did.',
+      'On the next line, write the full URL of the GitHub issue or pull request you worked on, if there was one.'
+    ].join('\n');
+    const log = await this.disk.log(wish);
+    const child = this.engine.start(this.disk.args(), signal);
+    child.stdin.on('error', () => {});
+    child.stdin.end(prompt);
+    child.stdout.pipe(log, { end: false });
+    child.stderr.pipe(log, { end: false });
+    let summary = '';
+    let link = '';
+    const usage = new Tokens();
+    const model = new Model();
+    let count = 0;
+    createInterface({ input: child.stderr }).on('line', () => {
+      count += 1;
+    });
+    createInterface({ input: child.stdout }).on('line', (line) => {
+      count += 1;
+      this.meter.add(line);
+      usage.add(line);
+      model.add(line);
+      summary = new Event(line, count).summary() || summary;
+      link = new Event(line, count).link() || link;
+      const text = new Event(line, count).text();
+      if (text !== '') {
+        row.show(text);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      child.on('error', (e) => {
+        if (!signal.aborted) {
+          reject(new Error(`Cannot start the agent "${child.spawnfile}": ${e.message}`));
+        }
+      });
+      child.on('close', (code) => log.end(() => resolve({ code: code ?? 1, summary, link, tokens: usage.text(), model: model.text() })));
+    });
+  }
+}

package/src/legend.js

@@ -4,10 +4,14 @@
 import { styleText } from 'node:util';
 
 export class Legend {
-  constructor(freeze) {
+  constructor(freeze, version) {
     this.freeze = freeze;
+    this.version = version;
   }
   text() {
+    return `${this.#keys()}\t${this.version}`;
+  }
+  #keys() {
     return this.freeze.active()
       ? `keys: ${styleText('bgGray', 'C', { validateStream: false })} - to continue`
       : `keys: ${styleText('bgGray', 'F', { validateStream: false })} - to finish and quit, ${styleText('bgGray', '+/-', { validateStream: false })} to add threads`;

package/src/logo.js

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Logo {
+  lines() {
+    return ['▚▄▄▙▄▄▄▄▗▄▖ ', '▞▀▀▛▀▀▀▛▀▀▀▀'].map((l) => `\x1b[38;2;215;119;87m${l}\x1b[39m`);
+  }
+}

package/src/quota.js

@@ -3,28 +3,35 @@
 
 export class Quota {
   constructor() {
-    this.shares = [];
     this.windows = [];
   }
   add(line) {
     try {
       const json = JSON.parse(line);
       if (json.type === 'rate_limit_event' && typeof json.rate_limit_info?.unifiedWindows === 'object') {
-        this.windows.push(Object.values(json.rate_limit_info.unifiedWindows).filter((w) => typeof w?.utilization === 'number'));
-      }
-      if (json.type === 'rate_limit_event' && typeof json.rate_limit_info?.unifiedWindows?.five_hour?.utilization === 'number') {
-        this.shares.push(json.rate_limit_info.unifiedWindows.five_hour.utilization);
+        this.windows.push(Object.entries(json.rate_limit_info.unifiedWindows).filter(([, w]) => typeof w?.utilization === 'number'));
       }
     } catch {
       return;
     }
   }
-  text() {
-    return this.shares.length === 0 ? '-' : `${Math.round((1 - this.shares.at(-1)) * 100)}%`;
+  text(now) {
+    return this.#live(now)
+      .map(([n, share]) => `${Math.round(share)}%-${{ 'five-hour': '5H', 'seven-day': 'W', 'thirty-day': 'M' }[n] ?? n}`)
+      .join(',') || '-';
   }
   left(now) {
-    return Math.min(100, ...(this.windows.at(-1) ?? [])
-      .filter((w) => typeof w.resetsAt !== 'number' || w.resetsAt * 1000 > now)
-      .map((w) => (1 - w.utilization) * 100));
+    return this.#tightest(now)[1];
+  }
+  name(now) {
+    return this.#tightest(now)[0];
+  }
+  #tightest(now) {
+    return this.#live(now).reduce((a, b) => (b[1] < a[1] ? b : a), ['', 100]);
+  }
+  #live(now) {
+    return (this.windows.at(-1) ?? [])
+      .filter(([, w]) => typeof w.resetsAt !== 'number' || w.resetsAt * 1000 > now)
+      .map(([n, w]) => [n.replaceAll('_', '-'), (1 - w.utilization) * 100]);
   }
 }

package/src/rollouts.js

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export class Rollouts {
+  constructor(origin, dir) {
+    this.origin = origin;
+    this.dir = dir;
+    this.files = new Map();
+    this.thread = '';
+  }
+  add(line) {
+    this.origin.add(line);
+    try {
+      const json = JSON.parse(line);
+      if (json.type === 'thread.started' && typeof json.thread_id === 'string') {
+        this.thread = json.thread_id;
+      }
+      if ((json.type === 'turn.completed' || json.type === 'item.completed') && this.thread !== '') {
+        this.#limits().forEach((limits) => this.origin.add(JSON.stringify({
+          type: 'rate_limit_event',
+          rate_limit_info: {
+            unifiedWindows: Object.fromEntries(
+              [limits.primary, limits.secondary]
+                .filter((w) => typeof w?.used_percent === 'number' && typeof w?.window_minutes === 'number')
+                .map((w) => [{ 300: 'five_hour', 10080: 'seven_day', 43200: 'thirty_day' }[w.window_minutes] ?? `${w.window_minutes}_minute`, { utilization: w.used_percent / 100, resetsAt: w.resets_at }])
+            )
+          }
+        })));
+      }
+    } catch {
+      return;
+    }
+  }
+  #limits() {
+    if (!this.files.has(this.thread) && existsSync(this.dir)) {
+      readdirSync(this.dir, { recursive: true })
+        .map(String)
+        .filter((path) => path.endsWith(`-${this.thread}.jsonl`))
+        .forEach((path) => this.files.set(this.thread, path));
+    }
+    return !this.files.has(this.thread)
+      ? []
+      : readFileSync(join(this.dir, this.files.get(this.thread)), 'utf8')
+        .split('\n')
+        .filter((text) => text.includes('"rate_limits"'))
+        .map((text) => JSON.parse(text).payload?.rate_limits)
+        .filter((limits) => typeof limits === 'object' && limits !== null)
+        .slice(-1);
+  }
+}

package/src/status.js

@@ -5,8 +5,7 @@ import { styleText } from 'node:util';
 import { Duration } from './duration.js';
 
 export class Status {
-  constructor(version, start, jobs, agent, model, tokens, quota) {
-    this.version = version;
+  constructor(start, jobs, agent, model, tokens, quota) {
     this.start = start;
     this.jobs = jobs;
     this.agent = agent;
@@ -15,14 +14,14 @@ export class Status {
     this.quota = quota;
   }
   text() {
+    const now = Date.now();
     return [
-      `jinka ${styleText('bgGray', this.version, { validateStream: false })}`,
-      `up ${styleText('bgGray', new Duration(Date.now() - this.start).hours(), { validateStream: false })}`,
-      `done ${styleText('bgGray', this.jobs.text(), { validateStream: false })}`,
-      `agent ${styleText('bgGray', this.agent, { validateStream: false })}`,
-      `model ${styleText('bgGray', this.model === '' ? 'default' : this.model, { validateStream: false })}`,
-      `tokens ${styleText('bgGray', this.tokens.text(), { validateStream: false })}`,
-      `5h-quota ${styleText('bgGray', this.quota.text(), { validateStream: false })}`
-    ].join(', ');
+      `up:${styleText('bgGray', new Duration(now - this.start).hours(), { validateStream: false })}`,
+      `done:${styleText('bgGray', this.jobs.text(), { validateStream: false })}`,
+      `agent:${styleText('bgGray', this.agent, { validateStream: false })}`,
+      `model:${styleText('bgGray', this.model === '' ? 'default' : this.model, { validateStream: false })}`,
+      `tokens:${styleText('bgGray', this.tokens.text(), { validateStream: false })}`,
+      `quota:${styleText('bgGray', this.quota.text(now), { validateStream: false })}`
+    ].join(' ');
   }
 }

package/src/summarized.js

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Summarized {
+  constructor(screen, summary, stream) {
+    this.screen = screen;
+    this.summary = summary;
+    this.stream = stream;
+    this.done = [];
+  }
+  row(index) {
+    return this.screen.row(index);
+  }
+  notice() {
+    return this.screen.notice();
+  }
+  up() {
+    this.screen.up();
+  }
+  down() {
+    this.screen.down();
+  }
+  close() {
+    this.screen.close();
+    if (this.done.length === 0) {
+      this.done.push(true);
+      this.stream.write(this.summary.text());
+    }
+  }
+}

package/src/summary.js

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { sep } from 'node:path';
+import { Duration } from './duration.js';
+
+export class Summary {
+  constructor(start, version, jobs, setup) {
+    this.start = start;
+    this.version = version;
+    this.jobs = jobs;
+    this.setup = setup;
+  }
+  text() {
+    return [
+      '---',
+      `jinka ${this.version} finished in ${new Duration(Date.now() - this.start).hours()}`,
+      `agent: ${this.setup.agent}, model: ${this.setup.model === '' ? 'default' : this.setup.model}, effort: ${this.setup.effort === '' ? 'default' : this.setup.effort}`,
+      `sessions finished: ${this.jobs.text()}`,
+      `wishes remained in ${this.setup.wishes.startsWith(`${homedir()}${sep}`) ? `~${this.setup.wishes.slice(homedir().length)}` : this.setup.wishes}: ${existsSync(this.setup.wishes) ? readdirSync(this.setup.wishes, { recursive: true, withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith('.md')).length : 0}`,
+      ''
+    ].join('\n');
+  }
+}

package/src/throttled.js

@@ -22,15 +22,12 @@ export class Throttled {
     if (left >= this.throttle && first) {
       return;
     }
+    const share = `${Math.round(left)}% of the ${this.quota.name(Date.now())} quota is left`;
     if (left >= this.throttle) {
-      this.notice.warn(`checked the quota again, ${Math.round(left)}% is left, which is not below ${this.throttle}%, so new jobs resume`);
+      this.notice.warn(`now ${share}, not below ${this.throttle}%, new jobs resume`);
       return;
     }
-    if (first) {
-      this.notice.warn(`only ${Math.round(left)}% of the quota is left, which is below ${this.throttle}%, so new jobs wait and the quota is checked again in ${new Duration(this.interval).minutes()}`);
-    } else {
-      this.notice.warn(`checked the quota again, only ${Math.round(left)}% is left, which is still below ${this.throttle}%, so new jobs wait and the quota is checked again in ${new Duration(this.interval).minutes()}`);
-    }
+    this.notice.warn(`${first ? '' : 'still '}only ${share}, below ${this.throttle}%, new jobs wait, next check in ${new Duration(this.interval).phrase()}`);
     await setTimeout(this.interval, undefined, { signal });
     await this.#wait(signal, false);
   }

package/src/tokens.js

@@ -15,6 +15,9 @@ export class Tokens {
             .reduce((sum, key) => sum + (json.message.usage[key] ?? 0), 0)
         );
       }
+      if (json.type === 'turn.completed' && json.usage !== undefined) {
+        this.messages.set(Symbol('turn'), (json.usage.input_tokens ?? 0) + (json.usage.output_tokens ?? 0));
+      }
     } catch {
       return;
     }

package/src/tty.js

@@ -6,6 +6,7 @@ import sliceAnsi from 'slice-ansi';
 import { Row } from './row.js';
 import { Protocol } from './protocol.js';
 import { Duration } from './duration.js';
+import { Logo } from './logo.js';
 
 export class Tty {
   constructor(stream, crew, status, legend) {
@@ -75,21 +76,26 @@ export class Tty {
     const notes = this.notes.flatMap((n) => this.#wrap(n, columns));
     const height = Math.max(0, rows - lines.length - 5);
     this.view.depth = Math.min(this.view.depth, Math.max(0, notes.length - height));
+    const [upper, lower] = new Logo().lines();
     const top = [
-      this.status.text(),
-      '',
-      ...lines.map(([, l]) => `${l.head}${' '.repeat(width - stripVTControlCharacters(l.head).length)}  ${styleText(['', 'idle'].includes(stripVTControlCharacters(l.head)) ? 'gray' : 'green', new Duration(Date.now() - l.start).minutes(), { validateStream: false })}  ${l.tail}`),
+      `${upper} ${this.status.text()}`,
+      lower,
+      ...lines.map(([, l]) => `${l.head}${' '.repeat(width - stripVTControlCharacters(l.head).length)}  ${styleText(['', 'idle'].includes(stripVTControlCharacters(l.head)) ? 'gray' : 'green', new Duration(Date.now() - l.start).clock(), { validateStream: false })}  ${l.tail}`),
       '-'.repeat(10),
       ...notes.slice(Math.max(0, notes.length - height - this.view.depth), notes.length - this.view.depth)
     ];
     this.stream.write(
       `\x1b[H${
-        [...top, ...Array(Math.max(1, rows - top.length - 1)).fill(''), this.legend.text()]
+        [...top, ...Array(Math.max(1, rows - top.length - 1)).fill(''), this.#edge(this.legend.text(), columns)]
           .map((l) => `\x1b[2K${sliceAnsi(l, 0, columns)}\x1b[0m`)
           .join('\n')
       }\x1b[J`
     );
   }
+  #edge(text, width) {
+    const [left, right] = text.split('\t');
+    return `${left}${' '.repeat(Math.max(1, width - 1 - stripVTControlCharacters(left).length - stripVTControlCharacters(right).length))}${right}`;
+  }
   #wrap(text, width) {
     return stripVTControlCharacters(text).length <= width || width < 3 ? [text] : [sliceAnsi(text, 0, width), ...this.#wrap(`  ${sliceAnsi(text, width)}`, width)];
   }