Task Panel

Development biography · earlier archive

Development profile compiled from project source and retained records in October 2026. Dates and test results describe those records; they do not imply a new build, live acceptance test or public release.

PUBLIC LINKS: none. AssistantApp is a private, unreleased macOS app. There is no download or public repository.

Biography

The problem. Most assistant apps treat a typed task as a prompt: a model writes a confident plan and the app shows it. AssistantApp already had the parts of something better: a per-task prompt architect, persona packs, an evidence model, a staged reasoning pipeline and a two-lane support planner. A source audit on 21 September 2026 found that most of these compiled but had zero production callers. The task list said "Plan ready" even when no planner had run and a placeholder outline was shown. So the work was mostly wiring, truthfulness and one durable spine, not new capability (roadmap header).

The idea. A task should travel from capture to reasoned completion with as little interruption as possible. It should also never pretend. Three principles run through every phase:

• Measure before believing. Every model-facing step is checked against hand-labelled tasks on the real on-device model, using a dedicated harness (Tools/TaskIntakeHarness). Fixes that didn't measure better were rejected.
• Provenance on everything. Each line on a task's page carries a badge saying whether it came from you, a rule, a connector receipt or a model's inference. The type system makes omitting it impossible.
• Autonomy by tier, not by trust. Silent and notify actions run alone. "Confirm" actions run only against a recorded grant for those exact words. "User-only" actions (send, dial, pay) never run on their own.

What happens to a task. You type something into the panel, for example "Book a dentist check-up next month".

• Read. Apple's on-device model decodes the text directly into Swift enums: intent, domain, timing, priority and a safety reading. This takes about 2 s instead of the ~50 s of the old three-pass chain. An off-vocabulary answer is impossible rather than merely detected. Agreement between the model and independent keyword cues gives an ordinal support level, not a fake confidence number. On the dev set, corroborated readings were right 94% of the time, single 86% and contested 79%.
• Gate. A deterministic sufficiency check decides whether the text identifies anything to act on. Of five gate designs measured, it was the only one that asked no needless question. If the text is too vague, you get one grounded question instead of a fabricated plan.
• Cast. A rule table picks an "architecture" for the task and assigns roles: who leads, who researches, who drafts, who critiques. Every decision is recorded with its reason. A safety reading floors autonomy. A crisis reading also removes every acting tool and signposts help (Samaritans, 116 123, UK), worded as a reading that may be wrong.
• Plan. A guided on-device planner produces three to six task-specific steps, any blockers, and up to two search hooks. Before the October fix, 54 of 71 planned tasks got a placeholder because the model's JSON broke. After it, 42 of 45 dev tasks and 24 of 24 fresh held-out tasks got real plans, and median planning time fell from 87 s to 16 s.
• Act. An executor works through the plan by tier and leaves a receipt for everything, including what it held back and why. A step counts as done because evidence exists, not because a model said so. A critic role reads the completion claim, built from receipts, and its doubts are shown, but it can't erase a receipt.
• Ask once. Questions from the gate and the planner are merged, typed (yes/no, choice, date, free text), and asked as one batch within the cast's question budget. Anything the plan already assumed is flagged, not asked.
• Show. The task's Overview page changes form as the task moves: questions, approvals, working, blocked, done, quiet. A "Next Best Move" and two lanes, "done for you" and "needs you", sit beneath it. An approvals tray shows exactly what a confirm-tier step would send or create. The task list badge tells the truth: Working, Needs you, Retrying at…, No plan yet, Done.
• Remember. Each stage is sealed into encrypted task memory. Observations, episodes and syntheses are encoded with Douglas's own CBOR-LD package, sealed with ChaChaPoly, hash-chained per task, and keyed from the login keychain. "Landmarks" record every transition, who decided it, and the page as it stood, so a relaunched app rebuilds history from the chain alone. A cut tail or swapped chain is reported by name. "Since you were last here" lists what happened without you.
• Learn, privately. A completed task leaves a de-identified lesson: how it went, never what it said. It uses closed vocabularies only. In testing, a seeded name, phone number, postcode, medicine and address never appeared in a lesson. Lessons feed "Tasks like this before" on similar open tasks.

Durability. Submitting a task posts an envelope to a durable mailroom. Retries back off from 30 s to 2 min to 8 min, then go to a dead letter that shows its reason and a "Try again" button. A quit mid-run is recovered at launch.

Who it's for. People who hand a lot of small life-admin to an assistant and need to trust it: anyone whose attention is limited, and anyone for whom a wrong autonomous action costs more than a question. The design treats "bad capture" and "low certainty" as facts to show, not to hide.

Status in one line. Phases 0–8a are committed in the integration branch, with green builds. Phases 8b and 8c, the planner fix and the chat improvements are built, tested and staged as a landing commit, but not yet merged.

Features (what a visitor could see, once captured)

Authored in AssistantApp (AssistantApp/Sources/Tasks/, Sources/AI/):

• Living Overview page (Tasks/Overview/): seven page forms, a stage rail, Next Best Move, "done for you" and "needs you" lanes, and provenance badges on every line.
• Approvals tray: concrete confirm-tier actions with their exact payload. "Not now" is kept as your decision.
• One-tap correction: settle an undetermined or contested reading, or deliberately override a safety reading. The override is bound to that exact text, and Undo is available.
• Honest task list: one truthful badge per row (TaskListStatus).
• Mailroom strip: what's being done, what it needs, what was tried, and dead letters with "Try again".
• Typed batch questions: EssentialQuestion.
• Landmark rail: choose a landmark to see the page as it was, read-only, with what changed and why. Plus "Since you were last here".
• Task document view: saved answers, open loops, assumptions, evidence-badged facts and a run timeline. It's rendered by a sealed web kit with no bridge, so nothing on the page can act.
• Notes tools on the task page: select part of the task conversation to remember it, make it a subtask, or ask about it. A selection keeps the weakest provenance of its parts.
• Streamed task chat, plus one shared parser for planner "Suggestions" (hooks for searches, places, YouTube, next step).

Dependencies, not authored here: Apple FoundationModels (on-device model), CryptoKit, WebKit, and Douglas's own local packages (below).

Technical foundations

• Swift 6 / SwiftUI, macOS 26; FoundationModels guided generation (@Generable) for the first pass and the planner. A schema trap was found and documented: a 0–1 list guide is refused by the model service.
• Local packages: CBORLD (Douglas's CBOR-LD library; task memory's encoding), SemanticControlCore and NodeBGGen (Utilities). The memory vocabulary is pinned by fingerprint: v1 frozen, landmarks under v2.
• Security: ChaChaPoly-sealed, hash-chained per-task stores, keys in the login keychain, an authenticated anchor outside the chain, and bounded decoding (an earlier crash-on-corrupt-file was fixed in Phase 3a).
• Test harness: Tools/TaskIntakeHarness, a headless CLI compiled against the app's real source files. The app's own XCTest host can't run on the build Mac.
• 495 contract checks.
• Golden and held-out sets with a ledger that marks a held-out slice "spent" once used.
• Prompt fingerprints that fail the contracts when wording changes without a replay.
• Mutation testing, e.g. 21/21 planner mutants and 23/23 at Phase 8a.
• metrics.py reports per split; it never pools dev and held-out.

Maturity by feature (dated evidence)

"Unknown" means the retained records contain no evidence of an in-app run since that phase. The app was last known run before Phase 2's live-metrics instrumentation, because no execution journal existed on the Mac on 26 Sep. Landing waits on the MacResilience consolidation plan and the studio’s agreement.

Limitations

• Not released, not on iPhone, and Phases 8b–8c are not merged.
• The cloud (OpenAI) path was never measured: the build Mac's network blocked it.
• The safety screen's 9/9 crisis detection isn't independent evidence: its phrases and the test items share an author. On its own, the model flagged crisis items at crisis tier only 2 of 5 (dev) and 1 of 4 (held-out) times.
• Every planned task currently asks 1–4 questions by design. Whether to always ask is an open decision.
• Remaining planner misses: 2 stalls and 2 guardrail declines on dev, and 1 held-out plan names the wrong blocker.
• Stages aren't yet separate workers. Only the critic role is called by the pipeline.
• Hand labels and rule tables share an author, so agreement between them isn't independent validation.

Roadmap

• Land 8b, 8c and the chat work via the MacResilience plan.
• Live-use metrics: time to first useful action, silent failures, re-entry.
• A "hand to an agent" action for code-shaped tasks via AgentBridge, as a dev build only. Proposed, not approved.
• Local model catalogue: choose among the Mac's 21 local MLX models per job, only where one beats the current model on fresh held-out tests. Proposed, not approved.
• Claude as planner after SDK adoption lands, measured first.

FAQs

• Does it act without asking? Only for silent or notify-tier steps. Anything that sends, pays or dials never runs on its own; confirm-tier steps need your recorded yes for those exact words.
• Does my task text leave the Mac? Not on the default path: reading and planning run on Apple's on-device model. A cloud model is used only if you pick one.
• What if it misreads my task? Contested readings are flagged and one tap settles them. Your choice outranks every model and survives reclassification.
• What does it remember? Everything about the task, encrypted and tamper-evident, kept while the task exists and removed 30 days after you delete it (undo cancels). Lessons shared across tasks are de-identified by construction.
• How do you know it works? A headless harness runs the real source against hand-labelled tasks and the real on-device model, with held-out sets and mutation tests. In-app runtime evidence is still pending.