@doguyilmaz/konvoy 0.1.1 → 0.2.0

package/README.md

@@ -41,6 +41,7 @@ to download; the npm package is a few kilobytes of source and runs on the Bun yo
 
 ```bash
 konvoy new "refactor the auth layer"
+konvoy new                     # no goal: named after the directory, like sinkaf-8f3a
 konvoy send codex "start with the token refresh path"
 konvoy ls
 konvoy resume                  # make a session current again and show its roster
@@ -52,6 +53,7 @@ konvoy attach kiro --id cli_8a1…   # adopt a session you started in kiro's own
 konvoy doctor
 konvoy update --all    # every agent CLI; konvoy itself follows its install channel (see Install)
 konvoy rm stale-slug --yes
+konvoy rename stale-slug token-refresh   # the session's .konvoy folder follows
 konvoy version
 konvoy dashboard --port 4000  # local page with the same numbers as `usage --chart`
 ```
@@ -97,7 +99,7 @@ opencode  ▁▁▂▁▁▁▁▂▁▂
 A failover notice, when codex hits its weekly limit mid-chain:
 
 ```text
-konvoy: codex is blocked (rate) — "You've hit your weekly limit · resets 7am" — claude is taking over
+konvoy: codex is blocked (rate) - "You've hit your weekly limit · resets 7am" - claude is taking over
 ```
 
 A handoff, with `delegation.enabled` on and `roles.reviewer` set to `claude`. codex ends its
@@ -120,7 +122,7 @@ decisions:
 konvoy resolves `reviewer` to claude, runs it, and prints:
 
 ```text
-konvoy: codex handed off to claude — "check the retry does not loop when the refresh itself 401s"
+konvoy: codex handed off to claude - "check the retry does not loop when the refresh itself 401s"
 ```
 
 claude's turn runs with codex's task as its prompt, preceded by this prelude:
@@ -139,7 +141,7 @@ decisions:
 ## How it works
 
 One konvoy session holds a binding per agent, and each binding holds that agent's own
-foreign session id — konvoy's id and the agent's id are never the same thing. Only claude
+foreign session id; konvoy's id and the agent's id are never the same thing. Only claude
 accepts a caller-chosen session id up front; the other three assign their own and hand it
 back after the first turn, which konvoy stores in that agent's binding and resumes on every
 turn after.
@@ -164,6 +166,9 @@ Global `~/.config/konvoy/config.jsonc`, per project `.konvoy/config.jsonc`. The
 file wins. `konvoy config get` shows each agent's resolved settings and whether a value came
 from that agent, from `defaults`, or from konvoy's own built-in.
 
+`konvoy new` also writes `.konvoy/.gitignore` (`*`, then `!config.jsonc`), so a session's `CONTEXT.md`
+and `LEDGER.md` never reach git while the project config can be committed.
+
 ```jsonc
 {
   "defaults": { "effort": "high", "permission": "edit" },
@@ -175,18 +180,18 @@ from that agent, from `defaults`, or from konvoy's own built-in.
 }
 ```
 
-`effort` is one scale — `low | medium | high | max` — mapped onto each CLI's own dial and
+`effort` is one scale, `low | medium | high | max`, mapped onto each CLI's own dial and
 clamped to what the target model actually supports.
 
-If a CLI is not on your `PATH`, point konvoy at it directly and every command — `doctor`,
-`status`, `send`, `attach`, `update` — uses that path:
+If a CLI is not on your `PATH`, point konvoy at it directly and every command (`doctor`,
+`status`, `send`, `attach`, `update`) uses that path:
 
 ```jsonc
 { "agents": { "opencode": { "bin": "~/.opencode/bin/opencode" } } }
 ```
 
 `konvoy config set <key> <value> [--global]` rewrites the layer it touches as plain JSON, so
-any comments in that file are lost — `--global` targets the global file instead of the
+any comments in that file are lost; `--global` targets the global file instead of the
 project one. Hand-edit the file instead when you want to keep them.
 
 Name a `failover` chain and konvoy follows it when an agent can't work, instead of asking:
@@ -198,7 +203,7 @@ Name a `failover` chain and konvoy follows it when an agent can't work, instead
 A rate limit or an auth failure moves to the next agent in the chain at once. An agent that failed on auth shows as `auth_required` in the roster until one of its turns succeeds. An upstream
 error (a reachable-but-refusing API) retries the same agent with backoff up to
 `upstreamRetries` times before moving on. A crash, a timeout, or an interrupted turn never
-moves the chain — the fault is in the work, and the next agent would just fail the same way.
+moves the chain: the fault is in the work, and the next agent would just fail the same way.
 There is no failback: once konvoy moves, it stays moved. An empty chain (the default) turns
 the feature off.
 
@@ -214,15 +219,15 @@ flowchart TD
 ```
 
 Set `style: "brief"` to have an agent lead with the action, number multi-step work, and skip
-preamble and pleasantries — it shapes the answer you read, not what agents send each other:
+preamble and pleasantries. It shapes the answer you read, not what agents send each other:
 
 ```jsonc
 { "defaults": { "style": "brief" }, "agents": { "kiro": { "style": null } } }
 ```
 
-Set `delegation.enabled` to have every turn told how to hand work to another agent — a
-`<<<konvoy ... >>>` block naming `to:` and `task:`, with optional `open:` and `decisions:`
-lists — instead of the weaker summary konvoy derives on its own. The agent decides when a
+Set `delegation.enabled` to have every turn told how to hand work to another agent, a
+`<<<konvoy ... >>>` block naming `to:` and `task:` with optional `open:` and `decisions:`
+lists, instead of the weaker summary konvoy derives on its own. The agent decides when a
 turn is actually handing off; a turn that isn't emits no block at all, so this costs nothing
 on the turns that don't need it. Off by default: a single-agent session has no handoff to
 describe.
@@ -231,7 +236,7 @@ describe.
 { "delegation": { "enabled": true } }
 ```
 
-Name a `gate` command — your test suite, a linter, whatever exits non-zero on bad work — and
+Name a `gate` command (your test suite, a linter, whatever exits non-zero on bad work) and
 konvoy runs it after each turn that produced something, recording a pass or fail against that
 turn. A command that can't even be spawned records nothing, and a failed turn is never gated:
 
@@ -240,8 +245,8 @@ turn. A command that can't even be spawned records nothing, and a failed turn is
 ```
 
 `harness` decides how much of a CLI's own setup a turn loads. `minimal`, the default, strips
-what konvoy already supplies — claude runs with no MCP servers, slash commands or settings
-files, codex with `--ignore-user-config` — and measured 2.6× less context per turn than
+what konvoy already supplies (claude runs with no MCP servers, slash commands or settings
+files, codex with `--ignore-user-config`) and measured 2.6× less context per turn than
 `inherit`, which runs the CLI exactly as you would by hand, hooks and skills included. kiro and
 opencode run with their own configuration either way. Privileged: the global config only.
 
@@ -249,7 +254,7 @@ opencode run with their own configuration either way. Privileged: the global con
 { "defaults": { "harness": "inherit" } }
 ```
 
-`gate` is privileged like `bin`, `permission` and `harness` — only the global config may set
+`gate` is privileged like `bin`, `permission` and `harness`: only the global config may set
 it, since a gate runs on every turn with no per-turn opt-in, unlike an agent binary the user
 chose to run. That also means one gate command serves every project; there's no per-project
 override yet.
@@ -279,11 +284,11 @@ bun test
 bun run typecheck
 bun run mutate         # mutation coverage of src/
 bun run verify:claims  # checks konvoy's own claims about the four CLIs against what --help says here
-bun run smoke          # two real turns per installed, authenticated agent, the second resumed — spends quota
+bun run smoke          # two real turns per installed, authenticated agent, the second resumed; spends quota
 ```
 
 `verify:claims` is the standing form of a manual check: it re-reads each CLI's own `--help`
-and confirms what this README and the adapters assume — that every flag an adapter puts on a
+and confirms what this README and the adapters assume: that every flag an adapter puts on a
 command line still exists, that each agent's update and auth-status subcommands exist, that
 only claude accepts a caller-chosen session id, and that opencode's `--session` continues a
 session rather than creating one. The flag list is built from the adapters' real argv, so a flag
@@ -293,8 +298,8 @@ quota, and it isn't part of `bun test` since it needs the CLIs installed to mean
 `smoke` closes the gap `verify:claims` and the frozen fixtures in `tests/fixtures/streams/`
 both leave open: it runs two turns per installed, logged-in agent through konvoy's real
 `send()`. The first stores a nonce and must return a foreign session id, some text and no
-error; the second is resumed through the binding konvoy captured and must give the nonce back —
+error; the second is resumed through the binding konvoy captured and must give the nonce back -
 the one cheap proof that a bound session carries its context, which every unit test of it
 checks with fakes. It skips an agent that isn't installed or isn't logged in, and flags
-when an installed CLI's version has drifted from the one a fixture was captured against — the
+when an installed CLI's version has drifted from the one a fixture was captured against, the
 moment to re-capture. It spends real quota, so it is opt-in and never part of `bun test`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@doguyilmaz/konvoy",
-  "version": "0.1.1",
-  "description": "One session across Claude Code, Codex, Kiro CLI and opencode — bind, hand off, fail over",
+  "version": "0.2.0",
+  "description": "One session across Claude Code, Codex, Kiro CLI and opencode: bind, hand off, fail over.",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/adapters/claude.ts

@@ -50,7 +50,7 @@ export const claudeAdapter: Adapter = {
 
     if (o.type === 'result') {
       const text = typeof o.result === 'string' ? o.result : ''
-      // a result can be is_error with no text at all — claude puts the reason on stderr then, and
+      // a result can be is_error with no text at all - claude puts the reason on stderr then, and
       // an invented placeholder here would stand in the way of turn.ts reading it
       if (o.is_error) return [{ t: 'error', message: text, kind: classifyError(text) }]
       const usage = o.usage as

package/src/adapters/kiro.ts

@@ -60,7 +60,7 @@ export const kiroAdapter: Adapter = {
 
     if (o.type === 'runFinished') {
       if (data.status === 'success') {
-        // finalText comes with a finalTextTruncated flag — kiro truncates it. Only an untruncated
+        // finalText comes with a finalTextTruncated flag - kiro truncates it. Only an untruncated
         // copy is authoritative; otherwise no done is emitted and the streamed chunks stand.
         if (typeof data.finalText === 'string' && data.finalTextTruncated !== true) events.push({ t: 'done', final: data.finalText })
       } else {

package/src/adapters/opencode.ts

@@ -39,7 +39,7 @@ export const opencodeAdapter: Adapter = {
           | undefined
         const tokens = step?.tokens
         if (tokens) {
-          // opencode's `input` is the uncached remainder, like claude's and unlike codex's —
+          // opencode's `input` is the uncached remainder, like claude's and unlike codex's -
           // its own `total` is input + output + cache, which is what settles that. It also
           // reports the turn's cost here, on the same part.
           const input = (tokens.input ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0)

package/src/adapters/types.ts

@@ -10,13 +10,13 @@ export interface Adapter {
   prepare?(ctx: TurnContext): Promise<void>
 }
 
-// konvoy's own instruction, owned here rather than vendored from any installed skill — a
+// konvoy's own instruction, owned here rather than vendored from any installed skill - a
 // user's own such skill is already reachable via `harness: inherit`. It shapes what the user
 // reads, not what agents exchange, so it asks for omission, never compression.
 export const BRIEF_INSTRUCTION =
   'Lead with the action. Number multi-step work. End with one concrete next step. Skip preamble, recap, and closing pleasantries.'
 
-// konvoy has no model and cannot decide when a turn hands off — only the agent running it
+// konvoy has no model and cannot decide when a turn hands off - only the agent running it
 // knows. This instruction is what asks it to say so. A turn not handing work over must emit
 // nothing: the envelope costs output tokens only on the turns that actually use it.
 export const DELEGATION_INSTRUCTION =
@@ -27,11 +27,11 @@ export const DELEGATION_INSTRUCTION =
   'open: <optional list>\n' +
   'decisions: <optional list>\n' +
   '>>>\n' +
-  'If this turn is not handing work over, emit nothing — no block at all.'
+  'If this turn is not handing work over, emit nothing - no block at all.'
 
 // One composition point rather than four: the adapters cannot drift in how they join these,
 // and the prelude leads because a stable prefix is what prompt caching discounts. The style
-// and delegation instructions trail the prompt for the same reason — they must never join
+// and delegation instructions trail the prompt for the same reason - they must never join
 // the cached prefix.
 export function withPrelude(ctx: TurnContext): string {
   const base = ctx.prelude ? `${ctx.prelude}\n\n${ctx.prompt}` : ctx.prompt
@@ -61,22 +61,22 @@ export function stripControlChars(value: string): string {
   return value.replace(ANSI, '').replace(/[\x00-\x1f\x7f]/g, '')
 }
 
-// For a notice or a table cell: one line, no control bytes, capped — an agent's own words or a
+// For a notice or a table cell: one line, no control bytes, capped - an agent's own words or a
 // CLI's stderr can run to kilobytes and can carry escapes that rewrite what konvoy printed.
 export function oneLine(value: string, max = 200): string {
   const flat = stripControlChars(value.replace(/\r?\n/g, ' ')).replace(/ {2,}/g, ' ').trim()
   return flat.length > max ? `${flat.slice(0, max)}…` : flat
 }
 
-// For an agent's final text: keep newlines and tabs, drop every other control byte — CR
+// For an agent's final text: keep newlines and tabs, drop every other control byte - CR
 // included, which would let a line overwrite the one before it.
 export function safeText(value: string): string {
   return value.replace(ANSI, '').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '')
 }
 
 // Extracted from the four installed binaries on 2026-09-20. Expiry is phrased around
-// "session" or "token" — "Cloud gateway session expired", "AWS session has expired",
-// "Login token is expired", "MCP OAuth access token is expired" — so requiring the literal
+// "session" or "token" - "Cloud gateway session expired", "AWS session has expired",
+// "Login token is expired", "MCP OAuth access token is expired" - so requiring the literal
 // word "credentials" missed every real expiry. The noun must sit next to the state, or a
 // parser's "Unexpected token" and "Invalid token in JSON" read as auth failures.
 const AUTH =
@@ -86,14 +86,14 @@ const AUTH =
 // · resets 12:40am", both carrying error type rate_limit / HTTP 429. The remaining
 // alternatives are conjecture from other vendors' wording and have never been observed here.
 // kiro-cli emits no rate-limit prose at all, only AWS exception type names, and those carry
-// no separators once lowercased — hence the optional separators below. codex's five-hour
+// no separators once lowercased - hence the optional separators below. codex's five-hour
 // window is worded "5-hour usage limit", which "usage limit" already covers.
 const RATE =
   /hit your \w+ limit|rate[_ ]?limit|quota exceeded|too ?many ?requests|usage limit|weekly limit|\d+[- ]hour (?:usage )?limit|throttl|\b429\b/
 // Captured verbatim from opencode's embedded overload classifier, recovered from its binary on
 // 2026-09-20: "the service is at capacity", "Overloaded", "temporarily unavailable", "503
 // Service Unavailable", "server is busy, try again", "Internal Server Error", and "upstream
-// connect error". These describe an API that is reachable but refusing — the one failure worth
+// connect error". These describe an API that is reachable but refusing - the one failure worth
 // retrying before giving up on an agent, unlike a rate limit (checked first: a message that is
 // both rate-limited and mentions 503 is a rate limit, since that window is hours, not seconds).
 const UPSTREAM =

package/src/chart.ts

@@ -7,7 +7,7 @@ export function sparkline(values: number[], max?: number): string {
   // an explicit max lets several series share one scale (see agentSparklines); omitted, a
   // series scales to its own peak, as a lone sparkline always has
   const m = max ?? Math.max(...values)
-  // counts have a fixed baseline of zero, not the series' own minimum — a flat run of busy
+  // counts have a fixed baseline of zero, not the series' own minimum - a flat run of busy
   // days must render full, not empty. Guard only the case where there's no signal at all.
   if (m <= 0) return BLOCKS[0]!.repeat(values.length)
   // a nonzero count is never the zero glyph: below m/14 Math.round lands on 0, and a quiet day
@@ -32,7 +32,7 @@ export function shareBars(rows: { label: string; value: number }[], width = 18):
   )
 }
 
-// a lone agent's sparkline can't reveal whether it's the busy one or the quiet one — every
+// a lone agent's sparkline can't reveal whether it's the busy one or the quiet one - every
 // agent must be drawn against the same peak, and every row must span the same dense day
 // range (gaps filled with zero) so the columns line up between agents
 export function agentSparklines(rows: { agent: string; day: string; count: number }[]): { agent: string; line: string }[] {

package/src/cli.ts

@@ -18,6 +18,7 @@ import { cmdUpdate } from './commands/update'
 import { cmdConfig } from './commands/config'
 import { cmdResume } from './commands/resume'
 import { cmdRm } from './commands/rm'
+import { cmdRename } from './commands/rename'
 import { cmdUsage } from './commands/usage'
 import { cmdDashboard } from './commands/dashboard'
 import { formatCommandList, resolveCommandName, type CommandName } from './commands/table'
@@ -44,7 +45,7 @@ interface CommandContext {
 
 type Handler = (ctx: CommandContext, rest: string[]) => number | Promise<number>
 
-// Every key of CommandName must be handled here — TypeScript's excess/missing property
+// Every key of CommandName must be handled here - TypeScript's excess/missing property
 // checks on an object literal assigned to Record<CommandName, Handler> make an
 // undocumented-yet-dispatched or dispatched-yet-undocumented command a compile error.
 const handlers: Record<CommandName, Handler> = {
@@ -78,6 +79,14 @@ const handlers: Record<CommandName, Handler> = {
     const [action, key, value] = rest
     return cmdConfig(ctx.cfg, ctx.cwd, action ?? 'get', key, value, { global: ctx.args.flags.global === true })
   },
+  rename: (ctx, rest) => {
+    const [from, to] = rest
+    if (!from || !to) {
+      console.error('usage: konvoy rename <session> <new-name>')
+      return 2
+    }
+    return cmdRename(ctx.db, from, to)
+  },
   rm: (ctx, rest) => {
     const [target] = rest
     if (!target) {

package/src/commands/attach.ts

@@ -26,7 +26,7 @@ export function attachPlan(db: Database, session: Session, agent: AgentId, bin?:
   return { ...plan, cmd, cwd: session.cwd }
 }
 
-// Bind a session the user started outside konvoy — the id a CLI prints for its own resume
+// Bind a session the user started outside konvoy - the id a CLI prints for its own resume
 // command. The same shape check as every stream-captured id applies at the write path; the
 // binding is only reported as adopted if it actually holds the id.
 export function adoptForeignSession(
@@ -52,12 +52,12 @@ export interface AttachOptions {
 export async function cmdAttach(db: Database, cwd: string, agent: string, opts: AttachOptions = {}): Promise<number> {
   const { slug, bin } = opts
   if (!agentIds.includes(agent as AgentId)) {
-    console.error(`unknown agent "${agent}" — expected one of ${agentIds.join(', ')}`)
+    console.error(`unknown agent "${agent}" - expected one of ${agentIds.join(', ')}`)
     return 2
   }
   const session = slug ? getSessionBySlug(db, slug) : currentSession(db, cwd)
   if (!session) {
-    console.error('no konvoy session here — run `konvoy new "<goal>"` first')
+    console.error('no konvoy session here - run `konvoy new "<goal>"` first')
     return 2
   }
 
@@ -73,10 +73,10 @@ export async function cmdAttach(db: Database, cwd: string, agent: string, opts:
       permission: opts.permission ?? 'edit',
     })
     if (!adopted) {
-      console.error(`konvoy: ${agent} not bound — the id was refused; nothing opened`)
+      console.error(`konvoy: ${agent} not bound - the id was refused; nothing opened`)
       return 2
     }
-    console.error(`konvoy: ${agent} bound to session ${oneLine(opts.id, 60)} — the next turn resumes it; opening it now`)
+    console.error(`konvoy: ${agent} bound to session ${oneLine(opts.id, 60)} - the next turn resumes it; opening it now`)
   }
 
   const plan = attachPlan(db, session, agent as AgentId, bin)

package/src/commands/config.ts

@@ -11,7 +11,7 @@ export function coerce(raw: string): string | number | boolean {
 }
 
 // `__proto__` resolves to Object.prototype through an ordinary property read, so a dotted path
-// containing it writes onto the shared prototype — poisoning every object in the process while
+// containing it writes onto the shared prototype - poisoning every object in the process while
 // the config itself stays empty. `constructor` and `prototype` are blocked for the same reason.
 const RESERVED = new Set(['__proto__', 'constructor', 'prototype'])
 
@@ -100,7 +100,7 @@ export async function cmdConfig(
     const parsed = configSchema.safeParse(next)
     if (!parsed.success) {
       const issue = parsed.error.issues[0]
-      console.error(`refusing to write: ${issue?.path.join('.')} — ${issue?.message}`)
+      console.error(`refusing to write: ${issue?.path.join('.')} - ${issue?.message}`)
       return 2
     }
     await Bun.write(path, JSON.stringify(next, null, 2) + '\n')

package/src/commands/dashboard.ts

@@ -20,7 +20,7 @@ export async function cmdDashboard(
       })
     },
   })
-  console.log(`konvoy dashboard on http://127.0.0.1:${server.port} — ctrl-c to stop`)
+  console.log(`konvoy dashboard on http://127.0.0.1:${server.port} - ctrl-c to stop`)
   await new Promise(() => {})
   return 0
 }

package/src/commands/doctor.ts

@@ -12,7 +12,7 @@ export function distinctPaths(stdout: string): string[] {
 }
 
 // engine, policy.maxDelegationDepth and policy.isolation are in the schema and the spec, but
-// nothing reads them yet — the delegation work will. Comparing the parsed policy values against
+// nothing reads them yet - the delegation work will. Comparing the parsed policy values against
 // their schema defaults is an approximation (a value set explicitly equal to the default reads
 // as unset), acceptable for an informational line with no behavioural effect.
 export function acceptedButUnusedKeys(cfg: Config): string[] {
@@ -59,10 +59,10 @@ export async function cmdDoctor(cfg: Config, deps?: DetectDeps): Promise<number>
     const auth = await detectAuth(agent, { bin: settings.bin, deps })
     if (auth.authed === false) {
       if (required.has(agent)) {
-        console.log(`x ${agent}: ${auth.detail} — ${loginHint(agent)}`)
+        console.log(`x ${agent}: ${auth.detail} - ${loginHint(agent)}`)
         problems++
       } else {
-        console.log(`- ${agent}: ${auth.detail} — ${loginHint(agent)}`)
+        console.log(`- ${agent}: ${auth.detail} - ${loginHint(agent)}`)
       }
       continue
     }
@@ -73,13 +73,13 @@ export async function cmdDoctor(cfg: Config, deps?: DetectDeps): Promise<number>
     }
 
     if (agent === 'opencode' && !settings.model) {
-      console.log(`! opencode: no model configured — it returns HTTP 403 without an explicit -m`)
+      console.log(`! opencode: no model configured - it returns HTTP 403 without an explicit -m`)
     }
 
     const shadow = Bun.spawnSync(['which', '-a', settings.bin ?? getAdapter(agent).bin])
     const paths = distinctPaths(new TextDecoder().decode(shadow.stdout))
     if (paths.length > 1 && !settings.bin) {
-      console.log(`! ${agent}: ${paths.length} binaries on PATH, "${paths[0]}" wins — set agents.${agent}.bin to be explicit`)
+      console.log(`! ${agent}: ${paths.length} binaries on PATH, "${paths[0]}" wins - set agents.${agent}.bin to be explicit`)
     }
 
     if (settings.model) {
@@ -90,13 +90,13 @@ export async function cmdDoctor(cfg: Config, deps?: DetectDeps): Promise<number>
 
   for (const [model, users] of models) {
     if (users.length > 1) {
-      console.log(`! ${users.join(' and ')} both run ${model} — they will not disagree with each other`)
+      console.log(`! ${users.join(' and ')} both run ${model} - they will not disagree with each other`)
     }
   }
 
   const unused = acceptedButUnusedKeys(cfg)
   if (unused.length > 0) {
-    console.log(`i ${unused.join(', ')} — accepted but not yet used`)
+    console.log(`i ${unused.join(', ')} - accepted but not yet used`)
   }
 
   console.log(problems === 0 ? '\nno problems found' : `\n${problems} problem(s) found`)

package/src/commands/new.ts

@@ -1,23 +1,26 @@
 import type { Database } from 'bun:sqlite'
 import type { Config } from '../config/schema'
-import { newSession } from '../core/session'
-import { sessionDir } from '../paths'
+import { newSession, slugify } from '../core/session'
+import { basename, join, sessionDir } from '../paths'
 
 export async function cmdNew(db: Database, cfg: Config, cwd: string, goal: string): Promise<number> {
   const lead = cfg.roles.lead ?? 'claude'
-  const session = newSession(db, { cwd, goal: goal || 'untitled', lead })
+  const suffix = Bun.randomUUIDv7().slice(-4)
+  const slug = goal ? undefined : `${slugify(basename(cwd)).slice(0, 30)}-${suffix}`
+  const session = newSession(db, { cwd, goal, lead, slug })
   const dir = sessionDir(cwd, session.slug)
-  // `konvoy rm` frees the slug but leaves these files — they are the user's. A new session under
+  const ignore = Bun.file(join(cwd, '.konvoy', '.gitignore'))
+  if (!(await ignore.exists())) await Bun.write(ignore, '*\n!config.jsonc\n')
+  // `konvoy rm` frees the slug but leaves these files - they are the user's. A new session under
   // an old slug adds its goal to the context and appends to the ledger; it truncates neither.
   const context = Bun.file(`${dir}/CONTEXT.md`)
+  const goalSection = session.goal ? `\n## Goal\n\n${session.goal}\n` : ''
   await Bun.write(
     context,
-    (await context.exists())
-      ? `${await context.text()}\n## Goal\n\n${session.goal}\n`
-      : `# ${session.slug}\n\n## Goal\n\n${session.goal}\n`,
+    (await context.exists()) ? `${await context.text()}${goalSection}` : `# ${session.slug}\n${goalSection}`,
   )
   const ledger = Bun.file(`${dir}/LEDGER.md`)
-  if (!(await ledger.exists())) await Bun.write(ledger, `# Ledger — ${session.slug}\n`)
+  if (!(await ledger.exists())) await Bun.write(ledger, `# Ledger - ${session.slug}\n`)
   console.log(`created session ${session.slug} (lead: ${lead})`)
   console.log(dir)
   return 0

package/src/commands/rename.ts

@@ -0,0 +1,49 @@
+import type { Database } from 'bun:sqlite'
+import { slugify } from '../core/session'
+import { sessionDir } from '../paths'
+import { getSessionBySlug, lockOwner, renameSession } from '../store/queries'
+
+const isDir = async (path: string): Promise<boolean> => (await Bun.$`test -d ${path}`.quiet().nothrow()).exitCode === 0
+
+async function retitle(path: string, from: string, to: string): Promise<void> {
+  const file = Bun.file(path)
+  if (!(await file.exists())) return
+  const text = await file.text()
+  if (text.startsWith(from)) await Bun.write(file, to + text.slice(from.length))
+}
+
+export async function cmdRename(db: Database, from: string, to: string): Promise<number> {
+  const session = getSessionBySlug(db, from)
+  if (!session) {
+    console.error(`no konvoy session named "${from}"`)
+    return 2
+  }
+  const busy = lockOwner(db, session.id)
+  if (busy) {
+    console.error(`"${from}" has a turn running (${busy}) - wait for it to finish, then retry`)
+    return 2
+  }
+  const slug = slugify(to)
+  if (getSessionBySlug(db, slug)) {
+    console.error(`a session named "${slug}" already exists`)
+    return 2
+  }
+  const oldDir = sessionDir(session.cwd, from)
+  const newDir = sessionDir(session.cwd, slug)
+  if (await isDir(oldDir)) {
+    if (await isDir(newDir)) {
+      console.error(`${newDir} already exists - move it away first`)
+      return 2
+    }
+    const moved = await Bun.$`mv ${oldDir} ${newDir}`.quiet().nothrow()
+    if (moved.exitCode !== 0) {
+      console.error(`could not move ${oldDir} to ${newDir}: ${moved.stderr.toString().trim()}`)
+      return 1
+    }
+    await retitle(`${newDir}/CONTEXT.md`, `# ${from}\n`, `# ${slug}\n`)
+    await retitle(`${newDir}/LEDGER.md`, `# Ledger - ${from}\n`, `# Ledger - ${slug}\n`)
+  }
+  renameSession(db, session.id, slug)
+  console.log(`renamed ${from} -> ${slug}`)
+  return 0
+}

package/src/commands/rm.ts

@@ -9,13 +9,13 @@ export function cmdRm(db: Database, cwd: string, slug: string, opts: { yes: bool
   }
   const busy = lockOwner(db, session.id)
   if (busy) {
-    console.error(`"${slug}" has a turn running (${busy}) — wait for it to finish, then retry`)
+    console.error(`"${slug}" has a turn running (${busy}) - wait for it to finish, then retry`)
     return 2
   }
   const bound = listBindings(db, session.id).filter((b) => b.foreignId)
   if (!opts.yes) {
     console.error(`this deletes konvoy session "${slug}" and its ${bound.length} binding(s)`)
-    console.error(`the sessions inside each CLI are NOT deleted — re-run with --yes to proceed`)
+    console.error(`the sessions inside each CLI are NOT deleted - re-run with --yes to proceed`)
     return 2
   }
   deleteSession(db, session.id)

package/src/commands/roster.ts

@@ -8,7 +8,7 @@ import { duplicateModels, formatRoster, type RosterRow } from '../format'
 export function cmdRoster(db: Database, cfg: Config, cwd: string, slug?: string): number {
   const session = slug ? getSessionBySlug(db, slug) : currentSession(db, cwd)
   if (!session) {
-    console.error('no konvoy session here — run `konvoy new "<goal>"` first')
+    console.error('no konvoy session here - run `konvoy new "<goal>"` first')
     return 2
   }
 
@@ -28,10 +28,10 @@ export function cmdRoster(db: Database, cfg: Config, cwd: string, slug?: string)
     }
   })
 
-  console.log(`session ${session.slug} — ${session.goal}`)
+  console.log(`session ${session.slug} - ${session.goal}`)
   console.log(formatRoster(rows))
   for (const model of duplicateModels(rows)) {
-    console.log(`warning: ${model} is used by more than one agent — a second opinion from the same model is not one`)
+    console.log(`warning: ${model} is used by more than one agent - a second opinion from the same model is not one`)
   }
   return 0
 }

package/src/commands/send.ts

@@ -16,12 +16,12 @@ export async function cmdSend(
   slug?: string,
 ): Promise<number> {
   if (!agentIds.includes(agent as AgentId)) {
-    console.error(`unknown agent "${agent}" — expected one of ${agentIds.join(', ')}`)
+    console.error(`unknown agent "${agent}" - expected one of ${agentIds.join(', ')}`)
     return 2
   }
   const session = slug ? getSessionBySlug(db, slug) : currentSession(db, cwd)
   if (!session) {
-    console.error('no konvoy session here — run `konvoy new "<goal>"` first')
+    console.error('no konvoy session here - run `konvoy new "<goal>"` first')
     return 2
   }
 
@@ -51,7 +51,7 @@ export interface SendOutcome {
 
 // The exit code is decided here, once, from the same two facts turn.ts keeps separate: whether
 // output was produced (result.final) and whether the agent is now blocked (result.error.kind).
-// A turn that answered and then hit a limit is both successful and blocked — it prints what it
+// A turn that answered and then hit a limit is both successful and blocked - it prints what it
 // produced, plus the one line saying the agent can't keep going, and exits 0.
 export function decideOutcome(agent: AgentId, result: TurnResult): SendOutcome {
   if (result.error) {

package/src/commands/status.ts

@@ -25,7 +25,7 @@ export async function cmdStatus(
   )
   console.log(formatVersions(rows))
   for (const r of rows) {
-    if (!r.installed) console.log(`warning: ${r.agent} is not installed — it will be skipped`)
+    if (!r.installed) console.log(`warning: ${r.agent} is not installed - it will be skipped`)
     else if (r.authed === false) console.log(`warning: ${r.agent}: ${r.detail}`)
   }
   // status reports; it does not judge. A directory with no session is not a failure of the

package/src/commands/table.ts

@@ -21,6 +21,7 @@ export const commandTable = [
     usage: 'rm <session> --yes',
     summary: 'delete a konvoy session (foreign sessions survive)',
   },
+  { name: 'rename', aliases: [], usage: 'rename <session> <new-name>', summary: 'rename a session; its .konvoy folder follows' },
   { name: 'roster', aliases: [], usage: 'roster', summary: 'who is in the convoy' },
   { name: 'usage', aliases: [], usage: 'usage [--all] [--chart]', summary: 'what this session spent, per agent' },
   { name: 'status', aliases: [], usage: 'status', summary: 'versions, auth and roster' },

package/src/commands/update.ts

@@ -35,7 +35,7 @@ export async function cmdUpdate(
   deps: UpdateDeps = realUpdateDeps,
 ): Promise<number> {
   if (!opts.all) {
-    // konvoy does not update itself — it follows the channel it was installed from
+    // konvoy does not update itself - it follows the channel it was installed from
     const channel = Bun.isStandaloneExecutable
       ? 'brew upgrade --cask konvoy, or download the latest release'
       : 'bun add -g @doguyilmaz/konvoy@latest, or bun run build in a checkout'

package/src/commands/usage.ts

@@ -37,12 +37,12 @@ export function cmdUsage(
   } else {
     session = opts.slug ? getSessionBySlug(db, opts.slug) : currentSession(db, cwd)
     if (!session) {
-      console.error('no konvoy session here — run `konvoy new "<goal>"` first')
+      console.error('no konvoy session here - run `konvoy new "<goal>"` first')
       return 2
     }
     rows = usageForSession(db, session.id)
     if (rows.length === 0) {
-      console.log(`session ${session.slug} — no turns yet`)
+      console.log(`session ${session.slug} - no turns yet`)
       return 0
     }
     console.log(`session ${session.slug}`)

package/src/config/load.ts

@@ -162,17 +162,17 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 }
 
 // bin, permission and harness decide what konvoy runs and how much it trusts the process it
-// spawns — properties of the machine the person is running konvoy on, not of the repo they
+// spawns - properties of the machine the person is running konvoy on, not of the repo they
 // cloned. A project layer may not set them at any level they appear; only the global config can.
 const PRIVILEGED_DEFAULTS_KEYS = ['permission', 'harness'] as const
 const PRIVILEGED_AGENT_KEYS = ['bin', 'permission', 'harness'] as const
-// gate names a command konvoy executes automatically after every turn — wider than `bin`,
+// gate names a command konvoy executes automatically after every turn - wider than `bin`,
 // which at least requires the user to already be using that agent. It sits at the top level
 // of the config, not under `defaults` or `agents.<id>`, so it needs its own case here.
 const PRIVILEGED_TOP_LEVEL_KEYS = ['gate'] as const
 
 function warnIgnored(path: string): void {
-  console.error(`konvoy: ignoring project-level "${path}" — privileged, set it in the global config instead`)
+  console.error(`konvoy: ignoring project-level "${path}" - privileged, set it in the global config instead`)
 }
 
 function stripProjectPrivileges(layer: Record<string, unknown>): Record<string, unknown> {
@@ -220,7 +220,7 @@ function stripProjectPrivileges(layer: Record<string, unknown>): Record<string,
 
 // A leading dash is what makes a model string dangerous: spawned with `--model <value>`, it
 // lands as the next argv token with no `--` guard, unlike the prompt. Unlike bin/permission/
-// harness, a project may legitimately pin a model — so this is validated, not merge-source
+// harness, a project may legitimately pin a model - so this is validated, not merge-source
 // restricted, and applies to whichever layer's value survives the merge.
 // `/` because opencode names models provider/model; `#` stays out because the variant after
 // it is konvoy's own effort dial, appended by the adapter
@@ -238,7 +238,7 @@ function stripInvalidModels(layer: Record<string, unknown>): Record<string, unkn
     }
     const cleaned = { ...agentCfg }
     if (typeof cleaned.model === 'string' && !MODEL_PATTERN.test(cleaned.model)) {
-      console.error(`konvoy: ignoring invalid agents.${id}.model "${cleaned.model}" — must match ${MODEL_PATTERN}`)
+      console.error(`konvoy: ignoring invalid agents.${id}.model "${cleaned.model}" - must match ${MODEL_PATTERN}`)
       delete cleaned.model
     }
     setOwn(cleanedAgents, id, cleaned)
@@ -247,7 +247,7 @@ function stripInvalidModels(layer: Record<string, unknown>): Record<string, unkn
   return out
 }
 
-// only a leading `~/`, or a bare `~`, is a home-directory reference — a tilde anywhere else
+// only a leading `~/`, or a bare `~`, is a home-directory reference - a tilde anywhere else
 // in the path (e.g. `rel/~/x`) is left alone
 function expandHome(p: string): string {
   if (p === '~') return home()
@@ -267,7 +267,7 @@ export async function loadConfig(opts: { cwd: string; globalPath?: string }): Pr
     // set aside, so konvoy still runs in that directory; the user's own file stays strict
     const globalOnly = configSchema.safeParse(stripInvalidModels(merge(globalLayer, {})))
     if (globalOnly.success) {
-      console.error(`konvoy: ignoring project-level config at ${projectConfigPath(opts.cwd)} — invalid at ${where}`)
+      console.error(`konvoy: ignoring project-level config at ${projectConfigPath(opts.cwd)} - invalid at ${where}`)
       return finishConfig(globalOnly.data)
     }
     throw new Error(`invalid konvoy config at ${where}`)
@@ -294,7 +294,7 @@ export function resolveAgent(cfg: Config, agent: AgentId): AgentSettings {
   const ownStyle = a.style
   const defaultStyle = cfg.defaults.style ?? undefined
   // an explicit `null` opts an agent out of a `defaults.style`, unlike `effort`/`permission`
-  // where the per-agent value is only ever absent or set — so this can't reuse `??`.
+  // where the per-agent value is only ever absent or set - so this can't reuse `??`.
   const style = ownStyle === null ? undefined : (ownStyle ?? defaultStyle)
   return {
     enabled: a.enabled ?? true,
@@ -310,7 +310,7 @@ export function resolveAgent(cfg: Config, agent: AgentId): AgentSettings {
 
 const isAgentId = (value: string): value is AgentId => (agentIds as readonly string[]).includes(value)
 
-// An envelope's `to` is free text a model wrote, not a validated key — trimmed and
+// An envelope's `to` is free text a model wrote, not a validated key - trimmed and
 // lower-cased before either check runs, since a model may write "Reviewer" or " claude ".
 // An agent id wins over a role of the same name: a role can be reassigned mid-session, an
 // agent id cannot.

package/src/config/schema.ts

@@ -5,7 +5,7 @@ export const effortSchema = z.enum(['low', 'medium', 'high', 'max'])
 export const permissionSchema = z.enum(['safe', 'edit', 'yolo'])
 export const harnessSchema = z.enum(['minimal', 'inherit'])
 export const agentIdSchema = z.enum(agentIds)
-// konvoy's own instruction, not a model capability — `.nullish()` so a per-agent `null` can
+// konvoy's own instruction, not a model capability - `.nullish()` so a per-agent `null` can
 // opt out of a `defaults.style` of 'brief', which a plain `.optional()` cannot express.
 export const styleSchema = z.enum(['brief'])
 
@@ -46,7 +46,7 @@ const MAX_TURN_TIMEOUT_SEC = 24 * 60 * 60
 const policyObjectSchema = z
   .object({
     maxDelegationDepth: z.number().int().positive().default(3),
-    // A project config sets this, so it is clamped rather than trusted outright — otherwise a
+    // A project config sets this, so it is clamped rather than trusted outright - otherwise a
     // hostile repo could make konvoy wait forever on every turn.
     turnTimeoutSec: z
       .number()
@@ -74,7 +74,7 @@ export const configSchema = z
     agents: z.partialRecord(agentIdSchema, agentConfigSchema).default({}),
     roles: rolesObjectSchema.prefault({}),
     policy: policyObjectSchema.prefault({}),
-    // The command konvoy runs after a turn to produce a pass/fail verdict on the work — a
+    // The command konvoy runs after a turn to produce a pass/fail verdict on the work - a
     // project layer may never set this; see stripProjectPrivileges in config/load.ts.
     gate: z.object({ command: z.string().nullish() }).strict().prefault({}),
     failover: failoverObjectSchema.prefault({}),

package/src/core/children.ts

@@ -48,7 +48,7 @@ export function liveCount(): number {
   return live.size
 }
 
-// Bun's own `timeout` sends killSignal once and never follows up — a child that traps or
+// Bun's own `timeout` sends killSignal once and never follows up - a child that traps or
 // ignores SIGTERM then hangs forever. SIGKILL cannot be trapped; it goes out once the timeout
 // has had a grace period to work. Every bounded spawn (a turn, a gate) uses this one.
 export const DEFAULT_KILL_GRACE_MS = 2_000

package/src/core/detect.ts

@@ -77,7 +77,7 @@ async function codexEfforts(deps: DetectDeps, model?: string): Promise<readonly
     const cache = JSON.parse(raw) as { models?: unknown }
     if (!Array.isArray(cache.models)) return undefined
     // the real file (codex 0.155.1, 2026-09-21) keys models by `slug` and lists each level as
-    // `{ effort, description }` — see tests/fixtures/codex-models-cache.json
+    // `{ effort, description }` - see tests/fixtures/codex-models-cache.json
     const hit = (cache.models as { slug?: string; supported_reasoning_levels?: unknown }[]).find(
       (m) => m.slug === model,
     )
@@ -178,8 +178,7 @@ function realDeps(): DetectDeps {
 const detectCacheMap = new Map<string, Promise<Detection>>()
 const detectAuthCacheMap = new Map<string, Promise<AuthState>>()
 
-// Real detection shares one memo; each injected deps object gets its own, so a fake answering in
-// one place is never handed to another.
+// one memo per injected deps object; real detection shares its own
 const depsIds = new WeakMap<DetectDeps, number>()
 let nextDepsId = 0
 function scope(deps?: DetectDeps): string {

package/src/core/facts.ts

@@ -52,7 +52,7 @@ export async function collectFacts(deps: FactsDeps, db: Database, session: Sessi
 }
 
 // A field is quoted only when it has to be. 48% of this repository's own commit subjects
-// contain a comma, so an unquoted row is the common case, not the edge one — and a shifted
+// contain a comma, so an unquoted row is the common case, not the edge one - and a shifted
 // row makes every number after it wrong while still looking like a table.
 function cell(value: string): string {
   return /[",\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value
@@ -99,7 +99,7 @@ export function realFactsDeps(): FactsDeps {
   return {
     git: async (args, cwd) => {
       try {
-        // stderr is never read, so it is not piped — a chatty git would fill the pipe and block;
+        // stderr is never read, so it is not piped - a chatty git would fill the pipe and block;
         // and a git that hangs must not hang the turn
         const proc = Bun.spawn(['git', ...args], { cwd, stdout: 'pipe', stderr: 'ignore', timeout: 10_000 })
         const stdout = await new Response(proc.stdout).text()

package/src/core/gate.ts

@@ -4,7 +4,7 @@ import type { Session } from '../types'
 import { setGateResult, turnExitCode } from '../store/queries'
 import { DEFAULT_KILL_GRACE_MS, escalateKill } from './children'
 
-// A quality check the user chose to run — konvoy has no model of its own, so it never
+// A quality check the user chose to run - konvoy has no model of its own, so it never
 // grades the work itself. Bounded so a hung suite can't block konvoy forever.
 const GATE_TIMEOUT_MS = 5 * 60 * 1000
 
@@ -17,7 +17,7 @@ export async function runGate(
 ): Promise<void> {
   const command = cfg.gate.command
   if (!command) return
-  // A turn with nothing for the gate to judge — running it now would blame the block on the work.
+  // A turn with nothing for the gate to judge - running it now would blame the block on the work.
   if (turnExitCode(db, turnId) !== 0) return
 
   const cmd = splitCommand(command)
@@ -43,7 +43,7 @@ export async function runGate(
 }
 
 // Whitespace outside quotes separates arguments; a quoted run is one argument, quotes removed.
-// No shell is involved — the gate is the user's own command, but it still deserves its quotes.
+// No shell is involved - the gate is the user's own command, but it still deserves its quotes.
 export function splitCommand(command: string): string[] {
   const out: string[] = []
   let current = ''

package/src/core/prelude.ts

@@ -39,7 +39,7 @@ export function parseEnvelope(final: string): Envelope | null {
     const value = kv[2]!.trim()
     switch (key) {
       case 'to':
-        // a recipient is an agent id or a role name — a bare identifier. The delegation
+        // a recipient is an agent id or a role name - a bare identifier. The delegation
         // instruction quotes the format with "<agent id or role>" in this slot, and an agent
         // explaining what it is not doing repeats it; that names nobody and is no handoff.
         env.to = RECIPIENT.test(value) ? value : null
@@ -104,7 +104,7 @@ export function buildPrelude(db: Database, session: Session, facts: string, opts
   // the same test followHandoff applies: a block with no recipient handed nothing to anyone,
   // so the answer it sits in is what the next agent must see
   if (!last) {
-    // recent: 0 — only the goal, the facts and the count of what was left out
+    // recent: 0 - only the goal, the facts and the count of what was left out
   } else if (envelope?.to) {
     turnBlocks.push(renderEnvelope(last.agent, envelope))
   } else {
@@ -112,10 +112,10 @@ export function buildPrelude(db: Database, session: Session, facts: string, opts
     // The cooperative case (section 21) has a sender who can still speak; failover does not.
     // A receiver that believes its context is complete proceeds on half the picture, so the
     // gap is stated plainly instead of silently filled with a prompt-and-answer transcript.
-    turnBlocks.push("the previous agent's intent was not recorded here — only what was asked and answered is known.")
+    turnBlocks.push("the previous agent's intent was not recorded here - only what was asked and answered is known.")
   }
 
   if (dropped > 0) turnBlocks.push(`(${dropped} earlier turn${dropped === 1 ? '' : 's'} not shown)`)
 
-  return [`goal: ${session.goal}`, facts, turnBlocks.join('\n\n')].filter(Boolean).join('\n\n')
+  return [session.goal ? `goal: ${session.goal}` : '', facts, turnBlocks.join('\n\n')].filter(Boolean).join('\n\n')
 }

package/src/core/session.ts

@@ -35,7 +35,7 @@ const RECENT_TURNS = 3
 //   kiro     "error: ACP load_session failed" on stderr, exit 1, no stream events at all
 //            (re-measured 2026-09-21 against kiro-cli 2.22.1). The 2026-09-19 note here said
 //            kiro reported nothing and silently opened an empty session under whatever id it
-//            was handed, and recorded that as an undetectable limit — it is detectable, and
+//            was handed, and recorded that as an undetectable limit - it is detectable, and
 //            leaving the old wording in place is what kept the rebind from firing for kiro.
 const STALE =
   /no conversation found|no rollout found|session not found|no such session|unknown session|not found with session|load_session failed/i
@@ -108,16 +108,16 @@ export async function send(
   const lease = inherited ?? crypto.randomUUID()
   const alreadyHeld = inherited !== undefined && lockOwner(deps.db, session.id) === inherited
   if (!alreadyHeld && !acquireLock(deps.db, session.id, lease)) {
-    throw new Error(`session "${session.slug}" is busy — another konvoy turn is running`)
+    throw new Error(`session "${session.slug}" is busy - another konvoy turn is running`)
   }
 
-  // Set once withLock() has built the primary prelude — followHandoff needs its own, built
+  // Set once withLock() has built the primary prelude - followHandoff needs its own, built
   // fresh after the handing-off turn is recorded, so it is read rather than recomputed here.
   let facts = ''
 
   try {
     const result = await withLock()
-    // The turn just finished writing its own row — runGate reads that row itself to decide
+    // The turn just finished writing its own row - runGate reads that row itself to decide
     // whether there is anything for it to judge, so it is always safe to call here.
     const turnId = lastTurnId(deps.db, session.id)
     if (turnId) await runGate(deps.db, deps.cfg, session, turnId)
@@ -133,7 +133,7 @@ export async function send(
   }
 
   // One hop per send: this reads the envelope on the turn `send()` was asked to run, resolves
-  // it once, and returns whatever that recipient's own turn produces — including an envelope
+  // it once, and returns whatever that recipient's own turn produces - including an envelope
   // of its own, which is never fed back in here. A mistaken `to:` pointing back at the sender
   // would otherwise loop until something ran out, and the caller asked for one turn.
   async function followHandoff(result: TurnResult, turnId: string): Promise<TurnResult | null> {
@@ -145,7 +145,7 @@ export async function send(
     const recipient = resolveRecipient(deps.cfg, envelope.to)
     if (!recipient) {
       console.error(
-        `konvoy: ${ranAsAgent} handed off to "${oneLine(envelope.to, 80)}" — no such agent or role, ${ranAsAgent}'s turn stands`,
+        `konvoy: ${ranAsAgent} handed off to "${oneLine(envelope.to, 80)}" - no such agent or role, ${ranAsAgent}'s turn stands`,
       )
       return null
     }
@@ -154,21 +154,21 @@ export async function send(
     const recipientDetection = recipientSettings.enabled
       ? await detectFor(recipient, { model: recipientSettings.model, bin: recipientSettings.bin })
       : { agent: recipient, installed: false, version: null }
-    // Reported, not silently dropped — the same rule the failover chain already follows for a
+    // Reported, not silently dropped - the same rule the failover chain already follows for a
     // disabled or uninstalled member.
     if (!recipientSettings.enabled || !recipientDetection.installed) {
       const why = !recipientSettings.enabled ? 'disabled in config' : 'not installed'
       console.error(
-        `konvoy: ${ranAsAgent} handed off to ${recipient}, but ${recipient} is ${why} — ${ranAsAgent}'s turn stands`,
+        `konvoy: ${ranAsAgent} handed off to ${recipient}, but ${recipient} is ${why} - ${ranAsAgent}'s turn stands`,
       )
       return null
     }
 
-    console.error(`konvoy: ${ranAsAgent} handed off to ${recipient} — "${oneLine(envelope.task)}"`)
+    console.error(`konvoy: ${ranAsAgent} handed off to ${recipient} - "${oneLine(envelope.task)}"`)
 
     const recipientEffort = clampEffort(recipientSettings.effort, recipientDetection.efforts)
     // Built fresh, after the handing-off turn was recorded: the prelude built at the top of
-    // this send() describes the state before that turn ran — the opposite of what the
+    // this send() describes the state before that turn ran - the opposite of what the
     // recipient needs, which is its own cooperative handoff, envelope and all.
     const delegatedPrelude = buildPrelude(deps.db, session, facts, { recent: RECENT_TURNS })
     return runOnce(
@@ -194,7 +194,7 @@ export async function send(
     )
   }
 
-  // One attempt at one agent: run the turn, and — exactly as before failover existed — rebind
+  // One attempt at one agent: run the turn, and - exactly as before failover existed - rebind
   // a stale foreign session once and retry, never more. This is unchanged by the chain walk;
   // it just now runs once per agent the chain visits instead of once per `send()` call.
   async function runOnce(
@@ -217,13 +217,13 @@ export async function send(
     // Only a crash can be a dead session. An auth failure phrased as "session not found" would
     // otherwise be rebound instead of surfaced, discarding a live session and then failing again
     // identically; a rate limit, a timeout and an interruption say nothing about the session at
-    // all. The kinds exist so that failures can be told apart — this is where it matters.
+    // all. The kinds exist so that failures can be told apart - this is where it matters.
     const recoverable = first.error?.kind === 'crash' || first.error?.kind === 'unknown'
     const stale = first.error != null && recoverable && STALE.test(first.error.message) && producedNothing
     if (!stale || !wasResuming) return first
 
     // said out loud: a silent rebind looks like continuity and is not
-    console.error(`konvoy: ${current} could not load session ${oneLine(resumedId ?? '', 60)} — starting a new one`)
+    console.error(`konvoy: ${current} could not load session ${oneLine(resumedId ?? '', 60)} - starting a new one`)
     clearForeignId(deps.db, session.id, current)
     return runTurn(
       { db: deps.db, adapter: currentAdapter },
@@ -262,13 +262,13 @@ export async function send(
           ? await detectFor(current, { model: currentSettings.model, bin: currentSettings.bin })
           : { agent: current, installed: false, version: null }
       }
-      // A chain member the user hasn't actually set up can't take the handoff — skip it
+      // A chain member the user hasn't actually set up can't take the handoff - skip it
       // rather than aborting the whole chain, since a later member might still work. Say so:
       // a three-agent chain that quietly becomes a two-agent chain is the user not being told.
       if (!currentSettings.enabled || !currentDetection.installed) {
         if (!isHead) {
           const why = !currentSettings.enabled ? 'disabled in config' : 'not installed'
-          console.error(`konvoy: skipping ${current} in the failover chain — ${why}`)
+          console.error(`konvoy: skipping ${current} in the failover chain - ${why}`)
         }
         if (result) continue
         break
@@ -279,7 +279,7 @@ export async function send(
       // said "moving to claude" and then ran kiro when claude turned out to be unusable.
       if (blocked) {
         console.error(
-          `konvoy: ${blocked.agent} is blocked (${blocked.kind}) — "${oneLine(blocked.message)}" — ${current} is taking over`,
+          `konvoy: ${blocked.agent} is blocked (${blocked.kind}) - "${oneLine(blocked.message)}" - ${current} is taking over`,
         )
         blocked = null
       }
@@ -308,7 +308,7 @@ export async function send(
         r = await runOnce(current, currentAdapter, ctxBuild, firstTurnId)
         if (firstTurnId === null) firstTurnId = lastTurnId(deps.db, session.id)
         // upstream is transient and usually returns, so it is worth retrying on the same
-        // agent — with backoff, since a hammered upstream is the last thing to hammer again.
+        // agent - with backoff, since a hammered upstream is the last thing to hammer again.
         if (r.error?.kind === 'upstream' && retries < upstreamRetries) {
           retries++
           await Bun.sleep((deps.upstreamBackoffMs ?? UPSTREAM_BACKOFF_MS) * retries)
@@ -319,7 +319,7 @@ export async function send(
       result = r
 
       const kind = result.error?.kind
-      // rate and auth switch at once — a rate window is hours and an auth failure needs a
+      // rate and auth switch at once - a rate window is hours and an auth failure needs a
       // human, so retrying either is pointless. upstream only reaches here once its retries
       // are spent. crash, timeout and interrupted never switch: the fault travels with the
       // agent, not with the CLI running it, so a second agent would just fail the same way.

package/src/core/turn.ts

@@ -142,7 +142,7 @@ export async function runTurn(deps: TurnDeps, ctx: TurnContext, opts: TurnOption
     killSignal: 'SIGTERM',
   })
   } catch (error) {
-    // the binary exists but cannot start — no execute bit, a bad interpreter: detection cannot
+    // the binary exists but cannot start - no execute bit, a bad interpreter: detection cannot
     // see it, and the turn row recorded above is what keeps the failure from leaving no trace
     result.exitCode = 127
     result.error = { message: `could not start ${plan.cmd[0]}: ${error instanceof Error ? error.message : String(error)}`, kind: 'crash' }
@@ -160,7 +160,7 @@ export async function runTurn(deps: TurnDeps, ctx: TurnContext, opts: TurnOption
 
 
   // exit_code -1 means konvoy itself died before it could record the turn. Every ordinary
-  // ending, including an interruption, replaces it — so a surviving -1 is a real signal, not
+  // ending, including an interruption, replaces it - so a surviving -1 is a real signal, not
   // a default. Failure is decided by the error field, not by the exit code alone: an interrupted turn
   // carries 130 or 143 and a message, and a codex turn can exit 0 with an informational error.
 
@@ -193,7 +193,7 @@ export async function runTurn(deps: TurnDeps, ctx: TurnContext, opts: TurnOption
 
 
   // every path below must reach finish(): an onEvent callback that throws, a parser crash a
-  // wrapper missed, or a signal — otherwise the turn row stays at its INSERT placeholder and
+  // wrapper missed, or a signal - otherwise the turn row stays at its INSERT placeholder and
   // usage counts it as a free turn.
   const releaseExitHandler = onExit((signal) => {
     if (!result.error) result.error = { message: `konvoy was interrupted by ${signal}`, kind: 'interrupted' }
@@ -236,10 +236,10 @@ export async function runTurn(deps: TurnDeps, ctx: TurnContext, opts: TurnOption
     }
 
     // The exit code says whether the turn produced its output; the error says whether the
-    // agent is now blocked. auth and rate never mean "just informational" — the agent cannot
-    // work until something changes — so they survive even a turn that answered and exited 0.
+    // agent is now blocked. auth and rate never mean "just informational" - the agent cannot
+    // work until something changes - so they survive even a turn that answered and exited 0.
     // crash and unknown keep the old behaviour: discarded once there was any output at all.
-    // an error that stayed wordless through the stream and stderr — say so, rather than show
+    // an error that stayed wordless through the stream and stderr - say so, rather than show
     // the user an empty quote
     if (result.error && !result.error.message.trim()) {
       result.error.message = `${adapter.id} exited ${result.exitCode} and reported an error without a message`

package/src/dashboard/page.ts

@@ -27,7 +27,7 @@ export interface DashboardData {
 }
 
 // collect is a pure read of the same tables `konvoy usage --chart` reads, through the same
-// queries — a parallel query here is exactly how the two views would start disagreeing
+// queries - a parallel query here is exactly how the two views would start disagreeing
 export function collect(db: Database, cfg: Config, sessionId?: string): DashboardData {
   const rows = sessionId ? usageForSession(db, sessionId) : usageAcrossSessions(db)
   const modelRows = usageByAgentModel(db, sessionId)
@@ -64,7 +64,7 @@ function escape(text: string): string {
   return text.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]!)
 }
 
-// every day between the first and last, inclusive — gaps filled with zero downstream — so
+// every day between the first and last, inclusive - gaps filled with zero downstream - so
 // bars line up between agents the same way the terminal's sparklines line up columns
 function expandDays(start: string, end: string): string[] {
   const days: string[] = []
@@ -124,7 +124,7 @@ function agentBarsSvg(rows: { agent: string; day: string; count: number }[]): st
     .sort(([a], [b]) => a.localeCompare(b))
     .map(([agent, dayCounts]) => ({ agent, values: range.map((d) => dayCounts.get(d) ?? 0) }))
 
-  // one shared max across every agent — a per-row scale would draw a quiet agent's two
+  // one shared max across every agent - a per-row scale would draw a quiet agent's two
   // turns at a busy agent's height, hiding exactly the comparison this chart is for
   const sharedMax = Math.max(...series.flatMap((s) => s.values), 1)
 
@@ -188,7 +188,7 @@ export function renderPage(data: DashboardData): string {
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>konvoy dashboard — ${title}</title>
+<title>konvoy dashboard - ${title}</title>
 <style>${STYLE}</style>
 </head>
 <body>

package/src/format.ts

@@ -36,7 +36,7 @@ function cost(r: RosterRow): string {
 // reimplementing the credits-before-dollars rule and risking the two drifting apart
 export function spend(row: UsageRow): string {
   // credits win when both are non-zero: they're what the agent actually charged, and the
-  // cost estimator derives its dollar figure from credits the same way — the two must
+  // cost estimator derives its dollar figure from credits the same way - the two must
   // never disagree about which number is the real one for a given row.
   if (row.credits > 0) return `${row.credits.toFixed(3)} cr`
   if (row.costUsd > 0) return `$${row.costUsd.toFixed(2)}`

package/src/paths.ts

@@ -14,6 +14,8 @@ export function join(...parts: string[]): string {
   return (absolute ? '/' : '') + segments.join('/')
 }
 
+export const basename = (p: string): string => p.split('/').filter(Boolean).at(-1) ?? ''
+
 export function dirname(p: string): string {
   const cut = p.lastIndexOf('/')
   if (cut < 0) return '.'

package/src/pricing.ts

@@ -23,7 +23,7 @@ export function estimateUsd(row: Priced, pricing: Pricing): number | null {
     const rate = pricing.models[row.model]
     if (rate) {
       // inputTokens is the whole context sent, cache reads included, and those bill at a
-      // tenth of this rate — so a cache-heavy turn estimates high. Only turns whose CLI
+      // tenth of this rate - so a cache-heavy turn estimates high. Only turns whose CLI
       // reported no cost of its own reach here, which today is never claude's.
       return (row.inputTokens / 1_000_000) * rate.inputPerMTok +
         (row.outputTokens / 1_000_000) * rate.outputPerMTok
@@ -33,7 +33,7 @@ export function estimateUsd(row: Priced, pricing: Pricing): number | null {
   return null
 }
 
-// pricing defaults to empty, so an unconfigured user must never see a ~USD column of dashes —
+// pricing defaults to empty, so an unconfigured user must never see a ~USD column of dashes -
 // the column exists only once there's at least one rate to estimate from
 export function isPricingConfigured(pricing: Pricing): boolean {
   return Object.keys(pricing.models).length > 0 || Object.keys(pricing.credits).length > 0
@@ -50,7 +50,7 @@ export interface ModelUsage {
 
 // Summed per model, never priced once on the aggregate: a session that ran half its turns on
 // an expensive model and half on a cheap one must not be priced as though it used either one
-// throughout — that's the whole reason `model` lives on the turn instead of the binding.
+// throughout - that's the whole reason `model` lives on the turn instead of the binding.
 export function estimateAgentUsd(agent: AgentId, rows: ModelUsage[], pricing: Pricing): number | null {
   const mine = rows.filter((r) => r.agent === agent)
   // An agent bills one way or the other. Kiro charges credits and reports token counts beside

package/src/store/db.ts

@@ -42,7 +42,7 @@ export function openDb(path: string): Database {
   try {
     db = new Database(path, { create: true, strict: true })
     if (path !== ':memory:') {
-      // konvoy runs concurrently by design — a nested konvoy inside an agent, a dashboard beside
+      // konvoy runs concurrently by design - a nested konvoy inside an agent, a dashboard beside
       // a send. Set before anything that takes a lock: switching a fresh file to WAL needs an
       // exclusive one, and without the timeout the losers of that first statement throw
       db.exec('PRAGMA busy_timeout = 5000')

package/src/store/queries.ts

@@ -76,6 +76,10 @@ export function touchSession(db: Database, id: string): void {
   ).run({ id, now: now() })
 }
 
+export function renameSession(db: Database, id: string, slug: string): void {
+  db.query('UPDATE session SET slug = $slug WHERE id = $id').run({ slug, id })
+}
+
 export function deleteSession(db: Database, id: string): void {
   db.transaction(() => {
     db.query('DELETE FROM event WHERE turn_id IN (SELECT id FROM turn WHERE session_id = $id)').run({ id })
@@ -87,8 +91,8 @@ export function deleteSession(db: Database, id: string): void {
 }
 
 // Every foreign id konvoy has met: UUIDs, kiro's cli_<uuid>_<suffix>, opencode's ses_…. An id
-// is replayed onto a command line — after a flag by three adapters, as a bare positional by
-// codex — so anything else, a leading dash above all, is refused here at the one write path.
+// is replayed onto a command line - after a flag by three adapters, as a bare positional by
+// codex - so anything else, a leading dash above all, is refused here at the one write path.
 const FOREIGN_ID = /^[A-Za-z0-9][\w.:-]*$/
 
 export function upsertBinding(
@@ -100,14 +104,14 @@ export function upsertBinding(
     effort: string
     permission: Permission
     model?: string | null
-    /** set by a turn that failed on auth — the roster then says which agent needs a login */
+    /** set by a turn that failed on auth - the roster then says which agent needs a login */
     status?: 'auth_required'
   },
 ): void {
   const foreignId = input.foreignId !== null && !FOREIGN_ID.test(input.foreignId) ? null : input.foreignId
   if (foreignId === null && input.foreignId !== null) {
     console.error(
-      `konvoy: ignoring foreign session id ${JSON.stringify(input.foreignId.slice(0, 60))} for ${input.agent} — not a shape konvoy places on a command line`,
+      `konvoy: ignoring foreign session id ${JSON.stringify(input.foreignId.slice(0, 60))} for ${input.agent} - not a shape konvoy places on a command line`,
     )
   }
   db.query(
@@ -235,7 +239,7 @@ export function lastTurnId(db: Database, sessionId: string): string | null {
   return row?.id ?? null
 }
 
-// Who actually produced the most recent turn — which, after a failover move, is not
+// Who actually produced the most recent turn - which, after a failover move, is not
 // necessarily the agent `send()` was originally asked to run.
 export function lastTurnAgent(db: Database, sessionId: string): AgentId | null {
   const row = db.query('SELECT agent FROM turn WHERE session_id = $sessionId ORDER BY rowid DESC LIMIT 1').get({
@@ -397,8 +401,7 @@ export function usageByAgentModel(db: Database, sessionId?: string): ModelUsage[
   }))
 }
 
-// Buckets are cut in JS so the CLI keeps one clock: bun:sqlite's 'localtime' modifier reads
-// libc's zone, which ignores process.env.TZ and needs tzdata on the host.
+// bun:sqlite's 'localtime' follows libc's zone, not process.env.TZ, and needs tzdata on the host
 function localDay(ms: number): string {
   const d = new Date(ms)
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`

package/src/types.ts

@@ -12,7 +12,7 @@ export type KonvoyEvent =
       t: 'error'
       message: string
       kind: 'auth' | 'rate' | 'upstream' | 'crash' | 'timeout' | 'interrupted' | 'unknown'
-      /** which wire event carried it, when a CLI has more than one — codex: item vs turn.failed */
+      /** which wire event carried it, when a CLI has more than one - codex: item vs turn.failed */
       source?: string
     }
   | { t: 'done'; final: string }