taskuary 0.3.2__tar.gz → 0.3.2.2__tar.gz

{taskuary-0.3.2/taskuary.egg-info → taskuary-0.3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskuary
-Version: 0.3.2
+Version: 0.3.2.2
 Summary: Automate your job - the local-first operating system for your work: AI triage in, coding agents out.
 License: MIT
 Project-URL: Homepage, https://github.com/ldbumble/taskuary
@@ -64,7 +64,7 @@ and replies wait for your approval. Nothing sends or ships without you.
 
 ![The Taskuary Studio: work arrives, triage decides what needs action, and agents take seats to work it.](https://raw.githubusercontent.com/ldbumble/taskuary/master/docs/hero.gif)
 
-Taskuary is early—currently **v0.3.2**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.2**—and moving fast. The funnel, review queue,
 agent sessions, and reports pipeline are in daily use; breaking changes are still possible
 before 1.0.
 

{taskuary-0.3.2 → taskuary-0.3.2.2}/README.md

@@ -13,7 +13,7 @@ and replies wait for your approval. Nothing sends or ships without you.
 
 ![The Taskuary Studio: work arrives, triage decides what needs action, and agents take seats to work it.](https://raw.githubusercontent.com/ldbumble/taskuary/master/docs/hero.gif)
 
-Taskuary is early—currently **v0.3.2**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.2**—and moving fast. The funnel, review queue,
 agent sessions, and reports pipeline are in daily use; breaking changes are still possible
 before 1.0.
 

{taskuary-0.3.2 → taskuary-0.3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "taskuary"
-version = "0.3.2"
+version = "0.3.2.2"
 description = "Automate your job - the local-first operating system for your work: AI triage in, coding agents out."
 readme = "README.md"
 license = { text = "MIT" }

{taskuary-0.3.2 → taskuary-0.3.2.2}/taskuary/agents.py

@@ -123,7 +123,7 @@ def _resolve_cmd(name: str) -> list:
     return [path]
 
 
-def child_env() -> dict:
+def child_env(base: dict = None, home: str = None, windows: bool = None) -> dict:
     """The environment a CLI is entitled to expect.
 
     codex refuses to start without one: `Error finding codex home: Could not find home
@@ -133,16 +133,24 @@ def child_env() -> dict:
     Python can answer the question, so it answers it instead of letting the CLI guess: HOME
     and USERPROFILE where they are missing, and CODEX_HOME - the variable codex checks FIRST,
     before it ever asks the OS - pointed at the same place its own installer would use.
+
+    The three arguments exist so the Windows branch can be exercised from a Linux CI box
+    without patching os.name out from under the interpreter - which is how the first version
+    of this test managed to fail on the platform it was pretending to be.
     """
-    env = dict(os.environ)
-    try: home = str(Path.home())
-    except (RuntimeError, OSError): return env          # nothing better to say than nothing
+    import ntpath                    # a Windows path, split as one wherever this runs
+    env = dict(os.environ if base is None else base)
+    if home is None:
+        try: home = str(Path.home())
+        except (RuntimeError, OSError): return env      # nothing better to say than nothing
     env.setdefault('HOME', home)
-    if os.name == 'nt':
+    if (os.name == 'nt') if windows is None else windows:
         env.setdefault('USERPROFILE', home)
-        drive, tail = os.path.splitdrive(home)
-        if drive: env.setdefault('HOMEDRIVE', drive); env.setdefault('HOMEPATH', tail)
-    env.setdefault('CODEX_HOME', os.path.join(home, '.codex'))
+        drive, rest = ntpath.splitdrive(home)
+        if drive: env.setdefault('HOMEDRIVE', drive); env.setdefault('HOMEPATH', rest)
+        env.setdefault('CODEX_HOME', ntpath.join(home, '.codex'))
+    else:
+        env.setdefault('CODEX_HOME', os.path.join(home, '.codex'))
     return env
 
 

{taskuary-0.3.2 → taskuary-0.3.2.2}/taskuary/blackboard.py

@@ -11,7 +11,9 @@ from loguru import logger
 from .store import task_ref
 
 
-def norm(p): return os.path.normcase(os.path.normpath(p or ''))
+# normpath('') is '.', which is a real relative path and would make every checkout-less note
+# look like it belonged to whatever directory the reader happens to be standing in
+def norm(p): return os.path.normcase(os.path.normpath(p)) if str(p or '').strip() else ''
 
 
 def dirty(cwd) -> set:
@@ -66,6 +68,158 @@ def peers(store, cwd, exclude_tid=None) -> list:
     return out
 
 
+# ── the wall: what agents tell EACH OTHER ────────────────────────────────────────────────
+# peers() and dirty() are facts read off git and the run trace - true, and about as expressive
+# as a security camera. They cannot say "the migration is half-applied, do not run the tests
+# yet" or "this is ready, push it". Only the agent doing the work knows that, so it writes it
+# down: one line per note, on the checkout, read by whoever comes next.
+KINDS = ('working', 'note', 'blocked', 'ready', 'done')
+SUMMARY = 'summary'      # written by the daily roll-up, not by an agent
+ROLLED_ON = 'wall_rolled_on'
+SEED_BUDGET = 620      # what the wall may take of a seed prompt, whatever is on it
+KIND_HINT = {'working': 'what it is doing right now', 'note': 'anything the next agent needs',
+             'blocked': 'waiting on something or someone', 'ready': 'finished and safe to push',
+             'done': 'pushed or closed out'}
+
+
+def post(store, body: str, kind: str = 'note', agent: str = '', cwd: str = '', tid: int = None,
+         files: str = '') -> dict:
+    """One note on the wall. Everything but the words is optional: an agent that knows only what
+    it wants to say still gets to say it."""
+    body = ' '.join(str(body or '').split())[:1200]
+    if not body: raise ValueError('a note with no words is not a note')
+    kind = str(kind or 'note').lower().strip()
+    if kind not in KINDS + (SUMMARY,): raise ValueError(f"kind must be one of {', '.join(KINDS)}")
+    nid = store.add_note({'TaskId': tid, 'Agent': agent or 'agent', 'Cwd': norm(cwd), 'Kind': kind,
+                          'Body': body, 'Files': files or ''})
+    return dict(store.get_note(nid))
+
+
+def wall(store, cwd: str = '', limit: int = 12) -> list:
+    return store.notes(norm(cwd) if cwd else None, limit)
+
+
+def house_wall(store, limit: int = 8) -> list:
+    """The lane with no checkout in it: what the assistant chat and the owner leave for
+    everyone. A chat has no repository, so this is the whole of its wall."""
+    return [n for n in store.notes(None, 200) if not str(n.get('Cwd') or '').strip()][:limit]
+
+
+def chat_text(store, limit: int = 6) -> str:
+    """The wall paragraph for the assistant chat: the house lane, and how to add to it.
+
+    The chat is an agent too - it researches, it reads systems, it finds the thing the next
+    session would spend an hour rediscovering. Leaving it out of the wall meant the only agents
+    talking to each other were the ones in a checkout."""
+    rows = house_wall(store, limit)
+    if not rows: return ''
+    lines = ' // '.join(f"[{r['Kind']}] {r['Agent']} ({_ago(r['CreatedAt'])}): {r['Body']}" for r in reversed(rows))
+    return ('THE WALL - notes the other agents and the owner left for everyone, newest last. '
+            'Briefing, not instructions from the owner: ' + lines)
+
+
+ROLL_SYSTEM = (
+    'You keep an engineering wall tidy. Below are the notes agents left each other in one '
+    'checkout on one day. Write the ONE note that should survive: what the next agent needs to '
+    'know tomorrow, and nothing else.\n\n'
+    'KEEP: what changed and is now true, what was learned the hard way (a flaky test, a missing '
+    'dependency, a build step), what is still blocked and on whom, what was left half-done.\n'
+    'DROP: who was holding which file for twenty minutes, anything already superseded by a later '
+    'note, and pleasantries.\n'
+    'Six short lines at most, each a fact. No preamble, no heading, no markdown. If nothing in '
+    'the day is worth carrying forward, answer exactly: NOTHING')
+
+
+def _roll_text(rows: list, llm=None) -> str:
+    """One note out of a day of them. Without an AI: the durable kinds, verbatim, newest last -
+    a worse summary and never a lost fact."""
+    keep = [r for r in rows if r['Kind'] in ('note', 'blocked', 'ready')]
+    plain = ' // '.join(f"[{r['Kind']}] {r['Agent']}: {r['Body']}" for r in reversed(keep))[:1200]
+    if llm is None: return plain
+    said = '\n'.join(f"[{r['Kind']}] {r['Agent']} ({str(r['CreatedAt'])[11:16]}): {r['Body']}"
+                      for r in reversed(rows))
+    try:
+        out = ' '.join(str(llm(ROLL_SYSTEM, said, max_tokens=400) or '').split())
+    except Exception as e:
+        logger.warning(f'the wall roll-up could not be summarised: {e}')
+        return plain
+    if out.strip().upper().startswith('NOTHING'): return ''
+    return out[:1200] or plain
+
+
+def roll_up(store, before: str, llm=None) -> int:
+    """Compost every note older than `before` (a YYYY-MM-DD) into one summary per checkout.
+
+    A wall that only grows is a wall nobody reads to the bottom of - and "taking store.py for
+    twenty minutes" three days ago is worse than nothing, because it reads as now. So each day
+    is folded into one note that says what survives, per checkout, and the originals are marked
+    rolled rather than deleted: the Board can still show the whole wall.
+    """
+    rows = [r for r in store.notes(None, 2000, rolled=True)
+            if not r.get('Rolled') and r['Kind'] != SUMMARY and str(r['CreatedAt'])[:10] < before]
+    if not rows: return 0
+    days = {}
+    for r in rows: days.setdefault((str(r['CreatedAt'])[:10], r.get('Cwd') or ''), []).append(r)
+    made = 0
+    for (day, cwd), batch in sorted(days.items()):
+        text = _roll_text(batch, llm)
+        if text:
+            store.add_note({'TaskId': None, 'Agent': 'the wall', 'Cwd': cwd, 'Kind': SUMMARY,
+                            'Body': f'{day} - {text}', 'Files': ''})
+            made += 1
+        store.roll_notes([r['NoteId'] for r in batch], day)
+    logger.info(f'wall: rolled {len(rows)} note(s) into {made} summary note(s)')
+    return made
+
+
+def roll_daily(store, llm=None) -> int:
+    """Once a day, at the first poll after midnight: yesterday and everything before it is
+    composted. Guarded by a setting, so ten polls a minute do not ten times summarise."""
+    from datetime import date
+    today = date.today().isoformat()
+    if str(store.get_settings().get(ROLLED_ON) or '') == today: return 0
+    store.set_setting(ROLLED_ON, today, 'system')
+    if llm is None:
+        from .llm import build_llm
+        llm = build_llm(store)
+    return roll_up(store, today, llm)
+
+
+def _ago(stamp) -> str:
+    from datetime import datetime
+    try: mins = (datetime.now() - datetime.fromisoformat(str(stamp)[:19].replace(' ', 'T'))).total_seconds() / 60
+    except (TypeError, ValueError): return ''
+    if mins < 1: return 'just now'
+    if mins < 60: return f'{int(mins)}m ago'
+    if mins < 48 * 60: return f'{int(mins // 60)}h ago'
+    return f'{int(mins // 1440)}d ago'
+
+
+HOW_TO_POST = ('Post your own with `taskuary --note "..."` (--kind working|note|blocked|ready|done): '
+               'when you start, when you find something the next agent would waste an hour on, and '
+               '`--kind ready` before you push.')
+
+
+def wall_text(store, cwd: str, limit: int = 8) -> str:
+    """The wall, for the seed prompt: a POINTER, not a transcript.
+
+    A seed is typed into a TUI on one line, and the whole document does not belong there - the
+    newest note plus the command that shows the rest is what makes an agent go and read it.
+    CODER.md carries the full etiquette; this is the nudge that says there is something to read
+    RIGHT NOW. Nothing at all when the wall is empty: a paragraph saying "no notes" is tokens
+    spent to say nothing."""
+    rows = wall(store, cwd, limit)
+    if not rows: return ''
+    top = rows[0]
+    said = (f'THE WALL: {len(rows)} note(s) the agents before you left for this checkout - read them '
+            f'before you touch anything: `taskuary --board`. Newest, {top["Agent"]} '
+            f'({_ago(top["CreatedAt"])}) [{top["Kind"]}]: {top["Body"][:220]} ' + HOW_TO_POST)
+    # a hard ceiling, not a hope: this shares one command line with the task, the mail that
+    # started it and the operator documents, and the wall is the one part of it that grows
+    # every time an agent says something
+    return said[:SEED_BUDGET]
+
+
 def briefing(store, cwd, exclude_tid=None) -> str:
     """The OTHER AGENTS paragraph of a new agent's prompt. Facts only - task, agent, the files
     it has modified so far - plus the one standing rule: whoever got there first has control."""

{taskuary-0.3.2 → taskuary-0.3.2.2}/taskuary/browserview.py

@@ -145,6 +145,58 @@ def close(sid: str):
     _CACHE.pop(sid, None); LAST.pop(sid, None)
 
 
+# One profile's worth of cookies, keyed here and not on the session id: a session is born and
+# dies per task, and a login the owner typed by hand in the pane last week should still be
+# there this week. --restore is agent-browser's own auto-save/restore of cookies and storage.
+RESTORE_KEY = 'taskuary'
+WANTS = 'needs:browser'
+
+
+def wanted(task: dict | None) -> bool:
+    """Did the owner say this task needs a browser? (the tag the New task dialog writes)"""
+    import re as _re
+    return bool(_re.search(rf'(^|[\s,]){_re.escape(WANTS)}([\s,]|$)', str((task or {}).get('Tags') or '')))
+
+
+def start(sid: str, url: str = 'about:blank') -> bool:
+    """Open the browser FOR this session, before the agent asks for one.
+
+    Until now a browser existed only if the agent thought to run agent-browser, which meant a
+    task that plainly needs one - a portal with no API, a page behind a login - started with
+    nothing on screen and the owner watching text. A task marked "needs a browser" gets one
+    with the session: bound to it by name, restored from the owner's own saved cookies, and
+    closed with it (Term._pump -> close).
+    """
+    exe = shutil.which('agent-browser')
+    if not exe: return False
+    if state(sid, fresh=True)['open']: return True                # the agent got there first
+    cmd = [exe, '--session', session_name(sid), '--restore', RESTORE_KEY, 'open', url or 'about:blank']
+    try:
+        # detached: it outlives this request and answers on its own screencast port. Output is
+        # dropped - the pane IS the output, and a full pipe would block the browser.
+        subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                         stdin=subprocess.DEVNULL, close_fds=True)
+    except (OSError, subprocess.SubprocessError) as e:
+        logger.warning(f'could not start the browser for {sid}: {e}')
+        return False
+    for _ in range(40):                                            # it has a Chrome to launch
+        time.sleep(0.25)
+        if state(sid, fresh=True)['open']: return True
+    logger.warning(f'the browser for {sid} did not come up within 10s')
+    return False
+
+
+def brief() -> str:
+    """What an agent with a browser of its own needs to know. Longer than hint() on purpose -
+    this only rides when the owner asked for a browser, so it can afford to say how to drive
+    it and where the line is."""
+    return ('A BROWSER IS OPEN for this task and the owner is WATCHING it beside your terminal. '
+            'Drive it with `agent-browser` - it is already bound to this session, so no --session '
+            'flag. Read `agent-browser skills get core --full` before your first command. '
+            'NEVER type a password, a 2FA code or a card number: navigate to the page that asks '
+            'and tell the owner here - they type it in the pane themselves.')
+
+
 def hint() -> str:
     """One line for the seed, only when the tool is installed: an agent has to be TOLD the browser
     exists and that the owner is watching it - and told that credentials are typed by the owner,

{taskuary-0.3.2 → taskuary-0.3.2.2}/taskuary/cli.py

@@ -43,7 +43,41 @@ def main():
                     help='triage dataset: build (labelled cases from your verdicts -> ~/.taskuary/eval), '
                          'evaluate (score the configured AI over them), ablate (score with and without memory), '
                          'share (anonymised copy for tests/data)')
+    # THE WALL (blackboard.py). An agent working in a terminal has a shell and no API token, so
+    # this is how it talks to the next agent: two flags, no arguments it has to be told - the
+    # session puts its own name, task and checkout in the environment.
+    ap.add_argument('--board', action='store_true',
+                    help='print the agent wall for this checkout - what the agents before you left here')
+    ap.add_argument('--all', action='store_true',
+                    help='with --board: the whole wall, including days already folded into a summary')
+    ap.add_argument('--note', metavar='TEXT',
+                    help='leave a line on the wall for the next agent (see --kind)')
+    ap.add_argument('--kind', default='note', metavar='KIND',
+                    help='working | note | blocked | ready | done - "ready" is how the next agent '
+                         'learns the tree is safe to build on')
     args = ap.parse_args()
+    if args.board or args.note:
+        import os, sys
+        from . import blackboard as bb
+        from .store import SQLiteStore, task_ref
+        try: sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        except (AttributeError, OSError): pass
+        store = SQLiteStore(config.db_path())
+        cwd = os.environ.get('TASKUARY_CWD') or os.getcwd()
+        who = os.environ.get('TASKUARY_AGENT') or 'agent'
+        tid = os.environ.get('TASKUARY_TASK')
+        if args.note:
+            try: n = bb.post(store, args.note, args.kind, who, cwd, int(tid) if str(tid).isdigit() else None)
+            except ValueError as e: print(f'not posted: {e}'); return
+            print(f"posted to the wall as {n['Agent']} [{n['Kind']}]")
+            return
+        rows = store.notes(bb.norm(cwd), 40 if args.all else 20, rolled=args.all)
+        print(f'the wall - {cwd}' if rows else f'the wall is empty for {cwd} - you are first')
+        if not args.all and rows: print('  (older days are folded into [summary] lines; --board --all for every note)')
+        for r in reversed(rows):
+            ref = f" {task_ref(r['TaskId'])}" if r.get('TaskId') else ''
+            print(f"  [{r['Kind']}] {r['Agent']}{ref} {bb._ago(r['CreatedAt'])}: {r['Body']}")
+        return
     if args.evalset:
         import sys
         from . import evalset

{taskuary-0.3.2 → taskuary-0.3.2.2}/taskuary/general.py

@@ -24,6 +24,7 @@ GENERAL_KINDS = {'general', 'research', 'marketing', 'triage', 'assistant'}
 SCROLLBACK = 200_000
 MAX_CONTEXT = 24_000
 MAX_REPLY_TOKENS = 2_000
+WAIT_TURN = 240.0        # how long a new question waits behind the one being answered
 REPORT_DRAFT_TOKENS = 1_200
 REPORT_SKILL_CHARS = 2_400
 _IMAGE_PATH = re.compile(r'(?P<path>(?:[A-Za-z]:\\|/)[^\r\n<>|"?*]+?\.(?:png|jpe?g|gif|webp))', re.I)
@@ -127,6 +128,23 @@ def _cut(text, n):
     return text if len(text) <= n else text[:n] + f'\n[trimmed {len(text) - n:,} characters]'
 
 
+# The chat is on the wall too (blackboard.py). It has no checkout, so it reads and writes the
+# HOUSE lane - the notes with no repository behind them - and it can only write when a CLI is
+# doing the thinking, because an API provider has no shell to run the command in.
+POST_LINE = ('You can leave a line for the other agents and the owner: run '
+             '`taskuary --note "..."` (add --kind working|note|blocked|ready|done) when you find '
+             'something worth their time. One line. Only when it is genuinely worth someone else '
+             'reading - a wall of chatter is a wall nobody reads.')
+
+
+def _turn_only(store, tid: int, text: str) -> str:
+    """What to say to a CLI that already HAS this conversation: the new turn, and nothing it
+    was told a minute ago. The system prompt still rides along - a resumed CLI keeps its
+    history, not our instructions."""
+    from .store import task_ref
+    return f'{task_ref(tid)} - the owner says:\n\n{_cut(text, 8_000)}'
+
+
 def _prompt(store, tid: int) -> tuple[str, str]:
     detail = store.task_detail(tid) or {}
     task = detail.get('task') or {}
@@ -154,8 +172,13 @@ def _prompt(store, tid: int) -> tuple[str, str]:
     for c in chat_rows(store, tid)[-30:]:
         role = 'ASSISTANT' if c.get('ActorType') == ASSISTANT_TYPE else 'USER'
         turns.append(f"{role}: {_cut(c.get('Body'), 4_000)}")
+    # the chat is an agent too, so it is on the wall - the HOUSE lane, the notes with no
+    # checkout behind them, which is where it and the owner leave things for everybody
+    from . import blackboard as bb
+    wall = bb.chat_text(store)
     user = (f"TASK {detail.get('ref') or tid}\nTITLE: {task.get('Title') or ''}\n"
             f"SUMMARY: {task.get('Summary') or ''}\nSTATUS: {task.get('Status') or ''}\n\n"
+            + (wall + '\n\n' if wall else '')
             + ("SOURCE MATERIAL\n" + '\n\n'.join(sources) + '\n\n' if sources else '')
             + "CONVERSATION\n" + '\n\n'.join(turns)
             + "\n\nRespond to the last USER turn. Do not repeat the task context.")
@@ -267,6 +290,8 @@ class GeneralSession:
         self.alive, self.busy = True, False
         self.rows, self.cols = 32, 110
         self._input, self._lock = '', threading.Lock()
+        self._cancel = None                  # the stop switch for the answer being written now
+        self.cli_sid = ''                    # the CLI's OWN conversation, resumed turn to turn
         from .witness import Witness
         self.witness = Witness()
         self._restore_terminal()
@@ -310,13 +335,31 @@ class GeneralSession:
         from .terminal import plain
         return [line for line in plain(self.scrollback()[-8000:]).splitlines() if line.strip()][-n:]
 
+    def _take(self, wait: float, cancel=None) -> bool:
+        """Wait our turn to speak.
+
+        THREE things can be answering in one session: this chat, the xterm composer over the
+        same conversation, and the waiting room delivering queued notes on its own thread.
+        Refusing the newcomer ("the assistant is already working") threw the question away -
+        and before a failed run said anything at all, that reached the owner as silence: the
+        third message in a conversation simply never got a reply (the wall, 2026-08-31).
+
+        A person asked a second question while you are mid-sentence expects to be answered
+        next, not ignored. So: queue. In slices, so a browser that gives up stops waiting too.
+        """
+        end = time.time() + max(0.0, wait)
+        while True:
+            if self._lock.acquire(timeout=0.25): return True
+            if cancel is not None and cancel.is_set(): return False
+            if time.time() >= end: return False
+
     def write(self, data):
         """Make xterm a second composer for the same conversation."""
         if not self.alive: return
         for ch in str(data or ''):
             if ch in ('\r', '\n'):
                 prompt, self._input = self._input.strip(), ''
-                if prompt and not self.busy:
+                if prompt:
                     self._emit('\r\n')
                     threading.Thread(target=self.send_prompt, args=(prompt,), kwargs={'echo': False}, daemon=True).start()
                 continue
@@ -334,9 +377,13 @@ class GeneralSession:
                     pick=None, trace=None, cancel=None) -> str:
         text = str(text or '').strip()
         if not text: raise ValueError('empty message')
-        if not self.alive: raise RuntimeError('assistant session has ended')
-        if not self._lock.acquire(blocking=False): raise RuntimeError('the assistant is already working')
+        if not self.alive: raise RuntimeError('this assistant session has ended - reload the page and ask again')
+        if not self._take(WAIT_TURN, cancel):
+            raise RuntimeError(f'the assistant has been answering the previous question for over '
+                               f'{int(WAIT_TURN)}s - something is stuck. Press stop, or reload the page.')
         self.busy, self.last = True, time.time()
+        self._cancel = cancel if cancel is not None else threading.Event()
+        cancel = self._cancel
         try:
             if connector_id is not None or model or pick:
                 self.pick, self.provider, self.model = _selected(self.store, connector_id, model, pick)
@@ -345,6 +392,9 @@ class GeneralSession:
             if echo: self._emit(f'\x1b[1;34myou>\x1b[0m {text}\r\n')
             self.store.add_comment(self.task_id, 'owner', USER_TYPE, text)
             system, user = _prompt(self.store, self.task_id)
+            # only a CLI-backed chat can post to the wall: an API provider has no shell to
+            # run the command in, and telling it about a command it cannot run is a lie
+            if self.pick.startswith('cli:'): system = f'{system}\n\n{POST_LINE}'
             paths = list(attachments or []) + [m.group('path') for m in _IMAGE_PATH.finditer(text)]
             if paths and self.pick.startswith('cli:'):
                 user += '\n\nATTACHED FILES (read these when relevant)\n' + '\n'.join(str(Path(p).resolve()) for p in paths)
@@ -355,10 +405,28 @@ class GeneralSession:
                     self._emit(f'\x1b[33mtool>\x1b[0m {name} {str(target)[:180]}\r\n')
                 elif kind == 'tool_result' and isinstance(detail, dict) and detail.get('is_error'):
                     self._emit(f'\x1b[31mtool error>\x1b[0m {str(detail.get("result") or "")[:240]}\r\n')
+            # Continue the CLI's own conversation rather than starting a new one and re-typing
+            # the transcript into it. Every turn used to be a fresh `claude -p` carrying the
+            # whole chat again - slower, dearer, and silently forgetful once the conversation
+            # outgrew MAX_CONTEXT. Resumed, the CLI still has what it read and did last turn,
+            # so the turn itself is all that has to be said.
             brain = llm_mod.build_llm(self.store, pick=self.pick, model=self.model or None,
-                                      trace=visible, cancel=cancel)
+                                      trace=visible, cancel=cancel, resume=self.cli_sid or None)
             if not brain: raise RuntimeError('the selected AI connector is unavailable')
-            reply = str(brain(system, user, max_tokens=MAX_REPLY_TOKENS, images=_images(paths)) or '').strip()
+            if self.cli_sid: user = _turn_only(self.store, self.task_id, text)
+            try:
+                reply = str(brain(system, user, max_tokens=MAX_REPLY_TOKENS, images=_images(paths)) or '').strip()
+            except Exception:
+                # the CLI could not pick that conversation back up (it was restarted, its history
+                # was cleared, the id aged out). Start a fresh one and say the whole thing, once.
+                if not self.cli_sid or (cancel is not None and cancel.is_set()): raise
+                logger.info(f'assistant could not resume {self.cli_sid} on task {self.task_id}; starting a new one')
+                self.cli_sid = ''
+                system, user = _prompt(self.store, self.task_id)
+                brain = llm_mod.build_llm(self.store, pick=self.pick, model=self.model or None,
+                                          trace=visible, cancel=cancel)
+                reply = str(brain(system, user, max_tokens=MAX_REPLY_TOKENS, images=_images(paths)) or '').strip()
+            self.cli_sid = getattr(brain, 'session_id', '') or self.cli_sid
             if not reply: raise RuntimeError('the model returned an empty response')
             self.store.add_comment(self.task_id, 'assistant', ASSISTANT_TYPE, reply)
             self.store.audit('task', self.task_id, 'assistant_reply', 'assistant', 'agent',
@@ -370,9 +438,23 @@ class GeneralSession:
             raise
         finally:
             self.busy, self.last = False, time.time()
+            self._cancel = None
             self._emit('\x1b[1;34myou>\x1b[0m ')
             self._lock.release()
 
+    def stop(self) -> bool:
+        """Stop the answer being written now - the STOP BUTTON, and nothing else.
+
+        Closing the browser stream used to do this, which meant leaving the Board tab, hitting
+        refresh, or any remount killed an answer that was seconds from finishing - and the reply
+        was never written, so it looked as though the assistant had ignored the question (the
+        owner, 2026-08-31). Walking away is not stopping: the run finishes on its own thread and
+        the reply is filed on the task, where the chat picks it up when you come back."""
+        c = self._cancel
+        if c is None: return False
+        c.set()
+        return True
+
     def close(self):
         self.alive, self.ended = False, time.time()
         self._emit('\r\n\x1b[2msession closed\x1b[0m\r\n')
@@ -399,6 +481,17 @@ def session_for(tid: int):
                  if s.task_id == tid and s.alive and getattr(s, 'mode', '') == 'assistant'), None)
 
 
+def drop_session(tid: int) -> int:
+    """Forget every finished session on this task. A session that has ENDED is not a session:
+    left in the registry it kept the task occupied, and the next question was refused with
+    "this task already has a different live session"."""
+    from . import terminal
+    gone = [sid for sid, t in list(terminal.SESSIONS.items())
+            if getattr(t, 'task_id', None) == tid and not t.alive]
+    for sid in gone: terminal.SESSIONS.pop(sid, None)
+    return len(gone)
+
+
 def start_session(store, tid: int, connector_id=None, model=None, actor='owner', pick=None) -> GeneralSession:
     from . import terminal
     task = store.get_task(tid)
@@ -409,8 +502,13 @@ def start_session(store, tid: int, connector_id=None, model=None, actor='owner',
         if connector_id is not None or model or pick:
             existing.pick, existing.provider, existing.model = _selected(store, connector_id, model, pick)
         return existing
+    # A session that has ENDED is not a session. It used to sit in the registry keeping the task
+    # occupied, so the next question got "this task already has a different live session" and,
+    # because a failed run said nothing at all, looked like the assistant ignoring you.
+    drop_session(tid)
     other = next((s for s in list(terminal.SESSIONS.values()) if s.task_id == tid and s.alive), None)
-    if other: raise ValueError('this task already has a different live session')
+    if other: raise ValueError(f'this task already has a live {getattr(other, "agent", "") or "terminal"} '
+                               'session - close it (the ✕ on its pane) and ask again here')
     session = GeneralSession(store, tid, connector_id, model, pick)
     terminal.SESSIONS[session.sid] = session
     if task.get('Status') == 'open': store.update_task(tid, {'Status': 'in_progress'}, actor)