@sporhq/spor 0.7.1 → 0.9.0

package/.claude-plugin/plugin.json

@@ -2,6 +2,6 @@
   "name": "spor",
   "displayName": "Spor Context Compiler",
   "description": "Maintains a typed, versioned knowledge graph and compiles compact briefings from it: session-start injection, per-prompt relevance digests, capture at discovery, end-of-session distillation, decision queue.",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "author": { "name": "losthammer" }
 }

package/API.md

@@ -22,7 +22,11 @@ graph's git repo. What a client sees:
   and `session: <id>` and uses `authored_via: dispatch`, while `author:` stays
   the agent's **owning person** — so the node reads "agent on behalf of person".
   These ride-along fields are token-derived too; any supplied in the payload are
-  discarded.
+  discarded. The `session` is the agent's REAL run session: `spor dispatch` mints
+  the token **session-deferred** (it can't know the session before `claude --bg`
+  self-allocates it) and binds the real one post-launch via `POST /v1/agents/session`
+  (§3, dec-spor-dispatch-bg-session-late-bind) — so writes BEFORE the bind carry no
+  `session` (honest, never a phantom), and writes after trace to the actual run.
 - **Create**: `if_exists: "skip"` → id collision is reported as `skipped`
   (the distiller default); `if_exists: "error"` → id collision is a
   `conflict` error.
@@ -301,8 +305,8 @@ endpoint is the REST twin of a core call:
 | `POST /v1/nodes` | drain-outbox, mechanical writers | `put_node` semantics, batch: `{nodes: [...], if_exists: "skip"}` (entries may be raw strings or `{node, if_exists, revision}`) → `{results: [...]}`, 207 when any entry failed |
 | `POST /v1/nodes/{id}/edges` `{type, to}` | scripts, mechanical writers | `add_edge` semantics (§1): normalize/flip, dedupe, append — no revision echo |
 | `POST /v1/nodes/{id}/status` `{status}` | scripts, mechanical writers | `set_status` semantics (§1): one-scalar update through the `transitions()` gate. Setting a work node to an in-progress status also CLAIMS it (same lease as `/claim` below) |
-| `POST /v1/nodes/{id}/claim` `{session?}` | `claim`/`set_status` MCP tools, `spor dispatch` | take the heartbeat-renewed lease (dec-cc-task-claim-lease): writes the durable `assigned` edge once, attributes to `$viewer` from the token (never an argument), and creates the ephemeral lease → `{ok, status, lease: {node_id, by, expires, expires_at, session, claimed_at}, edge}`. A live lease held by ANOTHER person is `409 conflict` naming the holder + expiry (re-claiming your OWN live claim just renews it). `session` scopes the heartbeat (omit to leave it person-scoped, so any of the claimer's sessions may renew — what `spor dispatch` does, since the launched agent renews from a different session) |
-| `POST /v1/nodes/{id}/renew` `{session?}` | post-tool heartbeat, `renew` MCP tool | bump the live lease's expiry only — no commit; the heartbeat that keeps a claim from lapsing. A lapsed/stolen lease is `409` (names the current holder). Person-scoped: any of the claimer's sessions may renew |
+| `POST /v1/nodes/{id}/claim` `{session?}` | `claim`/`set_status` MCP tools, `spor dispatch` | take the heartbeat-renewed lease (dec-cc-task-claim-lease): writes the durable `assigned` edge once, attributes to `$viewer` from the token (never an argument), and creates the ephemeral lease → `{ok, status, lease: {node_id, by, expires, expires_at, session, claimed_at}, edge}`. A live lease held by ANOTHER person is `409 conflict` naming the holder + expiry (re-claiming your OWN live claim just renews it). `session` scopes the heartbeat (omit to leave it person-scoped, so any of the claimer's sessions may renew — what `spor dispatch` does at the PRE-launch claim, since `claude --bg` self-allocates the run session only at launch; dispatch then renews with the real session once it has read it from `claude agents --json`, dec-spor-dispatch-bg-session-late-bind) |
+| `POST /v1/nodes/{id}/renew` `{session?}` | post-tool heartbeat, `renew` MCP tool, `spor dispatch` | bump the live lease's expiry only — no commit; the heartbeat that keeps a claim from lapsing. A lapsed/stolen lease is `409` (names the current holder). Person-scoped: any of the claimer's sessions may renew; a `session` binds the lease to that run (`spor dispatch` uses this to bind the captured `claude --bg` session post-launch) |
 | `POST /v1/nodes/{id}/release` | `release` MCP tool | drop the lease AND retire the durable `assigned` edge, returning the node to the pool. Idempotent (releasing a node you hold no lease on still succeeds, cleaning up any lingering `assigned` edge of yours); releasing a claim someone else holds is `409` naming the holder |
 | `POST /v1/nodes/{id}/commits` `{repo, sha}` | post-tool / link-commits | `link_commit`: append `repo@sha` to the node's `commits:` list (kebab-case repo slug, 7–40 lowercase hex, ≤40 commits per node); idempotent, prefix-aware dedup |
 | `GET /v1/commits/{sha}?repo=` | sessions doing git archaeology | sha → nodes lookup over the `commits:` fields (≥7 hex, abbreviated or full); each match carries `{repo, sha, id, type, title, summary, status, project}` — blame a line, get the why |
@@ -321,7 +325,8 @@ endpoint is the REST twin of a core call:
 | `DELETE /v1/admin/tokens/{hash-prefix}` | offboarding / rotation | revoke the single PAT matching the hash prefix (≥8 hex chars; an ambiguous prefix is a 409) → `{revoked, hash_prefix}`. Admin-only |
 | `GET /v1/agents` | `spor agent list` | list the agents the caller **owns** → `{agents: [{id, label, owner, spiffe, pubkey, status}], count}`; `?all=1` lists every agent (admin-only) |
 | `POST /v1/admin/agents` `{label, owner?, id?, pubkey?}` | `spor agent create`, onboarding | create a person-owned `agent` node + its `owned-by` edge (`owner` defaults to the caller's person; `id` derives from `label`) → 201 `{id, owner, spiffe, pubkey, status, revision}`. 409 dup id / 422 invalid / 403 non-admin. Admin-only, same `stewards→root` gate as `/v1/admin/tokens` |
-| `POST /v1/agents/{id}/token` `{session, audience?, expires?}` | `spor dispatch` | **self-serve** (NOT admin): mint a short-TTL, per-session token scoped to agent `{id}` → 201 `{token, expires_at, agent, session}`. Authorized iff the caller's person **owns** the agent (its `owned-by` edge) — else `403`; `404` unknown agent; `422` bad/missing `session`. The token carries `{agent, session}` (the person is derived from the `owned-by` edge at verify time); a write under it is stamped agent-on-behalf-of-person (§1). A caller `expires` may only shorten the default TTL, never extend it |
+| `POST /v1/agents/{id}/token` `{session?, audience?, expires?}` | `spor dispatch` | **self-serve** (NOT admin): mint a short-TTL, per-session token scoped to agent `{id}` → 201 `{token, expires_at, agent, session}` (`session: null` when deferred). Authorized iff the caller's person **owns** the agent (its `owned-by` edge) — else `403`; `404` unknown agent; `422` a SUPPLIED `session` that is malformed. `session` is now **OPTIONAL** (deferred binding, dec-spor-dispatch-bg-session-late-bind): `spor dispatch` mints it deferred because `claude --bg` self-allocates the run session only at launch, then binds the real one via `POST /v1/agents/session` below. The token carries `{agent, session?}` (the person is derived from the `owned-by` edge at verify time); a write under it is stamped agent-on-behalf-of-person (§1). A caller `expires` may only shorten the default TTL, never extend it |
+| `POST /v1/agents/session` `{session}` | `spor dispatch` (post-launch) | **late session binding** for a session-deferred agent token (dec-spor-dispatch-bg-session-late-bind). Authenticated by the **agent token itself** (the bearer hash identifies its own record — no agent id in the path, no ownership re-check), so only an agent-scoped token may call it (`403` otherwise). Sets that token's `session` → `200 {ok, agent, session}`. **Write-once**: idempotent on the same value (`{unchanged: true}`), `409 conflict` on a different one (a token's session is provenance, not a mutable field); `422` missing/malformed `session`. Every subsequent write under the token then stamps the bound session |
 
 Path parameters (node ids, project slugs) must match
 `^[a-z0-9][a-z0-9-]*$`. Request bodies are capped at 1MB
@@ -378,8 +383,20 @@ anything with a token.
   background agent (so the agent's own graph writes carry its identity), picking
   the machine's default agent from the `dispatch.agent` client config (set with
   `spor agent use <agent-id>`, or `SPOR_DISPATCH_AGENT`), which `spor dispatch
-  --as <agent-id>` overrides for a single run. (Not to be confused with `spor
-  dispatch --agent`, the unrelated `claude --agent` harness passthrough.)
+  --as <agent-id>` overrides for a single run. The `<agent-id>` is the agent's
+  `agent-`-prefixed NODE id (what `spor agent list` prints), **not** its bare
+  label — the token endpoint requires the prefix, so the client setters
+  (`spor agent use`, `--as`) reject a prefix-less id with a `did you mean
+  agent-…?` hint rather than persist one every dispatch would 422 on. (Not to be
+  confused with `spor dispatch --agent`, the unrelated `claude --agent` harness
+  passthrough.) The
+  token is minted **session-deferred** and bound to the real run session AFTER
+  launch (dec-spor-dispatch-bg-session-late-bind): `claude --bg` ignores
+  `--session-id` and self-allocates its session, so dispatch reads the real one
+  from `claude agents --json` and binds it via `POST /v1/agents/session` (§3) — the
+  one place an agent token's session is set, write-once. The session can't be
+  forged a-priori (it isn't known until the run exists) and can't ride the write
+  payload (token-derived, §1), so the binding is always the actual run.
 - **OAuth 2.1 for MCP connectors** (Cowork/claude.ai, which cannot carry a
   static bearer token): protected-resource metadata discovery (RFC 9728,
   advertised on the `/mcp` 401 via `WWW-Authenticate`), authorization-server

package/bin/spor.js

@@ -418,7 +418,9 @@ function dispatchedAgents() {
       if (!a || a.kind !== "background" || typeof a.name !== "string") continue;
       if (a.state === "done") continue; // finished — not in flight
       const list = map.get(a.name) || [];
-      list.push({ id: a.id, name: a.name, state: a.state, status: a.status, cwd: a.cwd });
+      // sessionId + startedAt ride along for post-launch session capture
+      // (dec-spor-dispatch-bg-session-late-bind); the dup-guard ignores them.
+      list.push({ id: a.id, name: a.name, state: a.state, status: a.status, cwd: a.cwd, sessionId: a.sessionId, startedAt: a.startedAt });
       map.set(a.name, list);
     }
     return map;
@@ -427,6 +429,40 @@ function dispatchedAgents() {
   }
 }
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Find the FULL run-session id of the agent `spor dispatch` just launched in `dir`
+// (dec-spor-dispatch-bg-session-late-bind). `claude --bg` self-allocates and
+// prints only a SHORT id, but `claude agents --json` reports the full `sessionId`
+// + `cwd` + `startedAt` — the reliable capture path. Match on cwd (the strong
+// signal — we just launched there), then on name when given, then pick the NEWEST
+// (the run we just started). Returns the sessionId or null.
+function newestDispatchedSession(name, dir) {
+  const all = [];
+  for (const arr of dispatchedAgents().values()) for (const a of arr) all.push(a);
+  let cands = all.filter((a) => a.sessionId && (!dir || a.cwd === dir));
+  if (name) {
+    const named = cands.filter((a) => a.name === name);
+    if (named.length) cands = named;
+  }
+  if (!cands.length) return null;
+  cands.sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0));
+  return cands[0].sessionId;
+}
+
+// Capture the launched run's session, polling briefly while the daemon registers
+// it. SPOR_SESSION_ID pins it (tests/reproducibility) and short-circuits the poll.
+// Returns the sessionId or null (fail-open — the caller degrades to session-null).
+async function captureDispatchSession(name, dir, pinned) {
+  if (pinned) return pinned;
+  for (let i = 0; i < 6; i++) {
+    const sid = newestDispatchedSession(name, dir);
+    if (sid) return sid;
+    await sleep(300);
+  }
+  return null;
+}
+
 // Stamp items[].in_flight from the dispatched-agent map, optionally dropping the
 // in-flight ones (--hide-dispatched). Every kept item gets an in_flight boolean
 // (so the flag is present on all of them — claude absent => uniformly false);
@@ -984,6 +1020,28 @@ async function cmdAgent(cfg, args) {
   return 1;
 }
 
+// A valid Spor agent id, mirroring the server's token-mint contract EXACTLY
+// (spor-server server/rest.js: `SLUG_RE.test(id) && id.startsWith("agent-")`).
+// The `agent-` prefix is load-bearing: the agent NODE id carries it, but the
+// `spor agent create`/`list` output also prints the bare LABEL, so copying the
+// label into `spor agent use`/`dispatch --as` is an easy slip — and the bare
+// slug passes a plain kebab check while the server's POST /v1/agents/{id}/token
+// 422s on it (invalid_node), silently dropping the dispatch to person-scoped.
+// One predicate, used by every client setter that feeds that endpoint, so the
+// client never accepts an id the server rejects
+// (issue-spor-dispatch-agent-id-prefix-validation-gap).
+function isAgentId(id) {
+  return typeof id === "string" && /^[a-z0-9][a-z0-9-]*$/.test(id) && id.startsWith("agent-");
+}
+
+// When a rejected id is a valid kebab slug that merely DROPPED the `agent-`
+// prefix (the common label-vs-id slip), suggest the prefixed form; else null.
+function agentIdGuess(id) {
+  return typeof id === "string" && /^[a-z0-9][a-z0-9-]*$/.test(id) && !id.startsWith("agent-")
+    ? `agent-${id}`
+    : null;
+}
+
 // `spor agent use <agent-id>` — make this agent the machine's default dispatch
 // identity by writing `dispatch.agent` to the USER config.json (the same
 // machine-local, never-committed file as the repo map; per-machine, like
@@ -997,8 +1055,10 @@ function cmdAgentUse(cfg, { id }) {
     err("usage: spor agent use <agent-id>   (or: spor agent use --clear)");
     return 1;
   }
-  if (!clear && !/^[a-z0-9][a-z0-9-]*$/.test(id)) {
-    err(`invalid agent id '${id}' — must match ^[a-z0-9][a-z0-9-]*$ (e.g. agent-your-machine)`);
+  if (!clear && !isAgentId(id)) {
+    err(`invalid agent id '${id}' — must be an 'agent-<slug>' kebab id (e.g. agent-your-machine)`);
+    const guess = agentIdGuess(id);
+    if (guess) err(`  did you mean '${guess}'?  ('spor agent list' shows the full id — the 'agent-' prefix is part of it, not the label)`);
     return 1;
   }
   const home = cfg.userConfigHome();
@@ -2056,17 +2116,16 @@ async function topQueueItem(cfg, slug) {
 // post-tool heartbeat drives (dec-cc-task-claim-lease, task-cc-claim-nudge-hook).
 // REMOTE-MODE ONLY: a claim is a server-held lease; local mode has no pool or
 // contention (dec-cc-task-claim-lease "Local mode"), so the caller skips it and
-// local dispatch stays byte-identical. SESSION-BOUND at dispatch
-// (dec-spor-session-identity-active-record): dispatch now FORCES the session id
-// (`--session-id <uuid>`), so it knows the working session up front and binds the
-// lease to it; the launched bg agent runs under that exact session, so its
-// post-tool heartbeat renews the same-session lease (the earlier person-scoped /
-// session:null workaround existed only because the old dispatcher did NOT know
-// the working session — that reason is gone). Omitting `session` leaves the lease
-// person-scoped, the prior behavior. Returns {ok} on success/idempotent-renew,
-// {conflict, message} when the node is already held (the concurrent-dispatch case
-// this guards), or {error} for any other failure (fail-open: the caller warns and
-// dispatches anyway).
+// local dispatch stays byte-identical. PRE-LAUNCH the claim is PERSON-SCOPED
+// (session omitted, dec-spor-dispatch-bg-session-late-bind): `claude --bg`
+// IGNORES `--session-id` and self-allocates its real session, so the working
+// session is NOT knowable up front — binding the lease to a forced uuid was a
+// phantom (issue-spor-dispatch-bg-ignores-forced-session-id). Dispatch instead
+// captures the real session post-launch and binds it via renewDispatch (and the
+// bg agent's own post-tool heartbeat renews the same-session lease thereafter).
+// Returns {ok} on success/idempotent-renew, {conflict, message} when the node is
+// already held (the concurrent-dispatch case this guards), or {error} for any
+// other failure (fail-open: the caller warns and dispatches anyway).
 async function claimDispatch(cfg, nodeId, session) {
   const body = session ? { session } : {};
   const r = await remote.post(cfg, `/v1/nodes/${encodeURIComponent(nodeId)}/claim`, body, { timeoutMs: 6000 });
@@ -2088,6 +2147,35 @@ async function claimDispatch(cfg, nodeId, session) {
   return { ok: false, error: r.transport ? r.error : `HTTP ${r.status}${code ? ` (${code})` : ""}` };
 }
 
+// Renew the dispatch lease, binding it to the REAL session captured post-launch
+// (dec-spor-dispatch-bg-session-late-bind). The pre-launch claim was person-scoped;
+// this binds the lease's session to the real `claude --bg` run so the lease and the
+// rebound agent token agree from the start (instead of waiting for the agent's first
+// heartbeat to self-heal it). Best-effort: a lapsed/stolen lease (409) or any other
+// failure is swallowed — the bg agent's heartbeat still renews it. Returns {ok}.
+async function renewDispatch(cfg, nodeId, session) {
+  const r = await remote.post(cfg, `/v1/nodes/${encodeURIComponent(nodeId)}/renew`, { session }, { timeoutMs: 3000 });
+  return { ok: !!r.ok };
+}
+
+// Late-bind the agent token's run session (dec-spor-dispatch-bg-session-late-bind).
+// The token was minted session-DEFERRED before launch (the session wasn't knowable
+// yet); this reports the REAL session captured from `claude agents --json`,
+// authenticated by the AGENT TOKEN ITSELF (not the person token) so the server can
+// set it on that token's record. Every subsequent write under the token then stamps
+// the real session. Best-effort/fail-open: a server without the route (404), a
+// conflict (409), or any transport error leaves the token session-null (writes carry
+// no session — honest, never a phantom) rather than blocking dispatch. Returns
+// {ok}|{absent}|{conflict}|{error}.
+async function bindAgentSession(cfg, agentToken, session) {
+  const r = await remote.post(cfg, `/v1/agents/session`, { session }, { timeoutMs: 3000, token: agentToken });
+  if (r.ok) return { ok: true };
+  if (r.status === 404) return { ok: false, absent: true };
+  if (r.status === 409) return { ok: false, conflict: true };
+  const code = r.json && r.json.error && r.json.error.code;
+  return { ok: false, error: r.transport ? r.error : `HTTP ${r.status}${code ? ` (${code})` : ""}` };
+}
+
 // Resolve the directory to launch in. --dir wins; else a known slug is looked up
 // in the map; else the cwd's durable repo root. { dir:null } means "slug unknown
 // here". The cwd fallback uses dispatchRoot() (not repoRoot()) so a dispatch run
@@ -2190,13 +2278,18 @@ function dispatchAgentId(cfg) {
 // OWNERSHIP-gated, NOT admin-gated: POST /v1/agents/{id}/token authenticated with
 // the dispatcher's normal person token (SPOR_TOKEN); the server checks the caller
 // OWNS agent {id} (the owned-by edge) — so a normal teammate can mint a token for
-// their own machine's agent without being an admin. REMOTE only. Returns
-// { ok, token } on success, { absent:true } when the mint surface isn't deployed
-// yet (404 — the spor-server stream is building it; fail soft, dispatch without
-// agent-scoping), or { error } on any other failure incl. 403/owner-mismatch
-// (also fail soft — warn and dispatch person-scoped, never block).
+// their own machine's agent without being an admin. REMOTE only. The token is
+// minted session-DEFERRED (session omitted) when the real session isn't yet known
+// — the standing case, since `claude --bg` allocates it only at launch
+// (dec-spor-dispatch-bg-session-late-bind); dispatch binds the real session
+// afterward via bindAgentSession. The `session` param is kept for a caller that
+// genuinely knows it up front (none today — dispatch always defers). Returns
+// { ok, token } on success, { absent:true }
+// when the mint surface isn't deployed yet (404 — fail soft, dispatch person-
+// scoped), or { error } on any other failure incl. 403/owner-mismatch (also fail
+// soft — warn and dispatch person-scoped, never block).
 async function mintAgentToken(cfg, { agent, session }) {
-  const r = await remote.post(cfg, `/v1/agents/${encodeURIComponent(agent)}/token`, { session }, { timeoutMs: 6000 });
+  const r = await remote.post(cfg, `/v1/agents/${encodeURIComponent(agent)}/token`, session ? { session } : {}, { timeoutMs: 6000 });
   if (r.transport) return { error: r.error };
   // 404 = no route (surface not deployed) => absent, dispatch falls back cleanly.
   if (r.status === 404) return { absent: true };
@@ -2209,16 +2302,17 @@ async function mintAgentToken(cfg, { agent, session }) {
 // Write the 0600 --mcp-config JSON that gives the bg agent ONLY its own
 // agent-scoped Spor MCP (account connector excluded by --strict-mcp-config,
 // verified #1). Machine-local, gitignored-adjacent path under the user config
-// home's outbox; per-session filename so concurrent dispatches don't collide.
-// Returns the file path. The bg agent reads it on startup AFTER this process
-// exits (claude --bg detaches), so we cannot delete it eagerly — cleanup is a
-// best-effort sweep of stale files here, plus the documented short-TTL token
-// inside it (dec-spor-session-identity-active-record open item).
-function writeDispatchMcpConfig(cfg, { token, session }) {
+// home's outbox; per-dispatch filename (`key`, a fresh uuid) so concurrent
+// dispatches don't collide — the session id is no longer known at this point
+// (deferred until post-launch, dec-spor-dispatch-bg-session-late-bind). Returns
+// the file path. The bg agent reads it on startup AFTER this process exits (claude
+// --bg detaches), so we cannot delete it eagerly — cleanup is a best-effort sweep
+// of stale files here, plus the documented short-TTL token inside it.
+function writeDispatchMcpConfig(cfg, { token, key }) {
   const dir = path.join(cfg.userConfigHome(), "outbox", "dispatch");
   fs.mkdirSync(dir, { recursive: true });
   sweepStaleMcpConfigs(dir);
-  const file = path.join(dir, `mcp-${session}.json`);
+  const file = path.join(dir, `mcp-${key}.json`);
   const conf = {
     mcpServers: {
       spor: {
@@ -2231,8 +2325,8 @@ function writeDispatchMcpConfig(cfg, { token, session }) {
   // 0600: the file holds a live bearer token. Create with O_EXCL (wx) so a
   // pre-placed file or symlink at this path is REFUSED rather than written
   // through, and the file is 0600 from creation (no widen-then-narrow window).
-  // The session-uuid filename makes a real collision a non-issue; a stale
-  // leftover was swept above.
+  // The uuid filename makes a real collision a non-issue; a stale leftover was
+  // swept above.
   const fd = fs.openSync(file, "wx", 0o600);
   try {
     fs.writeSync(fd, JSON.stringify(conf, null, 2) + "\n");
@@ -2396,23 +2490,45 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
   // exit / unparseable output => empty => no guard (fail-open); --force overrides.
   const inFlight = nodeId && !backfill ? dispatchedAgents().get(name) || [] : [];
 
-  // Session identity (dec-spor-session-identity-active-record). Force the
-  // session id up front — `--session-id <uuid>` makes the dispatched run's
-  // session deterministic, so the agent-scoped token below can bind it AND the
-  // claim can be session-bound at dispatch (the bg agent's post-tool heartbeat
-  // renews under this same id). SPOR_SESSION_ID pins it for tests/reproducibility.
-  const session = process.env.SPOR_SESSION_ID || crypto.randomUUID();
+  // Session identity (dec-spor-dispatch-bg-session-late-bind). `claude --bg`
+  // IGNORES `--session-id` and self-allocates its own run session (verified — it
+  // warns and ignores the flag), so we do NOT force one and the session is NOT
+  // knowable up front. The agent token is minted session-DEFERRED; the real
+  // session is captured from `claude agents --json` AFTER launch and bound then
+  // (rebind the token + renew the lease). SPOR_SESSION_ID pins the session for
+  // tests/reproducibility (short-circuits the capture). `mcpKey` names the 0600
+  // --mcp-config file — a fresh uuid, since the session id isn't available here.
+  const pinnedSession = process.env.SPOR_SESSION_ID || null;
+  const mcpKey = crypto.randomUUID();
   // This machine's agent node — the WHO a dispatched session runs as. `--as`
-  // overrides the per-machine dispatch.agent default for this one dispatch (its
-  // id format mirrors a node id; a bad/unowned one fails soft at token-mint
-  // below, like the config default). Only meaningful remotely (the server is the
-  // CA that mints the agent token); a local-mode dispatch or an unconfigured
-  // machine simply runs person-scoped.
-  if (asAgent && !/^[a-z0-9][a-z0-9-]*$/.test(asAgent)) {
-    err(`invalid --as agent id '${asAgent}' — must match ^[a-z0-9][a-z0-9-]*$ (e.g. agent-your-machine)`);
+  // overrides the per-machine dispatch.agent default for this one dispatch. The
+  // id must satisfy the SAME contract the server's token-mint endpoint enforces
+  // (an 'agent-<slug>' kebab id) — an EXPLICIT --as that doesn't is a hard error
+  // here, caught before any side effect rather than as a per-dispatch 422
+  // (issue-spor-dispatch-agent-id-prefix-validation-gap). Only meaningful remotely
+  // (the server is the CA that mints the agent token); a local-mode dispatch or an
+  // unconfigured machine simply runs person-scoped.
+  if (asAgent && !isAgentId(asAgent)) {
+    err(`invalid --as agent id '${asAgent}' — must be an 'agent-<slug>' kebab id (e.g. agent-your-machine)`);
+    const guess = agentIdGuess(asAgent);
+    if (guess) err(`  did you mean '--as ${guess}'?  ('spor agent list' shows the full id — the 'agent-' prefix is part of it, not the label)`);
     return 1;
   }
-  const identityAgent = cfg.mode() === "remote" ? (asAgent || dispatchAgentId(cfg)) : null;
+  let identityAgent = cfg.mode() === "remote" ? (asAgent || dispatchAgentId(cfg)) : null;
+  // A configured `dispatch.agent` (no --as) that isn't a valid agent id — e.g. the
+  // agent's LABEL stored instead of its 'agent-'-prefixed NODE id — would 422 at
+  // token-mint and silently fall back to person-scoped on EVERY dispatch, quietly
+  // defeating agent attribution (issue-spor-dispatch-agent-id-prefix-validation-gap).
+  // Catch it here with an actionable line and run person-scoped, rather than a
+  // round-trip to a 422 that names nothing. Fail-soft (don't block the dispatch):
+  // the explicit --as path already hard-errored above, so this only fires for the
+  // config default.
+  if (identityAgent && !isAgentId(identityAgent)) {
+    err(`warning: configured dispatch.agent '${identityAgent}' is not a valid agent id — dispatching person-scoped.`);
+    const guess = agentIdGuess(identityAgent);
+    err(`  agent ids start with 'agent-'.${guess ? ` fix: spor agent use ${guess}` : ""}  ('spor agent list' shows your agents.)`);
+    identityAgent = null;
+  }
   // An explicit --as can't take effect in local mode — there is no CA to mint the
   // agent token. Say so rather than silently dropping it to person-scoped.
   if (asAgent && cfg.mode() !== "remote") {
@@ -2425,9 +2541,8 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
   if (model) claudeArgs.push("--model", model);
   if (permMode) claudeArgs.push("--permission-mode", permMode);
   if (agent) claudeArgs.push("--agent", agent);
-  // Force the session id on every dispatch (local or remote). It is the run leaf
-  // of the agent's identity and what the session-bound claim + heartbeat key on.
-  claudeArgs.push("--session-id", session);
+  // NB: no `--session-id` — `claude --bg` ignores it (warns) and manages its own
+  // session; we capture the real one post-launch (dec-spor-dispatch-bg-session-late-bind).
 
   if (dryRun) {
     out(`dir:    ${res.dir}  (slug: ${res.slug}, via ${res.source})`);
@@ -2439,7 +2554,7 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
       out(`onboard: ${steps.join("; ")}`);
     }
     out(`brief:  ${brief ? `${brief.length} bytes` : "(none — graph had nothing relevant, or --no-brief/--backfill)"}`);
-    out(`session: ${session}`);
+    out(`session: ${pinnedSession || "(allocated by claude --bg at launch, bound after)"}`);
     // Identity preview: what the real dispatch would do for agent-scoping. The
     // token mint + 0600 mcp-config are SIDE EFFECTS, so --print only describes
     // them (it writes nothing and makes no network call here). Local mode and an
@@ -2447,7 +2562,7 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
     // session line, which is additive and always present now.
     if (identityAgent) {
       const src = asAgent ? " (via --as)" : "";
-      out(`agent:  ${identityAgent}${src} (would mint a per-session agent-scoped token + write a 0600 --mcp-config, then add --strict-mcp-config)`);
+      out(`agent:  ${identityAgent}${src} (would mint a session-deferred agent-scoped token + write a 0600 --mcp-config, add --strict-mcp-config, then bind the run session after launch)`);
     } else if (cfg.mode() === "remote") {
       out(`agent:  (none configured — 'spor agent use agent-<machine>' or --as to attribute as agent-on-behalf-of; dispatching person-scoped)`);
     }
@@ -2463,7 +2578,7 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
     // Auto-claim preview (remote node dispatch only — local mode has no lease, so
     // nothing is announced there and local --print stays byte-identical).
     if (nodeId && !backfill && cfg.mode() === "remote") {
-      out(`claim:  ${noClaim ? "(--no-claim — lease not established)" : `would establish a session-bound lease on ${nodeId} at launch`}`);
+      out(`claim:  ${noClaim ? "(--no-claim — lease not established)" : `would establish a lease on ${nodeId} at launch (session bound from the run after launch)`}`);
     }
     if (template != null) out(`template: ${path.resolve(templateOpt)}`);
     out(`run:    ${claudeBin} ${claudeArgs.map(shellQuote).join(" ")} <prompt>`);
@@ -2500,21 +2615,35 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
   // the VERIFIED mechanism): mint a per-session agent-scoped token, write it into
   // a 0600 --mcp-config that exposes ONLY the agent's own Spor MCP, and add
   // --strict-mcp-config so the account connector is excluded by construction. The
-  // server then stamps authored_by_agent + session from that token. FAIL SOFT at
+  // server then stamps authored_by_agent + session from that token. The token is
+  // minted session-DEFERRED — the run session isn't known until `claude --bg`
+  // self-allocates it, so we bind it AFTER launch (dec-spor-dispatch-bg-session-
+  // late-bind), keeping `agentToken` to authenticate that late bind. FAIL SOFT at
   // every step — a server without the mint surface, or a transient error, falls
   // back to the prior person-scoped dispatch with a clear line. Remote + a
-  // configured agent only; local/unconfigured dispatch is byte-identical but for
-  // the always-present --session-id.
+  // configured agent only; local/unconfigured dispatch is byte-identical.
+  let agentToken = null;
   if (identityAgent) {
-    const mint = await mintAgentToken(cfg, { agent: identityAgent, session });
+    // Always session-DEFERRED — the run session is bound after launch (below),
+    // even when SPOR_SESSION_ID pins it (the pin feeds the capture, not the mint),
+    // so the bind path is uniform.
+    const mint = await mintAgentToken(cfg, { agent: identityAgent });
     if (mint.ok) {
-      const mcpFile = writeDispatchMcpConfig(cfg, { token: mint.token, session });
+      agentToken = mint.token;
+      const mcpFile = writeDispatchMcpConfig(cfg, { token: mint.token, key: mcpKey });
       claudeArgs.push("--mcp-config", mcpFile, "--strict-mcp-config");
-      out(`agent:  ${identityAgent} (session ${session} — writes attributed agent-on-behalf-of-you)`);
+      out(`agent:  ${identityAgent} (writes attributed agent-on-behalf-of-you; run session bound after launch)`);
     } else if (mint.absent) {
-      err(`warning: this server can't mint agent-scoped session tokens yet — dispatching person-scoped (session ${session}).`);
+      err(`warning: this server can't mint agent-scoped session tokens yet — dispatching person-scoped.`);
     } else {
-      err(`warning: could not mint an agent token (${mint.error}) — dispatching person-scoped (session ${session}).`);
+      // Name the offending agent and the fix — a bare "(HTTP 422 …)" tells the
+      // operator nothing about WHICH id is wrong or how to repair it. The format
+      // gate is now caught client-side above, so a 422 here means the id is a
+      // well-formed 'agent-<slug>' the server still rejected (e.g. no such agent /
+      // not owned); point at the list either way
+      // (issue-spor-dispatch-agent-id-prefix-validation-gap).
+      err(`warning: could not mint an agent token for ${identityAgent} (${mint.error}) — dispatching person-scoped.`);
+      err(`  check it exists and you own it: spor agent list  (set this machine's default with: spor agent use <agent-id>)`);
     }
   }
 
@@ -2523,18 +2652,19 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
   // duplicate agent onto contested work, and the lease is live the moment the
   // agent starts (its post-tool writes then renew it — and seeing its own held
   // claim, it skips the redundant claim-nudge). Remote node-mode only; --no-claim
-  // opts out (dispatch with no lease, the prior behavior). Now SESSION-BOUND
-  // (dec-spor-session-identity-active-record): dispatch forces the session id, so
-  // the lease binds it and the bg agent's same-session heartbeat renews it.
+  // opts out (dispatch with no lease, the prior behavior). PERSON-SCOPED here
+  // (session omitted, dec-spor-dispatch-bg-session-late-bind): the real session
+  // isn't known until after launch, so we bind it to the lease via renewDispatch
+  // below; until then any of this person's sessions may renew it.
   if (nodeId && !backfill && !noClaim && cfg.mode() === "remote") {
-    const c = await claimDispatch(cfg, nodeId, session);
+    const c = await claimDispatch(cfg, nodeId);
     if (c.conflict) {
       err(`${nodeId} is already claimed — ${c.message}`);
       err(`  not dispatching a duplicate. Re-run with --no-claim to dispatch anyway (no lease),`);
       err(`  or pick another task with 'spor next'.`);
       return 1;
     }
-    if (c.ok) out(`claimed ${nodeId} (session-bound lease established; the agent's writes will renew it)`);
+    if (c.ok) out(`claimed ${nodeId} (lease established; the agent's writes will renew it)`);
     else err(`warning: could not establish a lease on ${nodeId}: ${c.error} — dispatching without a claim`);
   }
   claudeArgs.push(prompt);
@@ -2543,6 +2673,34 @@ async function cmdDispatch(cfg, { values, positionals: pos }) {
     err(`could not launch ${claudeBin}: ${r.error.message}`);
     return 1;
   }
+
+  // Late session binding (dec-spor-dispatch-bg-session-late-bind). `claude --bg`
+  // has now self-allocated its run session and registered the agent; read the
+  // REAL session from `claude agents --json` and bind it: (a) rebind the agent
+  // token's session so every subsequent agent write stamps the real run, and
+  // (b) renew the lease to it so lease and token agree (instead of waiting for
+  // the agent's first heartbeat to self-heal). Best-effort throughout — a capture
+  // miss or any bind failure leaves the token session-null (writes carry no
+  // session: honest, never a phantom) and the lease self-healing via heartbeat.
+  // Remote only, and only when there's something to bind (an agent token and/or a
+  // claimed node).
+  const wantBind = cfg.mode() === "remote" && (agentToken || (nodeId && !backfill && !noClaim));
+  if (wantBind) {
+    const realSession = await captureDispatchSession(name, res.dir, pinnedSession);
+    if (realSession) {
+      if (agentToken) {
+        const b = await bindAgentSession(cfg, agentToken, realSession);
+        if (b.ok) out(`session: ${realSession} (bound — the agent's writes trace to this run)`);
+        else if (b.conflict) err(`note: the agent token is already bound to another session — leaving it.`);
+        // absent/transport error: token stays session-deferred (no phantom) — silent, fail-open.
+      } else {
+        out(`session: ${realSession}`);
+      }
+      if (nodeId && !backfill && !noClaim) await renewDispatch(cfg, nodeId, realSession);
+    } else if (agentToken) {
+      err(`note: could not read the run session from 'claude agents' — writes will carry no session stamp (the lease still self-heals).`);
+    }
+  }
   return r.status == null ? 1 : r.status;
 }
 

package/lib/graph.js

@@ -42,6 +42,15 @@ function loadGraph(nodesDir) {
   return kernel.buildGraph(shell.readGraphFiles(dir), { nodesDir: dir, seedSchemas: loadSeedSchemas() });
 }
 
+// Incremental single-node cache update (SERVER.md §4.1, task-cc-spor-tier-2-scale):
+// mutate a resident graph in place for one created/updated node instead of the
+// O(corpus) loadGraph rebuild. Returns { id, mode } or { id, reloadRequired }.
+// The kernel owns the tf-idf/adjacency representation, so the incremental twin
+// of buildGraph lives beside it; the server reaches it through this seam.
+function applyNode(graph, text, file) {
+  return kernel.applyNode(graph, text, file);
+}
+
 function compile(graph, opts = {}) {
   return kernel.compile(graph, { ...opts, seedSchemas: opts.seedSchemas ?? loadSeedSchemas() });
 }
@@ -80,6 +89,7 @@ const KNOWN_EDGES = seedRegistry().knownEdgeTypes();
 
 module.exports = {
   loadGraph,
+  applyNode,
   compile,
   validateNode: kernel.validateNode,
   validateGraph,
@@ -108,6 +118,9 @@ module.exports = {
   // decision queue (QUEUE.md §4/§5): re-exported so the server keeps one door.
   // (Safe non-cycle: queue.js only requires graph.js inside its CLI block.)
   rankQueue: require("./queue.js").rankQueue,
+  // warm the queue's memoized HEAD-pure indexes on a resident graph
+  // (task-cc-rankqueue-memoization); the server calls it from store.reload().
+  warmQueueIndex: require("./queue.js").warmQueueIndex,
   EDGE_WEIGHTS,
   KNOWN_TYPES,
   KNOWN_EDGES,

package/lib/kernel/graph.js

@@ -152,10 +152,23 @@ function buildGraph(files, { nodesDir = "", seedSchemas = [] } = {}) {
 
   const adj = {};
   const supersededBy = {};
+  // danglingTo (task-cc-spor-tier-2-scale, §4.1 incremental cache): edges whose
+  // SOURCE is traversable but whose TARGET does not exist yet — the GRAPH.md
+  // "worth creating" markers. buildGraph skips them (no adjacency), but the
+  // incremental updater (applyNode) needs them: when the target is later
+  // created, those edges must light up, exactly as a from-scratch rebuild would
+  // make them. Keyed by the missing target id. A non-existent-but-non-
+  // traversable target is NOT dangling (it exists; the edge is permanently
+  // inactive), so only the `!nodes[e.to]` branch records here.
+  const danglingTo = {};
   for (const n of Object.values(nodes)) {
     if (!traversable(n)) continue;
     for (const e of n.edges) {
-      if (!nodes[e.to] || !traversable(nodes[e.to])) continue;
+      if (!nodes[e.to]) {
+        (danglingTo[e.to] ??= []).push({ from: n.id, type: e.type, weight: reg.edgeWeight(e.type) });
+        continue;
+      }
+      if (!traversable(nodes[e.to])) continue;
       const w = reg.edgeWeight(e.type);
       (adj[n.id] ??= []).push({ to: e.to, type: e.type, weight: w });
       (adj[e.to] ??= []).push({ to: n.id, type: `${e.type} (inbound)`, weight: w });
@@ -187,8 +200,12 @@ function buildGraph(files, { nodesDir = "", seedSchemas = [] } = {}) {
     postings[t] = { docs: new Int32Array(df[t]), w: new Float64Array(df[t]) };
     cursor[t] = 0;
   }
+  // docIndex (task-cc-spor-tier-2-scale, §4.1): id -> position in `docs`, so the
+  // incremental updater can find a node's doc slot in O(1) instead of scanning.
+  const docIndex = Object.create(null);
   for (let i = 0; i < docs.length; i++) {
     const d = docs[i];
+    docIndex[d.id] = i;
     const dv = vec(d.tf); // transient; folded into the posting lists below
     let nn = 0;
     for (const t of Object.keys(dv)) {
@@ -202,11 +219,224 @@ function buildGraph(files, { nodesDir = "", seedSchemas = [] } = {}) {
     delete d.tf; // dead after this; rankAgainst reads only postings + d.norm
   }
 
-  return { nodes, adj, supersededBy, docs, df, N, postings, nodesDir, registry: reg,
+  return { nodes, adj, supersededBy, docs, df, N, postings, docIndex, danglingTo, nodesDir, registry: reg,
     projectAliases: projectAliasMap(nodes), archivedProjects: archivedProjectSet(nodes),
     groupingRepos: groupingRepoMap(nodes) };
 }
 
+// ---------- incremental cache update (SERVER.md §4.1, task-cc-spor-tier-2-scale) ----------
+//
+// applyNode(graph, text, file) mutates a resident graph IN PLACE to reflect one
+// created or updated node, WITHOUT the O(corpus) rebuild loadGraph/buildGraph
+// does on every write. At 50k nodes a full reload is ~3-5s, dominated entirely
+// by re-tokenizing and re-vectorizing every node's tf-idf; this touches only the
+// changed node's terms, so a write is O(node size + its terms' posting lengths),
+// i.e. milliseconds. The structural maps (adj / supersededBy / danglingTo /
+// docIndex) are patched with exactly the rules buildGraph applies, so the result
+// is structurally identical to a rebuild.
+//
+// FIDELITY AND DRIFT. A from-scratch buildGraph scores every doc against the
+// FINAL df/N. applyNode (re)scores ONLY the changed doc against the current
+// df/N and leaves the already-resident docs' tf-idf weights at their last-build
+// df/N. The per-write idf drift for an unchanged doc is log((N±1)/df) vs
+// log(N/df) — vanishing against a large corpus — and is fully resynced by any
+// full reload (boot, SIGHUP, the §4.1 HEAD poll, or the server's periodic
+// resync after SPOR_RELOAD_EVERY writes). The changed doc itself is always
+// scored exactly as a rebuild would score it. Posting-list array ORDER differs
+// from a rebuild (append order vs directory order), but rankAgainst accumulates
+// each doc's score across its query terms independent of intra-posting order, so
+// only equal-sim tie ordering can differ — never a relevance result. The load-
+// test harness (task-cc-spor-tier-2-scale) verifies top-K parity at scale.
+//
+// SCHEMA WRITES change the registry (edge weights, traversability) for the WHOLE
+// graph and so cannot be patched locally — applyNode returns
+// { reloadRequired: true } and the caller falls back to reload(). DELETIONS are
+// likewise out of scope: the server write path never deletes a node, and an
+// external delete arrives through the HEAD-poll full reload.
+//
+// Returns { id, mode: "create" | "update" } on success, or
+// { id, reloadRequired: true } when a full reload is required instead.
+function applyNode(graph, text, file) {
+  const node = parseFrontmatter(text, file || "incoming.md");
+  const id = node.id;
+  const reg = graph.registry;
+  // A schema node alters the registry globally; rebuild rather than patch.
+  if (node.type === "schema") return { id, reloadRequired: true };
+
+  // Invalidate the queue's memoized HEAD-pure indexes (task-cc-rankqueue-
+  // memoization): this write may change a blocks/resolves/answers/finding edge,
+  // supersession, or status that resolutionMap/openFindingsMap/blockersIndex/
+  // blockingCounts depend on, so the resident cache must not survive the
+  // mutation. The next rankQueue rebuilds it lazily; a full reload starts from a
+  // fresh graph object that never had one. Symbol.for keys the same slot
+  // queue.js sets, with no require cycle back into the queue kernel.
+  delete graph[Symbol.for("spor.queue.derived-index")];
+
+  const old = graph.nodes[id] || null;
+  const trav = (n) => !!n && reg.isTraversable(n.type);
+
+  // ---- structural maps: adjacency, supersededBy, danglingTo ----
+  // Remove the OLD node's own forward edges (and their inbound mirrors / dangling
+  // registrations) before installing the new node, then add the new node's.
+  if (trav(old)) removeNodeStructure(graph, old, reg);
+  graph.nodes[id] = node;
+  if (trav(node)) {
+    addNodeStructure(graph, node, reg);
+    activateDangling(graph, id, reg); // edges that were dangling onto this id light up
+  } else {
+    // A non-traversable node now exists: edges pointing at it stay permanently
+    // inactive (buildGraph skips a non-traversable target), so they are no
+    // longer "worth creating" markers — drop the dangling registrations.
+    delete graph.danglingTo[id];
+  }
+
+  // ---- tf-idf index: df / N / docs / postings (traversable nodes only) ----
+  // Type is fixed by the id prefix, so traversability is invariant across an
+  // update: a node that has a doc keeps one, and a non-traversable node never
+  // gets one.
+  if (trav(node)) {
+    const newTf = tf(tokens(`${node.title ?? ""} ${node.summary ?? ""} ${node.body}`));
+    const idx = old ? graph.docIndex[id] : null;
+    if (old && idx != null) {
+      // UPDATE: reuse the doc slot. Remove the old term contributions, then add
+      // the new — net df change is +1/-1 only for terms that entered or left.
+      const oldTf = tf(tokens(`${old.title ?? ""} ${old.summary ?? ""} ${old.body}`));
+      for (const t of Object.keys(oldTf)) {
+        if (graph.df[t] != null && (graph.df[t] -= 1) <= 0) delete graph.df[t];
+        removePosting(graph.postings, t, idx);
+      }
+      for (const t of Object.keys(newTf)) graph.df[t] = (graph.df[t] ?? 0) + 1;
+      // N is unchanged on an update. Score with the now-current df/N, exactly as
+      // a rebuild would score this doc in the post-update corpus.
+      const vec = makeVec(graph.df, graph.N);
+      const dv = vec(newTf);
+      let nn = 0;
+      for (const t of Object.keys(dv)) { const x = dv[t]; nn += x * x; pushPosting(graph.postings, t, idx, x); }
+      graph.docs[idx].norm = Math.sqrt(nn);
+    } else {
+      // CREATE: append a new doc slot.
+      for (const t of Object.keys(newTf)) graph.df[t] = (graph.df[t] ?? 0) + 1;
+      graph.N += 1;
+      const i = graph.docs.length;
+      const vec = makeVec(graph.df, graph.N);
+      const dv = vec(newTf);
+      let nn = 0;
+      for (const t of Object.keys(dv)) { const x = dv[t]; nn += x * x; pushPosting(graph.postings, t, i, x); }
+      graph.docs.push({ id, norm: Math.sqrt(nn) });
+      graph.docIndex[id] = i;
+    }
+  }
+
+  // ---- project / grouping / archived maps ----
+  // Only repo and project nodes feed these three maps; recompute them (each an
+  // O(N) scan with negligible per-node work) only when such a node is touched.
+  if (node.type === "repo" || node.type === "project" ||
+      (old && (old.type === "repo" || old.type === "project"))) {
+    graph.projectAliases = projectAliasMap(graph.nodes);
+    graph.archivedProjects = archivedProjectSet(graph.nodes);
+    graph.groupingRepos = groupingRepoMap(graph.nodes);
+  }
+
+  return { id, mode: old ? "update" : "create" };
+}
+
+// Remove a (traversable) node's OWN forward edges from the adjacency, along with
+// the inbound mirrors they placed on their targets, the supersession entries
+// they set, and the dangling registrations they made onto not-yet-existent
+// targets. Inbound entries OTHER nodes placed on this node are owned by those
+// nodes and left untouched.
+function removeNodeStructure(graph, n, reg) {
+  const id = n.id;
+  for (const e of n.edges) {
+    const t = graph.nodes[e.to];
+    if (!t) { dropDangling(graph, e.to, id, e.type); continue; }
+    if (!reg.isTraversable(t.type)) continue;
+    removeAdjEdge(graph.adj, id, e.to, e.type);                 // forward
+    removeAdjEdge(graph.adj, e.to, id, `${e.type} (inbound)`);  // inbound mirror
+    if (e.type === "supersedes" && graph.supersededBy[e.to] === id) delete graph.supersededBy[e.to];
+  }
+}
+
+// Add a (traversable) node's forward edges to the adjacency (with inbound
+// mirrors), set supersession, and register edges onto not-yet-existent targets
+// as dangling — the exact rules buildGraph's adjacency loop applies.
+function addNodeStructure(graph, n, reg) {
+  const id = n.id;
+  for (const e of n.edges) {
+    const t = graph.nodes[e.to];
+    const w = reg.edgeWeight(e.type);
+    if (!t) { (graph.danglingTo[e.to] ??= []).push({ from: id, type: e.type, weight: w }); continue; }
+    if (!reg.isTraversable(t.type)) continue;
+    (graph.adj[id] ??= []).push({ to: e.to, type: e.type, weight: w });
+    (graph.adj[e.to] ??= []).push({ to: id, type: `${e.type} (inbound)`, weight: w });
+    if (e.type === "supersedes") graph.supersededBy[e.to] = id;
+  }
+}
+
+// A node `id` was just created and is traversable: edges that pointed at it
+// while it was missing now light up, both directions, exactly as a rebuild
+// would build them once the target exists.
+function activateDangling(graph, id, reg) {
+  const pend = graph.danglingTo[id];
+  if (!pend) return;
+  for (const d of pend) {
+    const from = graph.nodes[d.from];
+    if (!from || !reg.isTraversable(from.type)) continue; // source vanished/became inert
+    (graph.adj[d.from] ??= []).push({ to: id, type: d.type, weight: d.weight });
+    (graph.adj[id] ??= []).push({ to: d.from, type: `${d.type} (inbound)`, weight: d.weight });
+    if (d.type === "supersedes") graph.supersededBy[id] = d.from;
+  }
+  delete graph.danglingTo[id];
+}
+
+function dropDangling(graph, to, from, type) {
+  const list = graph.danglingTo[to];
+  if (!list) return;
+  const i = list.findIndex((d) => d.from === from && d.type === type);
+  if (i >= 0) list.splice(i, 1);
+  if (list.length === 0) delete graph.danglingTo[to];
+}
+
+// Remove ONE adjacency entry matching {to, type} from adj[from]. Weight is a
+// pure function of type, so to+type identifies the entry; duplicate edges
+// balance because the caller removes one per edge it adds.
+function removeAdjEdge(adj, from, to, type) {
+  const list = adj[from];
+  if (!list) return;
+  const i = list.findIndex((x) => x.to === to && x.type === type);
+  if (i >= 0) list.splice(i, 1);
+  if (list.length === 0) delete adj[from];
+}
+
+// Append (docIndex, weight) to term t's posting list. The base lists are typed
+// arrays sized exactly at build time (issue-cc-graph-vec-posting-lists); a list
+// touched by an incremental write is promoted once to plain growable arrays
+// (rankAgainst reads .length/index identically for both, and the Float64 values
+// are unchanged, so scores stay bit-identical). The next full reload restores
+// the compact typed-array form, bounding the memory give-back to terms touched
+// since the last reload.
+function pushPosting(postings, t, idx, w) {
+  let p = postings[t];
+  if (!p) { postings[t] = { docs: [idx], w: [w] }; return; }
+  if (ArrayBuffer.isView(p.docs)) { p.docs = Array.from(p.docs); p.w = Array.from(p.w); }
+  p.docs.push(idx); p.w.push(w);
+}
+
+// Remove every entry for `idx` from term t's posting list (an update may have
+// the same doc index appear once). Promotes a typed-array list to plain arrays.
+function removePosting(postings, t, idx) {
+  const p = postings[t];
+  if (!p) return;
+  const docsArr = p.docs, wArr = p.w;
+  const nd = [], nw = [];
+  for (let k = 0; k < docsArr.length; k++) {
+    if (docsArr[k] === idx) continue;
+    nd.push(docsArr[k]); nw.push(wArr[k]);
+  }
+  if (nd.length === 0) delete postings[t];
+  else { p.docs = nd; p.w = nw; }
+}
+
 // ---------- project identity (task-cc-project-identity-nodes) ----------
 
 // Slug -> project-node-id map from resident `type: project` nodes. Every
@@ -1065,6 +1295,7 @@ module.exports = {
   buildRegistry,
   schemaActive,
   buildGraph,
+  applyNode,
   resolveProject,
   groupingOf,
   scopeFor,

package/lib/kernel/queue.js

@@ -107,8 +107,15 @@ function isLive(node, supersededBy) {
 }
 
 // Distinct live nodes transitively reachable over OUTBOUND `blocks` edges
-// (GRAPH.md: `n blocks t` == t cannot proceed until n does).
-function blockingCount(graph, id) {
+// (GRAPH.md: `n blocks t` == t cannot proceed until n does). The result is a
+// pure function of the graph's HEAD (structure + status/supersession liveness),
+// so an optional `memo` (Map id->count) caches it across rankQueue calls on a
+// resident graph (task-cc-rankqueue-memoization) — this per-item traversal is
+// the dominant queue-build cost at scale. The cache lives on the graph object
+// (queueIndex below) and is invalidated by reload/applyNode, so a memoized hit
+// is byte-identical to a fresh traversal (norm-cc-byte-identical-refactor).
+function blockingCount(graph, id, memo) {
+  if (memo) { const c = memo.get(id); if (c !== undefined) return c; }
   const seen = new Set();
   const stack = [id];
   while (stack.length) {
@@ -123,6 +130,7 @@ function blockingCount(graph, id) {
   }
   let live = 0;
   for (const tid of seen) if (isLive(graph.nodes[tid], graph.supersededBy)) live++;
+  if (memo) memo.set(id, live);
   return live;
 }
 
@@ -324,21 +332,48 @@ function heatScore(graph, id, activity) {
   return h;
 }
 
-// Fraction of this node's anchors that are superseded or missing.
-function stalenessScore(graph, node) {
+// Fraction of this node's anchors that are superseded or missing. Like
+// blockingCount this is a pure function of the graph's HEAD (edge structure +
+// supersession), independent of every per-call input, so an optional `memo`
+// (Map id->fraction) caches it across rankQueue calls on a resident graph
+// (task-cc-rankqueue-staleness-date-memo). The cache lives on the graph object
+// (queueIndex) and dies with reload/applyNode, so a hit returns the exact
+// double a fresh scan produced (norm-cc-byte-identical-refactor).
+function stalenessScore(graph, node, memo) {
+  if (memo) { const c = memo.get(node.id); if (c !== undefined) return c; }
   const edges = node.edges ?? [];
-  if (!edges.length) return 0;
-  let stale = 0;
-  for (const e of edges) {
-    if (!graph.nodes[e.to] || graph.supersededBy[e.to]) stale++;
+  let v;
+  if (!edges.length) v = 0;
+  else {
+    let stale = 0;
+    for (const e of edges) {
+      if (!graph.nodes[e.to] || graph.supersededBy[e.to]) stale++;
+    }
+    v = stale / edges.length;
   }
-  return stale / edges.length;
+  if (memo) memo.set(node.id, v);
+  return v;
 }
 
-function ageDays(node, now) {
-  if (!node.date || !/^\d{4}-\d{2}-\d{2}/.test(node.date)) return null;
-  const t = Date.parse(node.date);
-  if (Number.isNaN(t)) return null;
+// The node's `date` parsed to epoch ms, or null when absent/malformed/
+// unparseable. HEAD-pure — only the `(now - t)` in ageDays is per-call — so the
+// parse is cacheable by id (task-cc-rankqueue-staleness-date-memo). A cached
+// `null` (no usable date) is distinguished from "uncached" by the `undefined`
+// check, so a dateless node is parsed at most once.
+function nodeDateMs(node, memo) {
+  if (memo) { const c = memo.get(node.id); if (c !== undefined) return c; }
+  let t = null;
+  if (node.date && /^\d{4}-\d{2}-\d{2}/.test(node.date)) {
+    const p = Date.parse(node.date);
+    if (!Number.isNaN(p)) t = p;
+  }
+  if (memo) memo.set(node.id, t);
+  return t;
+}
+
+function ageDays(node, now, memo) {
+  const t = nodeDateMs(node, memo);
+  if (t == null) return null;
   return Math.max(0, Math.floor((now - t) / 86_400_000));
 }
 
@@ -421,6 +456,71 @@ function attachedSignals(reg, node, baseSignals, neighbors, sandboxFor) {
   }
 }
 
+// HEAD-pure derived indexes the queue needs, memoized on the resident graph
+// (task-cc-rankqueue-memoization). rankQueue rebuilt resolutionMap,
+// openFindingsMap, blockersIndex, and a per-item transitive blockingCount on
+// EVERY call — ~185ms at 50k nodes, dominated by the per-item work — even
+// though every one of them is a pure function of the graph's HEAD, independent
+// of the per-call inputs (now/leases/activity/viewer/project/filters). The
+// server keeps the graph resident and only reloads when HEAD changes
+// (dec-cc-defer-rust-rankqueue-kernel: the resident-graph principle, no wasm
+// port), so these compute once and are reused across reads. Cache lifecycle is
+// by graph identity, with no scheduler:
+//   - a fresh buildGraph()/loadGraph() result carries no cache, so a full
+//     reload self-invalidates (the new graph object simply has none);
+//   - applyNode() — the in-place incremental write path — deletes the cache
+//     (kernel/graph.js) since a mutation may change any blocks/resolves/
+//     answers/finding edge, supersession, or status the maps depend on; the
+//     next rankQueue rebuilds lazily.
+// Keyed by a registry-global Symbol so it is invisible to Object.keys / JSON /
+// spread (nothing enumerates the graph object) and graph.js can clear it
+// without a require cycle back into queue.js. Outputs are byte-identical: the
+// same pure functions over the same unchanged graph (norm-cc-byte-identical-
+// refactor; the conformance queue goldens stand).
+const QUEUE_INDEX = Symbol.for("spor.queue.derived-index");
+
+function queueIndex(graph) {
+  let idx = graph[QUEUE_INDEX];
+  if (!idx) {
+    idx = graph[QUEUE_INDEX] = {
+      resolvedBy: resolution.resolutionMap(graph),
+      findingsFor: resolution.openFindingsMap(graph),
+      blockersOf: blockersIndex(graph),
+      blockingCounts: new Map(), // id -> transitive live-blocking count, lazily filled
+      stalenessScores: new Map(), // id -> edge-staleness fraction (HEAD-pure), lazily filled
+      dateMs: new Map(), // id -> parsed node.date ms or null (HEAD-pure), lazily filled
+    };
+  }
+  return idx;
+}
+
+// Eagerly populate the memoized index for a RESIDENT graph so the FIRST queue
+// read after a HEAD change pays no index-build cost on the request path — the
+// "compute at load/build time" half of task-cc-rankqueue-memoization. The
+// server calls this from store.reload() (already an O(corpus) rebuild, so the
+// warm is negligible against it and happens only when HEAD changes); the
+// incremental write path deliberately does NOT warm — it invalidates and lets
+// the next read rebuild lazily, keeping put_node latency flat
+// (task-cc-spor-tier-2-scale). Fills blockingCounts plus the per-node HEAD-pure
+// scoring pieces — edge-staleness and the parsed node.date
+// (task-cc-rankqueue-staleness-date-memo) — for every queueable-live, unresolved
+// node, the superset any project/assignee/type-filtered rankQueue draws from, so
+// every later read is a pure cache hit. Returns the index.
+function warmQueueIndex(graph) {
+  const idx = queueIndex(graph);
+  const reg = graph.registry;
+  if (!reg || typeof reg.isQueueable !== "function") return idx;
+  for (const node of Object.values(graph.nodes)) {
+    if (!reg.isQueueable(node.type)) continue;
+    if (!isLive(node, graph.supersededBy)) continue;
+    if (idx.resolvedBy[node.id]) continue; // retired by a live resolves/answers edge
+    blockingCount(graph, node.id, idx.blockingCounts);
+    stalenessScore(graph, node, idx.stalenessScores);
+    nodeDateMs(node, idx.dateMs);
+  }
+  return idx;
+}
+
 // rankQueue(graph, { project?, assignee?, includeTypes?, excludeTypes?, activity?, front?, leases?, now?, limit?, viewer?, sandboxFor? })
 //   -> { items, count, muted?, dormant?, archived?, leased?, reserved? }
 // `includeTypes`/`excludeTypes` (task-cc-queue-filtering-enhancements) are
@@ -548,11 +648,23 @@ function rankQueue(graph, opts = {}) {
   // questions already do — zero mutation, the status flip stays a human act
   // (the gardener's resolved-open finding nags for it). Open findings about
   // an item ride along so the consumer sees what the gardener already knows.
-  const resolvedBy = resolution.resolutionMap(graph);
-  const findingsFor = resolution.openFindingsMap(graph);
-  const blockersOf = blockersIndex(graph);
+  // HEAD-pure derived indexes, memoized on the resident graph and reused across
+  // reads (task-cc-rankqueue-memoization); recomputed lazily on a fresh/mutated
+  // graph. Independent of the per-call inputs above, so caching is sound.
+  const idx = queueIndex(graph);
+  const { resolvedBy, findingsFor, blockersOf } = idx;
 
   const items = [];
+  // Deferred per-item RENDER (issue-cc-queue-percall-blend-latency-floor,
+  // lever 1): the presentation labels (suggest, the why-line and its blocker/
+  // cross-project descriptors, the wake/lease/findings annotations) are built
+  // AFTER sort+slice for just the `limit` items actually returned, not for every
+  // live node. The only render input not cheap to recompute for the survivors is
+  // each node's live-blocker set (already allocated for `blocked_by` and needed
+  // for the cap pass over ALL items), so it rides in this id->blockers map; the
+  // render pass recomputes node/lease/wake from the id. An entry's presence also
+  // marks a normal (vs schema-approval) item for the render pass.
+  const blockersById = new Map();
   for (const node of Object.values(graph.nodes)) {
     // Schema-change proposals are queue items (§2.4/§5): a proposed schema
     // waits for a human to review the payload + attached code and flip its
@@ -563,7 +675,7 @@ function rankQueue(graph, opts = {}) {
       if (!inTypes("schema")) continue; // hard type scope, uncounted (like project)
       if (isArchived(node)) { archivedCount++; continue; }
       if (isMuted(node)) { muted++; continue; }
-      const age = ageDays(node, now);
+      const age = ageDays(node, now, idx.dateMs);
       items.push({
         id: node.id,
         title: node.title ?? null,
@@ -605,28 +717,17 @@ function rankQueue(graph, opts = {}) {
 
     const blockers = liveBlockers(graph, node.id, blockersOf, resolvedBy);
     const signals = {
-      blocking: blockingCount(graph, node.id),
+      blocking: blockingCount(graph, node.id, idx.blockingCounts),
       blocked_by: blockers.length,
       front: front?.[node.id] ?? 0, // this node only — no neighborhood spread
       heat: heatScore(graph, node.id, activity),
-      staleness: Number(stalenessScore(graph, node).toFixed(2)),
-      age_days: ageDays(node, now),
+      staleness: Number(stalenessScore(graph, node, idx.stalenessScores).toFixed(2)),
+      age_days: ageDays(node, now, idx.dateMs),
     };
     // needed_by_days rides along ONLY when the node carries a deadline, so the
     // signals shape (and every existing why-line/golden) is unchanged without it.
     const nbDays = neededByDays(neededByTime(node), now);
     if (nbDays != null) signals.needed_by_days = nbDays;
-    // Cross-project provenance descriptors for the why-line: blockers carry
-    // their project (annotated only when it differs), and the direct blocks
-    // targets in another project name who this dependency serves.
-    const ownProject = node.project ?? null;
-    const blockerDescs = blockers.map((id) => {
-      const p = graph.nodes[id]?.project ?? null;
-      return { id, project: p, cross: p !== ownProject };
-    });
-    const crossBlocking = directLiveBlocks(graph, node, resolvedBy)
-      .filter((t) => (t.project ?? null) !== ownProject)
-      .map((t) => ({ id: t.id, project: t.project ?? null }));
     const bump = PRIORITY_BUMP[node.priority] ?? 0;
     let score = bump + 3 * signals.blocking - 3 * signals.blocked_by +
       Math.min(Math.log2(1 + signals.front), 5) +
@@ -642,6 +743,10 @@ function rankQueue(graph, opts = {}) {
     }
     if (attached?.error) signals.queue_signals_error = attached.error;
 
+    // Ranking fields only; the presentation labels (suggest/why/blocked_by/
+    // lease/findings) are deferred to the post-slice render pass below
+    // (issue-cc-queue-percall-blend-latency-floor). Keys are inserted in the
+    // same order render later appends to, so the serialized item is unchanged.
     const item = {
       id: node.id,
       title: node.title ?? null,
@@ -651,33 +756,8 @@ function rankQueue(graph, opts = {}) {
       priority: node.priority ?? null,
       score: Number(score.toFixed(2)),
       signals,
-      // staleness wins (closing retires the item, blocked or not), then
-      // blocked — an item gated by live work isn't actionable either way.
-      suggest: signals.staleness >= STALE_SUGGEST_THRESHOLD ? "close"
-        : blockers.length ? "blocked" : "do",
-      why: whyLine(signals, node, blockerDescs, crossBlocking, frontDays),
     };
-    if (wake != null) item.why += `; woke ${node.wake} (was dormant)`;
-    if (blockers.length) item.blocked_by = blockers;
-    // A surviving lease rides along as `lease_state` so the consumer can render
-    // it (dec-cc-task-claim-lease's "demoted-not-erased" / the steward view's
-    // "in progress by X"). Only two ways an item gets here with a lease: the
-    // viewer holds it (their own queue), or this is the lease-exempt steward
-    // read. Tier-1 live -> "in progress", Tier-2 reservation -> "reserved"; the
-    // owner sees "yours", a steward sees "by <holder>". Counted demotions
-    // (held by another, hidden) never reach here — they `continue`d above.
-    if (lease) {
-      const mine = lease.by === viewerHolder;
-      item.lease_state = lease.reserved ? "reserved" : "in_progress";
-      item.lease_by = lease.by;
-      const label = lease.reserved ? "reserved" : "in progress";
-      item.why += mine ? `; ${label} (your claim)` : `; ${label} by ${lease.by}`;
-    }
-    const flagged = findingsFor[node.id];
-    if (flagged?.length) {
-      item.findings = flagged.map((f) => f.id);
-      item.why += `; ${flagged.length} open gardener finding${flagged.length === 1 ? "" : "s"}: ${item.findings.join(", ")}`;
-    }
+    blockersById.set(node.id, blockers);
     items.push(item);
   }
 
@@ -690,7 +770,9 @@ function rankQueue(graph, opts = {}) {
   for (let pass = 0; pass < 10; pass++) {
     let changed = false;
     for (const it of items) {
-      for (const bid of it.blocked_by ?? []) {
+      // blockers ride in blockersById until render re-adds `blocked_by` post-slice
+      // (deferred render); schema-approval items aren't in the map -> no blockers.
+      for (const bid of blockersById.get(it.id) ?? []) {
         const blocker = byId.get(bid);
         if (blocker && it.score >= blocker.score) {
           it.score = Number((blocker.score - 0.01).toFixed(2));
@@ -734,7 +816,65 @@ function rankQueue(graph, opts = {}) {
     (b.signals.age_days ?? 0) - (a.signals.age_days ?? 0) ||
     (a.id < b.id ? -1 : 1));
 
-  const r = { items: items.slice(0, Math.max(0, limit)), count: items.length };
+  // Render pass (issue-cc-queue-percall-blend-latency-floor, lever 1): build the
+  // presentation labels for ONLY the items the slice returns. The same labels the
+  // per-node loop used to build for every live node — suggest, the why-line with
+  // its blocker/cross-project descriptors, the wake/lease/findings annotations,
+  // and the re-added `blocked_by` — now cost O(limit), not O(live queue), cutting
+  // the per-call string/array allocations that drove the p95/p99 GC tail. Each
+  // appended key lands in its original position, so a returned item is
+  // byte-identical (norm-cc-byte-identical-refactor). Schema-approval items carry
+  // a constant why and aren't in blockersById, so they're left as rendered inline.
+  const top = items.slice(0, Math.max(0, limit));
+  for (const item of top) {
+    const blockers = blockersById.get(item.id);
+    if (blockers === undefined) continue; // schema-approval item: rendered inline
+    const node = graph.nodes[item.id];
+    // lease/wake are cheap to recompute for the survivors from the same `now`,
+    // so they aren't retained per node; identical to the loop's computation.
+    const lease = leaseState(leases, node.id, now);
+    const wake = wakeTime(node);
+    const signals = item.signals;
+    // staleness wins (closing retires the item, blocked or not), then blocked —
+    // an item gated by live work isn't actionable either way.
+    item.suggest = signals.staleness >= STALE_SUGGEST_THRESHOLD ? "close"
+      : blockers.length ? "blocked" : "do";
+    // Cross-project provenance descriptors for the why-line: blockers carry their
+    // project (annotated only when it differs), and the direct blocks targets in
+    // another project name who this dependency serves.
+    const ownProject = node.project ?? null;
+    const blockerDescs = blockers.map((id) => {
+      const p = graph.nodes[id]?.project ?? null;
+      return { id, project: p, cross: p !== ownProject };
+    });
+    const crossBlocking = directLiveBlocks(graph, node, resolvedBy)
+      .filter((t) => (t.project ?? null) !== ownProject)
+      .map((t) => ({ id: t.id, project: t.project ?? null }));
+    item.why = whyLine(signals, node, blockerDescs, crossBlocking, frontDays);
+    if (wake != null) item.why += `; woke ${node.wake} (was dormant)`;
+    if (blockers.length) item.blocked_by = blockers;
+    // A surviving lease rides along as `lease_state` so the consumer can render
+    // it (dec-cc-task-claim-lease's "demoted-not-erased" / the steward view's
+    // "in progress by X"). Only two ways an item gets here with a lease: the
+    // viewer holds it (their own queue), or this is the lease-exempt steward
+    // read. Tier-1 live -> "in progress", Tier-2 reservation -> "reserved"; the
+    // owner sees "yours", a steward sees "by <holder>". Counted demotions
+    // (held by another, hidden) never reach here — they `continue`d above.
+    if (lease) {
+      const mine = lease.by === viewerHolder;
+      item.lease_state = lease.reserved ? "reserved" : "in_progress";
+      item.lease_by = lease.by;
+      const label = lease.reserved ? "reserved" : "in progress";
+      item.why += mine ? `; ${label} (your claim)` : `; ${label} by ${lease.by}`;
+    }
+    const flagged = findingsFor[node.id];
+    if (flagged?.length) {
+      item.findings = flagged.map((f) => f.id);
+      item.why += `; ${flagged.length} open gardener finding${flagged.length === 1 ? "" : "s"}: ${item.findings.join(", ")}`;
+    }
+  }
+
+  const r = { items: top, count: items.length };
   if (muted > 0) r.muted = muted;
   if (dormant > 0) r.dormant = dormant;
   if (archivedCount > 0) r.archived = archivedCount;
@@ -746,4 +886,4 @@ function rankQueue(graph, opts = {}) {
   return r;
 }
 
-module.exports = { rankQueue, PRIORITY_BUMP, DEFAULT_LIMIT };
+module.exports = { rankQueue, warmQueueIndex, PRIORITY_BUMP, DEFAULT_LIMIT };

package/lib/queue.js

@@ -100,7 +100,7 @@ function gitFront(repoDir, nodesName, days) {
   return out;
 }
 
-module.exports = { rankQueue, gitFront, gitIdentityEmail, viewerFor, PRIORITY_BUMP: kernel.PRIORITY_BUMP, DEFAULT_LIMIT: kernel.DEFAULT_LIMIT };
+module.exports = { rankQueue, warmQueueIndex: kernel.warmQueueIndex, gitFront, gitIdentityEmail, viewerFor, PRIORITY_BUMP: kernel.PRIORITY_BUMP, DEFAULT_LIMIT: kernel.DEFAULT_LIMIT };
 
 // ---------- CLI (local mode / debugging; new entry point, existing CLIs untouched) ----------
 

package/lib/remote.js

@@ -27,8 +27,11 @@ function isRemote(cfg) {
 
 // One request. Returns { ok, status, json, text } on an HTTP response (any
 // status), or { ok:false, transport:true, error } when the request never
-// completed. Never throws.
-async function request(cfg, method, apiPath, { body, timeoutMs = 6000 } = {}) {
+// completed. Never throws. `opts.token` overrides the cfg-resolved bearer for
+// this one call — `spor dispatch` uses it to authenticate as the freshly-minted
+// agent token (not the person token) when late-binding the run session
+// (issue-spor-dispatch-bg-session-late-bind).
+async function request(cfg, method, apiPath, { body, timeoutMs = 6000, token: tokenOverride } = {}) {
   const url = base(cfg) + apiPath;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -36,7 +39,7 @@ async function request(cfg, method, apiPath, { body, timeoutMs = 6000 } = {}) {
     const res = await fetch(url, {
       method,
       headers: {
-        Authorization: `Bearer ${token(cfg)}`,
+        Authorization: `Bearer ${tokenOverride || token(cfg)}`,
         ...(body != null ? { "Content-Type": "application/json" } : {}),
       },
       body: body != null ? JSON.stringify(body) : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sporhq/spor",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Spor — a shared memory substrate for teams and agents. Decisions, their reasons, and the traces they leave. Knowledge-graph context compiler: session-start briefings, per-prompt digests, capture at discovery, end-of-session distillation, decision queue.",
   "license": "Apache-2.0",
   "author": "Anthony Allen",