Auspex 0.1.0

Fixed

• Packaged apps now resolve SwiftPM resources from Contents/Resources, so a
  GitHub-downloaded build no longer crashes in Bundle.module when the CI
  checkout fallback path is absent. Release CI smoke-tests the copied archive.
• MCP writes no longer infer identity from the most recently active socket;
  official bridge requests carry request-scoped, kernel-roster-corroborated
  process attribution, while ambiguous legacy connections fail closed.
• Takeover approval expires when the reviewed task version or holder changed,
  and Catch-up ignores tool/token churn, uses a fresh click-time cursor, avoids
  duplicate orphan rows, and scopes branch collisions to a project.
• Login launch respects a user disabling the item in macOS and a later
  Finder/Dock reopen restores the normal main window.
• Liveness probes exclude retained ended history instead of re-running every
  harness filesystem check over thousands of sessions every three seconds.
• Discovery tails a one-hour recent working set instead of a full day of
  dormant stores, while live presence/worker evidence overrides the cutoff and
  SQLite/WAL polling keeps its two-second correctness cadence.
• Person-authored task writes now refresh Roost, Live Ledger and Catch-up only
  after the store accepts the transaction, avoiding stale queues and read/write races.
• Every Auspex-owned window, sheet and popover clears only its implicit initial
  responder; no control starts highlighted, while Tab/arrow navigation and
  subsequent focus feedback remain intact. Native Kill alert is now an owned sheet.
• Roost no longer enters a 100% CPU SwiftUI transaction loop after scrolling:
  scroll views use a system viewport instead of custom placement, and the
  dynamic task board no longer participates in lazy-prefetch feedback.

Added

• A 30-second Catch-up panel with a ranked human queue (including takeover
  approvals), semantic changes and non-notifying amber watch signals.
• Carbon-inspired task integrity: monotonic versions and expected_version,
  atomic dependency validation, durable human-approved takeover requests,
  holder-only completion into Review, and attempt context in tasks.get.
• Review Next navigation, on-demand bounded local-Git Delivery evidence, and
  copy-only provenance-labelled Handoff Packets.
• Safe overview.get, tasks.get, tasks.release, sessions.get, and
  project-scoped sessions.list context without peer transcripts or prompts.
• An installable, versioned auspex-coordination Supervisor/Worker/Reviewer
  Skill with owned-directory hashing, backups and exact reversal.
• Explicit Launch at login controls in first-run setup and General Settings,
  implemented with ServiceManagement and a quiet login launch.

Changed

• The bundled coordination Skill now carries task versions through writes and
  treats pending_takeover as a request rather than ownership.

Auspex 0.1.0-dev.2 (Dev)

Changed

• The board's unit is the task, not the session. A session is a process,
  and half the processes on a busy machine are subagents — a step inside
  somebody else's job, spawned and finished within one turn. Drawing each as a
  peer of the thing that spawned it gave a wall where a delegation of four read
  as four independent pieces of work, and the reader reassembled the family in
  their head every time they looked.

  Every surface now folds them. The Ledger draws one card per piece of work
  with its sessions as a strip of member dots and a ↳ 3; the sidebar lists
  project → checkout → task, with sessions only under a task somebody opened;
  the Aviary gives one desk per task with the task's title on the nameplate;
  the Flock draws one bird per task with its members as small avatars under it;
  the Flight gains a Task scope that merges every member's lane into one
  waterfall. The header, the menu bar and the sidebar count units, so a
  family of three is one working task. A single global switch — "Show
  subagents", in the grouping menu, persisted — lists the sessions on every
  card at once for people who want the old density, and a chevron per card
  does it for one.

  Work nobody filed a task for gets exactly the same card, derived from the
  root of its delegation and marked auto, with "Promote to task…" beside it.
  The task protocol stays enrichment rather than a dependency.

• Finishing a task asks for a review; it does not close it. tasks.complete
  and auspex.notify(done) move a task to a new Review state — still open,
  still counted, still on the wall, wearing the sentence the worker wrote — and
  only a person's close moves it to done. An agent saying it is done is a
  claim about its own work, and the one thing a board full of agents must not
  let any of them do is mark their own homework. The chip that used to say
  ✓ N done says ✓ N in review.

• The views are named for the birds. Ledger, Aviary, Flock, Flight, and the
  Tasks page is the Roost. --view still takes board, scene, crew and
  trajectory, because they are in people's shell histories and in settings
  files already written.

• A flock bird's body is its session, and its colour is its harness. The
  wall gave each harness a silhouette; on a board of ninety that is one bird
  drawn forty times. Bodies now come from a ten-strong plump family seeded by
  the session key, every one of them at least 0.72 as narrow as it is wide —
  asserted over the catalogue, because a shape with a point in it reads as
  spiky at 56 points and vanishes at 22. The wall itself is half the size it
  was.

Added

• Tasks carry what they are and what they wait for. A kind
  (feature/fix/chore/research), labels, an importance in words as well as a
  number, and dependencies. tasks.list takes ready_only and label, so
  "find me something to pick up" is one call rather than a list plus a
  judgement. A task waiting on unfinished work says waits on AUX-… and is not
  ready.

• Notes have kinds and refs. tasks.log takes decision, evidence,
  risk or note, and a ref — a commit, a URL, a path. That is the whole
  difference between a work log and a chat transcript: an agent that writes
  "checked, it holds" has said nothing anybody can verify.

• A task has a page. Its handle, status, importance, labels, project and
  milestone; the claim and every session on it with per-member state and
  freshness; what it waits on; its history, with a place to write into it; and
  Close, Reopen, Release claim and Promote. Reached from a card's double click
  or ⌘↩.

• ⌘K. A palette over the frame in hand: a handle out of a brief, a project
  you have not scrolled to, a session by name, and the two or three actions
  that otherwise need a right-click on a card you have to find first.

• Filters. Importance, label, harness, ready-only, claimed/unclaimed and
  orphaned claims, offered only where the wall can answer them, with a bar that
  says what is on and one click per facet to take it off.

• Orphaned claims. A claim whose session ended without finishing is marked
  amber on its card, filterable, and has Release beside it. Its own marker
  rather than a bucket: debris is not the same thing as work that is stuck.

• What each harness finishes. The Harnesses page gains claimed, finished
  and median claim-to-finish, because "how many of its sessions are open" is
  mostly history on a machine that has run agents all week.

• Projects contain tasks. Plans and projects used to be two roots side by
  side, so a task an agent filed over MCP without a plan landed in a lane called
  "Unfiled" — which meant "nobody asked where this belongs", next to the project
  it obviously belonged to. There is one hierarchy now: project ⊃ task ⊃
  sessions. tasks.create resolves the caller's project from the session on
  the other end of the socket, using the same BoardSnapshot.projectKey(for:)
  the wall groups cards by, and a task inherits its project from the milestone
  it is filed under or from the session that first claims it.

  A plan is demoted to a milestone: an optional heading inside a project.
  The plans.* tools keep their names — briefs already in flight carry them —
  and describe themselves as milestones. The Tasks page draws one lane per
  project with milestone sub-headers inside, hides projects with nothing in them
  unless the window is bound to one, and says "Nothing to do" once instead of
  drawing a dash in each of four columns. The Projects page gains a column for
  the work each project is carrying, including projects whose sessions have all
  gone home.

  Schema v5 adds tasks.project_key and plans.project_key and backfills every
  task that was already there from its claimer, then its filer, then its
  milestone; what is left lands in a Scratch project a person can empty
  rather than a NULL nobody can find.

• Attention is something said, not something inferred. A card is counted as
  wanting a person, or as having finished, only when something explicit said so
  — an agent calling auspex.notify, a PermissionRequest hook, a harness's
  own permission wait, or tasks.complete. The old done unseen bucket was
  inferred from a closed turn, which on a machine that has been running agents
  all week is true of several hundred sessions at once; a count nobody can act
  on takes the counts beside it down with it. The inference survives as a faint
  dot on a card, counted nowhere and notified never.

  Activity and attention are now orthogonal: an agent that reports finishing
  while a swift build is still running is working and done at once. The
  buckets are needsYou · doneReported · working · idle · ended, and every
  surface reads the one map the frame carries — the board's ring and banner, the
  header's chips, the sidebar's dots and per-project counts, the menu bar, the
  crew wall's badges, the Trajectory's banner and timeline marker, and which
  column a task is drawn in.

  Both loud buckets clear themselves: opening the card, typing into that
  session's own terminal, the agent going back to work, "Dismiss", the header's
  new Mark all as seen, or a day going by. session_views grows
  acknowledged_at and ack_reason so the answer survives a relaunch.

• A session waiting on a person now walks to the garden's front row instead
  of keeping its desk, and shares that row with anything that reported
  finishing — a red ! and a green ✓ by the path. A raised hand among forty
  desks is something you have to find. The back lawn keeps the resting and the
  dozing, and is still the half that gives way when a busy repository fills the
  map; nothing on the front row is ever bounded away.

• Settings → Agents gains one switch: whether a reported finish raises a
  macOS notification (on by default). A session blocked on a person always
  raises one, and deliberately has no switch.

Added

• Every card says how full its session's context window is. The /context
  gauge, for the three harnesses whose stores record it: a thin bar and
  898.8k / 1M · 90 % under the counters, coloured by the board's own state
  language — quiet ink under 70 %, tool-amber to 90 %, needs-you red above it,
  because a session about to compact is closer to "somebody should look" than
  to anything new. A tiny ⟲ 2 after it counts the compactions it has already
  been through.

  One definition of "used" on every row, so the gauge means the same thing
  wherever it appears: the tokens that were in the model's context when it
  was last called — the whole prompt, cached prefix included, and the reply
  just generated excluded, because that lands in the next call's input. Claude
  Code's input_tokens plus both cache counters; Codex's
  last_token_usage.input_tokens; Grok Build's contextTokensUsed. Cursor,
  AntiGravity, Grok Bot, Claude Cowork and Gemini CLI record nothing that
  answers it and get no gauge at all — a bar at zero would say something none
  of them said.

  The dotted half is the part worth knowing about. Codex and Grok write their
  window size into their own logs; Claude Code computes it in-process and never
  writes it down, so Auspex looks it up from the model id. What is uncertain is
  therefore the denominator, never the fill — so the fill stays solid and the
  unfilled remainder goes dotted, which says "this is roughly where the wall is"
  rather than "this measurement is soft". A model the lookup table has never
  heard of still reports a fill, with no bar: 421k is worth showing, and a
  guessed denominator is not.

  And the gauge never prints more than 100 %. A fill past the window is not a
  session at 425 % — no harness overruns its own window by four times — it is
  Auspex holding the wrong denominator, which is what a model bigger than the
  lookup table knows about loo...