taskuary 0.3.2.1__tar.gz → 0.3.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskuary
-Version: 0.3.2.1
+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.1**—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.1 → 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.1**—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.1 → taskuary-0.3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "taskuary"
-version = "0.3.2.1"
+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.1 → 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,17 +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':
-        import ntpath              # a Windows path, split as one wherever this test runs
+    if (os.name == 'nt') if windows is None else windows:
         env.setdefault('USERPROFILE', home)
-        drive, tail = ntpath.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.1 → taskuary-0.3.2.2}/taskuary/blackboard.py

@@ -74,6 +74,9 @@ def peers(store, cwd, exclude_tid=None) -> list:
 # 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'}
@@ -86,7 +89,7 @@ def post(store, body: str, kind: str = 'note', agent: str = '', cwd: str = '', t
     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: raise ValueError(f"kind must be one of {', '.join(KINDS)}")
+    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))
@@ -96,6 +99,92 @@ 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
@@ -122,9 +211,13 @@ def wall_text(store, cwd: str, limit: int = 8) -> str:
     rows = wall(store, cwd, limit)
     if not rows: return ''
     top = rows[0]
-    return (f'THE WALL: {len(rows)} note(s) the agents before you left on this checkout - read them '
+    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:

{taskuary-0.3.2.1 → 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.1 → taskuary-0.3.2.2}/taskuary/cli.py

@@ -48,6 +48,8 @@ def main():
     # 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',
@@ -69,8 +71,9 @@ def main():
             except ValueError as e: print(f'not posted: {e}'); return
             print(f"posted to the wall as {n['Agent']} [{n['Kind']}]")
             return
-        rows = bb.wall(store, cwd, 20)
+        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']}")

{taskuary-0.3.2.1 → 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)

{taskuary-0.3.2.1 → taskuary-0.3.2.2}/taskuary/llm.py

@@ -50,7 +50,7 @@ def readable_images(store, message_ids, cap: int = VISION_MAX) -> list:
 MAX_TOKENS = 400
 
 
-def make_cli_llm(store, agent_name: str, model: str = None, cwd: str = None, trace=None, cancel=None):
+def make_cli_llm(store, agent_name: str, model: str = None, cwd: str = None, trace=None, cancel=None, resume=None):
     """A CLI agent as the classifier: prompt in on stdin, JSON out. The repo working dir
     is dropped - triage is about the message, not about any checkout.
 
@@ -82,17 +82,21 @@ def make_cli_llm(store, agent_name: str, model: str = None, cwd: str = None, tra
         disk itself, and the prompt already names their paths."""
         from .agents import run_cli
         kwargs = {'cancel': cancel} if cancel is not None else {}
-        out, _sid, _diff = run_cli(prof, f'{system}\n\n{user}', trace or (lambda *a: None), **kwargs)
+        out, sid, _diff = run_cli(prof, f'{system}\n\n{user}', trace or (lambda *a: None),
+                                  resume=resume, **kwargs)
+        # what the caller needs to CONTINUE this conversation instead of starting another one
+        llm.session_id = sid or resume
         return out
+    llm.session_id = resume
     return llm
 
 
-def build_llm(store, pick=None, model=None, trace=None, cancel=None):
+def build_llm(store, pick=None, model=None, trace=None, cancel=None, resume=None):
     """The brain named by `pick` ('' = first active AI connector, 'connector:<id>',
     'cli:<agent>'), defaulting to the triage_ai setting - callers like reports may name
     their OWN brain and model per job instead of riding the triage tier."""
     pick = (pick if pick is not None else store.get_settings().get('triage_ai') or '').strip()
-    if pick.startswith('cli:'): return make_cli_llm(store, pick[4:], model, trace=trace, cancel=cancel)
+    if pick.startswith('cli:'): return make_cli_llm(store, pick[4:], model, trace=trace, cancel=cancel, resume=resume)
     want = pick[10:] if pick.startswith('connector:') else None
     want_id = int(want) if want and want.isdigit() else None
     for c in store.list_connectors():

{taskuary-0.3.2.1 → taskuary-0.3.2.2}/taskuary/server.py

@@ -257,6 +257,14 @@ def assistant_message(task_id: int, body: AssistantMessageBody):
     except (ValueError, RuntimeError) as e: raise HTTPException(422, str(e))
     return {'reply': reply, **_assistant_payload(task_id, session)}
 
+@app.post('/api/tasks/{task_id}/assistant/cancel')
+def assistant_cancel(task_id: int):
+    """The stop button. The ONLY thing that stops an answer being written - walking away does
+    not (see the stream's docstring)."""
+    from . import general
+    session = general.session_for(task_id)
+    return {'stopped': bool(session and session.stop())}
+
 @app.post('/api/tasks/{task_id}/assistant/report')
 def assistant_create_report(task_id: int, body: AssistantSessionBody = None):
     """One click: summarize the discussion and create a native daily agent report.
@@ -308,14 +316,23 @@ async def assistant_stream(task_id: int, body: AssistantMessageBody):
     """NDJSON work stream for assistant-ui: the configured CLI's real tool/text events.
 
     The CLI stays on a worker thread (its subprocess pipes are blocking); events cross onto the
-    request loop through a queue. Closing the browser stream sets ``cancel`` and kills the CLI.
+    request loop through a queue.
+
+    Closing the browser stream DETACHES; it does not kill. It used to: leaving the Board tab,
+    pressing refresh, or any remount of the pane ended the response - and since the reply is
+    only filed once the run finishes, an answer that was seconds away was lost and the chat
+    looked as though it had ignored the question. Stopping is now an explicit act
+    (/assistant/cancel, the stop button), and a run nobody is watching still finishes and still
+    files its reply on the task.
     """
     from . import general
     loop, events, cancel = asyncio.get_running_loop(), asyncio.Queue(), threading.Event()
 
     def put(event):
+        # the reader is gone: drop the event and keep working. The answer is filed on the task
+        # either way, which is what the chat reads when it comes back.
         try: loop.call_soon_threadsafe(events.put_nowait, event)
-        except RuntimeError: cancel.set()
+        except RuntimeError: pass
 
     def trace(kind, name, detail):
         put({'type': kind, 'name': name, 'detail': detail})
@@ -324,13 +341,26 @@ async def assistant_stream(task_id: int, body: AssistantMessageBody):
         try:
             session = general.start_session(store, task_id, body.connector_id, body.model, ACTOR, body.pick)
             put({'type': 'start', 'session': session.info()})
-            reply = session.send_prompt(body.text, body.attachments, body.connector_id, body.model,
-                                        pick=body.pick, trace=trace, cancel=cancel)
+            try:
+                reply = session.send_prompt(body.text, body.attachments, body.connector_id, body.model,
+                                            pick=body.pick, trace=trace, cancel=cancel)
+            except RuntimeError as e:
+                # it ended between being handed over and being spoken to (the owner closed the
+                # pane, a wrap-up ran). A question is not lost over a race: start a fresh one
+                # and ask it there, once.
+                if 'has ended' not in str(e) or cancel.is_set(): raise
+                general.drop_session(task_id)
+                session = general.start_session(store, task_id, body.connector_id, body.model, ACTOR, body.pick)
+                reply = session.send_prompt(body.text, body.attachments, body.connector_id, body.model,
+                                            pick=body.pick, trace=trace, cancel=cancel)
             put({'type': 'done', 'reply': reply, 'payload': _assistant_payload(task_id, session)})
         # Once headers are streaming, FastAPI cannot replace this with its normal JSON error
         # response. Always terminate the NDJSON stream explicitly instead of leaving the UI's
         # spinner alive forever (missing CLI, provider/network errors, and bugs all land here).
         except Exception as e:
+            # the browser shows this under the question now; the log is for the run nobody was
+            # watching, and for the owner who can only report that nothing happened
+            logger.warning(f'assistant stream for task {task_id} failed: {e}')
             put({'type': 'error', 'error': str(e)})
 
     threading.Thread(target=work, daemon=True).start()
@@ -342,7 +372,8 @@ async def assistant_stream(task_id: int, body: AssistantMessageBody):
                 yield json.dumps(event, default=str) + '\n'
                 if event.get('type') in ('done', 'error'): break
         finally:
-            cancel.set()
+            # NOT cancel.set(): see the docstring. A browser that walked away is not a stop.
+            if not cancel.is_set(): logger.debug(f'assistant stream for task {task_id} detached; the run continues')
 
     return StreamingResponse(generate(), media_type='application/x-ndjson',
                              headers={'Cache-Control': 'no-cache, no-transform'})
@@ -954,9 +985,11 @@ class NoteBody(BaseModel):
     cwd: str | None = None; task_id: int | None = None; files: str | None = None
 
 @app.get('/api/board/notes')
-def board_notes(cwd: str = '', limit: int = 60):
-    """Everything by default - the Board is one wall - or one checkout's own when cwd is given."""
-    return {'data': blackboard.wall(store, cwd, limit), 'kinds': list(blackboard.KINDS)}
+def board_notes(cwd: str = '', limit: int = 60, all: bool = False):
+    """Everything by default - the Board is one wall - or one checkout's own when cwd is given.
+    `all` includes the notes a daily roll-up has already composted into a summary."""
+    return {'data': store.notes(blackboard.norm(cwd) or None, limit, rolled=all),
+            'kinds': list(blackboard.KINDS), 'summary_kind': blackboard.SUMMARY}
 
 @app.post('/api/board/notes')
 def board_post(body: NoteBody):
@@ -2238,6 +2271,12 @@ def _poll_reports(backfill_days: int = 0, what: str = 'syncing', startup: bool =
             ci.poll(store)
         except Exception as e:
             logger.warning(f'CI poll failed: {e}')
+        # the agent wall composts once a day: yesterday's notes become one summary per checkout,
+        # so what an agent reads tomorrow is what still matters (blackboard.roll_up)
+        try:
+            blackboard.roll_daily(store)
+        except Exception as e:
+            logger.warning(f'the wall roll-up failed: {e}')
         run_due_reports(store, startup)          # ...the seeded 'Assistant' report among them (assistant.py)
     finally:
         try: store.set_setting('ingest_status', json.dumps({'state': 'idle'}), 'system')