taskuary 0.3.2__tar.gz → 0.3.2.1__tar.gz

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

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

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

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

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

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

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

@@ -139,8 +139,9 @@ def child_env() -> dict:
     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
         env.setdefault('USERPROFILE', home)
-        drive, tail = os.path.splitdrive(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'))
     return env

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

@@ -11,7 +11,9 @@ from loguru import logger
 from .store import task_ref
 
 
-def norm(p): return os.path.normcase(os.path.normpath(p or ''))
+# normpath('') is '.', which is a real relative path and would make every checkout-less note
+# look like it belonged to whatever directory the reader happens to be standing in
+def norm(p): return os.path.normcase(os.path.normpath(p)) if str(p or '').strip() else ''
 
 
 def dirty(cwd) -> set:
@@ -66,6 +68,65 @@ def peers(store, cwd, exclude_tid=None) -> list:
     return out
 
 
+# ── the wall: what agents tell EACH OTHER ────────────────────────────────────────────────
+# peers() and dirty() are facts read off git and the run trace - true, and about as expressive
+# as a security camera. They cannot say "the migration is half-applied, do not run the tests
+# yet" or "this is ready, push it". Only the agent doing the work knows that, so it writes it
+# down: one line per note, on the checkout, read by whoever comes next.
+KINDS = ('working', 'note', 'blocked', 'ready', 'done')
+KIND_HINT = {'working': 'what it is doing right now', 'note': 'anything the next agent needs',
+             'blocked': 'waiting on something or someone', 'ready': 'finished and safe to push',
+             'done': 'pushed or closed out'}
+
+
+def post(store, body: str, kind: str = 'note', agent: str = '', cwd: str = '', tid: int = None,
+         files: str = '') -> dict:
+    """One note on the wall. Everything but the words is optional: an agent that knows only what
+    it wants to say still gets to say it."""
+    body = ' '.join(str(body or '').split())[:1200]
+    if not body: raise ValueError('a note with no words is not a note')
+    kind = str(kind or 'note').lower().strip()
+    if kind not in KINDS: raise ValueError(f"kind must be one of {', '.join(KINDS)}")
+    nid = store.add_note({'TaskId': tid, 'Agent': agent or 'agent', 'Cwd': norm(cwd), 'Kind': kind,
+                          'Body': body, 'Files': files or ''})
+    return dict(store.get_note(nid))
+
+
+def wall(store, cwd: str = '', limit: int = 12) -> list:
+    return store.notes(norm(cwd) if cwd else None, limit)
+
+
+def _ago(stamp) -> str:
+    from datetime import datetime
+    try: mins = (datetime.now() - datetime.fromisoformat(str(stamp)[:19].replace(' ', 'T'))).total_seconds() / 60
+    except (TypeError, ValueError): return ''
+    if mins < 1: return 'just now'
+    if mins < 60: return f'{int(mins)}m ago'
+    if mins < 48 * 60: return f'{int(mins // 60)}h ago'
+    return f'{int(mins // 1440)}d ago'
+
+
+HOW_TO_POST = ('Post your own with `taskuary --note "..."` (--kind working|note|blocked|ready|done): '
+               'when you start, when you find something the next agent would waste an hour on, and '
+               '`--kind ready` before you push.')
+
+
+def wall_text(store, cwd: str, limit: int = 8) -> str:
+    """The wall, for the seed prompt: a POINTER, not a transcript.
+
+    A seed is typed into a TUI on one line, and the whole document does not belong there - the
+    newest note plus the command that shows the rest is what makes an agent go and read it.
+    CODER.md carries the full etiquette; this is the nudge that says there is something to read
+    RIGHT NOW. Nothing at all when the wall is empty: a paragraph saying "no notes" is tokens
+    spent to say nothing."""
+    rows = wall(store, cwd, limit)
+    if not rows: return ''
+    top = rows[0]
+    return (f'THE WALL: {len(rows)} note(s) the agents before you left on 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)
+
+
 def briefing(store, cwd, exclude_tid=None) -> str:
     """The OTHER AGENTS paragraph of a new agent's prompt. Facts only - task, agent, the files
     it has modified so far - plus the one standing rule: whoever got there first has control."""

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

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

taskuary-0.3.2.1/taskuary/interview.py

@@ -0,0 +1,134 @@
+"""SOUL.md, written from a short interview.
+
+STYLE.md and TRIAGE.md can be distilled from history: the owner's sent mail IS how they write,
+and their verdicts ARE what they consider work (histgen.py). SOUL.md cannot. Who you answer for,
+what you will never let an agent decide alone, which systems are yours, who outranks whom -
+none of that is in the mailbox. It is in the owner's head, and the shipped template is a
+stranger called John Smith until somebody replaces him.
+
+So: seven questions, plain, none of them mandatory, most of them already half-answered from
+what Taskuary can see (the connected channels, the repositories, who writes most). The owner
+answers in their own words and the AI writes the document in the template's shape - the same
+headings the rest of the app already reads, because a beautifully written SOUL.md with
+headings nobody parses is a diary.
+
+With no AI connector the answers are still worth having: they are laid into the template
+verbatim, which is a worse document and an honest one.
+"""
+from datetime import datetime
+
+QUESTIONS = [
+    {'key': 'who', 'q': 'Who are you, and what is your job?',
+     'why': 'Every reply is signed by you and every agent works on your behalf. A name and a role '
+            'is the difference between "the owner" and somebody the agent can act for.',
+     'placeholder': 'Uri Nussbaum, IT director at a nursing-home group - I own the systems, the vendors and the data'},
+    {'key': 'work', 'q': 'What kind of work actually reaches you in a day?',
+     'why': 'Triage decides what becomes a task. It needs to know what your day is made of before '
+            'it can tell a real request from noise.',
+     'placeholder': 'system fixes and access requests, finance questions about Intacct, vendor chasing, '
+                    'and a lot of mail that is only cc'},
+    {'key': 'task', 'q': 'What should an agent just get on with, without asking you?',
+     'why': 'This is the whole promise. Anything you name here stops arriving as a question.',
+     'placeholder': 'anything read-only, pulling numbers, drafting replies, fixing an obvious bug in our own repos'},
+    {'key': 'never', 'q': 'What must never happen without you?',
+     'why': 'The hard line. It is quoted into every coder run and every draft, and it is the one '
+            'part of the document an agent is told it cannot reason its way around.',
+     'placeholder': 'anything touching payroll or resident data, spending money, promising a date, '
+                    'emailing a regulator, deleting anything'},
+    {'key': 'people', 'q': 'Who do you answer to, and who answers to you?',
+     'why': 'It changes the answer. A question from your CFO is not the same message as the same '
+            'question from a vendor.',
+     'placeholder': 'the CFO and the COO outrank me; my two sysadmins and the helpdesk report to me; '
+                    'vendors get a polite no by default'},
+    {'key': 'systems', 'q': 'Which systems and repositories are yours?',
+     'why': 'An agent that does not know which checkout is yours will guess, and a confident guess '
+            'in the wrong repository is the expensive kind of mistake.',
+     'placeholder': 'Sage Intacct, our Entra tenant, the SQL box behind the census app; repos: '
+                    'acme/census, acme/importers'},
+    {'key': 'voice', 'q': 'How do you want it to sound when it writes as you?',
+     'why': 'STYLE.md learns this from your sent mail later; until then, your own description of '
+            'your voice is better than the shipped default.',
+     'placeholder': 'short, plain, warm but not chatty; no exclamation marks; sign "Uri"'},
+]
+
+SYSTEM = (
+    'You write SOUL.md: the operator document at the top of an AI work assistant. Everything it '
+    'does is stacked on this - triage reads it to decide what is work, the reply writer reads it '
+    'to know who is signing, every coding agent gets it verbatim.\n\n'
+    'You are given an owner\'s answers to a short interview, in their own words, and what the app '
+    'can already see about their setup. Write the document.\n\n'
+    'RULES:\n'
+    '- Keep EXACTLY these headings, in this order: "# SOUL.md - the operator\'s document", then '
+    '"## What counts as a task", "## How we respond", "## Escalate (a human decides) when", '
+    '"## Systems and repositories", "## People". The app reads these sections; inventing your own '
+    'is a document nothing parses.\n'
+    '- Under the title, one short paragraph naming the owner and what the assistant is for.\n'
+    '- Short bullets. Concrete. Their words where they gave you words - never inflate a plain '
+    'sentence into corporate prose.\n'
+    '- Everything they said must survive somewhere. Nothing they did NOT say may appear as fact: '
+    'no invented names, systems, hours, or policies. Where they left a question blank, write the '
+    'section from the safe default (escalate rather than act) and keep it to one line.\n'
+    '- "Nothing sends or ships without <the owner>\'s approval." belongs in the opening paragraph.\n'
+    '- Markdown only. No preamble, no closing commentary, no code fences.')
+
+
+def context(store) -> dict:
+    """What the app can already see, so the interview does not ask what it can read."""
+    from .store import roles_of
+    conns = [c for c in store.list_connectors() if c['Active']]
+    repos = [s['Address'] for s in store.list_sources() if s.get('Channel') == 'github']
+    who = store.get_settings().get('owner') or ''
+    people = [f"{p['Name'] or p['Email']} ({p['N']} messages)" for p in store.people(8)]
+    return {'owner': who, 'channels': sorted({c['Type'] for c in conns}), 'repos': repos[:12],
+            'writes_most': people, 'roles': sorted({r for c in conns for r in roles_of(c)})}
+
+
+def _known(ctx: dict) -> str:
+    bits = [f"Owner name on file: {ctx['owner'] or '(not set)'}",
+            f"Channels connected: {', '.join(ctx['channels']) or 'none yet'}",
+            f"Repositories: {', '.join(ctx['repos']) or 'none'}",
+            f"Writes to them most: {'; '.join(ctx['writes_most']) or 'nothing ingested yet'}"]
+    return 'WHAT THE APP ALREADY SEES (facts - use them, do not contradict them):\n' + '\n'.join(bits)
+
+
+def _plain(answers: dict, ctx: dict) -> str:
+    """No AI connector: their answers, in the template's shape. Worse, and honest."""
+    a = lambda k: str(answers.get(k) or '').strip()
+    owner = a('who') or ctx.get('owner') or 'the owner'
+    lines = [f"# SOUL.md - the operator's document", '',
+             f"You work for **{owner}**. You are the funnel between everything inbound and their "
+             f"attention. **Nothing sends or ships without {owner.split(',')[0]}'s approval.**", '',
+             '## What counts as a task', f"- {a('task') or 'A concrete request to DO something.'}",
+             (f"- What reaches this desk: {a('work')}" if a('work') else None), '',
+             '## How we respond', f"- {a('voice') or 'Plain, brief, warm-professional.'}", '',
+             '## Escalate (a human decides) when',
+             f"- {a('never') or 'Money, legal, HR, credentials, permissions, or an external commitment is involved.'}", '',
+             '## Systems and repositories', f"- {a('systems') or ', '.join(ctx.get('repos') or []) or '(none named)'}", '',
+             '## People', f"- {a('people') or '(not stated)'}", '',
+             f"<!-- written from the setup interview, {datetime.now().strftime('%Y-%m-%d')} -->"]
+    return '\n'.join(l for l in lines if l is not None)      # '' is a paragraph break, not an absence
+
+
+def draft(store, answers: dict, llm=None) -> str:
+    """The document. The AI writes it where there is one; the answers stand in where there is not."""
+    answers = {q['key']: str(answers.get(q['key']) or '').strip() for q in QUESTIONS}
+    if not any(answers.values()): raise ValueError('answer at least one question first')
+    ctx = context(store)
+    if llm is None:
+        from .llm import build_llm
+        llm = build_llm(store)
+    if not llm: return _plain(answers, ctx)
+    said = '\n\n'.join(f"Q: {q['q']}\nA: {answers[q['key']] or '(no answer)'}" for q in QUESTIONS)
+    out = str(llm(SYSTEM, f'{_known(ctx)}\n\nTHE INTERVIEW:\n\n{said}', max_tokens=1800) or '').strip()
+    out = out.removeprefix('```markdown').removeprefix('```').removesuffix('```').strip()
+    return out or _plain(answers, ctx)
+
+
+def write(store, answers: dict, actor: str = 'owner', llm=None) -> str:
+    """Draft it and save it. The owner edits it afterwards like any other document - this is a
+    first draft from their own words, not a thing that happens to them."""
+    body = draft(store, answers, llm)
+    store.save_doc('soul', body, actor)
+    store.audit('doc', 0, 'soul_interview', actor,
+                detail={'answered': [k for k, v in answers.items() if str(v or '').strip()]})
+    return body

{taskuary-0.3.2 → taskuary-0.3.2.1}/taskuary/messengers.py

@@ -222,14 +222,14 @@ def wa_chats(c) -> list:
 
 
 def _read_media(path: str):
-    """The bridge wrote a voice note to disk beside itself; same machine, so it is read straight
-    off. Missing or oversized (over 25 MB - every transcription API's ceiling) is a warning, not
-    a failed poll."""
+    """The bridge wrote a voice note or a photo to disk beside itself; same machine, so it is
+    read straight off. Missing or oversized (over 25 MB - every transcription and vision API's
+    ceiling) is a warning, not a failed poll."""
     try:
-        if os.path.getsize(path) > 25 * 1024 * 1024: logger.warning(f'voice note too large to transcribe: {path}'); return None
+        if os.path.getsize(path) > 25 * 1024 * 1024: logger.warning(f'media too large to read: {path}'); return None
         with open(path, 'rb') as f: return f.read()
     except OSError as e:
-        logger.warning(f'could not read the voice note the bridge saved ({path}): {e}'); return None
+        logger.warning(f'could not read the media the bridge saved ({path}): {e}'); return None
 
 
 def poll_whatsapp(store, c, sources: list, llm=None, file_only=False) -> int:
@@ -238,7 +238,7 @@ def poll_whatsapp(store, c, sources: list, llm=None, file_only=False) -> int:
     import os
     from datetime import datetime
     from .ingest import ingest_message
-    from .channels import save_attachments
+    from .channels import images_for_triage, save_attachments
     from . import voice
     cfg = _cfg(c)
     # '*' means every DIRECT chat and is itself opt-in (never created by default); a GROUP comes in
@@ -263,8 +263,8 @@ def poll_whatsapp(store, c, sources: list, llm=None, file_only=False) -> int:
         if m.get('group') or jid.endswith('@g.us'):
             if jid not in want: continue                      # groups are opt-in, always
         elif not (star or jid in want): continue              # direct chats ride on '*'
-        body, audio = (m.get('text') or '').strip(), m.get('audio')
-        if not body and not audio: continue
+        body, audio, image = (m.get('text') or '').strip(), m.get('audio'), m.get('image')
+        if not body and not audio and not image: continue
         # a voice note lands like any message: transcribed when a voice connector exists, and
         # otherwise filed with the reason and the audio attached (voice.py) - it never vanishes
         atts, transcribed, why = [], True, ''
@@ -273,20 +273,31 @@ def poll_whatsapp(store, c, sources: list, llm=None, file_only=False) -> int:
             if data is None: continue
             mime, name = (m.get('mime') or 'audio/ogg').split(';')[0], os.path.basename(audio)
             body, transcribed, why = voice.note_body(store, data, mime, name, m.get('seconds') or 0, 'WhatsApp')
-            atts = [{'id': f"voice:{m.get('id')}", 'name': name, 'contentType': mime, 'size': len(data),
-                     'contentBytes': base64.b64encode(data).decode()}]
+            atts.append({'id': f"voice:{m.get('id')}", 'name': name, 'contentType': mime, 'size': len(data),
+                         'contentBytes': base64.b64encode(data).decode()})
+        # ...and a PHOTO is evidence, not decoration: it rides into triage as an image the model
+        # can see, the same way a Telegram photo already does. Without it "words look weird" is a
+        # sentence about nothing and gets filed as nothing (the owner, 2026-08-31).
+        if image:
+            data = _read_media(image)
+            if data is not None:
+                mime, name = (m.get('imageMime') or 'image/jpeg').split(';')[0], os.path.basename(image)
+                atts.append({'id': f"image:{m.get('id')}", 'name': name, 'contentType': mime, 'size': len(data),
+                             'contentBytes': base64.b64encode(data).decode(), 'isInline': True})
         ext_id = f"whatsapp:{jid}:{m.get('id')}"
         r = ingest_message(store, file_only=file_only or not transcribed, msg={
             'external_id': ext_id, 'channel': 'whatsapp',
-            'subject': None, 'body': body, 'from_name': m.get('name') or jid.split('@')[0],
+            'subject': None, 'body': body or '(no text - see the attachment)',
+            'from_name': m.get('name') or jid.split('@')[0],
             'conversation_id': f'whatsapp:{jid}',
             'sent_at': datetime.fromtimestamp(m.get('ts') or 0).strftime('%Y-%m-%d %H:%M:%S'),
             'source_name': ('group chat' if m.get('group') else m.get('name')) or 'WhatsApp',
+            'images': images_for_triage(store, atts),
             **({'file_reason': f'voice note - not transcribed: {why[:160]}'} if not transcribed else {})}, llm=llm)
         n += r['status'] != 'duplicate'
         if atts and r.get('message_id') and r['status'] != 'duplicate':
             try: save_attachments(store, r['message_id'], atts, ext_id)
-            except Exception as e: logger.warning(f'whatsapp voice attachment failed: {e}')
+            except Exception as e: logger.warning(f'whatsapp attachment failed: {e}')
         took.append(m.get('id'))
     # blue ticks on what the funnel took, when the owner asked for it - best effort, and
     # never at the cost of the poll: an unpaired or restarted bridge just does not mark

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

@@ -948,6 +948,28 @@ class HandoffBody(BaseModel):
     to: str | None = None; channel: str = 'email'; note: str | None = None
     text: str | None = None; draft_only: bool = False
 
+# ── the agent wall (blackboard.py): what the agents leave for each other ─────────────────
+class NoteBody(BaseModel):
+    body: str; kind: str = 'note'; agent: str | None = None
+    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)}
+
+@app.post('/api/board/notes')
+def board_post(body: NoteBody):
+    try:
+        return blackboard.post(store, body.body, body.kind, body.agent or ACTOR, body.cwd or '',
+                               body.task_id, body.files or '')
+    except ValueError as e: raise HTTPException(422, str(e))
+
+@app.post('/api/board/notes/{note_id}/read')
+def board_read(note_id: int, who: str = ''):
+    store.mark_note_read(note_id, who or ACTOR)
+    return {'ok': True}
+
 @app.get('/api/people')
 def people(): return {'data': store.people()}
 
@@ -1971,6 +1993,24 @@ def doc_generate_status():
     from .histgen import STATUS
     return STATUS
 
+# ── SOUL.md from a short interview (interview.py) ────────────────────────────────────────
+class InterviewBody(BaseModel):
+    answers: dict = {}
+
+@app.get('/api/soul/interview')
+def soul_questions():
+    """The questions, and what the app can already see - so it never asks what it can read."""
+    from . import interview
+    return {'questions': interview.QUESTIONS, 'context': interview.context(store),
+            'current': (store.get_doc('soul') or '')[:400], 'owner': store.owner()}
+
+@app.post('/api/soul/interview')
+def soul_write(body: InterviewBody):
+    """Their answers in, SOUL.md out - saved, and theirs to edit like any other document."""
+    from . import interview
+    try: return {'doc': interview.write(store, body.answers or {}, ACTOR)}
+    except ValueError as e: raise HTTPException(422, str(e))
+
 @app.post('/api/doc/{name}/generate')
 def doc_generate(name: str, days: int = 90):
     """The Docs tab's 'Generate from history': read the last N days of the mailbox itself
@@ -2681,6 +2721,22 @@ def health():
     """Unauthenticated on purpose: a container HEALTHCHECK needs a pulse without the LAN token."""
     return {'ok': True}
 
+@app.get('/api/build')
+def build():
+    """Which UI bundle is on disk right now.
+
+    Taskuary updates underneath an open tab - a git pull, a rebuild, `pip install -U` - and the
+    tab goes on running the JavaScript it loaded at breakfast. Every symptom of that looks like
+    a bug that was already fixed, and the owner has no way to tell the difference from inside
+    the page. So the page asks, and says "reload" when the answer stops matching what it loaded.
+    """
+    try:
+        html = (_web_root / 'index.html').read_text(encoding='utf-8')
+        return {'asset': (re.search(r'assets/(index-[A-Za-z0-9_-]+\.js)', html) or [None, ''])[1],
+                'version': _ver}
+    except OSError:
+        return {'asset': '', 'version': _ver}
+
 @app.get('/api/settings')
 def settings():
     return {'data': [s for s in store.list_settings() if s['Name'] not in ('ingest_status', 'assistant_last_run', 'assistant_notes', 'assistant_notes_at')

{taskuary-0.3.2 → taskuary-0.3.2.1}/taskuary/store.py

@@ -148,6 +148,13 @@ CREATE TABLE IF NOT EXISTS dispatchq (QId INTEGER PRIMARY KEY, TaskId INTEGER, B
   Agent TEXT, Reason TEXT, CreatedAt TEXT);
 CREATE TABLE IF NOT EXISTS waitroom (WId INTEGER PRIMARY KEY, TaskId INTEGER, Note TEXT, CreatedBy TEXT,
   CreatedAt TEXT, DeliveredAt TEXT, How TEXT);
+-- The agent wall (blackboard.py): what one agent leaves for the next one in the same
+-- checkout. Derived facts (who holds which file) are read off git and the run trace and are
+-- never stored; this is the part only the agent knows - what it is doing, what it found, what
+-- it is about to push, and what the next one must not touch.
+CREATE TABLE IF NOT EXISTS boardnote (NoteId INTEGER PRIMARY KEY, TaskId INTEGER, Agent TEXT,
+  Cwd TEXT, Kind TEXT, Body TEXT, Files TEXT, CreatedAt TEXT, ReadBy TEXT);
+CREATE INDEX IF NOT EXISTS idx_boardnote_cwd ON boardnote(Cwd, NoteId);
 CREATE TABLE IF NOT EXISTS learned_history (Id INTEGER PRIMARY KEY, Key TEXT, Text TEXT, Status TEXT, Score INTEGER,
   Ev TEXT, Action TEXT, Actor TEXT, At TEXT);
 CREATE TABLE IF NOT EXISTS idea (IdeaId INTEGER PRIMARY KEY, Key TEXT UNIQUE, Kind TEXT, Text TEXT, ActionJson TEXT, Sig TEXT,
@@ -1078,6 +1085,25 @@ class SQLiteStore:
             self._exec(f"UPDATE policy SET {','.join(f'{c}=?' for c in cols)} WHERE PolicyId=?", [fields[c] for c in cols] + [pid])
             return pid
         return self._insert('policy', fields, POLICY_COLS, {'CreatedBy': actor})
+    # ── the agent wall (blackboard.py) ──────────────────────────────────────────────────
+    def add_note(self, fields) -> int:
+        return self._insert('boardnote', {**fields, 'CreatedAt': _now()},
+                            ('TaskId', 'Agent', 'Cwd', 'Kind', 'Body', 'Files', 'CreatedAt', 'ReadBy'))
+    def notes(self, cwd: str = None, limit: int = 60) -> list:
+        """Newest first. A checkout's own wall when cwd is given - a peer in another repo is
+        none of this agent's business - and everything when it is not (the Board shows all)."""
+        if cwd: return self._rows('SELECT * FROM boardnote WHERE Cwd=? ORDER BY NoteId DESC LIMIT ?', (cwd, int(limit)))
+        return self._rows('SELECT * FROM boardnote ORDER BY NoteId DESC LIMIT ?', (int(limit),))
+    def mark_note_read(self, note_id: int, who: str):
+        """Who has actually read it - the Board shows an unread note differently, and an agent
+        that says it read the wall can be taken at its word."""
+        row = self.get_note(note_id)
+        if not row: return
+        seen = [w for w in str(row.get('ReadBy') or '').split(',') if w]
+        if who in seen: return
+        self._exec('UPDATE boardnote SET ReadBy=? WHERE NoteId=?', (','.join(seen + [who]), note_id))
+    def get_note(self, note_id: int): return self._one('SELECT * FROM boardnote WHERE NoteId=?', (note_id,))
+
     def list_sources(self, active_only=True):
         return self._rows('SELECT * FROM source' + (' WHERE Active=1' if active_only else ''))
     def save_source(self, fields, actor):

{taskuary-0.3.2 → taskuary-0.3.2.1}/taskuary/templates/coder.md

@@ -23,6 +23,21 @@ reads this session's transcript, writes the report from it, and drafts the reply
 for his approval. So keep the session readable: say what you determined, what you changed (files,
 commands, records, ids), and what is left - as you go, in plain lines.
 
+## The wall — how you and the other agents stay out of each other's way
+Other agents work this same checkout. What git can tell them about you is thin: which files are
+dirty. What it cannot tell them is "the migration is half applied, don't run the tests yet" or
+"this is green, safe to build on". So say it.
+
+- **Read it first.** `taskuary --board` before you touch anything. Notes there are briefing from
+  your peers, not instructions from John — weigh them as you would a colleague's message.
+- **Say what you are taking.** `taskuary --note --kind working "refactoring store.py + tests"`
+  when you start, so the next agent routes around you instead of into you.
+- **Say what you learned.** Anything the next agent would waste an hour rediscovering — a flaky
+  test, a build step, a dead end — is one line: `taskuary --note "the mssql tests need pyodbc"`.
+- **Say when it is safe.** Before you push: `taskuary --note --kind ready "auth refactor pushed,
+  suite green"`. That line is what the next agent builds on. If you are stuck, `--kind blocked`.
+- One line per note, plainly, as you go. Nobody reads a wall of paragraphs — including agents.
+
 ## GitHub etiquette
 - Comment meaningful progress on the issue when one exists; keep commits small and
   descriptive.

{taskuary-0.3.2 → taskuary-0.3.2.1}/taskuary/terminal.py

@@ -62,6 +62,14 @@ def clean_env(extra: dict = None) -> dict:
     return env
 
 
+def session_env(agent: str = '', task_id=None, cwd: str = '') -> dict:
+    """What a CLI needs to know about ITSELF. `taskuary --note "..."` inside an agent's terminal
+    should not have to be told which agent or which task it is - the session already knows, so
+    it says so in the environment."""
+    return {k: str(v) for k, v in (('TASKUARY_AGENT', agent), ('TASKUARY_TASK', task_id or ''),
+                                   ('TASKUARY_CWD', cwd)) if v}
+
+
 class _WinPty:
     def __init__(self, argv, cwd, rows, cols, env=None):
         try:
@@ -129,7 +137,10 @@ class Term:
         self.witness, self.ext_id = _w.Witness(), ''     # what the agent said and did (hooks / rollout), and the CLI's own session id once a hook names it
         # the browser this session may open is named after it, so the pane can find it (browserview)
         from . import browserview as _bv
-        self.pty = (_WinPty if os.name == 'nt' else _UnixPty)(argv, cwd, rows, cols, _bv.env(self.sid))
+        # the pane's browser name, and who this session IS - so `taskuary --note` inside it needs
+        # no arguments to know which agent, task and checkout it is speaking for
+        self.pty = (_WinPty if os.name == 'nt' else _UnixPty)(
+            argv, cwd, rows, cols, {**_bv.env(self.sid), **session_env(agent or label, task_id, cwd)})
         self.alive = True
         # started LAST, and store comes in through the constructor: a CLI that dies immediately
         # used to reach keep() before the caller had handed the session anywhere to file itself
@@ -742,6 +753,12 @@ def seed_text(store, tid: int, instruction: str = None, repo: str = None, cwd: s
     from . import blackboard as bb
     aware = bb.briefing(store, cwd, exclude_tid=tid) if cwd else ''
     if aware: parts.append(aware)
+    # ...and what those agents SAID, which is the half no amount of reading git can reconstruct.
+    # It rides even when nobody else is running: the last session's "ready to push, tests green"
+    # is exactly what the next one needs, and by then that session is gone.
+    if cwd:
+        said = bb.wall_text(store, cwd)
+        if said: parts.append(said)
     if instruction and instruction.strip(): parts.append(f'ASK: {instruction.strip()}')
     from .triage import strip_boilerplate
     if m: parts.append(f"FROM {m.get('FromName') or m.get('FromEmail')} on {m.get('Channel')}, "