overcode 0.6.1__tar.gz → 0.6.2__tar.gz

{overcode-0.6.1/src/overcode.egg-info → overcode-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.6.1
+Version: 0.6.2
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.6.1 → overcode-0.6.2}/docs/children.md

@@ -121,7 +121,7 @@ The command reads the child's identity from its environment (overcode sets
 launches), so it only works inside an agent. When the child's turn ends:
 
 - **with a report**, it is `done`: ⚪ with ✅ or ❌. Any budget it didn't
-  use goes back to its parent.
+  use goes back to its parent (unless budget reclaim is manual, below).
 - **without a report**, it is `waiting_oversight`: ⚪ with 📭. Its
   oversight policy (below) decides what happens next. If you or its parent
   prompt it again, it goes back to work.
@@ -212,7 +212,10 @@ children:
   its budget without a deduction. A preset can set a default budget, which
   `--budget` overrides.
 - When a child reports and turns done, whatever is left of its budget goes
-  back to its parent.
+  back to its parent. With `children.budget_reclaim: manual` (config.yaml,
+  or "Budget reclaim" in the TUI palette) it stays with the child, so you
+  can keep talking to it without it running out, until the parent takes it
+  back with `overcode budget reclaim <child>`. The default is `auto`.
 - Budgets are soft limits. When an agent goes over its budget, it isn't
   killed, but its heartbeats and supervisor nudges stop. See
   [Cost Budgets](advanced-features.md#cost-budgets).

{overcode-0.6.1 → overcode-0.6.2}/docs/configuration.md

@@ -110,6 +110,8 @@ naming:
 children:
   preset: supervised              # default for children: supervised | balanced | autonomous | yours
   presets: {}                     # change a built-in or add your own
+  budget_reclaim: auto            # auto: a finished child's unused budget goes back to its
+                                  # parent; manual: only `overcode budget reclaim <child>`
 
 # Claude subscription quota: the Q% column's estimate
 # See "Subscription Quota" below
@@ -907,8 +909,9 @@ naming:
     warn_humans: false      # warn (never refuse) when a name you type breaks the rules
   enabled: false            # auto-naming: the engine names agents (off by default)
   first_after: {minutes: 5} # the first name, this long after the agent's first prompt
-  max_renames: 2            # auto renames in an agent's life (the first name + one refinement)
-  cost_cap_per_day: 0.50    # USD a day for the namer's model calls (per tmux session)
+  rename_every: {minutes: 30}  # then a check per this much work (0: never re-checked)
+  max_renames: null         # a cap on auto renames per agent (null: none)
+  cost_cap_per_day: 10.00   # USD a day for the namer's model calls (per tmux session)
   # provider:               # the namer's model; default: the summarizer: block
   #   api_type: anthropic
   #   api_url: https://api.anthropic.com/v1/messages
@@ -918,7 +921,10 @@ naming:
 ```
 
 **Auto-naming** (`enabled: true`, `/` → "Auto-naming" in the TUI, or a
-children preset that sets it). The engine names an agent whose name is
+children preset that sets it). `/` → "Auto-naming settings…" sets
+`enabled`, `first_after`, `rename_every`, `max_renames`,
+`cost_cap_per_day` and `cli_title` from the TUI, saving each change here
+at once; `overcode config show` prints them. The engine names an agent whose name is
 `default` or `auto` `first_after.minutes` (default 5) after its first
 prompt (the launch prompt, or the first one you typed), once it has started
 on it: mid-turn or while it waits, whichever it is doing then. An agent
@@ -929,13 +935,23 @@ naming advice, case included ("use capitals" gets capitals); names that
 differ only in case count as the same name. `overcode name policy` says
 whether auto-naming is on and when it names, the new-agent dialog's tip
 for the name says what will happen to a name you leave as it is, and the
-naming lab's header says it too. One refinement comes after 20 turns and
-30 minutes of work (or 150k output tokens), and renames only if the model
-says the task has changed. "Let overcode name it" (`overcode rename
+naming lab's header says it too.
+
+After the first name, the engine asks again every `rename_every.minutes`
+(default 30) of work: green time, counted from the last check, so an agent
+at rest is never asked, and the check comes mid-turn or idle, whenever
+the work adds up. The model sees what the agent is doing now (its last
+three prompts with how long ago each was, the files it edited since the
+last check, and why its name was chosen) beside its brief, and keeps the
+name unless the focus of the work has clearly moved on, so most checks
+rename nothing. There is no cap on auto renames unless you set
+`max_renames`. A check costs one call (well under a cent with a mini model);
+`cost_cap_per_day` still bounds the lot. A naming prompt saved from the
+naming lab before this had no place for the recent work; the engine adds
+it at the end. "Let overcode name it" (`overcode rename
 <agent> --auto`, or "Named by" in the rename dialog) makes the name a
 `default` one again, without a `~` (overcode did not choose it), and the
-agent is named afresh by the same rule. An auto
-name changes at most `max_renames` times, at least 10 minutes apart. The
+agent is named afresh by the same rule. The
 namer never renames a `human` or `parent` name. It does not wait for the
 TUI to go quiet: a rename interrupts nothing, and the old name still
 reaches the agent. A rename is overcode's ordinary

{overcode-0.6.1 → overcode-0.6.2}/docs/design/auto-naming.md

@@ -181,7 +181,7 @@ status going from green to waiting_user / waiting_heartbeat /
 waiting_oversight / done, as the daemon publishes it (so hookless agents
 count too); the turn count is the larger of those seen (kept in
 `agents/<id>/namer.json`) and the transcript's interaction count; the
-refinement needs 10x every threshold (turns and green minutes or tokens);
+refinement needs 10x every threshold (turns and green minutes or tokens; replaced by `rename_every` in #547);
 a failed or unreadable call is retried no sooner than 10 minutes later.
 There is no wait for the TUI to go quiet (an earlier draft held renames
 for 30 s after any TUI keypress; it only delayed names, since a rename
@@ -204,14 +204,19 @@ from events and adds no polling.
   most 3 times (`first_tries`). "Let overcode name it" sets the source to
   `default` (no `~`: overcode did not choose the name) and clears the
   naming history (`hand_to_namer`), so the rule applies afresh.
-- **One refinement** comes at a Stop after 20 turns and 30 green minutes or
-  150k output tokens (`REFINE_AFTER`).
-  It renames only when the namer is confident the task has changed (see the
-  `keep` reply below). So `auto` names change at most twice in an agent's
-  life (`max_renames`, default 2), and at least 10 minutes apart.
+- **A check every `rename_every.minutes` of work** (default 30; #547,
+  replacing the one refinement after 20 turns). Green time since the last
+  answered check, any tick, mid-turn or idle (owner decision 2026-10-22:
+  "any time", not only at a Stop). The model sees the recent window (last
+  3 prompts from `recent_prompts.jsonl` with their age, files edited since
+  the check, and the `why` of the current name) beside the brief, and is
+  told to keep an `auto` name unless the focus has clearly moved on.
+  No cap on auto renames by default (`max_renames: null`); a failed call
+  waits 10 minutes. A green-time count that starts again (a restart)
+  restarts the check's count.
 - Never while the name is `human` (or `parent`).
 - Calls run on the daemon's worker pool, with a per-day cost cap
-  (`naming.cost_cap_per_day`, default $0.50). Spend goes in the ledger
+  (`naming.cost_cap_per_day`, default $10; was $0.50). Spend goes in the ledger
   under the billing code `overcode` (closing the gap the summariser has).
   At about 2 calls per agent with a mini model, 100 agents cost about $0.05.
 
@@ -262,7 +267,7 @@ of a root agent calls `codes.follow_agent_name` on its code (owner decision
 
 The model returns JSON: `{"candidates": ["jwt-refresh", "auth-refresh",
 "jwt-fix"], "keep": false, "why": "..."}`, best first. `keep: true` means
-the current name still fits, which is how refinements stay rare. Overcode
+the current name still fits, which is how most checks rename nothing. Overcode
 then decides on its own, without the model:
 
 1. Normalise each candidate to overcode's name pattern. Drop any that
@@ -304,8 +309,9 @@ naming:
     llm_check: false         # check the advice with the model too
     warn_humans: false
   first_after: {minutes: 5}
-  max_renames: 2
-  cost_cap_per_day: 0.50
+  rename_every: {minutes: 30}
+  max_renames: null
+  cost_cap_per_day: 10.00
   # provider: falls back to the summarizer: block (api_type, url, model, key var)
 ```
 

overcode-0.6.2/docs/release-notes-0.6.2.md

@@ -0,0 +1,27 @@
+# overcode 0.6.2
+
+- **A held key no longer kills agents one after another.** Holding `x`
+  confirmed the kill on the first key repeat, then moved on to the next
+  agent; a held key now confirms nothing (#548).
+- **Restart and rename never type into a running agent.** Overcode waits for
+  the agent's shell to have the terminal back (read from the process table on
+  macOS and Linux, not the screen) and refuses if it never exits; this fixes
+  stray sessions from agents in Claude's background worker (#549). Agents also
+  no longer inherit a host Claude session's identity when tmux was started from
+  inside Claude (#550).
+- **Model and effort follow `/model` and `/effort` within seconds.** After a
+  model switch, effort reads `-` until the next reply says what it is (#539).
+- **Auto names follow the work.** With auto-naming on, a name is re-checked
+  every 30 min of work and changes when the work has moved on. "Auto-naming
+  settings…" in the palette sets the timings, a cap, and the daily cost cap
+  (now an amount you type, $10 by default) (#547).
+- **Budget reclaim can be manual.** `children.budget_reclaim: manual` (or
+  "Budget reclaim" in the palette) keeps a finished child's unused budget with
+  the child, so you can keep talking to it, until its parent runs
+  `overcode budget reclaim <child>`. The default stays `auto` (#546).
+- **Smaller fixes.** A subagent row's empty bell cell no longer makes its time
+  read as negative (#545).
+
+**Upgrading:** nothing to convert. If you use auto-naming, names may now
+change during long sessions, and the namer's daily cap rises from $0.50 to $10
+unless you set `naming.cost_cap_per_day`.

{overcode-0.6.1 → overcode-0.6.2}/docs/tui-guide.md

@@ -471,7 +471,8 @@ name Claude still shows.
   same for the focused agent (`overcode rename <agent> --auto` / `--lock`).
 
 With auto-naming on (`/` → "Auto-naming", or `naming.enabled`; see
-[Naming](configuration.md#naming)), the engine names an agent with a
+[Naming](configuration.md#naming); `/` → "Auto-naming settings…" sets
+its timings, cap and cost cap), the engine names an agent with a
 default name 5 minutes after its first prompt
 (`naming.first_after.minutes`), once it has started on it, working or
 waiting; an agent never given a task is not named. It may rename it once

{overcode-0.6.1 → overcode-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.6.1"
+version = "0.6.2"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/bundled_skills.py

@@ -82,6 +82,10 @@ Other options:
 - `-B opencode` (or `codex`, `grok`, ...) launches a different agent CLI.
 - `-m <model>` picks the model.
 - `--budget 2.00` caps its spend, and is taken from your budget if you have one.
+  What it doesn't spend comes back to you when it finishes, unless
+  `overcode config show` says `children.budget_reclaim: manual`: then take
+  it back yourself with `overcode budget reclaim <child>` once you are done
+  talking to it.
 - `--allowed-tools "Read,Grep,Glob"` makes a read-only Claude Code child.
 - `--skills <profile>` switches on a skill profile.
 

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/child_presets.py

@@ -73,7 +73,7 @@ BUILTIN_PRESETS: Dict[str, ChildPreset] = {
 DEFAULT_PRESET = "supervised"
 
 _PRESET_KEYS = ("on_stuck", "oversight_timeout", "archive_after", "budget", "description")
-_SECTION_KEYS = ("preset", "presets")
+_SECTION_KEYS = ("preset", "presets", "budget_reclaim")
 _NEVER = ("never", "off", "none")
 
 
@@ -222,6 +222,9 @@ def load_presets(section: Any = None) -> Tuple[Dict[str, ChildPreset], str, List
             continue
         base = presets.get(name, BUILTIN_PRESETS[DEFAULT_PRESET])
         presets[name] = _apply_fields(base, name, raw, warnings)
+    reclaim = section.get("budget_reclaim")
+    if reclaim is not None and str(reclaim).strip().lower() not in ("auto", "manual"):
+        warnings.append(f"children.budget_reclaim: '{reclaim}' is not auto or manual — using auto")
     default = section.get("preset") or DEFAULT_PRESET
     default = str(default).strip()
     if default not in presets:

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/cli/agent.py

@@ -3,6 +3,7 @@ Agent commands: launch, list, attach, kill, follow, report, cleanup,
 set-value, set-budget, annotate, send, show.
 """
 
+import time
 from typing import Annotated, Optional, List
 
 import typer
@@ -1217,7 +1218,13 @@ def restart(
     launcher = launcher.for_agent(sess)
 
     if model:
-        launcher.sessions.update_session(sess.id, model=model)
+        # From now on the transcript's older model and effort no longer
+        # apply; on another model the effort is unknown until it replies
+        # (Claude picks it per model) (#539)
+        changes = {"model": model, "model_chosen_at": time.time()}
+        if model != sess.model:
+            changes["effort"] = None
+        launcher.sessions.update_session(sess.id, **changes)
         sess = launcher.sessions.get_session(sess.id)
 
     # Window gone (killed, reboot): bring it back in a new window, as the

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/cli/budget.py

@@ -114,6 +114,10 @@ def budget_reclaim(
 
     Examples:
         overcode budget reclaim my-dead-child
+
+    A child that finishes gives its unused budget back by itself unless
+    children.budget_reclaim is manual (config.yaml, or "Budget reclaim" in
+    the TUI palette); then this is how the parent takes it back.
     """
     from ..session_manager import SessionManager
 

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/cli/config.py

@@ -36,12 +36,27 @@ CONFIG_TEMPLATE = """\
 # agents (`overcode launch --preset`; `overcode config presets` lists them)
 # children:
 #   preset: supervised         # default for children: supervised | balanced | autonomous | yours
+#   budget_reclaim: auto       # auto: a finished child's unused budget goes back to its
+#                              # parent; manual: the parent runs `overcode budget reclaim`
 #   presets:
 #     overnight:
 #       on_stuck: timeout:8h   # wait | fail | timeout:DURATION
 #       archive_after: never   # DURATION or never
 #       budget: 5.00           # USD
 
+# Auto-naming (Agent names in docs/configuration.md; "Auto-naming settings…"
+# in the TUI palette sets the switches and timings)
+# naming:
+#   enabled: false             # the engine names agents with default/auto names
+#   advice: |                  # free text: how names should look (the policy)
+#     lowercase kebab-case, 1-3 words, what the work is about
+#   max_length: 18             # the namer's target length
+#   first_after: {minutes: 5}  # the first name, this long after the first prompt
+#   rename_every: {minutes: 30}  # then a check per this much work (0: never)
+#   max_renames: null          # a cap on auto renames per agent (null: none)
+#   cost_cap_per_day: 10.00    # USD a day for the namer's model calls
+#   cli_title: true            # keep Claude Code's session title in step
+
 # AI summarizer settings (for corporate API gateways)
 # summarizer:
 #   api_url: https://api.openai.com/v1/chat/completions
@@ -160,6 +175,25 @@ def _config_show():
         if "api_key_var" in s:
             rprint(f"    api_key_var: {s['api_key_var']}")
 
+    if "children" in config:
+        from ..config import get_budget_reclaim_mode
+        rprint(f"  children.budget_reclaim: {get_budget_reclaim_mode()}")
+
+    if "naming" in config:
+        from ..config import describe_auto_naming, get_naming_config
+        cfg = get_naming_config()
+        every = cfg["rename_every"]["minutes"]
+        rprint("  naming:")
+        rprint(f"    enabled: {cfg['enabled']}")
+        rprint(f"    first_after: {cfg['first_after']['minutes']:g} min")
+        rprint(f"    rename_every: {f'{every:g} min of work' if every else 'never'}")
+        rprint(f"    max_renames: {cfg['max_renames'] if cfg['max_renames'] is not None else 'no cap'}")
+        rprint(f"    cost_cap_per_day: ${cfg['cost_cap_per_day']:.2f}")
+        rprint(f"    cli_title: {cfg['cli_title']}")
+        rprint(f"    [dim]{describe_auto_naming(cfg)}[/dim]")
+        for warning in cfg["warnings"]:
+            rprint(f"    [yellow]Warning:[/yellow] {warning}")
+
     if "status_theme" in config:
         from ..status_theme import resolve
         theme, warnings = resolve(config["status_theme"])

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/cli/naming.py

@@ -194,8 +194,8 @@ def name_policy(
     rprint(f"Aim for at most {cfg['max_length']} characters.")
 
     rprint(f"\n[bold]Auto-naming[/bold] {escape(describe_auto_naming(cfg))}")
-    rprint("[dim](naming.enabled in config.yaml, or / Auto-naming in the TUI; "
-           "naming.first_after.minutes sets how long after its first prompt)[/dim]")
+    rprint("[dim](naming: in config.yaml, or \"Auto-naming settings…\" in the TUI palette: "
+           "enabled, first_after.minutes, rename_every.minutes, max_renames)[/dim]")
 
     rprint("\n[bold]Always refused[/bold] (even with --force-name)")
     rprint("  a name outside letters, digits, - and _ (at most 64)")
@@ -246,10 +246,11 @@ def name_suggest(
     One model call (the summarizer's, or naming.provider), billed to the
     `overcode` billing code. Works whether or not naming.enabled is on.
     """
+    import time
     from pathlib import Path
     from ..config import get_naming_config
-    from ..namer import (advice_for, gather_inputs, make_client, naming_context, recent_archived,
-                         record_spend, suggest)
+    from ..namer import (advice_for, gather_inputs, load_state, make_client, naming_context,
+                         recent_archived, record_spend, suggest)
     from ..session_manager import SessionManager
     from ..summarizer_prompts import load_naming_prompt
     from ._shared import find_agent
@@ -278,7 +279,8 @@ def name_suggest(
     sessions = sm.list_sessions()
     archived = recent_archived(sm)
     inputs = gather_inputs(sess, tmux_session=tmux_session, sessions=sessions, archived=archived,
-                           max_length=cfg["max_length"], pane=pane)
+                           max_length=cfg["max_length"], pane=pane,
+                           state=load_state(tmux_session, sess.id), now=time.time())
     result = suggest(inputs, naming_context(cfg, sessions, archived, sess),
                      client=make_client(cfg.get("provider")), template=load_naming_prompt(),
                      advice=advice)

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/columns/registry.py

@@ -97,6 +97,7 @@ from .render_supervision import (
     render_wrapper_plain,
 )
 from .render_virtual import (
+    render_virtual_alert,
     hover_virtual_name,
     render_virtual_cost,
     render_virtual_expand,
@@ -251,7 +252,8 @@ SUMMARY_COLUMNS: List[SummaryColumn] = [
                   name="Alert",
                   description="Flags an agent that stalled and you haven't looked at since",
                   sort_key=lambda ctx: int(ctx.is_unvisited_stalled),
-                  sort_desc=True),
+                  sort_desc=True,
+                  virtual_render=render_virtual_alert),
     SummaryColumn(id="time_in_state", ticks=True, group="identity", detail_levels=ALL, render=render_time_in_state,
                   header="ST", name="Time in State",
                   description="How long the agent has been in its current status",

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/columns/render_virtual.py

@@ -115,6 +115,15 @@ def render_virtual_status(ctx: ColumnContext) -> ColumnOutput:
     return render_status_symbol(ctx)
 
 
+def render_virtual_alert(ctx: ColumnContext) -> ColumnOutput:
+    """Blank, as an agent's bell cell with no bell: a member never rings it.
+
+    The "-" placeholder there would touch the time in state and read as a
+    minus sign (#545).
+    """
+    return [("  ", "dim")]
+
+
 def render_virtual_time(ctx: ColumnContext) -> ColumnOutput:
     """Time in state: since it started; its run time once finished."""
     seconds = virtual_seconds(_line(ctx), _now())

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/command_palette.py

@@ -136,6 +136,14 @@ def _summarizer_state(app: Any) -> StateView:
         return _toggle(None)
 
 
+def _budget_reclaim_state(app: Any) -> StateView:
+    try:
+        from .config import BUDGET_RECLAIM_MODES, get_budget_reclaim_mode
+        return _cycle(BUDGET_RECLAIM_MODES, get_budget_reclaim_mode())
+    except Exception:
+        return StateView(("auto", "manual"), None)
+
+
 def _auto_naming_state(app: Any) -> StateView:
     try:
         from .config import get_naming_config
@@ -408,6 +416,11 @@ COMMANDS: Tuple[PaletteCommand, ...] = (
     _C("open_passthru_config", "Passthru keys…", "Settings", "forward ctrl"),
     _C("open_status_colours", "Status colours…", "Settings",
        "theme light lights colour color blind colorblind custom glyph emoji legend"),
+    _C("toggle_budget_reclaim", "Budget reclaim", "Settings",
+       "refund child budget finished done return parent manual auto spend money",
+       state=_budget_reclaim_state),
+    _C("open_auto_naming_settings", "Auto-naming settings…", "Settings",
+       "names namer rename auto-name first name re-check every minutes cap cost title"),
     _C("open_agent_visibility", "Agent visibility…", "Settings",
        "show hide killed terminated ghost sleeping asleep done children subagents "
        "delegated work finished failures rows seconds swarm"),

{overcode-0.6.1 → overcode-0.6.2}/src/overcode/config.py

@@ -1046,12 +1046,40 @@ def save_billing_defaults(new_agent_code: str, default_code: str) -> None:
     save_config(config)
 
 
+BUDGET_RECLAIM_MODES = ("auto", "manual")
+
+
+def get_budget_reclaim_mode() -> str:
+    """``children.budget_reclaim`` (#546): ``auto`` (default) refunds a
+    finished child's unused budget to its parent; ``manual`` leaves it with
+    the child until the parent runs ``overcode budget reclaim <child>``, so
+    the child can be talked to again without running out."""
+    section = _get_config_value("children", {})
+    mode = section.get("budget_reclaim", "auto") if isinstance(section, dict) else "auto"
+    mode = str(mode).strip().lower()
+    return mode if mode in BUDGET_RECLAIM_MODES else "auto"
+
+
+def save_budget_reclaim_mode(mode: str) -> None:
+    """Set ``children.budget_reclaim`` in config.yaml, keeping the rest of ``children:``."""
+    if mode not in BUDGET_RECLAIM_MODES:
+        raise ValueError(f"budget_reclaim must be one of {BUDGET_RECLAIM_MODES}, not {mode!r}")
+    config = load_config()
+    children = config.get("children")
+    children = dict(children) if isinstance(children, dict) else {}
+    children["budget_reclaim"] = mode
+    config["children"] = children
+    save_config(config)
+
+
 NAMING_MAX_LENGTH_DEFAULT = 18
-_NAMING_KEYS = ("enabled", "advice", "max_length", "rules", "first_after", "max_renames",
-                "cost_cap_per_day", "provider", "cli_title")
+NAMING_COST_CAP_DEFAULT = 10.0  # USD a day for the namer's model calls
+_NAMING_KEYS = ("enabled", "advice", "max_length", "rules", "first_after", "rename_every",
+                "max_renames", "cost_cap_per_day", "provider", "cli_title")
 _NAMING_RULE_KEYS = ("pattern", "max_length", "forbid", "require", "no_repo_prefix",
                      "recent_archived_hours", "llm_check", "warn_humans")
 _NAMING_FIRST_AFTER = {"minutes": 5.0}
+_NAMING_RENAME_EVERY = {"minutes": 30.0}
 
 
 def _positive_int(value) -> Optional[int]:
@@ -1088,6 +1116,28 @@ def save_naming_enabled(enabled: bool) -> None:
     save_config(config)
 
 
+# naming: keys whose value is {minutes: N} in config.yaml
+_NAMING_MINUTES_KEYS = ("first_after", "rename_every")
+
+
+def save_naming_setting(key: str, value) -> None:
+    """Set one ``naming.<key>`` in config.yaml (the auto-naming dialog),
+    keeping the rest of ``naming:``. ``first_after`` and ``rename_every``
+    take minutes; ``max_renames`` None removes the cap."""
+    config = load_config()
+    naming = config.get("naming")
+    naming = dict(naming) if isinstance(naming, dict) else {}
+    if key in _NAMING_MINUTES_KEYS:
+        block = naming.get(key)
+        block = dict(block) if isinstance(block, dict) else {}
+        block["minutes"] = value
+        naming[key] = block
+    else:
+        naming[key] = value
+    config["naming"] = naming
+    save_config(config)
+
+
 def describe_auto_naming(cfg: Optional[dict] = None) -> str:
     """Auto-naming in one line, for the palette, the new-agent dialog, the
     naming lab and ``overcode name policy``."""
@@ -1098,7 +1148,13 @@ def describe_auto_naming(cfg: Optional[dict] = None) -> str:
     minutes = float(first.get("minutes") or 0)
     when = (f"{minutes:g} min after its first prompt" if minutes
             else "as soon as it starts on its first prompt")
-    return f"on: a default name is replaced {when}, following the naming advice"
+    every = float((cfg.get("rename_every") or {}).get("minutes") or 0)
+    then = (f"; then re-checked every {every:g} min of work, renamed when the work has moved on"
+            if every else "")
+    cap = cfg.get("max_renames")
+    if every and cap is not None:
+        then += f" (at most {cap} auto renames)"
+    return f"on: a default name is replaced {when}, following the naming advice{then}"
 
 
 def get_naming_config() -> dict:
@@ -1121,8 +1177,9 @@ def get_naming_config() -> dict:
             warn_humans: false  # warn (never refuse) a human's -n too
           first_after: {minutes: 5}  # the first name, this long after the agent's
                                 # first prompt, once it has started on it
-          max_renames: 2
-          cost_cap_per_day: 0.50
+          rename_every: {minutes: 30}  # then a check per this much work (0 = never)
+          max_renames: null     # a cap on auto renames per agent (null = none)
+          cost_cap_per_day: 10.00
           provider: {...}       # api_type/api_url/model/api_key_var; default: the summarizer: block
           cli_title: true       # keep Claude's own session name (--name, /rename) in step
 
@@ -1200,9 +1257,20 @@ def get_naming_config() -> dict:
             warnings.append(f"naming.first_after: '{key}' is not used — the first name comes "
                             "first_after.minutes after the agent's first prompt")
     first_after = {k: _non_negative(raw_first.get(k, d), d) for k, d in _NAMING_FIRST_AFTER.items()}
-    max_renames = cfg.get("max_renames", 2)
-    max_renames = max_renames if isinstance(max_renames, int) and not isinstance(
-        max_renames, bool) and max_renames >= 0 else 2
+    raw_every = cfg.get("rename_every") or {}
+    if not isinstance(raw_every, dict):
+        warnings.append("naming.rename_every: should be a mapping like {minutes: 30} — ignored")
+        raw_every = {}
+    for key in raw_every:
+        if key not in _NAMING_RENAME_EVERY:
+            warnings.append(f"naming.rename_every: '{key}' is not used — names are re-checked "
+                            "every rename_every.minutes of work")
+    rename_every = {k: _non_negative(raw_every.get(k, d), d) for k, d in _NAMING_RENAME_EVERY.items()}
+    max_renames = cfg.get("max_renames")
+    if max_renames is not None and not (isinstance(max_renames, int) and not isinstance(
+            max_renames, bool) and max_renames >= 0):
+        warnings.append("naming.max_renames: should be a whole number or null — no cap")
+        max_renames = None
     provider = cfg.get("provider") if isinstance(cfg.get("provider"), dict) else None
     if cfg.get("provider") is not None and provider is None:
         warnings.append("naming.provider: should be a mapping — using the summarizer: block")
@@ -1213,8 +1281,10 @@ def get_naming_config() -> dict:
         "max_length": max_length,
         "rules": rules,
         "first_after": first_after,
+        "rename_every": rename_every,
         "max_renames": max_renames,
-        "cost_cap_per_day": _non_negative(cfg.get("cost_cap_per_day", 0.50), 0.50),
+        "cost_cap_per_day": _non_negative(cfg.get("cost_cap_per_day", NAMING_COST_CAP_DEFAULT),
+                                          NAMING_COST_CAP_DEFAULT),
         "provider": provider,
         "cli_title": cfg.get("cli_title") is not False,
         "warnings": warnings,