taskuary 0.3.2.2__tar.gz → 0.3.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskuary
-Version: 0.3.2.2
+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,10 +64,19 @@ 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.2**—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.
 
+<p align="center">
+  <a href="https://taskuary.com/demo/"><img
+    src="https://img.shields.io/badge/%E2%96%B6%20Try%20it%20now-no%20install%2C%20in%20your%20browser-2f4858?style=for-the-badge&labelColor=1f2a22"
+    alt="Try Taskuary now, in your browser"></a>
+</p>
+
+<p align="center"><sub>The real app over invented work — timeline, triage, a coding session mid-run,
+reports with charts. Nothing to install and nothing connects to anything.</sub></p>
+
 ## One timeline for incoming work
 
 Outlook, Gmail, Teams, Slack, Telegram, WhatsApp, GitHub, Jira, alerts, and reports all
@@ -141,6 +150,21 @@ On first run, connect an AI provider or local Ollama model, add at least one inb
 channel, then choose the coding CLI that should receive tasks. The setup wizards test each
 connection before it goes live.
 
+## Try it without installing anything
+
+```bash
+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, 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.
+
 ## Installs
 
 ![Daily installs of taskuary from PyPI, mirror traffic excluded](https://raw.githubusercontent.com/ldbumble/taskuary/master/docs/downloads.svg)

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

@@ -13,10 +13,19 @@ 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.2**—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.
 
+<p align="center">
+  <a href="https://taskuary.com/demo/"><img
+    src="https://img.shields.io/badge/%E2%96%B6%20Try%20it%20now-no%20install%2C%20in%20your%20browser-2f4858?style=for-the-badge&labelColor=1f2a22"
+    alt="Try Taskuary now, in your browser"></a>
+</p>
+
+<p align="center"><sub>The real app over invented work — timeline, triage, a coding session mid-run,
+reports with charts. Nothing to install and nothing connects to anything.</sub></p>
+
 ## One timeline for incoming work
 
 Outlook, Gmail, Teams, Slack, Telegram, WhatsApp, GitHub, Jira, alerts, and reports all
@@ -90,6 +99,21 @@ On first run, connect an AI provider or local Ollama model, add at least one inb
 channel, then choose the coding CLI that should receive tasks. The setup wizards test each
 connection before it goes live.
 
+## Try it without installing anything
+
+```bash
+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, 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.
+
 ## Installs
 
 ![Daily installs of taskuary from PyPI, mirror traffic excluded](https://raw.githubusercontent.com/ldbumble/taskuary/master/docs/downloads.svg)

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

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

@@ -9,7 +9,7 @@ Both writers are hand-rolled on the standard library on purpose: xlsx is a zip o
 XML parts, and a bar chart is a few dozen rects. Neither is worth a dependency that has to be
 frozen into the one-file exe.
 """
-import json, re, zipfile
+import json, math, re, zipfile
 from datetime import datetime
 from xml.sax.saxutils import escape
 
@@ -145,6 +145,65 @@ def chart_columns(rows: list) -> tuple:
     return ((labels[0] if labels else None), (vals[0] if vals else None))
 
 
+INK, GRID, MUTED, LINE = '#1f2430', '#e7e3da', '#8a94a6', '#4f46e5'
+
+_DATE = re.compile(r'^\s*(\d{4}-\d{2}-\d{2}|\d{1,2}/\d{1,2}(/\d{2,4})?|\d{4}-\d{2}|[A-Z][a-z]{2} \d{1,2})')
+
+def _dated(labels: list) -> bool:
+    """Is the label column a run of dates? A report over time is the one shape horizontal bars
+    get wrong - fourteen days of tickets became fourteen stacked bars, which reads as fourteen
+    unrelated things rather than one line going up."""
+    return len(labels) >= 5 and all(_DATE.match(str(l or '')) for l in labels)
+
+
+def _ticks(top: float, n: int = 4) -> list:
+    """Round gridline values at or above the data, so the axis reads 0/50/100 and never 0/47/94."""
+    if top <= 0: return [0.0, 1.0]
+    step = 10.0 ** math.floor(math.log10(top / n))
+    for mult in (1, 2, 2.5, 5, 10):
+        if step * mult * n >= top: step *= mult; break
+    return [step * i for i in range(int(math.ceil(top / step)) + 1)]
+
+
+def _line_svg(pts: list, title: str, val: str, lab: str) -> str:
+    """One measure over time: a 2px line, a light band under it, gridlines behind, and the last
+    value labelled where the eye already is. One series, so no legend - the title names it."""
+    W, H, L, R, T, B = 760, 260, 56, 74, 34, 34
+    ticks = _ticks(max(v for _l, v in pts))
+    top = ticks[-1] or 1.0
+    px = lambda i: L + (W - L - R) * (i / max(1, len(pts) - 1))
+    py = lambda v: H - B - (H - T - B) * (v / top)
+    pl = ' '.join(f'{px(i):.1f},{py(v):.1f}' for i, (_l, v) in enumerate(pts))
+    out = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}" height="{H}" viewBox="0 0 {W} {H}" '
+           f'font-family="Segoe UI, Helvetica, Arial, sans-serif">',
+           f'<rect width="{W}" height="{H}" fill="#ffffff"/>',
+           f'<text x="{L - 40}" y="20" font-size="13" font-weight="700" fill="{INK}">{escape(title or val)}</text>',
+           f'<text x="{W - 12}" y="20" font-size="10" fill="{MUTED}" text-anchor="end">'
+           f'{escape(val)} by {escape(lab or "row")} · {len(pts)} points</text>']
+    for t in ticks:
+        y = py(t)
+        out += [f'<line x1="{L}" y1="{y:.1f}" x2="{W - R}" y2="{y:.1f}" stroke="{GRID}" stroke-width="1"/>',
+                f'<text x="{L - 8}" y="{y + 3.5:.1f}" font-size="10" fill="{MUTED}" text-anchor="end">'
+                f'{escape(f"{t:,.10g}")}</text>']
+    out.append(f'<polygon points="{L},{H - B} {pl} {W - R},{H - B}" fill="{LINE}" fill-opacity="0.08"/>')
+    out.append(f'<polyline points="{pl}" fill="none" stroke="{LINE}" stroke-width="2" '
+               f'stroke-linejoin="round" stroke-linecap="round"/>')
+    # every point is a target, but only the ends are named - a number on all fourteen is noise
+    for i, (_l, v) in enumerate(pts):
+        out.append(f'<circle cx="{px(i):.1f}" cy="{py(v):.1f}" r="{4 if i in (0, len(pts) - 1) else 2.4}" '
+                   f'fill="{LINE}" stroke="#ffffff" stroke-width="1.5"/>')
+    lv = pts[-1][1]
+    out.append(f'<text x="{W - R + 8}" y="{py(lv) + 4:.1f}" font-size="11.5" font-weight="700" fill="{INK}">'
+               f'{escape(f"{lv:,.2f}".rstrip("0").rstrip("."))}</text>')
+    every = max(1, len(pts) // 7)
+    for i, (l, _v) in enumerate(pts):
+        if i % every and i != len(pts) - 1: continue
+        out.append(f'<text x="{px(i):.1f}" y="{H - B + 16}" font-size="10" fill="{MUTED}" '
+                   f'text-anchor="middle">{escape(str(l)[-5:])}</text>')
+    out.append('</svg>')
+    return ''.join(out)
+
+
 # Taskuary's own indigo, and a chart that reads in both the panel and a screenshot of it.
 def to_svg_chart(rows: list, path, title: str = '', want_val: str = None, want_lab: str = None) -> str:
     """Horizontal bars: label, bar, value. Horizontal because report labels are names and dates,
@@ -159,6 +218,10 @@ def to_svg_chart(rows: list, path, title: str = '', want_val: str = None, want_l
     pts = [(str(r.get(lab, ''))[:42] if lab else f'#{i + 1}', _num(r.get(val)) or 0.0)
            for i, r in enumerate(rows)][:MAX_BARS]
     if not pts: return ''
+    if _dated([l for l, _v in pts]):
+        svg = _line_svg(pts, title or val, val, lab or 'row')
+        if path is not None: path.write_text(svg, encoding='utf-8')
+        return svg if path is None else f'{val} by {lab or "row"}'
     top = max(abs(v) for _l, v in pts) or 1.0
     W, LW, RH, PAD = 760, 210, 22, 18
     H = PAD * 2 + 26 + RH * len(pts)

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

@@ -46,6 +46,11 @@ def main():
     # 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.
+    # try-it-out in one command: a throwaway home, a world of invented work, and every door
+    # to the outside nailed shut (demo.py). This is what /demo on the website runs.
+    ap.add_argument('--demo', action='store_true',
+                    help='run a DEMO instance: invented data, a scripted AI, replayed coding '
+                         'sessions, and nothing that can reach a real system')
     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',
@@ -55,8 +60,65 @@ 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.board or args.note:
+    if args.demo:
+        import os, tempfile
+        from . import demo
+        os.environ[demo.FLAG] = '1'
+        # 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')
+    # --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
@@ -66,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