taskuary 0.3.2.5__tar.gz → 0.3.2.7__tar.gz

{taskuary-0.3.2.5/taskuary.egg-info → taskuary-0.3.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskuary
-Version: 0.3.2.5
+Version: 0.3.2.7
 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.5**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.7**—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.5 → taskuary-0.3.2.7}/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.5**—and moving fast. The funnel, review queue,
+Taskuary is early—currently **v0.3.2.7**—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.5 → taskuary-0.3.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "taskuary"
-version = "0.3.2.5"
+version = "0.3.2.7"
 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.5 → taskuary-0.3.2.7}/taskuary/agents.py

@@ -9,13 +9,14 @@ from datetime import datetime
 from pathlib import Path
 from loguru import logger
 
+from . import spawn
 from .store import task_ref
 from .clis import preset_args
 
 
 def _git(cwd, *args):
     try:
-        p = subprocess.run(['git', '-C', cwd or os.getcwd(), *args], capture_output=True, text=True,
+        p = spawn.run(['git', '-C', cwd or os.getcwd(), *args], capture_output=True, text=True,
                            encoding='utf-8', errors='replace', timeout=30)
         return p.stdout.strip() if p.returncode == 0 else ''
     except Exception:
@@ -50,7 +51,7 @@ def _fresh_path() -> str:
 
 
 def _shim_target(path: str) -> list:
-    """What an npm .CMD shim actually runs. The shim is four lines of batch around one real
+    r"""What an npm .CMD shim actually runs. The shim is four lines of batch around one real
     program - claude.CMD ends with "%dp0%\node_modules\@anthropic-ai\claude-code\bin\claude.exe" %* -
     and going through cmd /c to reach it is what costs us the prompt: cmd.exe owns & | < > and
     stray quotes, so the first prompt cannot be passed as an ARGUMENT and has to be TYPED into
@@ -303,7 +304,7 @@ def run_cli(profile: dict, prompt: str, trace, resume: str = None, cancel=None):
     trace('prompt', 'prompt_sent_to_agent', prompt)
     trace('tool', 'cli', f'{name} cwd={cwd or os.getcwd()}' + (f' resume={resume}' if resume else ''))
     try:
-        p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        p = spawn.popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                              text=True, encoding='utf-8', errors='replace', cwd=cwd, shell=False,
                              env=child_env())
     except PermissionError as e:

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/browserview.py

@@ -25,6 +25,7 @@ import base64, json, os, re, shutil, socket, subprocess, time
 from datetime import datetime
 from pathlib import Path
 from loguru import logger
+from . import spawn
 
 MAX_FPS = 12                    # a watched page, not a game: 12 frames/s at ~50KB each is plenty and easy on a LAN tab
 MAX_FRAME = 8 * 1024 * 1024     # a 1280x720 jpeg is ~54KB; this is the ceiling for a huge viewport, not a target
@@ -140,7 +141,7 @@ def close(sid: str):
     headless Chrome per finished task sits idle for an hour each."""
     exe = shutil.which('agent-browser')
     if not exe or not _read(session_name(sid), 'stream'): return
-    try: subprocess.run([exe, '--session', session_name(sid), 'close'], timeout=20, capture_output=True)
+    try: spawn.run([exe, '--session', session_name(sid), 'close'], timeout=20, capture_output=True)
     except (OSError, subprocess.SubprocessError) as e: logger.debug(f'could not close the browser of {sid}: {e}')
     _CACHE.pop(sid, None); LAST.pop(sid, None)
 
@@ -174,7 +175,7 @@ def start(sid: str, url: str = 'about:blank') -> bool:
     try:
         # detached: it outlives this request and answers on its own screencast port. Output is
         # dropped - the pane IS the output, and a full pipe would block the browser.
-        subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        spawn.popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                          stdin=subprocess.DEVNULL, close_fds=True)
     except (OSError, subprocess.SubprocessError) as e:
         logger.warning(f'could not start the browser for {sid}: {e}')

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/channels.py

@@ -10,6 +10,7 @@ from datetime import datetime, timedelta
 import requests
 from loguru import logger
 
+from . import spawn
 from .github import _h as gh_headers, list_accessible_repos
 from .ingest import ingest_message
 from .counsel import is_invite
@@ -272,7 +273,7 @@ def test_connector(store, cid: int) -> dict:
             import subprocess
             host = cfg.get('host')
             if not host: raise RuntimeError('no host set - enter the machine name (e.g. AZWEB01)')
-            p = subprocess.run(['powershell', '-NoProfile', '-NonInteractive', '-Command',
+            p = spawn.run(['powershell', '-NoProfile', '-NonInteractive', '-Command',
                                 f'Test-WSMan -ComputerName {host} -ErrorAction Stop | Out-Null; '
                                 f'Invoke-Command -ComputerName {host} -ScriptBlock {{ $env:COMPUTERNAME }}'],
                                capture_output=True, text=True, encoding='utf-8', errors='replace', timeout=60)
@@ -795,6 +796,15 @@ def poll_channels(store, backfill_days: int = 0, progress=None, only=None) -> in
     try: llm = build_llm(store)
     except Exception: llm = None
     read_it = wants_read(store)   # asked once per run, not once per message
+    # a mailbox card whose source row was never created polls nothing at all, and looks connected
+    # the whole time it is doing so - so it heals itself here, before the source list is read
+    for c in store.list_connectors():
+        if c['Type'] in ('imap', 'gmail') and c['Active']:
+            try:
+                from . import imapmail
+                imapmail.ensure_source(store, store.get_connector(c['ConnectorId']))
+            except Exception as e:
+                logger.debug(f"imap: could not heal the source row for {c.get('Name')} - {e}")
     n = 0
     for c in store.list_connectors():
         if not c['Active'] or c['Type'] not in CH2SRC: continue

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/guard.py

@@ -57,6 +57,7 @@ DENIED = (
     (r'POST|PUT|PATCH', r'^/api/settings', 'the settings decide what agents may do'),
     (r'POST|PUT|PATCH|DELETE', r'^/api/(policies|agents)', 'the rules and the agent profiles'),
     (r'POST|PUT|PATCH|DELETE', r'^/api/(docs?|playbooks)(/|$)', 'SOUL.md, the playbooks and the rest are the owner\'s word, not an agent\'s - propose, do not write'),
+    (r'POST', r'^/api/update$', 'replacing the program is the owner\'s decision'),
 )
 _DENIED = tuple((re.compile(f'^({m})$', re.I), re.compile(p), why) for m, p, why in DENIED)
 

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/histgen.py

@@ -26,6 +26,10 @@ def _status(state, what='', doc=None, evidence=None):
     if doc is not None: STATUS['doc'] = doc
     if evidence is not None: STATUS['evidence'] = evidence
 SENT_CAP, INBOX_CAP = 300, 500            # per mailbox; enough signal, bounded Graph bill
+# IMAP costs one round trip PER MESSAGE (Graph pages 50 at a time), so the same 300 would be a
+# minute of silence. STYLE_SAMPLES caps what reaches the model at 60 regardless, so a smaller
+# read loses nothing worth having.
+IMAP_SENT_CAP = 120
 STYLE_SAMPLES, TRIAGE_LINES = 60, 240
 TOPIC_MIN = 3            # a subject seen this often is routine work, not a one-off
 GUIDE_TOKENS = 1400
@@ -112,6 +116,31 @@ def _graph_mail(store, days):
     return sent, inbox, n
 
 
+def _imap_sent(store, days):
+    """The same history, for a mailbox connected over IMAP. Graph is not the only way mail gets
+    here, but every history reader assumed it was - so "Generate my reply style" on a working
+    IMAP card said "connect the Outlook card", which is advice the owner cannot act on."""
+    from . import imapmail
+    _status('running', 'reading your Sent folder over IMAP...')
+    try: rows = imapmail.sent_history(store, days, cap=IMAP_SENT_CAP, progress=_status)
+    except Exception as e:
+        logger.warning(f'history: no IMAP sent mail read - {e}')
+        return []
+    # shaped like a Graph message so one reader serves both
+    return [{'subject': m.get('subject'), 'receivedDateTime': (m.get('sent_at') or '').replace(' ', 'T'),
+             'conversationId': m.get('conversation_id'),
+             'body': {'contentType': 'text', 'content': m.get('body') or ''}} for m in rows]
+
+
+def sent_mail(store, days):
+    """(messages, mailboxes, where they came from). Graph first because it can also pair the
+    inbox; IMAP when Outlook is not the mailbox on this install."""
+    sent, inbox, n = _graph_mail(store, days)
+    if sent or inbox: return sent, inbox, n, 'Graph'
+    rows = _imap_sent(store, days)
+    return rows, [], (1 if rows else 0), 'IMAP'
+
+
 def _db_window(store, days):
     since = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d %H:%M:%S')
     return [m for m in store.scan_messages() if str(m.get('SentAt') or '') >= since]
@@ -121,20 +150,21 @@ def gen_style(store, llm, days):
     """Sent mail -> how the owner writes. Graph sentitems first; Taskuary's own record
     (your context replies + drafts you approved) fills in or stands alone."""
     from .channels import _body
-    sent, _, n = _graph_mail(store, days)
+    sent, _inbox, n, how = sent_mail(store, days)
     samples = []
     for m in sent:
         t = cut_quoted(_body(m))
         if len(t) >= 30: samples.append(f"--- sent {str(m.get('receivedDateTime') or '')[:10]} · \"{(m.get('subject') or '')[:60]}\"\n{t[:800]}")
-    src = f'{len(samples)} sent mails from the last {days} days across {n} mailbox(es)'
+    src = f'{len(samples)} sent mails from the last {days} days across {n} mailbox(es), read over {how}'
     if not samples:
         msgs = [m for m in _db_window(store, days) if m.get('Status') == 'context']
         finals = [r for r in store.list_reviews() if r.get('FinalText') and r['Status'] in ('approved', 'edited')]
         samples = [f"--- your reply · \"{(m.get('Subject') or '')[:60]}\"\n{cut_quoted(str(m.get('BodyText') or ''))[:800]}" for m in msgs]
         samples += [f'--- approved draft\n{str(r["FinalText"])[:800]}' for r in finals]
-        src = f'no Graph mailbox history - used {len(samples)} replies Taskuary itself has seen'
+        src = f'no mailbox history to read - used {len(samples)} replies Taskuary itself has seen'
     if not samples:
-        raise RuntimeError('no sent mail to learn from - connect the Outlook card (or approve a few drafts) first')
+        raise RuntimeError('no sent mail to learn from - connect a mailbox (Outlook, Gmail or IMAP) and let one sync '
+                           'run, or approve a few drafts first')
     step = max(1, len(samples) // STYLE_SAMPLES)          # spread across the window, not just last week
     picked = samples[::step][:STYLE_SAMPLES]
     # receipts: which replies the model actually saw - each one is a vote on greeting,
@@ -153,21 +183,28 @@ def gen_triage(store, llm, days):
     """Inbox paired with sentitems by conversation: ANSWERED is the ground truth for what
     matters. Falls back to Taskuary's own outcomes (task/replied vs filed/ignored/skipped)."""
     lines, doms = [], {}
-    sent, inbox, n = _graph_mail(store, days)
+    sent, inbox, n, how = sent_mail(store, days)
     if inbox:
         answered = {m.get('conversationId') for m in sent if m.get('conversationId')}
         rows = [((((m.get('from') or {}).get('emailAddress') or {}).get('address') or '?').lower(),
                  str(m.get('receivedDateTime') or '')[:10], (m.get('subject') or '')[:70],
                  m.get('conversationId') in answered) for m in inbox]
-        src = f'{len(rows)} inbound + {len(sent)} sent from the last {days} days across {n} mailbox(es)'
+        src = f'{len(rows)} inbound + {len(sent)} sent from the last {days} days across {n} mailbox(es), read over {how}'
     else:
         msgs = _db_window(store, days)
+        # what the owner actually WROTE BACK beats "a task was made": the sent mail names the
+        # threads they answered, and answering is the ground truth this document is about
+        answered = {m.get('conversationId') for m in sent if m.get('conversationId')}
         rows = [((m.get('FromEmail') or '?').lower(), str(m.get('SentAt') or '')[:10], (m.get('Subject') or '')[:70],
-                 m['Status'] == 'routed' and bool(m.get('TaskId')))
+                 (m.get('ConversationId') in answered) if answered
+                 else (m['Status'] == 'routed' and bool(m.get('TaskId'))))
                 for m in msgs if m.get('Status') != 'context']
-        src = f'no Graph mailbox history - used {len(rows)} messages Taskuary itself has ingested'
+        src = (f'{len(rows)} messages Taskuary has ingested'
+               + (f', answered checked against {len(sent)} sent mails read over {how}' if answered
+                  else ' - no mailbox sent history, so "answered" is whether a task was made'))
     if not rows:
-        raise RuntimeError('no inbound history to learn from - connect the Outlook card (or let a few syncs run) first')
+        raise RuntimeError('no inbound history to learn from - connect a mailbox (Outlook, Gmail or IMAP) and let a '
+                           'few syncs run first')
     from .routing import subject_topic
     tops = {}
     for addr, _, subj, ans in rows:

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/imapmail.py

@@ -105,6 +105,109 @@ def _body_and_attachments(msg) -> tuple:
     return (text or _clean(html) or '').strip(), atts
 
 
+# ── the Sent folder ─────────────────────────────────────────────────────────────────────
+# Outlook has one name for it and Graph exposes it as `sentitems`; IMAP servers agree on nothing,
+# and Gmail hides it under a namespace. Without it an IMAP install has NO record of what the owner
+# writes, which is why "Generate my reply style" on a perfectly connected IMAP card answered "no
+# sent mail to learn from - connect the Outlook card" (owner, 2026-09-02). Ask the server instead
+# of guessing: RFC 6154 marks the folder with \Sent, and the familiar names are the fallback.
+SENT_NAMES = ('Sent', 'Sent Items', 'Sent Mail', 'INBOX.Sent', 'INBOX.Sent Items', '[Gmail]/Sent Mail')
+# (flags) "separator" name - the name may be quoted or bare, and may itself contain the separator
+_LIST_LINE = re.compile(r'^\((?P<flags>[^)]*)\)\s+(?:"(?P<sep>[^"]*)"|NIL)\s+(?P<name>.*)$')
+
+
+def _list_line(raw) -> tuple:
+    line = raw.decode('utf-8', 'replace') if isinstance(raw, (bytes, bytearray)) else str(raw)
+    m = _LIST_LINE.match(line.strip())
+    if not m: return '', ''
+    return m.group('flags') or '', (m.group('name') or '').strip().strip('"')
+
+
+def sent_folder(M) -> str:
+    """The mailbox's Sent folder, as this server spells it. '' when there is none to be found."""
+    try: typ, data = M.list()
+    except Exception: return ''
+    if typ != 'OK': return ''
+    named = []
+    for raw in data or []:
+        flags, name = _list_line(raw)
+        if not name: continue
+        if '\\Sent' in flags: return name            # the server said so: no guessing needed
+        named.append(name)
+    lower = {n.lower(): n for n in named}
+    return next((lower[w.lower()] for w in SENT_NAMES if w.lower() in lower), '')
+
+
+def sent_window(c, days: int, cap: int = 300, progress=None) -> list:
+    """What this mailbox has SENT in the last `days`, oldest first, each as
+    {subject, body, sent_at, to, conversation_id, external_id}. [] when there is no Sent folder.
+
+    Read-only by construction - the owner's own outbox is never modified, and nothing here is
+    triaged: sent mail is evidence about how they write, never work arriving."""
+    M, user = _login(c)
+    try:
+        box = sent_folder(M)
+        if not box: return []
+        typ, _d = M.select(_quoted(box), readonly=True)
+        if typ != 'OK': return []
+        since = (datetime.now() - timedelta(days=max(1, days))).strftime('%d-%b-%Y')
+        typ, data = M.uid('search', None, f'(SINCE {since})')
+        if typ != 'OK': return []
+        uids = [int(u) for u in (data[0] or b'').split()][-cap:]
+        out = []
+        for uid in uids:
+            # one fetch per message: say how far along, or the button sits silent for a minute
+            if progress and len(out) % 20 == 0:
+                progress('running', f'reading {user} - {len(out)} of {len(uids)} sent mails')
+            try:
+                typ, parts = M.uid('fetch', str(uid), '(RFC822)')
+                if typ != 'OK' or not parts or parts[0] is None: continue
+                msg = email.message_from_bytes(parts[0][1])
+                body, _atts = _body_and_attachments(msg)
+                try: when = email.utils.parsedate_to_datetime(msg.get('Date')).astimezone().strftime('%Y-%m-%d %H:%M:%S')
+                except Exception: when = ''
+                out.append({'external_id': f'imap-sent:{user}:{uid}', 'subject': _dec(msg.get('Subject')),
+                            'body': body[:20000], 'sent_at': when, 'to': _hdr_addrs(msg, 'To'),
+                            'from_email': user,
+                            'conversation_id': (msg.get('References') or msg.get('Message-ID') or '').split()[0][:200] or None})
+            except Exception as e:
+                logger.debug(f'imap: sent uid {uid} skipped - {e}')
+        return out
+    finally:
+        try: M.logout()
+        except Exception: pass
+
+
+def _quoted(name: str) -> str:
+    """A folder with a space in it ('Sent Items', '[Gmail]/Sent Mail') must reach SELECT quoted."""
+    return f'"{name}"' if any(ch in name for ch in ' ()') else name
+
+
+def sent_history(store, days: int, cap: int = 300, progress=None) -> list:
+    """Every IMAP/Gmail card's Sent folder for the window. The card list is the point: an install
+    can have two mailboxes, and the owner writes the same way in both."""
+    out = []
+    for c in store.list_connectors():
+        if c['Type'] not in ('imap', 'gmail') or not c['Active']: continue
+        try: out += sent_window(store.get_connector(c['ConnectorId'], with_secret=True), days, cap, progress)
+        except Exception as e:
+            logger.warning(f"imap: could not read sent mail from {c.get('Name') or c['Type']} - {e}")
+    return sorted(out, key=lambda m: m.get('sent_at') or '')
+
+
+def ensure_source(store, c) -> bool:
+    """Give an IMAP/Gmail card the source row the poller reads it through, if it has none. True
+    when one was just made. The mailbox address IS the source name and it is already saved on the
+    card, so there is nothing to ask the owner and nothing to guess."""
+    user = (_cfg(c).get('address') or '').strip()
+    if not user: return False
+    if any(s['Channel'] == 'email' and (s.get('Address') or '').lower() == user.lower()
+           for s in store.list_sources(active_only=False)): return False
+    store.save_source({'Channel': 'email', 'Address': user, 'ConnectorId': c['ConnectorId'], 'Active': 1}, 'self-heal')
+    logger.info(f'imap: {user} had no source row - added one so it is actually polled')
+    return True
+
+
 def poll_imap(store, c, sources: list, llm=None, file_only=False, backfill_days: int = 0) -> int:
     """UIDs are IMAP's own cursor: strictly increasing per mailbox, so the watermark on the
     connector never re-ingests - and a backfill just lowers the SINCE date, with dedupe

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/intacct.py

@@ -189,6 +189,75 @@ def fields_of(cfg, obj):
             for f in res.iter('Field')]
 
 
+# ── writing ─────────────────────────────────────────────────────────────────────────────
+# The gateway writes the same way it reads: generically, by object. So there is no create_bill,
+# create_vendor, create_journal_entry here for the same reason there are no per-object read
+# wrappers - each would be a hardcoded field list that goes stale, and `fields_of` already asks
+# the company's own schema. One create, one update, any object.
+#
+# What keeps this safe is NOT this module: the Intacct card ships at scope `read` (scopes.py), so
+# an agent calling these through /api/tools/run is refused. It reaches them only by PROPOSING
+# (proposals.py, run_tool), and the owner approves the proposal in Review. That is the same road
+# a QuickBooks bill takes, and it is deliberate: nothing posts to the books on an agent's say-so.
+
+def _record_xml(parent, fields):
+    """A record as the gateway wants it. A scalar becomes an element; a dict becomes a nested
+    element (`{'VENDORID': 'V1'}`); a list becomes REPEATED children named by dropping one
+    trailing S from the key, which is how Intacct spells line items - APBILLITEMS holds
+    APBILLITEM. Nest a dict explicitly when an object does not follow that rule."""
+    for k, v in (fields or {}).items():
+        if isinstance(v, dict):
+            _record_xml(_el(parent, k), v)
+        elif isinstance(v, (list, tuple)):
+            holder = _el(parent, k)
+            child = k[:-1] if k.upper().endswith('S') else k
+            for item in v:
+                if isinstance(item, dict): _record_xml(_el(holder, child), item)
+                else: _el(holder, child, item)
+        else:
+            _el(parent, k, '' if v is None else v)
+
+
+def _written(res, obj, verb):
+    """What came back: the key Intacct assigned and the record it echoed, so the owner's receipt
+    names a real document number rather than 'success'."""
+    rows = _rows(res)
+    rec = rows[0] if rows else {}
+    key = res.findtext('.//result/key') or rec.get('RECORDNO') or rec.get('RECORDKEY') or ''
+    return {'verb': verb, 'object': obj, 'key': str(key), 'record': rec}
+
+
+def create(cfg, obj, record):
+    """Create ONE record of `obj` (APBILL, VENDOR, GLBATCH…) from a field dict. Returns the key
+    Intacct assigned. Raises IntacctError on the usual 200-with-failure."""
+    if not str(obj or '').strip(): raise IntacctError('no Intacct object to create')
+    if not record: raise IntacctError(f'nothing to put in the new {obj} - give it fields')
+    sid, end = login(cfg)
+    root, fn = _envelope(cfg, sid)
+    _record_xml(_el(_el(fn, 'create'), obj), record)
+    res = _post(end, root)
+    _check(res)
+    logger.info(f"intacct: created {obj} in company {cfg['company_id']}")
+    return _written(res, obj, 'create')
+
+
+def update(cfg, obj, record):
+    """Change ONE existing record. The record MUST carry the key Intacct knows it by (RECORDNO,
+    or the object's own id field such as VENDORID) - without one the gateway would have to guess
+    which row is meant, and a write that guesses is the one thing this must never do."""
+    if not str(obj or '').strip(): raise IntacctError('no Intacct object to update')
+    keys = [k for k in (record or {}) if k.upper() in ('RECORDNO', 'RECORDKEY', 'KEY', f'{obj.upper()}ID')]
+    if not keys:
+        raise IntacctError(f'an update to {obj} needs the record it is changing - include RECORDNO or {obj.upper()}ID')
+    sid, end = login(cfg)
+    root, fn = _envelope(cfg, sid)
+    _record_xml(_el(_el(fn, 'update'), obj), record)
+    res = _post(end, root)
+    _check(res)
+    logger.info(f"intacct: updated {obj} {record.get(keys[0])} in company {cfg['company_id']}")
+    return _written(res, obj, 'update')
+
+
 def probe(cfg):
     """One real call for the Test button: log in, then read the company's own record. A green
     card that only proves the password was accepted hides the usual failure, which is an API

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/mcp.py

@@ -4,6 +4,7 @@ on the timeline. Config: {"cmd": "npx", "args": [...], "tool": "query", "tool_ar
 SDK dependency - keeps the single-exe desktop build lean. Spec: modelcontextprotocol.io.
 """
 import json, os, subprocess, threading, queue
+from . import spawn
 
 PROTOCOL = '2025-06-18'
 
@@ -13,7 +14,7 @@ class MCPClient:
 
     def __init__(self, cmd, args=None, env=None, timeout=60):
         self.timeout, self._id = timeout, 0
-        self.p = subprocess.Popen([cmd] + list(args or []), stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+        self.p = spawn.popen([cmd] + list(args or []), stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                                   stderr=subprocess.DEVNULL, text=True, encoding='utf-8',
                                   env={**os.environ, **(env or {})}, shell=False)
         self.q = queue.Queue()

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/proof.py

@@ -10,6 +10,7 @@ not.
 import re
 from datetime import datetime
 from loguru import logger
+from . import spawn
 
 # What a test run looks like on screen, per runner. Deliberately narrow: a line that only
 # MENTIONS pytest is not a test result, and counting it as one would turn the card into a
@@ -88,7 +89,7 @@ def _git(cwd, *args, ok=(0,)):
     the files DIFFER, which is the entire question we are asking it."""
     import subprocess
     try:
-        p = subprocess.run(['git', '-C', cwd, *args], capture_output=True, text=True,
+        p = spawn.run(['git', '-C', cwd, *args], capture_output=True, text=True,
                            encoding='utf-8', errors='replace', timeout=30)
         return p.stdout if p.returncode in ok else ''
     except Exception as e:

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/reports.py

@@ -10,6 +10,7 @@ entry - PRs welcome.
 import io, json, re, sqlite3, time
 from datetime import datetime, timedelta
 from loguru import logger
+from . import spawn
 
 PLANNED = ['graphql', 'smb_file',
            # systems of record. Intacct is BUILT (see run_intacct); the rest are named because
@@ -85,6 +86,26 @@ def run_intacct_fields(cfg):
     return rows_out(fields_of(cfg, obj), lim, unit='fields', mine=mine)
 
 
+def run_intacct_create(cfg):
+    """{"object": "APBILL", "record": {"VENDORID": "V100", "WHENCREATED": "09/01/2026",
+    "APBILLITEMS": [{"ACCOUNTNO": "6120", "AMOUNT": "412.50"}]}} - create one record.
+
+    A WRITE. The Intacct card ships at scope `read`, so an agent cannot run this directly: it
+    PROPOSES it (TASKUARY-PROPOSE run_tool) and the owner approves it in Review."""
+    from .intacct import create
+    out = create(cfg, (cfg.get('object') or '').strip(), cfg.get('record') or cfg.get('fields'))
+    return f"{out['object']} created — key {out['key'] or '(none returned)'}", json.dumps(out, indent=1, default=str)
+
+
+def run_intacct_update(cfg):
+    """{"object": "APBILL", "record": {"RECORDNO": "1042", "DESCRIPTION": "corrected memo"}} -
+    change one existing record. The record must name itself (RECORDNO, or the object's own id).
+    A WRITE, gated exactly like run_intacct_create."""
+    from .intacct import update
+    out = update(cfg, (cfg.get('object') or '').strip(), cfg.get('record') or cfg.get('fields'))
+    return f"{out['object']} {out['key'] or ''} updated".replace('  ', ' '), json.dumps(out, indent=1, default=str)
+
+
 def run_metric(cfg):
     """{"name": "<metric>", "scope": "<what names one row>", "period": "2026-07"} - ONE certified number.
 
@@ -215,7 +236,7 @@ def run_winrm(cfg):
     it once (elevated)."""
     import subprocess
     host, script = cfg['host'], cfg['script']
-    p = subprocess.run(['powershell', '-NoProfile', '-NonInteractive', '-Command',
+    p = spawn.run(['powershell', '-NoProfile', '-NonInteractive', '-Command',
                         f'Invoke-Command -ComputerName {host} -ScriptBlock {{ {script} }}'],
                        capture_output=True, text=True, encoding='utf-8', errors='replace', timeout=180)
     if p.returncode != 0: raise RuntimeError((p.stderr or p.stdout or 'remote run failed')[:500])
@@ -488,6 +509,9 @@ REGISTRY = {'sqlite': run_sqlite, 'mssql': run_mssql, 'database': run_database,
             'prometheus': run_prometheus, 'datadog': run_datadog,
             'winrm': run_winrm, 'mcp': run_mcp, 'rest': run_rest,
             'intacct': run_intacct, 'intacct_fields': run_intacct_fields,
+            # ...and the two WRITES: generic by object, like the reads. Gated by the card's scope
+            # (it ships at read), so an agent proposes them and the owner approves.
+            'intacct_create': run_intacct_create, 'intacct_update': run_intacct_update,
             # QuickBooks Online: three reads, and the first two WRITES a Corporate system has here -
             # a bill and a paid expense, gated by the card's scope (proposals below write)
             'quickbooks': _lazy('quickbooks', 'run_quickbooks'), 'quickbooks_vendors': _lazy('quickbooks', 'run_quickbooks_vendors'),
@@ -514,7 +538,8 @@ REGISTRY = {'sqlite': run_sqlite, 'mssql': run_mssql, 'database': run_database,
 # card's keys, the blob/logs types on the azure card's app - roles and creds resolve there.
 CARD_OF = {'s3_object': 'aws', 'cloudwatch_logs': 'aws', 'azure_blob': 'azure', 'azure_logs': 'azure', 'calendar': 'outlook',
            'entra_users': 'azure', 'entra_groups': 'azure', 'entra_signins': 'azure', 'entra_licenses': 'azure',
-           'intacct_fields': 'intacct', 'sharepoint_list': 'sharepoint', 'sharepoint_file': 'sharepoint',
+           'intacct_fields': 'intacct', 'intacct_create': 'intacct', 'intacct_update': 'intacct',
+           'sharepoint_list': 'sharepoint', 'sharepoint_file': 'sharepoint',
            'quickbooks_vendors': 'quickbooks', 'quickbooks_accounts': 'quickbooks', 'quickbooks_bill': 'quickbooks', 'quickbooks_expense': 'quickbooks',
            'teller_accounts': 'teller', 'teller_transactions': 'teller', 'teller_balances': 'teller',
            'kb_search': 'knowledge', 'kb_reindex': 'knowledge',
@@ -628,6 +653,7 @@ CONNECTION_OF = {'mssql': mssql_connection, 'winrm': winrm_connection, 'database
                  'entra_signins': azure_connection, 'entra_licenses': azure_connection,
                  'prometheus': prometheus_connection, 'datadog': datadog_connection,
                  'intacct': intacct_connection, 'intacct_fields': intacct_connection,
+                 'intacct_create': intacct_connection, 'intacct_update': intacct_connection,
                  **{t: _quickbooks_connection for t in ('quickbooks', 'quickbooks_vendors', 'quickbooks_accounts', 'quickbooks_bill', 'quickbooks_expense')},
                  **{t: _teller_connection for t in ('teller_accounts', 'teller_transactions', 'teller_balances')},
                  # both borrow: SharePoint the Outlook tenant app, Sheets the Gmail card's Google client

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/scopes.py

@@ -35,6 +35,10 @@ ACTIONS = {
     # run_tool) and the owner approves it in Review. Raising the card to 'write' is the owner's call.
     'quickbooks': 'read', 'quickbooks_vendors': 'read', 'quickbooks_accounts': 'read',
     'quickbooks_bill': 'write', 'quickbooks_expense': 'write',
+    # Intacct writes the same way it reads - generically, by object - so ONE pair covers posting a
+    # bill, adding a vendor and correcting a memo. The card ships at 'read' like QuickBooks', which
+    # is what makes a bill an agent's PROPOSAL rather than an agent's decision.
+    'intacct_create': 'write', 'intacct_update': 'write',
     'teller_accounts': 'read', 'teller_transactions': 'read', 'teller_balances': 'read',    # a feed cannot move money
     # the semantic layer (semantic.py) reaches the ERP only through those same reads. The check
     # DOES write - a metric it cannot reconcile is demoted, a verified one is frozen to a skill -

{taskuary-0.3.2.5 → taskuary-0.3.2.7}/taskuary/server.py

@@ -197,6 +197,23 @@ _started = datetime.now().isoformat(sep=' ', timespec='seconds')
 @app.get('/api/version')
 def version(): return {'version': _ver, 'started': _started}
 
+# ── update in place (update.py): Settings → Updates ─────────────────────────────────────
+@app.get('/api/update')
+def update_check(force: int = 0):
+    from . import update
+    return update.check(force=bool(force))
+
+@app.post('/api/update')
+def update_apply():
+    """Fetch the latest release and swap it in. The answer goes out first; the process ends a
+    moment later so the new build can start. Owner-only: guard.py refuses an agent token."""
+    from . import update
+    try: out = update.apply()
+    except Exception as e: raise HTTPException(422, str(e))
+    store.audit('app', 0, 'update', ACTOR, detail={k: v for k, v in out.items() if k != 'pip'})
+    if out.get('restarting'): update.exit_soon()
+    return out
+
 def _can_send(channel, has_message=True, gh_ok=None) -> bool:
     """Can an approved reply actually LEAVE on this channel? One answer for the whole app -
     outbound.can_reply - so the Approve button, triage and the coder wrap-up cannot
@@ -2989,13 +3006,12 @@ async def terminal_ws(ws: WebSocket, sid: str):
             await asyncio.to_thread(t.write, ''.join(chunks))
     input_pump = asyncio.create_task(to_pty())
     try:
-        # scrubbed: a replayed scrollback that still contains the TUI's terminal queries makes
-        # xterm answer them AGAIN, and the answers land in the CLI as typed junk - see terminal.py
-        # flagged as a REPLAY so the browser can hold the curtain over it: writing a long
-        # scrollback runs the viewport from the top of the session down to the bottom, and
-        # watching a week of coding scroll past every time you reopen a task is not a feature
+        # RENDERED, not raw (terminal.replay_text): the raw bytes of a full-screen TUI replay as
+        # debris in a fresh xterm, and the live repaint then appends to that debris. Flagged as a
+        # REPLAY so the browser holds the curtain over it until the live screen is up.
         if t.scrollback():
-            await send_frame({'type': 'out', 'replay': True, 'data': hub_term.scrub_queries(t.scrollback())})
+            snap = hub_term.replay_text(t)
+            if snap: await send_frame({'type': 'out', 'replay': True, 'data': snap})
         first_resize = True
         while True:
             m = await ws.receive_json()

taskuary-0.3.2.7/taskuary/spawn.py

@@ -0,0 +1,34 @@
+"""Child processes that do not open a console window.
+
+Taskuary ships as a WINDOWED app - `taskuary.spec` builds Taskuary.exe with `console=False`, and
+the desktop launcher is a pywebview window. On Windows a process with no console of its own gives
+every child it starts a BRAND NEW one: a black window that pops up, flashes, and sometimes stays.
+Nothing was wrong with the work being done; it was `git status`, a PowerShell report, a headless
+agent run, each politely allocating a terminal nobody asked for. ("It keeps on opening terminal
+windows which doesn't happen on this machine" - the owner, 2026-09-02, on a machine running the
+exe. The machine where it never happened launches from a terminal, whose console the children
+quietly inherit, which is exactly why this went unnoticed for so long.)
+
+CREATE_NO_WINDOW says "run, but allocate no console". It is Windows-only and a no-op elsewhere.
+
+What must NOT come through here: the interactive pty sessions. ConPTY (pywinpty) manages its own
+hidden console and the flag has no business there - and the WhatsApp bridge, which already asks
+for DETACHED_PROCESS, a stronger statement of the same intent.
+"""
+import os
+import subprocess
+
+# defined on Windows Python 3.7+; the literal keeps this importable (and testable) anywhere
+CREATE_NO_WINDOW = getattr(subprocess, 'CREATE_NO_WINDOW', 0x08000000)
+WINDOWS = os.name == 'nt'
+
+
+def flags(**kw) -> dict:
+    """The caller's keyword arguments, plus the flag that keeps the console shut on Windows.
+    An explicit creationflags is kept and OR-ed, never replaced."""
+    if not WINDOWS: return kw
+    return {**kw, 'creationflags': kw.get('creationflags', 0) | CREATE_NO_WINDOW}
+
+
+def run(*args, **kw): return subprocess.run(*args, **flags(**kw))
+def popen(*args, **kw): return subprocess.Popen(*args, **flags(**kw))