taskuary 0.3.2.3__tar.gz → 0.3.2.4__tar.gz

{taskuary-0.3.2.3/taskuary.egg-info → taskuary-0.3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskuary
-Version: 0.3.2.3
+Version: 0.3.2.4
 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.3**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.4**—and moving fast. The funnel, review queue,
 agent sessions, and reports pipeline are in daily use; breaking changes are still possible
 before 1.0.
 
@@ -158,7 +158,9 @@ taskuary --demo                    # or: docker compose --profile demo up
 
 A full Taskuary over invented work — a morning's mail and chats already triaged with the
 reasons attached, drafts waiting in Review, agents on the board with their transcripts
-playing, the wall they leave each other notes on. The AI answers from a script and every door
+playing, live task handoffs on the Board, and the durable agent-written handbook in Social.
+Every Social entry names the agent and originating task; Board handoffs are short-lived
+checkout coordination that rolls up nightly. The AI answers from a script and every door
 to the outside world is shut at the API layer (`taskuary/demo.py`): nothing sends, no
 connection can be made or edited, no tool runs, and no CLI starts. Nobody's real data is in
 it — Dana Whitfield and Northwind Facilities are invented.

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/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.3**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.4**—and moving fast. The funnel, review queue,
 agent sessions, and reports pipeline are in daily use; breaking changes are still possible
 before 1.0.
 
@@ -107,7 +107,9 @@ taskuary --demo                    # or: docker compose --profile demo up
 
 A full Taskuary over invented work — a morning's mail and chats already triaged with the
 reasons attached, drafts waiting in Review, agents on the board with their transcripts
-playing, the wall they leave each other notes on. The AI answers from a script and every door
+playing, live task handoffs on the Board, and the durable agent-written handbook in Social.
+Every Social entry names the agent and originating task; Board handoffs are short-lived
+checkout coordination that rolls up nightly. The AI answers from a script and every door
 to the outside world is shut at the API layer (`taskuary/demo.py`): nothing sends, no
 connection can be made or edited, no tool runs, and no CLI starts. Nobody's real data is in
 it — Dana Whitfield and Northwind Facilities are invented.

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "taskuary"
-version = "0.3.2.3"
+version = "0.3.2.4"
 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.3 → taskuary-0.3.2.4}/taskuary/aisetup.py

@@ -87,7 +87,7 @@ def start(store, server: dict, cid: int, guide: list, fields: list = None, secre
     if live: return {**live, 'existing': True}
     from . import agents as hub_agents
     agent = (agent or hub_agents.default_agent(store)).strip()
-    if not store.get_agent(agent): raise ValueError(f'no CLI agent named {agent!r} - add one under Connectors > AI CLI agents first')
+    if not store.get_agent(agent): raise ValueError(f'no CLI agent named {agent!r} - add one under Connections > AI CLI agents first')
     tid = store.create_task({'Title': f"Set up {c.get('Name') or c.get('Type')}", 'Kind': KIND, 'Status': 'in_progress', 'Tags': tag(cid),
                              'Summary': f"{agent} walks the owner through the {c.get('Type')} guide in a live session on the card and saves what they give it."}, actor)
     # no repo: the session sits in Taskuary's own data folder, where there is no checkout to attribute dirt to

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/assistant.py

@@ -301,6 +301,10 @@ CONTRACT = ('\n\nYou are writing your POST on the owner\'s Timeline - the short
             'CALENDAR, what arrived (with each report\'s schedule and each failure\'s cause), what got done, what is open, and WHAT '
             'YOU ALREADY SAID. Answer JSON only: {"say": [{"key": "<a candidate key, or idea:<short-slug> for a thought of your own>", '
             '"text": "<one line, under 30 words, first person: the fact and what I would do - quote the phrase or name the cause when there is one>", '
+            '"section": "<people|loose|ideas|systems - which part of the post this belongs under: people = what somebody said '
+            'or asked, loose = something waiting on somebody (a chase, a promise, work gone quiet), systems = a threshold, a '
+            'failure or a number out of a connected system, ideas = your own thought. A candidate the hub found has a section '
+            'already and yours is ignored for those; this is for idea:* lines>", '
             '"why": "<one line: what this rests on - the mail, the date, the silence, the pattern - named as it appears in what you '
             'were given (sender, subject, mid, TQ-ref), so the owner can check it>", "mid": <the message id it is '
             'about, or null>, "task": "<idea:* only - a task title the owner could accept as-is, or null>"}], '
@@ -495,6 +499,9 @@ def parse(text: str, cands: list, max_lines: int = MAX_LINES) -> list:
             mid = s.get('mid') if isinstance(s.get('mid'), int) else None
             title = _short(s.get('task'), 120) or None
             act = {'type': 'task', 'mid': mid, 'title': title} if title and mid else {'type': 'message', 'mid': mid} if mid else {'type': 'note'}
+            # where in the post it goes. Only an idea gets to choose: a candidate the hub found is
+            # placed by the producer that found it, and no model answer overrides that.
+            act['section'] = section_of({'section': s.get('section'), 'kind': 'idea'})
             out.append({'key': key[:120], 'kind': 'idea', 'sig': txt[:60], 'text': txt, 'action': act,
                         'why': why or 'the model gave no reason - treat it as a hunch' + (f' (about mid {mid})' if mid else '')})
         else: continue
@@ -575,6 +582,43 @@ def system_checks(store, source_ids=None, inline=None) -> str:
     return '\n\n'.join(blocks)
 
 
+def _verdicts_block(store, cands: list, source: str = "") -> str:
+    """The owner's standing verdicts - the SAME memory triage reads before it classifies
+    (ingest.relevant_notes / applicable_notes).
+
+    The assistant was the one brain in this app that never saw them. So "resident refunds are not
+    our problem" stayed true for triage - which quietly files them - and was news to the brief,
+    which went on raising the next refund thread as an idea worth acting on. A verdict the owner
+    gives once should not have to be given again per surface.
+
+    Scoped by the words of the material this check is READING, so a note about a topic nothing
+    today touches costs nothing; global notes always apply.
+
+    `source` is what the model was handed - the threads and the sender/subject lines - and it
+    matters more here than the candidates do. A subject-scoped verdict is matched (ingest.topic_hit)
+    against the words it was learned from, "resident refund request approved"; a candidate's
+    `facts` is the MODEL'S PARAPHRASE of a thread, and "Barnes and Watson stall the same way"
+    carries not one of those four words. So the ruling missed and the brief went on raising a
+    subject the owner had closed. Match the source it summarised, not the summary."""
+    from .ingest import relevant_notes
+    text = ' '.join([source or '', *(str(c.get('facts') or c.get('text') or '') for c in cands)])[:8000]
+    if not text.strip():
+        return ''
+    try:
+        emails = sorted({(r.get('FromEmail') or '').lower()
+                         for r in store.recent_messages(_since(2), limit=500) if r.get('FromEmail')})
+        notes_, left = relevant_notes(store, emails, text)
+    except Exception as e:
+        logger.debug(f'assistant: standing verdicts skipped - {e}')
+        return ''
+    if not notes_:
+        return ''
+    more = f' ({left} more matched and were left out)' if left else ''
+    return ('\n\nWHAT THE OWNER HAS ALREADY DECIDED - their standing verdicts, the same ones triage '
+            f'reads before it files anything{more}. Never raise something they have ruled out, and '
+            'never argue with one:\n' + '\n'.join(f'- {n}' for n in notes_))
+
+
 def inputs(store, cands: list, head: str = 'CANDIDATES', watch_source_ids=None, watch_sources=None) -> str:
     """Everything one check reads, as the model sees it - the same text is the Reports tab's Preview
     (facts) and the run record (reports.run_report_source), so what it was given is never a guess."""
@@ -582,15 +626,20 @@ def inputs(store, cands: list, head: str = 'CANDIDATES', watch_source_ids=None,
     away = ooo(store)
     from . import knowledge
     facts_text = ' '.join(str(c.get('facts') or '') for c in cands)[:4000]
+    # built once: the model reads them, and so does the verdict matcher, which needs the real
+    # subjects rather than the model's words about them
+    said, recent = _people(store), _recent(store)
     return (f"NOW: {now.strftime('%A %d %B %Y %H:%M')}\n\n{head}:\n" + ('\n'.join(f"[{c['key']}] {c['facts']}" for c in cands) or '(none)')
             + knowledge.block(store, facts_text)
             + f"\n\nCONFIGURED SYSTEM CHECKS (pulled live for this check; failures are also worth noticing):\n{system_checks(store, watch_source_ids, watch_sources)}"
-            + f"\n\nWHAT PEOPLE SAID (the last two days, by thread, newest first; the last lines of each, oldest first):\n{_people(store)}"
+            + f"\n\nWHAT PEOPLE SAID (the last two days, by thread, newest first; the last lines of each, oldest first):\n{said}"
             + '\n\nOUT OF OFFICE (from their auto-replies):\n' + ('\n'.join(f'- {k}: {v}' for k, v in away.items()) or '(nobody)')
             + f"\n\nCALENDAR (the next two days):\n{_calendar(store)}"
-            + f"\n\nARRIVED IN THE LAST TWO DAYS (xN = that many alike; each line carries the latest message's words, a report's schedule, and a failure's cause):\n{_recent(store)}"
+            + f"\n\nARRIVED IN THE LAST TWO DAYS (xN = that many alike; each line carries the latest message's words, a report's schedule, and a failure's cause):\n{recent}"
             + f"\n\nDONE THIS WEEK (my own work, with the agent's summary):\n{_week(store)}"
-            + f"\n\nOPEN WORK:\n{_open(store)}\n\nALREADY SAID (never repeat):\n{_said(store)}\n\n{_notes_block(store)}")
+            + f"\n\nOPEN WORK:\n{_open(store)}\n\nALREADY SAID (never repeat):\n{_said(store)}"
+            + _verdicts_block(store, cands, f'{said}\n{recent}')
+            + f"\n\n{_notes_block(store)}")
 
 
 def think(store, cands: list, llm, instruction: str = None, max_lines: int = MAX_LINES) -> list:
@@ -633,10 +682,81 @@ def _notes(text: str) -> str:
 
 
 # ── the post ─────────────────────────────────────────────────────────────────────────────────
+# ── the post's shape ────────────────────────────────────────────────────────────────────
+# A flat list of lines is what the post used to be, and the owner (2026-09-01): "it should
+# summarize into sections... summary of what the info emails said to you, then open tasks and
+# what they are working on, then things you forgot to follow up from last week, then some stats".
+# The lines themselves stay exactly as they were - each one still carries its own buttons and its
+# own state, which is the whole value of them - they are just SORTED into sections that say what
+# kind of thing you are looking at.
+#
+# Two of the sections are not the model's work at all. What is in flight and what the day counted
+# are FACTS the hub already holds, and asking a model to restate them is how a brief starts
+# inventing a task that is not there (the digest did exactly that: TQ-0032 "pending review" when
+# nothing was pending). So they are computed here and the model never sees them as its own output.
+SECTIONS = (
+    ('people',  '📥', 'What people said',  'the ask in a thread, the thing somebody told you, the answer nobody picked up'),
+    ('flight',  '🚀', 'In flight',         'what an agent has, what closed, what has gone quiet'),
+    ('loose',   '🧵', 'Loose ends',        'what you are waiting on, what you promised, what went cold'),
+    ('ideas',   '💡', 'Worth a thought',   'the connection nobody made, the thing to do now so the next ask never comes'),
+    ('systems', '🛠️', 'From the systems',  'a threshold crossed, a job failing the same way twice, a number that moved'),
+)
+SECTION_KEYS = tuple(s[0] for s in SECTIONS)
+# where a candidate lands when the model does not say (and it never says for hub-found ones)
+KIND_SECTION = {'followup': 'loose', 'promise': 'loose', 'cold': 'loose', 'prep': 'people', 'idea': 'ideas'}
+
+
+def section_of(line: dict) -> str:
+    """Which section one line belongs in. The model's own choice wins for its ideas; a candidate
+    the hub found is placed by its kind, which is the thing that produced it."""
+    s = str(line.get('section') or '').strip().lower()
+    if s in SECTION_KEYS: return s
+    return KIND_SECTION.get(str(line.get('kind') or ''), 'ideas')
+
+
+def in_flight(store) -> list:
+    """What is being worked, straight off the tasks - never the model's recollection of it.
+    [{ref, tid, title, state}] newest activity first, the ones an agent has at the top."""
+    from . import terminal as term
+    live = {}
+    try: live = {t['taskId']: (t.get('agent') or t.get('label') or 'an agent') for t in term.live_sessions(tail=0) if t.get('taskId')}
+    except Exception: pass
+    out = []
+    for t in store.list_tasks(active_only=True):
+        if t.get('Status') not in ('open', 'in_progress', 'waiting'): continue
+        tid = t['TaskId']
+        agent = live.get(tid) or (t.get('RunAgent') if t.get('RunStatus') == 'running' else None)
+        last = _dt(store.task_last_activity(tid) or t.get('UpdatedAt') or t.get('CreatedAt'))
+        quiet_h = int((datetime.now() - last).total_seconds() // 3600) if last else None
+        state = (f'{agent} has it' if agent
+                 else 'a reply is drafted and waiting on you' if t.get('ReviewStatus') == 'pending'
+                 else f'quiet for {quiet_h}h' if quiet_h and quiet_h >= 24
+                 else 'nobody is on it')
+        out.append({'tid': tid, 'ref': task_ref(tid), 'title': _short(t.get('Title'), 90),
+                    'kind': t.get('Kind') or '', 'agent': agent or '', 'state': state,
+                    'hot': bool(agent) or t.get('ReviewStatus') == 'pending'})
+    out.sort(key=lambda r: (not r['hot'],))
+    return out[:8]
+
+
+def day_stats(store) -> list:
+    """The few numbers that mean something, counted - not asked for. [{n, label}]."""
+    from .categories import category_of, team_domains_of
+    team = team_domains_of(store.get_settings())
+    rows = store.feed(400, 1)
+    cats = [category_of(r, team) for r in rows]
+    tasks = [t for t in store.list_tasks(active_only=True) if t.get('Status') in ('open', 'in_progress', 'waiting')]
+    return [{'n': len(rows), 'label': 'arrived today'},
+            {'n': sum(1 for c in cats if c in ('info', 'automated', 'promo', 'feed', 'report')), 'label': 'wanted nothing'},
+            {'n': len(tasks), 'label': 'open'},
+            {'n': sum(1 for t in tasks if t.get('ReviewStatus') == 'pending'), 'label': 'waiting on you', 'hot': True}]
+
+
 def _public(i: dict) -> dict:
     try: a = json.loads(i.get('ActionJson') or '{}')
     except ValueError: a = {}
-    return {'id': i['IdeaId'], 'key': i['Key'], 'kind': i['Kind'], 'text': i['Text'], 'why': a.pop('why', ''), 'action': a, 'status': i.get('Status')}
+    return {'id': i['IdeaId'], 'key': i['Key'], 'kind': i['Kind'], 'text': i['Text'], 'why': a.pop('why', ''), 'action': a, 'status': i.get('Status'),
+            'section': section_of({'section': a.get('section'), 'kind': i['Kind']})}
 
 
 def talk(store, idea_id: int, text: str, actor: str = 'owner', llm=None) -> dict:
@@ -791,7 +911,11 @@ def _run(store, llm, instruction) -> dict:
                              'BodyText': body, 'Status': 'feed'})
     store.add_route(mid, None, 'feed', None, "the assistant's post: what it noticed and what it would do - open it to talk back or act",
                     [], 'assistant')
-    store.set_brief(mid, json.dumps({'ideas': [_public(i) for i in rows], 'reviewed': rv}))
+    # the two blocks the model does not write. What is in flight and what the day counted are facts
+    # the hub already holds; asking a model to restate them is how a brief starts describing work
+    # that is not there. Snapshotted onto the post so it still reads correctly tomorrow.
+    store.set_brief(mid, json.dumps({'ideas': [_public(i) for i in rows], 'reviewed': rv,
+                                     'flight': in_flight(store), 'stats': day_stats(store)}))
     store.set_ideas_message([i['IdeaId'] for i in rows], mid)
     store.audit('message', mid, 'assistant_post', 'assistant', 'agent', {'ideas': len(rows)})
     logger.info(f'assistant: posted {len(rows)} idea(s) as message {mid}')

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/categories.py

@@ -8,8 +8,9 @@ means the same thing in the feed, the digest and the task page:
   review    - a reply is drafted for you to send  info   - a PERSON told you something; nothing to do
   automated - a system told you something          promo  - marketing / newsletter; safe to skim past
   filed     - kept, no verdict beyond "not work"   ignored - a policy or you said no
-  report / feed / yours / triaging                - not verdicts: a scheduled report, a feed-only
-                                                    connection, your own reply, or still deciding
+  report / feed / yours / mine / triaging         - not verdicts: a scheduled report, a feed-only
+                                                    connection, your own reply, a note you left
+                                                    yourself, or still deciding
 
 The info / automated / promo split is the point (owner, 2026-08-27): "info from a team member
 is more important than an FYI from a vendor's marketing team". Both are 'fyi' to the
@@ -55,6 +56,10 @@ def category_of(r: dict, team_domains=()) -> str:
     st, reason = r.get('MsgStatus') or r.get('Status') or '', (r.get('RouteReason') or '').lower()
     if r.get('Channel') == 'report': return 'report'
     if r.get('Channel') == 'assistant': return 'assistant'         # the assistant's own post (assistant.py)
+    # a row nothing sent you: a note you left yourself, or a task you started from the Board
+    # (ownwork.py). It is the one kind of row that is yours rather than something that happened
+    # to you, and it must never wear a verdict - nothing judged it, because nothing arrived.
+    if r.get('Channel') == 'own': return 'mine' if (r.get('TaskKind') or '') == 'note' else 'todo'
     if r.get('Direction') == 'out' or 'your reply' in reason or 'your sent reply' in reason: return 'yours'
     if st == 'feed': return 'feed'
     if st == 'triaging': return 'triaging'

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/channels.py

@@ -1,4 +1,4 @@
-"""Channel connectors - the cards on the Connectors tab: Outlook mail + Microsoft Teams
+"""Channel connectors - the cards on the Connections tab: Outlook mail + Microsoft Teams
 (Graph, app-only client credentials) and GitHub (fine-grained PAT). test_connector is a
 live probe (token/chat-read/repo-discovery); poll_channels is the scheduled ingest that
 funnels mail and chats through the same triage as everything else. Credentials left blank
@@ -568,7 +568,15 @@ def ingest_teams_chats(store, upn: str, tok: str, since, llm=None, file_only=Fal
     for m in reversed(_teams_delta(tok, upn, since_iso)):          # oldest first, so threads read in order
         user = (m.get('from') or {}).get('user') or {}
         body = _clean((m.get('body') or {}).get('content'))
-        if m.get('messageType') != 'message' or m.get('deletedDateTime') or not user.get('id') or not body: continue
+        # Deleted at the source. Teams' delta reports it (mail's plain $top list does not, so
+        # the mailbox side of this needs a delta migration before it can say the same). If we
+        # already carry the row, say so on it rather than leaving a message on the Timeline that
+        # no longer exists in the chat - and never remove it: work may hang off it.
+        if m.get('deletedDateTime'):
+            cid_d = m.get('chatId') or ''
+            if cid_d: store.withdraw_message(f'teams:{cid_d}:{m["id"]}')
+            continue
+        if m.get('messageType') != 'message' or not user.get('id') or not body: continue
         cid = m.get('chatId') or ''
         topic, kind = _chat_meta(tok, cid, chats) if cid else ('', 'chat')
         name, addr = _graph_user(tok, user['id'], users)
@@ -655,7 +663,7 @@ def gh_modes(src: dict, file_only: bool) -> tuple:
 # GitHub's own author_association. Everyone else's items still become tasks (in 'tasks' mode)
 # and wait for the owner to promote them. Default off: a public repo would otherwise start an
 # agent per drive-by PR (the session cap still holds, but a queue full of strangers is not
-# what the cap is for). The Connectors card warns before switching a PUBLIC repo on.
+# what the cap is for). The Connections card warns before switching a PUBLIC repo on.
 GH_TEAM = ('OWNER', 'MEMBER', 'COLLABORATOR')
 GH_AUTO = {'off': (), 'team': GH_TEAM, 'contributors': GH_TEAM + ('CONTRIBUTOR',), 'anyone': None}
 

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/ci.py

@@ -24,7 +24,7 @@ TOKEN_URL = re.compile(r'https://[^@/]*@')     # never let a PAT reach a log lin
 
 def _conn(store):
     c = store.get_connector_by_type('github', with_secret=True)
-    if not (c and c.get('Secret')): raise RuntimeError('no GitHub PAT saved (Connectors → GitHub)')
+    if not (c and c.get('Secret')): raise RuntimeError('no GitHub PAT saved (Connections → GitHub)')
     return c
 
 

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/cli.py

@@ -60,6 +60,27 @@ def main():
     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')
+    # ...and how a session ENDS itself. The Done button was the only way a finished task ever
+    # produced its report and its reply, so an agent that finished at 2am and a person who never
+    # opened the tab left the sender with nothing (selfclose.py).
+    # THE HANDBOOK (handbook.py). The wall is what the next hour needs; this is what next month
+    # needs - and it is the difference between a company whose know-how lives in its people and
+    # one a new agent can be plugged into.
+    ap.add_argument('--learned', metavar='TEXT',
+                    help='write one line into the company handbook: something still true next month '
+                         '(a trap, how a system actually works, who owns what). NOT what you did - that '
+                         'is the task. See --topic and --body.')
+    ap.add_argument('--topic', default='', metavar='TOPIC',
+                    help='with --learned: which shelf it goes on - a repository, a system, a part of '
+                         'the business. Defaults to the checkout you are in.')
+    ap.add_argument('--body', default='', metavar='TEXT',
+                    help='with --learned: the two or three sentences under the title - the fact, why it '
+                         'is so, and what to do about it')
+    ap.add_argument('--done', metavar='SUMMARY', nargs='?', const='',
+                    help='finish the task this session is working: close it, file the report from '
+                         'this transcript, and draft the reply the sender gets (you are not '
+                         'sending it - the owner approves it). Give one sentence on what you did '
+                         'or found. Do not run this while waiting on the owner.')
     args = ap.parse_args()
     if args.demo:
         import os, tempfile
@@ -68,7 +89,36 @@ def main():
         # a throwaway home, so a demo can never be pointed at somebody's real database by accident
         os.environ.setdefault('TASKUARY_HOME', tempfile.mkdtemp(prefix='taskuary-demo-'))
         print(f'demo mode: invented data in {os.environ["TASKUARY_HOME"]}, nothing can reach a real system')
-    if args.board or args.note:
+    # --done goes over HTTP, unlike --note. A note is a database row and any process can write
+    # one; ENDING a task needs the live session's scrollback, which exists only inside the
+    # running server - this process would find no transcript and wrap an empty one.
+    if args.done is not None:
+        import os, sys, requests
+        try: sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        except (AttributeError, OSError): pass
+        tid = os.environ.get('TASKUARY_TASK')
+        if not str(tid).isdigit():
+            print('not in a Taskuary session - TASKUARY_TASK is not set, so there is no task to finish')
+            return
+        srv = config.load()['server']
+        host = '127.0.0.1' if srv.get('host') in ('0.0.0.0', '::', '', None) else srv['host']
+        base = f"http://{host}:{srv.get('port') or 7787}"
+        hdr = {'X-Taskuary-Token': srv['token']} if srv.get('token') else {}
+        try:
+            r = requests.post(f'{base}/api/agent/done', timeout=120, headers=hdr,
+                              json={'task_id': int(tid), 'summary': args.done,
+                                    'agent': os.environ.get('TASKUARY_AGENT') or 'agent'})
+            out = r.json() if r.headers.get('content-type', '').startswith('application/json') else {}
+        except Exception as e:
+            print(f'could not reach Taskuary at {base}: {e}'); return
+        if out.get('closed'):
+            print('task closed. Report filed from this session.'
+                  + (' A reply to the sender is drafted and waiting on the owner.' if out.get('drafting')
+                     else ' No reply was needed.'))
+        else:
+            print(f"not closed: {out.get('why') or out.get('detail') or r.text[:200]}")
+        return
+    if args.board or args.note or args.learned:
         import os, sys
         from . import blackboard as bb
         from .store import SQLiteStore, task_ref
@@ -78,6 +128,13 @@ def main():
         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.learned:
+            from . import handbook
+            try: p = handbook.post(store, args.learned, args.body, args.topic, args.kind if args.kind in handbook.KINDS else 'howto',
+                                   who, int(tid) if str(tid).isdigit() else None, cwd)
+            except ValueError as e: print(f'not filed: {e}'); return
+            print(f"filed in the handbook under {p['Topic']}: {p['Title']}")
+            return
         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

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/coder.py

@@ -14,8 +14,11 @@ TRANSCRIPT_SYSTEM = (
     'the transcript ALONE - never a step it did not take, never a claim it did not make.\n'
     'Output ONLY this JSON: {"determination": "...", "actions": "...", "summary": "...", '
     '"outcome": "did_work|nothing_to_do"} - '
-    'determination is what was decided and why, actions is what was actually changed (files, '
-    'commands, records, ids), summary is the two-sentence version for someone who read none of it.\n'
+    'determination is what was decided and why, in plain language and at most 80 words. '
+    'actions is only what was actually changed or produced (files, commands, records, ids), '
+    'at most 80 words; do not repeat the determination. summary is the concrete outcome for '
+    'someone who read none of the transcript: one or two natural sentences, at most 55 words, '
+    'with no headings, process narration, or repetition of the other fields.\n'
     'outcome is nothing_to_do ONLY when the session changed, produced and chased nothing because there '
     'was nothing here to do at all - the message turned out to be a notice, a reminder, a newsletter or '
     "somebody else's job. Anything the session did, found out or settled for the owner is did_work, and "
@@ -122,17 +125,108 @@ def finish(store, task_id: int, rep: dict, run_id: int = None, actor: str = 'cod
     # off, finished work just closes: the report lands on the task, no dead-end draft.
     if mid:
         from .outbound import can_reply
-        if not can_reply(store, (store.get_message(mid) or {}).get('Channel')): mid = None
+        m = store.get_message(mid) or {}
+        if not can_reply(store, m.get('Channel')):
+            # a report cannot be replied to (nobody sent it), but its card may name somewhere its
+            # FINDINGS should go - the one configured exception to "work off a report lands on the
+            # timeline and nowhere else" (reports.findings_target)
+            from .reports import findings_target
+            tgt = findings_target(store, m)
+            if tgt:
+                deliver_findings(store, task_id, mid, run_id, rep, tgt)
+                store.update_task(task_id, {'Status': 'waiting'}, actor)
+                return {'drafting': True, 'message_id': mid}
+            mid = None
     # a held draft is proof somebody IS waiting on an answer, so it is never quietly dropped here
     if mid and not held and nobody_waiting(store, mid, rep):
         store.add_comment(task_id, actor, 'agent', 'Nothing needed doing here and the sender is not waiting on an '
                                                    'answer - filed with the report, no reply drafted.')
         mid = None
-    if mid: raise_reply(store, task_id, mid, run_id, rep)
+    # The terminal and report are already closed at this point. Publish that truth BEFORE the
+    # reply-writing AI call: it can take seconds (or fail), and during that time the task used to
+    # remain `in_progress` with no live agent. A pending review is already durable, so `waiting`
+    # is honest even while its draft text is being filled in.
     store.update_task(task_id, {'Status': 'waiting' if mid else 'done'}, actor)
+    if mid: raise_reply(store, task_id, mid, run_id, rep)
     return {'drafting': bool(mid), 'message_id': mid}
 
 
+def deliver_findings(store, task_id: int, mid: int, run_id: int, rep: dict, tgt: dict) -> None:
+    """A report's task finished and its card names somewhere the findings should go. Same shape as
+    every other outgoing message: a pending review carrying its destination, which the owner reads
+    and approves. Nothing about "a report started this" makes the sending automatic."""
+    from . import outbox
+    rid = store.add_review({'TaskId': task_id, 'MessageId': mid, 'RunId': run_id, 'Kind': 'draft_reply',
+                            'Status': 'pending', 'Deliver': json.dumps(tgt),
+                            'Reason': f"the report's findings, for {tgt['to']} - approve to send"})
+    try:
+        draft = outbox.draft_message(store, tgt['channel'], tgt['to'],
+                                     f"what we found looking into the \"{tgt['subject']}\" report", resolution_text(rep))
+        store.update_review_draft(rid, draft, run_id)
+    except Exception as e:
+        logger.warning(f'findings draft failed for task {task_id}: {e}')
+
+
+def wrap(store, tid: int, close: bool = True, actor: str = 'owner', sid: str = None) -> dict:
+    """"We're done" - the whole ending, in one callable. The transcript becomes the report, the
+    session dies, proposals become reviews, and finish() drafts the reply the sender gets.
+
+    It lived inside the HTTP handler, which meant the ONLY way a task could be closed out was a
+    person clicking Done in the browser. An agent that has finished knows it has finished long
+    before anyone looks at the screen (selfclose.py), so the ending had to become something other
+    than a route. Raises ValueError for the cases a caller must be told about; the route maps
+    those to 422.
+
+    Wrapping up belongs to the TASK, not to a pty: keyed on a live session it quietly vanished
+    ten minutes after the CLI exited and was reaped, leaving a task that could never be closed."""
+    from . import aisetup, general, proposals, terminal as term
+    task = store.get_task(tid) if tid else None
+    if not task: raise ValueError('this session is not on a task')
+    # a setup session kept no transcript on purpose (secrets were typed into it) and has no report to write
+    if task.get('Kind') == aisetup.KIND: return aisetup.finish(store, tid, actor)
+    # General work already has a durable, turn-by-turn record in task comments. It does not need a
+    # coding-transcript summarizer or a synthetic CODER REPORT; close the shared session and the
+    # task, leaving that conversation intact.
+    session = general.session_for(tid)
+    if general.handles(task) and session:
+        term.close(session.sid)
+        if close and task.get('Status') not in ('done', 'dropped'):
+            store.update_task(tid, {'Status': 'done'}, actor)
+        store.add_comment(tid, actor, 'human', 'Closed the general-work session.' + (' Marked the task done.' if close else ''))
+        store.audit('terminal', tid, 'wrap', actor, detail={'sid': sid or session.sid, 'close': close, 'mode': 'assistant'})
+        last = next((m['content'][0]['text'] for m in reversed(general.history(store, tid)) if m['role'] == 'assistant'), '')
+        return {'wrap': 'done', 'taskId': tid, 'report': last, 'proposed': [], 'drafting': False}
+    text, agent, found = term.transcript_for(store, tid)
+    if not text.strip(): raise ValueError('nothing to wrap up - this task has no session transcript')
+    if found: term.close(found)              # done means done - the pty and its shells go too
+    rep = report_from_transcript(store, tid, text, agent)
+    report = resolution_text(rep)
+    store.add_comment(tid, actor, 'human', 'Closed the session - wrapped up from what was on screen.')
+    store.add_comment(tid, agent, 'agent', f'CODER REPORT\n{report}')
+    # anything the agent PROPOSED becomes a pending review here, at the one moment its whole
+    # transcript is in hand - and refusals are recorded rather than dropped (proposals.py)
+    proposed = []
+    if store.get_settings().get('proposals_enabled', '1') == '1':
+        try: proposed = proposals.collect(store, tid, text, agent)
+        except Exception as e: logger.warning(f'proposal collection failed for task {tid}: {e}')
+    # ...and the one question worth asking the transcript that is NOT about this task: did the
+    # session work out anything still true next month? Usually not, and "not" is the answer it
+    # is told to give (handbook.py). A failure here never stops a task closing.
+    from . import handbook
+    if handbook.enabled(store):
+        try: handbook.learn_from_session(store, tid, text, agent, repo=term.repo_tag(task) or '')
+        except Exception as e: logger.debug(f'handbook: nothing filed for task {tid} - {e}')
+    # 'drafting' must be what finish() ACTUALLY did, not a second guess at it: recomputing it from
+    # reply_target alone skipped the can-this-channel-even-reply rule, so a GitHub task with
+    # replies off closed with no draft while the card still promised one in Review.
+    fin = {}
+    if close and (store.get_task(tid) or {}).get('Status') not in ('done', 'dropped'):
+        fin = finish(store, tid, rep, None, agent) or {}
+    store.audit('terminal', tid, 'wrap', actor, detail={'sid': sid or found, 'close': close})
+    return {'wrap': 'done', 'taskId': tid, 'report': report, 'proposed': proposed,
+            'drafting': bool(fin.get('drafting'))}
+
+
 def raise_reply(store, task_id: int, mid: int, run_id: int, rep: dict) -> None:
     """The session reported; the responder writes what the sender actually reads. One voice for
     every reply the owner sends - and no coding CLI drafting prose from inside a repo. A draft

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/compose.py

@@ -211,7 +211,7 @@ def compose(store, ask: str, llm, answers: dict = None, rounds: int = MAX_PEEKS)
 
     `answers` are the owner's replies to a previous round's questions, so asking is a
     conversation rather than a dead end."""
-    if not llm: return {'error': 'no AI connector is configured - Connectors → AI'}
+    if not llm: return {'error': 'no AI connector is configured - Connections → AI'}
     if not (ask or '').strip(): return {'error': 'say what you want the report to do'}
     cat = catalog(store)
     user = {'request': ask.strip(), 'catalog': cat,
@@ -235,7 +235,7 @@ def compose_sources(store, ask: str, llm, one_type: str = None, answers: dict =
 
     `one_type` is the card the owner is standing on: exactly one source comes back, of that type
     unless the ask plainly needs another system - and then `explain` says which and why."""
-    if not llm: return {'error': 'no AI connector is configured - Connectors → AI'}
+    if not llm: return {'error': 'no AI connector is configured - Connections → AI'}
     if not (ask or '').strip(): return {'error': 'say what it should read'}
     cat = catalog(store)
     if one_type:

{taskuary-0.3.2.3 → taskuary-0.3.2.4}/taskuary/config.py

@@ -12,11 +12,43 @@ try: import tomllib
 except ImportError: import tomli as tomllib  # py3.10
 from pathlib import Path
 
+_TEST_MARKS = ('pytest', 'unittest', 'fastapi.testclient', 'starlette.testclient')
+
+
+def _under_test() -> bool:
+    """Are we inside a test run? sys.modules is the honest signal: pytest and unittest are both
+    imported by the time anything of ours is."""
+    import sys
+    # fastapi's TestClient is the other one, and it is the one that got past this guard the very
+    # day it was written: a throwaway `python -c` driving the API to check a fix imports neither
+    # pytest nor unittest, and wrote a message, a task, two routes and a memory note into the
+    # owner's database. TestClient exists for nothing but testing, so its presence is proof.
+    return any(m in sys.modules for m in _TEST_MARKS) and not os.getenv('TASKUARY_ALLOW_TEST_HOME')
+
+
 def home() -> Path:
-    p = Path(os.getenv('TASKUARY_HOME') or Path.home() / '.taskuary')
+    """Where the owner's data lives - unless a test is asking, in which case it never is.
+
+    tests/conftest.py points TASKUARY_HOME at a temp dir before anything of ours is imported, and
+    that works for `pytest`. It does NOT work for `python tests/test_terminal.py`, because every
+    test file here ends in unittest.main() and running one directly loads no conftest at all. That
+    door was open, and something went through it: two copies of test_terminal's fixture task, and
+    its graph:E2E message, in the owner's live database (2026-09-01; and the same class of
+    accident on 2026-08-27, which cost SOUL.md and left 140 fixture tasks on the board).
+
+    So the guard moves to where the decision is actually made. A test that has not been given a
+    home gets a temp one and is told so - loudly, once - instead of quietly opening the real
+    database. Set TASKUARY_ALLOW_TEST_HOME=1 for the rare test that means it."""
+    env = os.getenv('TASKUARY_HOME')
+    if not env and _under_test():
+        import tempfile
+        env = os.environ['TASKUARY_HOME'] = tempfile.mkdtemp(prefix='taskuary_test_')
+        print(f'taskuary: test run with no TASKUARY_HOME - using {env}, not your real data',
+              file=__import__('sys').stderr)
+    p = Path(env or Path.home() / '.taskuary')
     old = Path.home() / '.taskhub'
     # one-time migration from the pre-rename data dir
-    if not os.getenv('TASKUARY_HOME') and not p.exists() and old.exists(): old.rename(p)
+    if not env and not p.exists() and old.exists(): old.rename(p)
     p.mkdir(parents=True, exist_ok=True)
     return p
 
@@ -24,6 +56,9 @@ def _read() -> dict:
     f = home() / 'config.toml'
     return tomllib.loads(f.read_text(encoding='utf-8')) if f.exists() else {}
 
+def _write(d: dict):
+    (home() / 'config.toml').write_text(dumps_toml(d) + '\n', encoding='utf-8')
+
 def _env_server() -> dict:
     """Non-empty TASKUARY_* overlays. Empty is unset — an injected '' must not disable a stored token."""
     out = {}
@@ -38,6 +73,11 @@ def load() -> dict:
     cfg.setdefault('server', {})
     cfg['server'].setdefault('host', '127.0.0.1')
     cfg['server'].setdefault('port', 7787)
+    # every install gets an AGENT token, whether or not the owner set an owner token: without one
+    # there is no way to tell a session's request from a person's, and guard.DENIED has nothing
+    # to act on. It is written back to config.toml so it survives a restart.
+    from . import guard
+    guard.ensure_tokens(_read, _write, cfg['server'])
     # --dangerously-skip-permissions matters: without it a headless claude waits forever
     # for permission approvals nobody can click. stream-json (+ required --verbose) makes
     # claude emit events AS IT WORKS so the Board can stream the run live.