legion-gaia 0.9.66 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0229532bc53d2868fac7cc6279bb2875ceaaedbb63269dc8b5a742a7c95832
-  data.tar.gz: da7e11d18691d6af5e90e2c4da209feaf1b6ab79b4aaa91f4c409e517d7428cf
+  metadata.gz: 48f3c59dd119b1a9a314313c5440d2003e65747dafbfe25e743cff50a4e4e511
+  data.tar.gz: 676df1567bda9c7011f39d3a409396eb1414d2938e07a14d6eb656c5d71521e8
 SHA512:
-  metadata.gz: c87775e2f41b815da9b996ceca3383dbf956ec8c8e643c26ec8390fb7477fc0ead9739b4802cbdc5984ebf1266f1d5dd22d145c7b657cc8e7712035f0496932c
-  data.tar.gz: e03a41455d7d36dbb49d89e2b7c74e3db930c07a1a730cb4c695a088c446be020463ff0ea588bdea1ce01b06504890890afa08c42344fbd16e71b6818058727b
+  metadata.gz: 6ec28771fc7715ad86327681f6132bc3063c963e18f96611a969a463e7291be54f49a5c9f2a3d22de62338486af9a273749bddebee75fc81a2fc60ef90ac39a3
+  data.tar.gz: d7107fc5c623d251c89cfdcdd42589ee0a79ad8f5e665a473a55363bf90cc9f36c2173237a6dddc433da619266370b4126bcab7f1a79c8db5310211552e10294

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.10.0] - 2026-10-30
+
+### Added
+- Identity/conversation-scoped cognitive hosts, tick history, advisory provenance, delivered-response receipts, and explicit human-observed prediction/intention outcomes.
+- Durable response claims, correction evidence, consent barriers, and resumable termination through Apollo Local. Interrupted feedback remains uncertain rather than being graded twice.
+- Explicit `gaia.tick.enabled_optional_phases` opt-ins for `global_workspace` and `metacognition` with supporting `lex-tick`; both remain disabled by default.
+- Per-capability demonstrated readiness and last meaningful outcomes, including measured cognitive health and introspection assessments.
+
+### Fixed
+- Select bounded, relevant, authorized dream memories; unwrap ranked traces correctly and verify actual Hebbian associations.
+- Store supported episodic corrections and preserve their constraints/source references. Explicit corrections affect PartnerModel and Gut even when scoped calibration is unavailable.
+- Keep trusted principal IDs, native channel ownership, session continuity, feedback, growth, and delayed delivery isolated across humans and conversations.
+- Persist the actual live bond, behavioral, and scoped calibration stores; acknowledge dirty revisions only after successful writes.
+- Complete scoped session/attribution erasure against the real runtime, preserve lifecycle barriers across restart, and remove owned local snapshots and FTS/source-link rows.
+- Preserve failure, partial, deferred, missing-handler, and budget-skipped phase meaning. A loaded extension, empty competition, or proposed intention is not completed work.
+- Consume attended inputs and workspace-selected memories in prediction/executive decisions; resolve only explicitly correlated human-observed outcomes.
+- Defer shutdown finalization when a heartbeat exceeds its wait timeout instead of deadlocking or clearing state underneath active work.
+
+### Changed
+- Require published `legion-apollo >= 0.5.13` for correct changed-content FTS snapshot updates.
+- Pipeline notifications no longer count as a second human observation. Uncorrelated or unapplied response suggestions remain ungraded.
+- Human history/disclosure/termination routes require the authenticated owner; Teams webhooks reject missing application authentication.
+- Remove disconnected BondStore state and obsolete nil-ID phase mappings. Background maintenance and request/event-owned work are not implicitly scheduled.
+- Existing pre-0.10 readers do not enforce the new privacy barriers: quiesce and forward-fix rather than rolling back to an unsafe reader.
+
+## [0.9.67] - 2026-07-24
+### Added
+- H5: `Legion::Gaia::Gut.check(identity:, draft_stats:)` — fast per-response conflict detection (v1: correction veto only). Compares draft stats against high-strength correction traces and transform-tier behavioral synapses. No LLM calls. Completes within 50ms latency budget (scalar setting); degrades to no-op if exceeded. Soft-guarded on lex-agentic-memory. The gut itself is a behavioral synapse (`domain: 'gut'`); new partners start in observe mode (emergent confidence 0.3 → observe tier).
+- H6: `Legion::Gaia::Anticipation.build(identity:, context:)` — builds anticipation context from actionable pending predictions (confidence >= threshold). Pre-stages RAG entries capped at 25% of total. Soft-guarded on lex-agentic-inference.
+- H6: `Legion::Gaia::Anticipation.resolve(identity:, prediction_id:, actual:)` — grades a pending prediction as `:correct`, `:incorrect`, or `:partial` against the partner's actual input. Entropy guard: no resolution under high identity entropy.
+- H6: `Legion::Gaia::Anticipation.deferred?(identity:, anticipation:)` — §12.8 emotional modulation: negative-valence anticipations defer when partner affect baseline is low. Soft-guarded on lex-agentic-affect.
+- Settings defaults: `gut.latency_budget_ms` (50ms), `gut.correction_min_strength` (0.6), `gut.correction_trace_limit` (20), `anticipation.actionable_threshold` (0.65)
+
 ## [0.9.66] - 2026-07-24
 ### Added
 - `Gaia.observe_from_pipeline(identity:, caller:, exchange_id:)` — pipeline observation for API clients; reinforces bond, triggers coldstart, registers duckling partner on first human request

data/Gemfile

@@ -4,7 +4,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'legion-apollo', path: '../legion-apollo' if File.exist?(File.expand_path('../legion-apollo', __dir__))
+gem 'legion-apollo', path: '../legion-apollo' if File.directory?(File.expand_path('../legion-apollo', __dir__))
 
 gem 'rake'
 gem 'rspec'

data/README.md

@@ -25,8 +25,8 @@ job engine runs without it, and none of its cognitive mechanics activate unless
 ├──────────────────────┤     ├────────────────────────────┤     ├──────────────────────┤
 │ CLI                  │     │ SensoryBuffer              │     │ ChannelAwareRenderer │
 │ Microsoft Teams      │ ──▶ │ Heartbeat → lex-tick       │ ──▶ │ NotificationGate     │
-│ Slack                │     │ 37 cognitive phases        │     │ OutputRouter         │
-│ HTTP /api/gaia/ingest│     │ (16 active · 21 dream)     │     │ ChannelAdapter#deliver│
+│ Slack                │     │ Scoped phase handlers      │     │ OutputRouter         │
+│ HTTP /api/gaia/ingest│     │ Explicit optional groups   │     │ ChannelAdapter#deliver│
 └──────────────────────┘     └────────────────────────────┘     └──────────────────────┘
    translate inbound  ───▶   ingest · tick · think · decide   ───▶   gate · render · deliver
 ```
@@ -37,12 +37,12 @@ job engine runs without it, and none of its cognitive mechanics activate unless
 
 ### Highlights
 
-- 🧠 **Continuous cognition.** A 1-second heartbeat drains the sensory buffer and runs a full tick through `lex-tick`, so the agent is always thinking — not just request/response.
-- 🔌 **Channel abstraction.** CLI, Microsoft Teams, and Slack share one `ChannelAdapter` contract; the cognitive core never knows which interface it is talking to.
-- 🌙 **Active *and* dream cycles.** 16 active-tick phases (sensory → emotion → memory → action) plus 21 dream-cycle phases (memory audit, association walk, creativity, metacognition, global workspace) run through one weighted pipeline.
-- 🛡️ **Notification gating.** Outbound frames pass schedule (quiet hours) → presence (Teams status) → behavioral (arousal/idle) evaluators before delivery; urgent priority bypasses the gate.
-- 🛰️ **Hub-and-spoke router mode.** Keep channel-facing ingress on a public router while private agents do the cognitive work, relayed over Legion transport with worker allowlists.
-- 🕊️ **Graceful quiescence.** Shutdown blocks new heartbeats, drains in-flight work, and skips phase handlers cleanly so late tick work never writes into closed services.
+- **Bounded cognition.** A heartbeat drains one identity/conversation at a time under the existing tick budget.
+- **Channel abstraction.** CLI, Microsoft Teams, and Slack share a channel contract while retaining exact authenticated owners and destinations.
+- **Explicit activation.** Default active/dream schedules remain unchanged; workspace and metacognition require opt-in and supporting providers.
+- **Notification gating.** Quiet hours, presence, and behavioral gates precede delivery. Priority never bypasses a consent or termination barrier.
+- **Hub-and-spoke router mode.** Public ingress can relay to private agents through existing Legion transport and worker allowlists.
+- **Graceful quiescence.** New work stops before teardown; an over-time heartbeat defers finalization instead of losing its live state.
 
 ## What GAIA Does
 
@@ -78,7 +78,7 @@ Channel input
 The registry resolves runners from the loaded LegionIO extension set and builds phase handlers. Each
 phase handler annotates its result with:
 
-- `status`: `completed`, `skipped`, or `failed`
+- `status`: truthful `completed`, `skipped`, `failed`, `partial`, `deferred`, or `unavailable`; history also exposes missing handlers and budget skips
 - `elapsed_ms`: monotonic elapsed time in milliseconds
 
 Those fields feed `/api/gaia/ticks` for operator-facing tick-stream observability — every event
@@ -86,9 +86,9 @@ should have a non-null `status` and `elapsed_ms`.
 
 ## The Mechanics, From Source
 
-GAIA itself does not implement learning — it schedules and wires the extensions that do. The
-formulas below live in the sibling gems GAIA coordinates, and are cited here so the claims can be
-checked against source rather than taken on faith.
+GAIA coordinates extension learning and owns scoped relationship/response attribution. The
+formulas below describe specific mechanisms, not evidence that a proposed action succeeded.
+Confidence and bond strength never grant permission.
 
 **Connection reinforcement — [`lex-synapse`](https://github.com/LegionIO/lex-synapse):**
 
@@ -118,10 +118,11 @@ have different confidence constants. Do not conflate them.
 
 **Tick scheduling — `lex-tick` constants:**
 
-- 16 full-active phases, 10 dream phases.
-- 4 modes with fixed time budgets: `dormant` 0.2s, `sentinel` 0.5s, `full` and `dream` 5.0s each.
-- Tick history is an **in-memory, 200-entry ring buffer** recording `{ timestamp, phase, duration_ms,
-  status }` per phase. This is not database-persisted — restart the process and it is gone.
+- Default schedules: 16 full-active phases and 10 dream phases (identity entropy is shared).
+- Four modes and existing budgets: `dormant` 0.2s, `sentinel` 0.5s, `full_active` and `dormant_active` 5.0s.
+- The budget is checked between handlers; a blocking handler is not preempted. Optional work receives no extra budget.
+- Tick history is an in-memory, 200-entry ring buffer with identity/conversation/exchange ownership.
+  It records scheduled, missing, deferred, failed, and budget-skipped work; it does not survive restart.
 
 ## Measured, From the Maintainer's Development Instance
 
@@ -176,6 +177,24 @@ domain gems and operational extensions such as `lex-mesh`, `lex-synapse`, `lex-d
 `lex-coldstart`. Channel-specific delivery depends on the matching extension (for example
 `lex-microsoft_teams` or `lex-slack`).
 
+### Provider compatibility and activation
+
+| Provider | Supported behavior |
+|----------|--------------------|
+| `legion-apollo >= 0.5.13` | Required. Earlier changed-content FTS updates can break durable GAIA snapshots. |
+| `lex-agentic-memory 0.1.41` | Verified existing audit, association, episodic correction, and Gut consumption APIs; no new memory release is required for these handoffs. |
+| `lex-tick 0.1.17` | Default schedules remain usable; optional groups report unsupported. |
+| `lex-tick >= 0.1.18` | Explicit `global_workspace` / `metacognition` scheduling. Capability detection requires the actual keyword contract, not a catch-all `**kwargs`. |
+| `lex-agentic-social 0.1.21` | Explicit corrections remain effective; scoped calibration is unavailable and never falls back to shared/latest-response state. |
+| `lex-agentic-social >= 0.2.0` | Scoped calibration receipts, weights, and restoration when the explicit identity APIs are available. |
+| `lex-agentic-inference 0.1.11` | Existing identity-aware generation/resolution APIs support verifiable predictions; no newer inference release is required. Providers missing those contracts remain unavailable. |
+
+New tick/social versions are optional capability prerequisites, not permission to deploy unpublished
+branches. Leave their capabilities unavailable until their independent releases are installed.
+Published-provider and candidate-package combinations are exercised separately.
+Existing LLM callers that do not return applied source IDs remain ungraded; GAIA does not fabricate
+delivery acknowledgments or require a coordinated LLM upgrade.
+
 ## Basic Usage
 
 ```ruby
@@ -201,13 +220,17 @@ Legion::Gaia.shutdown
 | Method | Description |
 |--------|-------------|
 | `Legion::Gaia.boot(mode: nil)` | Boot the runtime. `mode: :router` boots channels only (hub-and-spoke router). |
-| `Legion::Gaia.ingest(input_frame)` | Push an `InputFrame` into the sensory buffer. Returns `{ ingested:, buffer_depth:, session_id: }`. |
-| `Legion::Gaia.heartbeat` | Drain the buffer and execute one cognitive tick. Returns the tick result hash. |
-| `Legion::Gaia.respond(content:, channel_id:, ...)` | Build an `OutputFrame` and route it through the output pipeline. |
-| `Legion::Gaia.status` | Runtime + UI state for status/observability tooling. |
-| `Legion::Gaia.tick_history` | Ring buffer of recent phase events. |
-| `Legion::Gaia.shutdown` | Quiesce and tear down the runtime. |
+| `Legion::Gaia.ingest(input_frame)` | Accept trusted input; return `{ ingested:, buffer_depth:, session_id:, exchange_id: }` and any explicit `cognitive_outcome`. Rejections include a reason. |
+| `Legion::Gaia.heartbeat` | Drain one scoped batch and execute one budgeted tick. Includes `phases_scheduled`, results, and correlation. |
+| `Legion::Gaia.respond(content:, channel_id:, ...)` | Preserve the original input owner/destination when replying; apply lifecycle and delivery gates. |
+| `Legion::Gaia.status(identity: nil)` | Runtime state, persistence readiness, and scoped demonstrated capabilities. |
+| `Legion::Gaia.tick_history.recent(identity:, conversation_id:, limit:)` | Read owner-scoped phase history. Unscoped internal access is administrative, not a human endpoint. |
+| `Legion::Gaia.shutdown` | Quiesce; return `{ stopped: false, quiescing: true }` if an active heartbeat must finish before finalization. |
 | `Legion::Gaia.started?` / `shutting_down?` | Lifecycle predicates. |
+| `Legion::Gaia::Advisory.advise(caller:, conversation_id:, exchange_id:)` | Return proposed adjustments with an advisory ID and selected-source provenance, without claiming application. |
+| `Legion::Gaia.record_response_applied(advisory_id:, identity:, applied:)` | Persist a returned/sent/acknowledged receipt for explicitly selected source IDs. |
+| `Legion::Gaia::Disclosure.report(identity:)` | Describe the same live/restored state used by behavior and the actual privacy/deletion boundaries. |
+| `Legion::Gaia::DeathProtocol.terminate_bond(identity:, confirm: true)` | Persist the barrier before erasure and return per-store acknowledgments; partial failure remains blocked and retryable. |
 
 ## Configuration
 
@@ -222,6 +245,8 @@ gaia:
   shutdown:
     heartbeat_wait_timeout: 30.0
     heartbeat_wait_log_interval: 5.0
+  tick:
+    enabled_optional_phases: []  # opt in one verified group at a time
   channels:
     cli:
       enabled: true
@@ -258,7 +283,6 @@ gaia:
     retrieval_min_confidence: 0.3
     memory_retrieval_limit: 10
     memory_audit_limit: 20
-    memory_skip_threshold: 0.8
 ```
 
 `connected` is managed by GAIA at boot and shutdown. Set `router.mode` to `true` on private agent
@@ -267,23 +291,89 @@ processes that should publish through a central router; boot the public router w
 
 ## Cognitive Phases
 
-GAIA wires two phase groups through `PhaseWiring::PHASE_MAP` — 37 phases in total (16 active-tick,
-21 dream-cycle). Each entry maps a phase name to an extension runner and method; phases whose runner
-extension is not loaded are skipped, and the rest are wired into the tick pipeline.
+The default full-active schedule has 16 phases; the dream schedule has 10, including the shared
+identity-entropy phase. Discovery does not activate extra work. Missing handlers remain visible.
+
+**Full active:** sensory processing, emotional evaluation, memory retrieval, knowledge retrieval,
+identity entropy, working memory integration, procedural check, prediction, mesh interface, social
+cognition, theory of mind, gut instinct, action selection, memory consolidation, homeostasis,
+and post-tick reflection.
+
+**Dream:** memory audit, association walk, contradiction resolution, identity entropy, agenda
+formation, consolidation commit, knowledge promotion, dream reflection, partner reflection,
+and dream narration.
+
+**Optional full-active groups:**
+
+| Group | Placement and prerequisite | Observable consumer |
+|-------|----------------------------|---------------------|
+| `global_workspace` | After gut instinct; requires meaningful sensory processing and correlated candidates | The selected signal/memory changes executive drives and intention formation. |
+| `metacognition` | After meaningful post-tick reflection | Current demonstrated assessments update scoped capability readiness/history; loaded constants are only inventory. |
+
+Opt in with `gaia.tick.enabled_optional_phases: [global_workspace]` or `[metacognition]`.
+Both default to off. Failed prerequisites defer the group; unavailable providers do not produce
+success-shaped placeholders. `status(identity:)[:capabilities]` reports readiness, ownership,
+the latest observed status/reason, and the last meaningful outcome/time. A later budget skip
+does not erase earlier evidence or continue claiming current readiness.
 
-**Active tick (16):** sensory processing, emotional evaluation, memory retrieval, knowledge
-retrieval, identity entropy check, working memory integration, procedural check, prediction engine,
-mesh interface, social cognition, theory of mind, gut instinct, action selection, memory
-consolidation, homeostasis regulation, and post-tick reflection.
+Other former extra mappings retain their actual owners:
 
-**Dream cycle (21):** memory audit, association walk, contradiction resolution, agenda formation,
-curiosity execution, consolidation commit, knowledge promotion, dream reflection, partner
-reflection, dream narration, dream cycle, creativity tick, lucid dream, epistemic vigilance,
-predictive processing, free energy, metacognition, default mode network, prospective memory, inner
-speech, and global workspace.
+| Work | Owner |
+|------|-------|
+| Curiosity execution, dream-cycle orchestration, creativity tick, default-mode thought | Existing background actors |
+| Lucid dream, epistemic vigilance, inner speech | Explicit requests with real content and consumers |
+| Predictive processing, free energy, prospective memory | Existing events with real observations, beliefs, or intentions |
 
-Phase handlers may skip expensive work when idle or while GAIA is shutting down. Skipped phases still
-produce `status` and timing metadata so the tick stream stays complete.
+Memory decay and tier migration remain background-owned; their heartbeat placeholders report
+`deferred` and do not duplicate maintenance. Prediction/intention creation is a proposal, not
+task completion. Technical task completion and human sentiment are not objective outcome evidence.
+
+### Explicit outcome reports
+
+A trusted human `InputFrame` may carry `metadata[:prediction_request]` with a nonblank `domain`,
+`description`, and scalar `expected_outcome`. Later authenticated input can report:
+
+```ruby
+cognitive_outcome: {
+  prediction_id: prediction_id,       # or intention_id, never both
+  source_exchange_id: original_exchange_id,
+  outcome: :incorrect,               # prediction: correct/incorrect/partial; intention: completed
+  actual: false,
+  confirmation: 'human_observed'
+}
+```
+
+GAIA derives the owner from the authenticated frame, checks the generated ID and original exchange,
+and labels the evidence `human_confirmation`. A contradictory classification is rejected.
+Heuristic predictions, missing IDs, mismatched people/exchanges, and duplicate reports cannot
+resolve or reinforce another prediction/intention. No machine execution proof is invented.
+
+## Identity, Feedback, and Recovery
+
+- Trusted principal IDs take precedence. Native Teams IDs include tenant ownership; Slack IDs
+  include workspace ownership. Display names and continuity tokens are not identity evidence.
+- Input ingestion owns the human observation. Pipeline notifications do not reinforce it again.
+- Advice is only a proposal. A delivery receipt must name selected behavioral/trace/adjustment
+  IDs and a `returned`, `sent`, or `acknowledged` delivery outcome before feedback can grade it.
+- Feedback must agree with all supplied identity, conversation, response-exchange, advisory, and
+  reply references. There is no global/latest-response fallback.
+- Explicit corrected constraints outrank inferred preferences in the matching scope. Generic
+  rejection vetoes the rejected sources; it neither invents a preference nor crystallizes the
+  rejected directive.
+- Private snapshots use exact identity tags and are stored through Apollo Local. Lifecycle barriers
+  and response claims/acknowledgments are synchronous. Ordinary bond/behavior changes can lose up
+  to the existing 300-second flush interval on abrupt process loss; graceful shutdown flushes them.
+- A persisted but interrupted feedback claim remains uncertain and is not automatically replayed.
+  Durable explicit correction evidence still constrains future behavior.
+- Missing/unreadable lifecycle storage fails closed for private identities. Anonymous/core operation
+  stays available. Recovery retries are bounded; no shared-store fallback is used.
+- Termination removes acknowledged owned snapshots, FTS/source links, live memories where supported,
+  sessions, pending outputs, and attribution. Its minimal barrier survives restart; partial erasure
+  is retried. Disclosure distinguishes local storage from deployment-dependent external processing.
+
+Before adoption, quiesce writers and retain the previous resolved configuration. Older GAIA
+versions do not honor these lifecycle barriers: rollback to them is unsafe. Disable affected optional
+capabilities and forward-fix; never restore a stale snapshot over a correction or revocation.
 
 ## HTTP API
 
@@ -293,13 +383,15 @@ GAIA registers routes with [`Legion::API`](https://github.com/LegionIO/LegionIO)
 
 | Method | Path | Description |
 |--------|------|-------------|
-| `GET`  | `/api/gaia/status` | Runtime + UI state (mode, buffer depth, channels, sessions, tick count, notification gate). |
-| `GET`  | `/api/gaia/ticks?limit=50` | Recent phase events; `limit` is clamped to the tick-history ring-buffer size. |
+| `GET`  | `/api/gaia/status` | Runtime/persistence state and the authenticated owner's demonstrated capabilities. |
+| `GET`  | `/api/gaia/ticks?limit=50` | Requires authentication; returns only that owner's phase history. |
 | `GET`  | `/api/gaia/channels` | Active channel adapters and their capabilities. |
 | `GET`  | `/api/gaia/buffer` | Sensory buffer depth, emptiness, and max size. |
 | `GET`  | `/api/gaia/sessions` | Active session count. |
-| `POST` | `/api/gaia/ingest` | Push a normalized content payload into the sensory buffer without a channel adapter. |
-| `POST` | `/api/channels/teams/webhook` | Microsoft Teams Bot Framework activity intake (auth-gated when `app_id` is set). |
+| `POST` | `/api/gaia/ingest` | Normalize input using trusted request auth, not a body-supplied identity; rejected input returns `409`. |
+| `POST` | `/api/channels/teams/webhook` | Requires configured application authentication and a verified Bot Framework bearer token. |
+| `GET` | `/api/gaia/partner/:identity/report` | Authenticated-owner disclosure only. |
+| `DELETE` | `/api/gaia/bond/:identity` | Authenticated-owner termination with explicit confirmation. |
 
 ### `GET /api/gaia/status`
 
@@ -327,9 +419,9 @@ delivery-likelihood score.
 
 Accepts Microsoft Teams Bot Framework activities. The route delegates to
 `Legion::Gaia::Channels::Teams::WebhookHandler`, then ingests translated message activities through
-`Legion::Gaia.ingest`. When a Teams `app_id` is configured, requests must carry a bearer token; GAIA
+`Legion::Gaia.ingest`. A configured Teams `app_id` and bearer token are required; GAIA
 validates JWT claims and verifies the signature against Bot Framework signing keys before translating
-or ingesting. Missing or invalid authorization returns `401`.
+or ingesting. Missing configuration or invalid authorization returns `401`.
 
 Non-message activities are intentionally acknowledged without entering cognition:
 
@@ -345,11 +437,13 @@ Non-message activities are intentionally acknowledged without entering cognition
 | Adapter | Purpose | Notes |
 |---------|---------|-------|
 | CLI | Local text interaction | Built in, enabled by default. |
-| Teams | Bot Framework activity ingestion and proactive delivery | Validates bearer tokens when `app_id` is set. |
+| Teams | Bot Framework activity ingestion and proactive delivery | Requires application authentication; preserves exact tenant/user/conversation ownership. |
 | Slack | Slack-style rich text and threaded delivery | HMAC-SHA256 signing verification. |
 
-Adapters translate format and delivery semantics only. Cognitive interpretation happens downstream in
-the tick pipeline, so adapters stay thin, stateless, and recreatable without loss.
+Adapters translate format and delivery semantics. Teams delivery requires the intended tenant and
+conversation; proactive lookup matches the target user instead of borrowing another conversation in
+the tenant. An explicit Slack destination cannot fall back to a default webhook. Received timestamps,
+owners, destinations, and correlation survive router serialization.
 
 ## Notification Gate
 
@@ -359,8 +453,9 @@ The notification gate evaluates outbound frames before delivery, in order:
 2. `PresenceEvaluator` — maps Teams presence to a minimum delivery priority.
 3. `BehavioralEvaluator` — scores arousal and idle signals into a delivery-likelihood value.
 
-Urgent or critical frames bypass quiet-hour delays through `priority_override`. Delayed frames are
-stored in a bounded `DelayQueue` and re-evaluated each heartbeat.
+Urgent or critical frames bypass quiet-hour delays through `priority_override`, but never bypass
+revocation/termination. Delayed frames remain scoped and bounded; lifecycle is checked again at
+final delivery and terminated identities' queued frames are removed.
 
 ## Router Mode
 
@@ -395,10 +490,11 @@ Channel client -> GAIA router -> Legion transport -> GAIA agent
 4. Trackers and channel/router bridges are flushed or stopped.
 5. Runtime references are cleared.
 
-`shutdown.heartbeat_wait_timeout` bounds how long shutdown waits for in-flight heartbeat work before
-logging a warning and continuing; `shutdown.heartbeat_wait_log_interval` controls wait-progress logs.
-This keeps routine shutdown from producing late writes to closed data/logging resources while
-avoiding an indefinite hang if a heartbeat blocks inside extension work.
+`shutdown.heartbeat_wait_timeout` bounds the caller's wait. If a heartbeat is still running, shutdown
+returns `quiescing: true`, leaves its resources intact, and rejects reboot/new work. The last active
+heartbeat performs final teardown after leaving the shared write lock.
+`shutdown.heartbeat_wait_log_interval` controls wait-progress logs. Operators must not close shared
+data/logging services while GAIA still reports quiescing.
 
 ## Integration with LegionIO
 
@@ -417,10 +513,16 @@ Sibling gems referenced above:
 
 ```bash
 bundle install
-bundle exec rspec    # 0 failures required before commit
-bundle exec rubocop  # 0 offenses required
+bundle exec rubocop -A
+bundle exec rspec --format json --out tmp/rspec_results.json --format progress --out tmp/rspec_progress.txt
 ```
 
+Require a clean whole-repo lint pass and full-suite exit status after the last Ruby edit. Keep RSpec
+stdout quiet; inspect only extracted failed examples when it fails. Package acceptance must use
+installed gem artifacts, not sibling path overrides. Release scenarios cover real memory/association,
+correction-to-next-context, two-human/conversation isolation, interrupted feedback claims, SQLite/FTS
+termination, and independently opted-in workspace/metacognition with supporting provider artifacts.
+
 The build artifact (`*.gem`) is not the source of truth; release tooling builds it from the version
 in `lib/legion/gaia/version.rb`.
 

data/legion-gaia.gemspec

@@ -40,7 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'lex-privatecore'
 
   # PHASE_MAP operational extensions (required for full tick cycle)
-  spec.add_dependency 'legion-apollo', '>= 0.2.1'
+  spec.add_dependency 'legion-apollo', '>= 0.5.13'
   spec.add_dependency 'lex-apollo'
   spec.add_dependency 'lex-coldstart'
   spec.add_dependency 'lex-detect'