@staix/agent-hub 0.34.1 → 0.35.0

package/src/hub/daemon.ts

@@ -1,3 +1,10 @@
+import { GeneratedNoteRegistry, type GeneratedNoteProof } from "../memory/record-provenance.ts";
+import { RecordCapture, type RecordCapturePolicy } from "../memory/records.ts";
+import { VisualStore, validateVisualInput, validateVisualPayload, VISUAL_ID_PATTERN, type VisualRecord, type VisualSummary } from "./visual.ts";
+import { resolveVisualAssets } from "./visual-assets.ts";
+import type { DeliverablePorts } from "./deliverable-files.ts";
+import { readStartupEventSeeds } from "./startup-event-seeds.ts";
+import { StartupTimings } from "./startup-timing.ts";
 import { repoGitArgs, repoGitEnv } from "./snapshots.ts";
 import { createReviewMaterialReader, type ReviewReadRequest, type ReviewMaterialBatch } from "./review-material.ts";
 import { readSdlcPr } from "./sdlc.ts";
@@ -35,7 +42,7 @@ import type { DocEvidence } from "./sdlc-release.ts";
 import { loadExternalAdapterDefinitions, readAdapterModuleDeclarations, externalModuleIdentity, externalModuleIdentityCurrent, type AdapterModuleDeclaration } from "../adapters/external-modules.ts";
 import { WsPeer, isWsPeer } from "../adapters/channel-peer.ts";
 import { ownerToolEffect, canonicalWriteUnknown } from "./no-writes.ts";
-import { NativeHookLaunches } from "./native-hook-launch.ts";
+import { NativeHookLaunches, type NativeHookLaunch } from "./native-hook-launch.ts";
 import { readReleaseHostAdmission, type ReleaseHostAdmission } from "./release-admission.ts";
 import { ContainerRunner, RemoteRunner, remoteRunnerConfig, type RemoteRunnerConfig, type RunnerOptions, type RunReceipt } from "./check-runner.ts";
 import { fetchSpec, specAvailable, specRefs } from "./spec-read.ts";
@@ -56,7 +63,7 @@ import { listenWithoutPortCollision } from "./listen.ts";
 import { needs, type NeedsInput } from "../ui/needs.ts";
 import { loadPetConfig, PET_WINDOW_RETIRED_NOTICE, stripLegacyPetWindow } from "../pet/config.ts";
 import { projectionConfig, TextProjections, type ProjectionConfig } from "./text-projection.ts";
-import { policyPaths, matchesPolicy } from "./path-policy.ts";
+import { policyPaths, policyRealPath, matchesPolicy } from "./path-policy.ts";
 import { CodeFacts, type CodeFactResult, type CodeSymbol } from "./code-facts.ts";
 import { buildReviewBrief, withCodeSymbols } from "./review-brief.ts";
 import { profileName, projectProfile, resolveProfile, mergeProfileOverrides, type ProfileName } from "./profiles.ts";
@@ -75,6 +82,7 @@ import { RecoveryDeferredHubError } from "./deferred-hub.ts";
 import { databaseBusySite, isDatabaseBusy, RecoveryDatabaseBusy } from "./recovery-error.ts";
 import { ADAPTERS, DEFAULT_REVIEW_POOL, REVIEW_POOL_KINDS, QUOTA_HANDOFF_PLATFORMS, NATIVE_CONFIG_BLOCKS, nativeConfigurationDefaults, mergeNativeConfiguration, retainNativeRouting, DAEMON_PORTS, definitionOf, createProjectAdapterCatalog, isFixedBuiltinDefinition } from "../adapters/registry.ts";
 import { isSupportedPeer as registrySupportedPeer, definitionOf as builtinDefinitionOf, KNOWN_PEERS as BASE_KNOWN_PEERS, SUPPORTED_PEERS as BASE_SUPPORTED_PEERS, STARTABLE_PEERS as BASE_STARTABLE_PEERS } from "../adapters/registry.ts";
+import type { NativeFactsTranscript } from "../adapters/registry-types.ts";
 import type { ReviewScope } from "./review-scope.ts";
 import { checkJcodeInstanceHomes, instanceDefinitionOf, effectiveInstanceRoles, isPlannerOnly, instancePeerIds, validateInstances, type InstancesConfig } from "./instances.ts";
 import { INSTANCE_CONFIG_FILES, readInstanceConfig, withoutInertInstancePolicy, readInstanceConfigLayers, readInstanceRoleConfig } from "./instance-config.ts";
@@ -105,7 +113,7 @@ import { QuestionDesk } from "./question-desk.ts";
 import type { ScannedFile } from "./schedules.ts";
 import { corpusConfig } from "./corpus-config.ts";
 import { ALL_MACHINE_LOCAL, configRefusal, configRepositoryPresent, configTracked, stripUntrusted } from "./config-trust.ts";
-import { authorizeConfigLeaf, configApply, configIdentityScope, configChanges, validateEffectiveConfig, validateOperationalConfig, validatePetConfig } from "./config-apply.ts";
+import { authorizeConfigLeaf, configApply, configIdentityScope, configChanges, validateRawConfig, validateEffectiveConfig, validateOperationalConfig, validatePetConfig } from "./config-apply.ts";
 import { resolveSettledRoles } from "./settled-roles.ts";
 import { CONFIG_SOURCE_FILES, configFingerprint, configSourceTexts, parseConfigSources, type ConfigSourceTexts, type ConfigSources } from "./config-reload.ts";
 import { issueConductorRecoveryAuthority, authorizeConductorRecovery, assertConductorRecovery, RecoveryAuthorityError, type ConductorRecoveryBinding } from "./recovery-authority.ts";
@@ -116,9 +124,10 @@ import { planFingerprint, registeredProjects, type UpgradePlan } from "../cli/up
 import { conductorRecoveryBinding } from "../cli/conductor-recovery.ts";
 import { createConfigEditor } from "./config-edit-host.ts";
 import { readEditable } from "./config-edit.ts";
-import { eventLog, readEvents, type RoleIdentity } from "./events.ts";
+import { eventLog, readEvents, type HubEvent, type RoleIdentity } from "./events.ts";
 import { SpecTaskInspector } from "./specs-task.ts";
-import { KimiUsage, kimiSeedRows } from "./kimi-usage.ts";
+import { KimiUsage, kimiSeedRows, type KimiRowAttribution, type KimiUsageScheduler } from "./kimi-usage.ts";
+import { KimiEventWriter } from "./kimi-events.ts";
 import { TokenWindow } from "./token-window.ts";
 import { budgetNotes, type BudgetPeerNote } from "./budget-notes.ts";
 import { kimiRowTotal } from "../adapters/kimi-wire-usage.ts";
@@ -133,6 +142,8 @@ import { startModelRelay, type ModelRelay } from "../models/relay.ts";
 import { ensureMlx, type MlxOptions } from "../models/mlx.ts";
 import { PiToolReceipts, packPiShellResult } from "../pi/tool-receipts.ts";
 import { PreEffectToolRefusal } from "./tool-refusal.ts";
+import { ModelOverrides, ModelOverrideLatches, type RuntimeModelStatus, type ModelSource } from "./model-overrides.ts";
+import { isNativeModelToken } from "../adapters/model-token.ts";
 import { processSignature, processLiveness } from "../pi/process-signature.ts";
 import { PiSessionBookmarkMismatch, PiSessionUnresumable, recordPiReplacement, validatePiSession } from "../pi/session.ts";
 import { profile, proxyEnv, sandboxAvailable, type SandboxNetwork } from "../local/sandbox.ts";
@@ -156,7 +167,7 @@ import { Capture } from "../memory/capture.ts";
 import { DEFAULT_OMNIROUTE, OmniRoute, type OmniRouteConfig } from "../omniroute/client.ts";
 import { CorpusIndex } from "./corpus.ts";
 import { corpusEvidence } from "./corpus-evidence.ts";
-import { Briefs, type BriefTask } from "../memory/brief.ts";
+import { Briefs, preferRecordItems, type NativeItem, type BriefTask } from "../memory/brief.ts";
 import { Board, isClosedTaskState, taskProposalAt, taskHasStarted, CLASSES, type Task, type TaskClass } from "./board.ts";
 import { UsageRollup, USAGE_GROUPS, LIMITS_MAX, type UsageGroup } from "./usage-rollup.ts";
 import { Budget, readNativeQuota, DEFAULT_BUDGET, type BudgetConfig } from "./budget.ts";
@@ -200,12 +211,14 @@ import { ControlClient, DAEMON_FEATURES, HANDOFF_CONNECT_MS, HANDOFF_LOOKUP_CONN
 import { negotiateProtocol, protocolWindow } from "./protocol-window.ts";
 import { attachEvent, originOf, type Origin } from "./provenance.ts";
 import { mintSessionId, sessionGate } from "./session-identity.ts";
-import { MAX_HOP, newEnvelope, parseMarker, replyParent, sanitize, USER, type Envelope, type PeerId, type Priority } from "./envelope.ts";
+import { MAX_HOP, isInvocationKind, newEnvelope, parseMarker, replyParent, sanitize, USER, type Envelope, type PeerId, type Priority } from "./envelope.ts";
 import { BasePeer, DEFAULT_WATCHDOG_MS, type FrontendProxyPort, type PeerAdapter, type PeerTakeoverClaim } from "./peers.ts";
 import { ClaudeTodoSource, DoingTracker, readAiTitle, DOING_STUB, SESSION_TITLE_HINT, sessionTitleText, sessionTitleBindings, unnamedSessionLabel, type DoingKind, type PeerDoing, type TitleCursor } from "./peer-doing.ts";
 import { MemoryClient } from "../memory/client.ts";
 import { VERSION } from "../version.ts";
 import { appendRecords, taskRecords } from "./research.ts";
+import { readEvidence } from "./research-record.ts";
+import { memoryFigures, onlyTaskMemory, UNKNOWN_MEMORY_FIGURES, type MemoryFigures } from "./research-memory.ts";
 import { parseResearchRunners, type RegisteredRunnerV1 } from "./research-runner.ts";
 import { benchReport, MIN_ATTEMPTS, readRuns, runSummary, type Measures, type RunSummary } from "./bench.ts";
 import { projectChain } from "@staix/agent-mem";
@@ -225,11 +238,11 @@ import { START_AGENTS_DEFAULT, checkStartAgents } from "./start-agents.ts";
 import { peerStartConfig, PEER_START_RETRY_MS, startModeOf, terminalTemplate, type PeerStartConfig, type StartMode } from "./start-mode.ts";
 import { hasKimiHubMcp } from "../cli/kimi-mcp.ts";
 import type { TerminalOpener } from "./terminal-open.ts";
-import { grantablePath, instructionProtection, isPermissionMode, permissionBoundary, permissionDefaults, permissionGrant, PI_EDIT_TOOLS, type PermissionMode } from "./permission-mode.ts";
+import { isHubWritePath, grantablePath, instructionProtection, isPermissionMode, permissionBoundary, permissionDefaults, permissionGrant, PI_EDIT_TOOLS, type PermissionMode } from "./permission-mode.ts";
 import { ContextWindows, DEFAULT_CONTEXT, readNativeContext, type ContextConfig } from "./context-window.ts";
 import { projectFileTool, scopedWriteBlocked } from "../cli/facts-hook.ts";
 import { detectTooling } from "./tooling.ts";
-import { looksSecret, DEFAULT_LEASE_MS, memoryHome, SUGGESTED, taskKey, type CandidateStore, type MemoryStore, type GoalView, type Suggested, type View as MemoryView } from "@staix/agent-mem";
+import { CaptureStore, configuredPolicy, recordsEnabled, looksSecret, DEFAULT_LEASE_MS, memoryHome, SUGGESTED, taskKey, type CandidateStore, type MemoryStore, type GoalView, type Suggested, type View as MemoryView } from "@staix/agent-mem";
 import { memoryProjectKey } from "@staix/agent-mem";
 import { AGENT_MEM_VERSION, MEMORY_SPLIT_INCOMPLETE, memoryProjectFor, openProfileMemory, openProfileCandidates, MemoryProfileBinding, type UnboundMemoryProfileReceipt } from "./memory-profile.ts";
 import { syncMemory, createIntentBriefSource, createStandalonePolicy } from "@staix/agent-mem";
@@ -237,7 +250,8 @@ import { SourceRegistry } from "./sources.ts";
 import { MEMORY_READ_TOOLS, memoryRead, validateMemoryRead, sourceRead, validateSourceRead } from "./read-tools.ts";
 import { nativeRecall } from "../memory/recall.ts";
 import { promotionScreen, withoutPii, mentionsPrivatePath } from "./memory-policy.ts";
-import { classifyMemorySyncFailure, initialMemorySyncState, memorySyncDeclinedDetails, memorySyncFailureDetailHash, memorySyncView, memorySyncPlacementCounts, reduceMemorySync } from "./memory-sync-state.ts";
+import { hostPlacementAttestation, memorySyncErrorText, writerRefusalOf, type WriterRefusal } from "./memory-sync-attestation.ts";
+import { classifyMemorySyncFailure, initialMemorySyncState, memorySyncDeclinedDetails, memorySyncFailureDetailHash, memorySyncView, memorySyncNextStep, memorySyncPlacementCounts, reduceMemorySync } from "./memory-sync-state.ts";
 import { createMemorySyncPolicy, inspectDeclinedMemoryRows } from "./memory-sync-policy.ts";
 import { DEFAULT_SPECS_CONFIG, parseSpecsConfig, type SpecsConfig } from "./specs-config.ts";
 
@@ -307,6 +321,8 @@ export interface HubConfig {
   checks: { timeout_s: number; runner?: "container" | "remote"; remote?: RemoteRunnerConfig; [cls: string]: string | number | RemoteRunnerConfig | undefined };
   /** A git tree at each turn boundary for `ahub turns` and `ahub undo`, the last `keep` per peer (issue #33). */
   snapshots: { enabled: boolean; keep: number };
+  /** Unbound visuals expire; task-bound records retain the task lifetime. */
+  visuals: { retention_days: number };
   /** #1057: the worktree shelf. `quiet_days` shelves a worktree idle that long (0 = never); `alert_over` is the settled count that raises one inbox alert (0 = never). */
   worktrees: { quiet_days: number; alert_over: number };
   /** #1053: `ttl_s` expires an unanswered question (default 86400); `wait_ms` overrides an adapter definition's `questionWaitMs` per kind. */
@@ -385,6 +401,7 @@ export const DEFAULT_CONFIG: HubConfig = {
   snapshots: { enabled: false, keep: 20 },
   worktrees: { quiet_days: 7, alert_over: 10 },
   questions: { ttl_s: 86_400, wait_ms: {} },
+  visuals: { retention_days: 30 },
   research: { enabled: false },
   bench: { enabled: false },
   peers: {},
@@ -400,14 +417,14 @@ export const DEFAULT_CONFIG: HubConfig = {
 export { stateDirFor };
 
 /** Ids an external process may not claim: the console user and the adapters the daemon runs itself. */
-const READ_ONLY_HUB_TOOLS = new Set(["hub_capabilities", "hub_inbox", "hub_send", "hub_delivery_done", "hub_review", "hub_task_show", "hub_task_list", "hub_study_show", "hub_experiment_show", "hub_memory_search", "hub_memory_show", "hub_memory_graph", "hub_source_read", "hub_status", "hub_specs"]);
+const READ_ONLY_HUB_TOOLS = new Set(["hub_visual_show", "hub_capabilities", "hub_inbox", "hub_send", "hub_delivery_done", "hub_review", "hub_task_show", "hub_task_list", "hub_study_show", "hub_experiment_show", "hub_memory_search", "hub_memory_show", "hub_memory_graph", "hub_source_read", "hub_status", "hub_specs"]);
 const BASE_RESERVED_IDS = new Set<string>([USER, ...SUPPORTED_PEERS.filter(peer => definitionOf(peer)?.attach?.externalHello !== true), HUB, DIGEST]);
 const PEER_ID = /^[a-z][a-z0-9-]{0,31}$/;
 
 /** The shared project config, then the machine's own file, which overrides it block by block (issue #17). */
 const CONFIG_FILES = INSTANCE_CONFIG_FILES;
 export interface ConfigLayer { name: typeof CONFIG_FILES[number]; raw: Record<string, any> }
-const CONFIG_BLOCKS = ["action_policy", "memory", "roster", "roles", "catalog_roles", "pii", "data", "conductor", "budget", "context", "inference", "omniroute", ...NATIVE_CONFIG_BLOCKS, "approvals", "tasks", "task_sweep", "bus", "adapter_timing", "model_relay", "console", "corpus", "specs", "checks", "snapshots", "worktrees", "research", "bench", "limits", "review", "recovery", "capabilities", "mlx", "permission_modes", "peers", "terminal", "start", "pet", "questions"];
+const CONFIG_BLOCKS = ["action_policy", "memory", "roster", "roles", "catalog_roles", "pii", "data", "conductor", "budget", "context", "inference", "omniroute", ...NATIVE_CONFIG_BLOCKS, "approvals", "tasks", "task_sweep", "bus", "adapter_timing", "model_relay", "console", "corpus", "specs", "checks", "snapshots", "worktrees", "visuals", "research", "bench", "limits", "review", "recovery", "capabilities", "mlx", "permission_modes", "peers", "terminal", "start", "pet", "questions"];
 
 /** Older targets parse raw keys before placement/trust checks, so even an empty or refused declaration needs the floor. */
 function rawResearchRunnersPresent(cwd: string): boolean {
@@ -424,6 +441,18 @@ function rawResearchRunnersPresent(cwd: string): boolean {
   return present;
 }
 
+/** Raw declaration presence is the floor: defaults in the in-memory config are not an opt-in. */
+function rawVisualsPresent(cwd: string): boolean {
+  const texts = configSourceTexts(cwd);
+  for (const name of CONFIG_FILES) {
+    if (texts[name] === null) continue;
+    const raw: unknown = JSON.parse(texts[name]!);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("invalid configuration");
+    if (Object.hasOwn(raw, "visuals")) return true;
+  }
+  return false;
+}
+
 /** Connection-time policy refresh reads role/feed fields only, never launches or machine-local configuration. */
 export function loadConductorPolicy(cwd: string, layers?: readonly ConfigLayer[], scope: Pick<ReturnType<typeof readInstanceConfig>, "instances" | "catalog"> = readInstanceConfig(cwd, layers)): { roles: Record<string, string[]>; conductor: HubConfig["conductor"]; planner?: string | string[]; notices?: string[] } {
   const roles: Record<string, string[]> = { ...DEFAULT_ROLES };
@@ -650,6 +679,7 @@ export function loadConfig(cwd: string, layers?: readonly ConfigLayer[], routing
     snapshots: { ...DEFAULT_CONFIG.snapshots, enabled: true, ...file.snapshots },
     worktrees: { quiet_days: wholeDays(file.worktrees?.quiet_days, DEFAULT_CONFIG.worktrees.quiet_days), alert_over: wholeDays(file.worktrees?.alert_over, DEFAULT_CONFIG.worktrees.alert_over) },
     questions: questionsConfig(file.questions),
+    visuals: { retention_days: typeof file.visuals?.retention_days === "number" && Number.isSafeInteger(file.visuals.retention_days) && file.visuals.retention_days >= 1 && file.visuals.retention_days <= 3650 ? file.visuals.retention_days : DEFAULT_CONFIG.visuals.retention_days },
     research: { enabled: file.research?.enabled === true, ...(file.research?.runners !== undefined ? { runners: parseResearchRunners(file.research.runners) } : {}) }, // opt-in: anything but true is off
     bench: { enabled: file.bench?.enabled === true }, // opt-in: a run resets this project's work tree
     peers: { ...instanceModes, ...peerStartConfig(file.peers, instances, adapterCatalog) },
@@ -686,6 +716,10 @@ function mlxPinProblem(routing: Routing, project: boolean): string | undefined {
 }
 
 export interface DaemonOptions {
+  /** Host-only fixture override; production reads the active memory home's and execution repository's public Record policy. */
+  effectiveRecordPolicy?: (cwd: string) => { enabled: boolean; version: string } | undefined;
+  /** Host-only numeric startup reader observation; never read from config or control input. Observer failure changes no replay state. */
+  startupSeedObserved?: (observation: { readPasses: number; readBytes: number }) => void;
   /** Host-only test/embedding port; never read from project configuration or a tool. */
   memoryClient?: MemoryClient;
   /** Host-only remote-default evidence seam; never read from config or control messages. */
@@ -710,6 +744,8 @@ export interface DaemonOptions {
   releaseHostAdmission?: (cwd: string) => Promise<ReleaseHostAdmission>;
   /** Host-only (#285): Kimi's data home for its wire-log usage reader; default `KIMI_CODE_HOME`, else `~/.kimi-code`. Never read from config or tools. */
   kimiHome?: string;
+  /** Host-only delayed-drain scheduler; tests fire it explicitly. Production leaves it unset and uses unreferenced timers. */
+  kimiUsageScheduler?: KimiUsageScheduler;
   /** Host-only replay-window test ceiling (1..512); never read from project config or a tool. */
   toolWriteReplayMaxEntries?: number;
   /** Host-only evidence seam; never supplied by project config or control messages. */
@@ -863,13 +899,16 @@ function capturedRecoverySourceDigest(): string | undefined {
 }
 
 export async function startDaemon(opts: DaemonOptions) {
+  const startupTimings = new StartupTimings();
   // Refuse unknown formats before logs, session cleanup, module factories or any writable store is opened.
   assertHubDbCompatible(join(opts.stateDir, "hub.db"));
+  startupTimings.mark("schema");
   if (opts.toolWriteReplayMaxEntries !== undefined && (!Number.isSafeInteger(opts.toolWriteReplayMaxEntries) || opts.toolWriteReplayMaxEntries < 1 || opts.toolWriteReplayMaxEntries > 512)) throw new Error("invalid host tool write replay capacity");
   const resolveExecutionCwd = (peer: string, currentDeclarations: InstancesConfig | undefined, currentRoles: readonly string[], catalog: ReturnType<typeof createProjectAdapterCatalog>): string =>
     resolveInstanceExecutionCwd(opts.cwd, peer, currentDeclarations, currentRoles, catalog, undefined, undefined, opts.instanceExecutionGit);
   const projectId = opts.projectId ?? randomUUID();
   const sourcePackageDigest = capturedRecoverySourceDigest();
+  startupTimings.mark("source");
   const instanceId = opts.instanceId ?? randomUUID();
   const startupCleanup: (() => void | Promise<void>)[] = [];
   let ready = false;
@@ -1121,6 +1160,7 @@ export async function startDaemon(opts: DaemonOptions) {
     let publicLine:string|undefined,view:ReturnType<typeof operationalView>|undefined;
     for(const [sock,current] of operationalLogSubscribers)try {current();if(sock.getBufferedAmount()>64*1024)throw new Error("slow log consumer");view??=publicOperationalView();publicLine??=view.line(text);sock.send(JSON.stringify({t:"operational_log",line:publicLine,complete:view.complete,...(!view.complete?{incompleteReason:view.incompleteReason}:{})}));}catch{operationalLogSubscribers.delete(sock);try{sock.close(4403,"operational log authority ended");}catch{/* The subscription is already gone. */}}
   };
+  startupTimings.mark("configuration");
   let runningRoutingDefault = recoveryDefaultRouting;
   if (runningRoutingDefault === undefined) try { runningRoutingDefault = recoveryRoutingFallback(); } catch { /* unknown defaults refuse conductor recovery */ }
   let runningRouting = recoveryRouting ?? currentRouting(opts.cwd, log);
@@ -1242,12 +1282,42 @@ export async function startDaemon(opts: DaemonOptions) {
   // first writes once its peers have stopped and their turns ended.
   const researchGraceMs = opts.researchGraceMs ?? 10_000;
   const researchPending = new Map<number, { since: number; timer: ReturnType<typeof setTimeout> }>();
+  /**
+   * #1279: the counter figures of one task, read from agent-mem's sidecar at the moment the record is written (the sidecar, the store and the memory project are bound further down, and exist by
+   * then). Undefined when memory or the sidecar is off, so the record's counters stay unknown; a task that is private reports none, whatever the sidecar holds.
+   */
+  const memoryFiguresFor = (taskId: number): MemoryFigures => {
+    const row = board.get(taskId);
+    if (!candidates || !memoryStore || !row || tasks.isPii(row)) return { ...UNKNOWN_MEMORY_FIGURES };
+    try {
+      const store = memoryStore, project = memoryProject;
+      const planContext = { cwd: opts.cwd, project, repo: memoryRepo, deny: config.local.deny };
+      const briefTask = { id: row.id, created: row.created, title: "", refs: { paths: row.refs.paths ?? [] }, plan: { paths: row.plan?.paths ?? [], symbols: row.plan?.symbols ?? [] } };
+      // The store has no read by id (`get` and `list` each rebuild the whole live view), so it is listed at most once per record, and only when the task has a rendered counter at all: a task with
+      // none never touches it. Only the rendered entries are screened, not the store. A hidden or unreadable entry is simply absent, and the figures then call their fail counts unknown.
+      let listed: Map<string, ReturnType<MemoryStore["list"]>[number]> | undefined;
+      const view = (id: string) => {
+        listed ??= new Map(store.list({ project, limit: Number.MAX_SAFE_INTEGER, includeSuperseded: true }).map(v => [v.id, v]));
+        const found = listed.get(id);
+        return found ? screenMemory([found])[0] : undefined;
+      };
+      return memoryFigures({
+        counters: candidates.counters(project),
+        taskKey: taskKey(project, row),
+        view,
+        matchingPlan: fails => matchingPlanFails(briefTask, fails, planContext),
+      });
+    } catch { return { ...UNKNOWN_MEMORY_FIGURES }; }
+  };
   const writeResearch = (taskId: number) => {
     const pending = researchPending.get(taskId);
     if (pending) clearTimeout(pending.timer);
     researchPending.delete(taskId);
     try {
-      appendRecords(projectId, taskRecords(readEvents(join(opts.stateDir, "events.jsonl")), projectId, { version: VERSION, source: "live" }).filter((r) => r.task === taskId));
+      // #1277: the board and journal are read through a read-only handle, so the record carries its v2 blocks; the family lookup is the project's own (instances resolve there).
+      // Scoped to the one task: the live writer runs on the daemon thread and must not parse every task's history and the whole journal for one record (a backfill reads them all).
+      const evidence = { ...readEvidence(opts.stateDir, projectId, taskId), familyOf: (peer: string) => adapterCatalog.familyOf(peer, declarations), memory: onlyTaskMemory(taskId, memoryFiguresFor) };
+      appendRecords(projectId, taskRecords(readEvents(join(opts.stateDir, "events.jsonl")), projectId, { version: VERSION, source: "live" }, evidence).filter((r) => r.task === taskId));
     } catch (error) {
       if (!researchLogged) log(`research record not written: ${(error as Error).message}`);
       researchLogged = true;
@@ -1298,7 +1368,13 @@ export async function startDaemon(opts: DaemonOptions) {
         sock.data.closed = true;
         for (const request of sock.data.invocationRequests?.values() ?? []) request.abort();
         sock.data.invocationRequests?.clear();
-        nativeHookLaunches.endOwner(sock);
+        for (const { peer } of nativeHookLaunches.endOwner(sock)) {
+          const run = runs.get(peer);
+          if (!run) continue;
+          if (budget.record(peer)) completionStore.dropRun(run.runTurn);
+          else completionDone(peer, run, "interrupted");
+          runs.close(peer);
+        }
         if (sock.data.session && sock.data.peer) sessionIds.delete(sock.data.peer);
         consoles.delete(sock);
         operationalLogSubscribers.delete(sock);
@@ -1321,8 +1397,9 @@ export async function startDaemon(opts: DaemonOptions) {
   }), opts.controlPort === 0 ? [opts.codexAppPort, opts.codexProxyPort] : []);
   // Written once this run owns the port, before any connection can attach a peer: a daemon that fails to bind (another
   // is running) never marks a run boundary in the live one's events.
-  event({ type: "hub_start", instance: instanceId });
+  event({ type: "hub_start", instance: instanceId, personAttribution: true });
   startupCleanup.push(() => server.stop(true));
+  startupTimings.mark("control");
 
 
   const recoveryOperation = process.env.AGENTHUB_RECOVERY_OPERATION;
@@ -1374,12 +1451,14 @@ export async function startDaemon(opts: DaemonOptions) {
   const { terminalHistoryLimit, ...busReaders } = busOperationalReaders(() => config);
   const adapterTiming = adapterOperationalReaders(() => config);
   const modelTiming = modelOperationalReaders(() => config);
+  startupTimings.mark("recovery");
   const journal = new DeliveryJournal({ file: join(opts.stateDir, "hub.db"), projectRoot: opts.cwd, projectId, instanceId, operationId: recoveryOperation, terminalHistoryLimit });
   // What the crash left in flight, per recipient: opening the journal just marked these needs_review.
   const lost = new Map<PeerId, JournalDelivery[]>();
   if (crashed) for (const d of journal.list()) if (d.state === "needs_review" && d.reason === "daemon stopped during delivery" && d.updatedAt >= startedAt) { lost.set(d.peer, [...(lost.get(d.peer) ?? []), d]); crashLostIds.add(d.id); }
   // Capabilities (issue #39): enforced here and in taskOp, never by role text alone. Unlisted peers keep everything.
   // A listed peer whose value is not a list gets nothing: whoever listed it meant to narrow it.
+  startupTimings.mark("journal");
   const may = (peer: PeerId, cap: "propose" | "assign" | "remember" | "memory_correct" | "memory_read" | "important" | "spec_read" | "check_run" | "invoke"): boolean => {
     if (peer === USER || peer === HUB || !Object.hasOwn(config.capabilities, peer)) return true;
     const list = config.capabilities[peer];
@@ -1769,6 +1848,7 @@ export async function startDaemon(opts: DaemonOptions) {
     }, delayMs);
     recoveryLeaseTimer.unref?.();
   };
+  startupTimings.mark("bus");
   const chain = projectChain(opts.cwd);
   const recalled = new Set<PeerId>(); // once per peer per hub run, however often the peer's session restarts
   // #258: the hub's own store, machine-wide in ~/.agenthub/memory. Entries are filed under the project's memory key (its
@@ -1862,7 +1942,10 @@ export async function startDaemon(opts: DaemonOptions) {
     publicText: text => !looksSecret(text) && withoutPii([{ title: "", text }], activeRouting(), opts.cwd, config.pii?.paths ?? []).length === 1,
     capture: () => ({ memoryDir: captureBinding!.home }), log,
   });
+  // ponytail: generated-note proofs are bounded to this daemon lifetime; after restart, unknown notes remain untouched.
+  const generatedRecordNotes = new GeneratedNoteRegistry();
   const memoryTelemetry = candidates && memoryStore ? new MemoryTelemetry(candidates, memoryStore, memoryProject, screenMemory, checkMemory) : undefined;
+  startupTimings.mark("memory");
   const staleness = () => createStalenessProbe({ cwd: opts.cwd, privatePaths: config.pii?.paths ?? [], deny: config.local.deny });
   const memoryLine = (v: MemoryView) => `mem:${v.id.slice(0, 8)} ${v.kind} ${v.tier}: ${`${v.title ? `${v.title}: ` : ""}${v.text}`.replace(/\s+/g, " ").slice(0, 160)}`;
   /** A task's own nodes: what its title names (an issue, a path), its refs and plan paths, plan symbols, and the task itself. */
@@ -2033,18 +2116,23 @@ export async function startDaemon(opts: DaemonOptions) {
   /** Machine sync, when a person set a remote; one log line per failure, never a blocked turn. Stopping aborts and awaits it. */
   function syncNow(): Promise<void> {
     if (!memoryStore || syncRun || stopping) return syncRun ?? Promise.resolve();
-    const recordFailure = (cause: ReturnType<typeof classifyMemorySyncFailure> & { declinedIdsFingerprint?: string; declinedIdsKnown?: false; failureDetailHash?: string; placementActive?: false }, errorText?: string) => {
-      if (quietSyncError(errorText)) {
+    let attestation: ReturnType<typeof hostPlacementAttestation> | undefined;
+    const recordFailure = (cause: ReturnType<typeof classifyMemorySyncFailure> & { declinedIdsFingerprint?: string; declinedIdsKnown?: false; failureDetailHash?: string; placementActive?: false; writerCategory?: string; writerCauseClass?: string }, errorText?: string) => {
+      if (cause.cause !== "writer" && quietSyncError(errorText)) {
         const state = errorText?.startsWith("stopped") ? "stopped" : "not-configured";
         memorySyncState = reduceMemorySync(memorySyncState, { type: "quiet", at: Date.now(), state }).state;
         return;
       }
       const reduced = reduceMemorySync(memorySyncState, { type: "failure", at: Date.now(), ...cause });
       memorySyncState = reduced.state;
-      if (reduced.logFailure && !quietSyncError(errorText)) log(`hub memory sync failed: ${cause.cause}${cause.cause === "declined" ? ` (${cause.declinedCount ?? 0} declined)` : ""}`);
+      if (reduced.logFailure) log(`hub memory sync failed: ${cause.cause}${cause.cause === "declined" ? ` (${cause.declinedCount ?? 0} declined)` : cause.cause === "writer" ? ` (${cause.writerCategory ?? "unknown"}, ${cause.writerCauseClass ?? "unavailable"}); next: ${memorySyncNextStep("writer")}` : ""}`);
     };
+    /** #1173: a refused writer attestation is its own closed cause with its category and next step, never a silent skip or a generic unknown. */
+    const writerFailure = (refusal: WriterRefusal) => ({ cause: "writer" as const, writerCategory: refusal.category, writerCauseClass: refusal.causeClass });
     const recordUnexpectedFailure = (error: unknown) => {
-      const errorText = typeof error === "string" ? error : error instanceof Error ? error.message : undefined;
+      const refusal = attestation?.refusal() ?? writerRefusalOf(error);
+      if (refusal) { recordFailure(writerFailure(refusal), undefined); return; }
+      const errorText = memorySyncErrorText(error);
       if (quietSyncError(errorText)) {
         recordFailure(classifyMemorySyncFailure(error), errorText);
         return;
@@ -2056,11 +2144,16 @@ export async function startDaemon(opts: DaemonOptions) {
         checkMemory();
         const policy = currentMemorySyncPolicy();
         const policyVersion = memorySyncPolicyVersion();
+        // Fresh per pass: agent-mem re-measures every writer install on each check; the legacy transport ignores it.
+        attestation = hostPlacementAttestation(memoryStore!.profile.home);
         const r = await (opts.memorySync ?? syncMemory)(memoryStore!, {
           signal: syncStop.signal,
+          placementAttestation: attestation.attest,
           screen: row => policy.screen(row, true).ok,
           policyVersion: () => memorySyncPolicyVersion(),
         });
+        const refused = attestation.refusal();
+        if (refused) { recordFailure(writerFailure(refused)); return; }
         if (memorySyncPolicyVersion() !== policyVersion) {
           recordFailure({ cause: "binding" }, "binding changed");
           return;
@@ -2108,7 +2201,14 @@ export async function startDaemon(opts: DaemonOptions) {
       own = memoryStore ? nativeRecall([...goals, ...recallMemoryLines(screenMemory(memoryStore.list({ project: memoryProject, tier: "long", limit: Number.MAX_SAFE_INTEGER }).filter((v) => v.kind !== "finding")), 30, staleness())], config.memory.enabled ? Math.floor(config.memory.inject_tokens / 2) : config.memory.inject_tokens, (line) => sanitize(line.replace(/\s+/g, " "))) : undefined;
     }
     catch (e) { log(`hub memory recall failed: ${(e as Error).message}`); }
-    const theirs = config.memory.enabled ? await recallFor(peer, memory, chain, own ? Math.ceil(config.memory.inject_tokens / 2) : config.memory.inject_tokens) : undefined;
+    const recordRecallTask: BriefTask = { owner: peer, title: "", refs: {} };
+    const recordRecallAllowed = () => !reviewOnlyPeer(peer) && !contextPii(peer) && !reviewObserverInput(peer) && recordReadAllowed(undefined, recordReadCwd(recordRecallTask));
+    const recordRecallTokens = own ? Math.ceil(config.memory.inject_tokens / 2) : config.memory.inject_tokens;
+    const theirs = config.memory.enabled ? await recallFor(peer, memory, chain, recordRecallTokens, {
+      allowed: recordRecallAllowed, policyVersion: () => recordReadVersion(recordRecallTask),
+      project: original => projectRecordRecall(peer, original, recordRecallTokens),
+      observe: counts => { if (recordRecallAllowed()) log(`records recall before=${counts.beforeBytes} after=${counts.afterBytes}`); },
+    }) : undefined;
     const block = [own, theirs].filter(Boolean).join("\n\n");
     if (!block || recalled.has(peer)) return; // nothing yet (worker down, no memory): the peer's next session tries again
     recalled.add(peer);
@@ -2162,7 +2262,13 @@ export async function startDaemon(opts: DaemonOptions) {
     try { notify(`conductor ${action.actor}: ${action.action}${action.task === undefined ? "" : ` #${action.task}`}${action.peer ? ` ${action.peer}` : ""}`); } catch { /* never throw after a task/hold write */ }
   };
   const inboxPolling = new InboxPolling();
+  startupTimings.mark("model_runtime");
   const board = new Board(join(opts.stateDir, "hub.db"));
+  const visuals = new VisualStore(join(opts.stateDir, "hub.db"));
+  startupCleanup.push(() => visuals.close());
+  // Held recovery must compare the source's exact rows before any retention mutation.
+  if (!recoveryActive() && !bus.isRecoveryHeld) visuals.prune(config.visuals.retention_days, Date.now(), task => !!board.get(task));
+  startupTimings.mark("board");
   const reviewInputHeld = (peer: PeerId, envs: readonly Envelope[]): boolean => {
     if (envs.some(isReviewObserverExcluded)) return true;
     const taskIds = envs.flatMap(env => {
@@ -2397,6 +2503,12 @@ export async function startDaemon(opts: DaemonOptions) {
   const reviewSymbols = new Map<string, CodeFactResult<CodeSymbol[]>>();
   const memorySymbols = new Map<string, MemorySymbolNodes>();
   startupCleanup.push(() => board.close());
+  const modelOverrides = new ModelOverrides(join(opts.stateDir, "hub.db"));
+  const modelLatches = new ModelOverrideLatches(modelOverrides);
+  const modelManagedOwners = new WeakSet<PeerAdapter>();
+  const modelAcpOwners = new WeakMap<PeerAdapter, AcpPeer>();
+  const modelLaunchModels = new WeakMap<PeerAdapter, string>();
+  startupCleanup.push(() => modelOverrides.close());
   startupCleanup.push(() => codeFacts.close());
   const supervision = new SupervisionFeed({
     conductor: () => conductorPeer(config.roles) ?? undefined,
@@ -2838,6 +2950,9 @@ export async function startDaemon(opts: DaemonOptions) {
       {
         allowed: corpusBriefAllowed, policyVersion: corpusPolicyVersion,
         read: task => publicCorpus([task.title, ...task.refs.paths ?? [], ...task.plan?.paths ?? [], ...task.plan?.symbols ?? []].join(" "), () => corpusBriefAllowed(task)).map(item => ({ id: item.id, kind: "note", line: `${item.id}: ${item.text.replace(/\s+/g, " ")}` })),
+      }, {
+        allowed: recordReadAllowed, policyVersion: recordReadVersion, read: readRecordSnapshot,
+        observe: (_peer, task, counts) => { const row = task === undefined ? undefined : board.get(task); if (row && recordReadAllowed(row)) log(`records brief before=${counts.beforeBytes} after=${counts.afterBytes} replaced=${counts.replacedNotes} records=${counts.records}`); },
       }),
     ...(memoryStore ? { planFails: (task: import("./board.ts").Task) => {
       const read = () => {
@@ -2851,7 +2966,7 @@ export async function startDaemon(opts: DaemonOptions) {
       };
       return controlWriteTelemetry ? controlWriteTelemetry.observe("memory", controlWritePrivacyGuard(true, true, undefined, task.id), read) : read();
     } } : {}),
-    ...(memoryStore ? { store: { store: memoryStore, project: memoryProject, repo: memoryRepo, deny: config.local.deny, onNote: (id: string) => void suggestEdges(id) } } : {}),
+    ...(memoryStore ? { store: { store: memoryStore, project: memoryProject, repo: memoryRepo, deny: config.local.deny, onGeneratedNote: (proof: GeneratedNoteProof) => generatedRecordNotes.record(proof), onNote: (id: string) => void suggestEdges(id) } } : {}),
     notify,
     recordOverlap: (task, owner, others) => event({ type: "overlap", task, owner, others }),
     checkEnded: owner => settleCheck(owner), // #1054: a run waited on its owner's completion check
@@ -3134,14 +3249,29 @@ export async function startDaemon(opts: DaemonOptions) {
   // same peer cannot undo a settlement.
   const turnEnded = new Map<PeerId, number>();
   const nativeCompletedAt = new Map<PeerId, number>();
-  const nativeStopsSeen = new Set(readEvents(join(opts.stateDir, "events.jsonl")).flatMap(event => event.type === "native_turn_end" && event.id ? [event.id] : []));
+  startupTimings.mark("task_runtime");
+  const startupSeeds = readStartupEventSeeds(join(opts.stateDir, "events.jsonl"));
+  try { opts.startupSeedObserved?.({ readPasses: startupSeeds.readPasses, readBytes: startupSeeds.readBytes }); } catch { /* Diagnostic observers cannot change replay or readiness. */ }
+  const nativeStopsSeen = startupSeeds.nativeStopsSeen;
+  startupTimings.mark("native_stop_seed");
   const activeAt = new Map<PeerId, number>();
   interface NativeTurnStart { at: number; baseline?: string; generation: string; session: string; launch: string }
   const nativeTurnStart = new Map<PeerId, NativeTurnStart>();
   const stopUnconfirmedNoticed = new WeakSet<NativeTurnStart>();
   const nativeStopWaits = new Map<PeerId, { start: NativeTurnStart; wait: ReturnType<typeof waitForClaudeCompletion> }>();
-  /** Every Claude hook call's own start-up and the hub's time for it, summed per turn (issue #108): reported at Stop. */
+  /** Every Claude or managed native hook call's own start-up and the hub's time for it, summed per turn (issue #108): reported at Stop. */
   const hookStats = new Map<PeerId, { n: number; startupMs: number; hubMs: number; maxStartupMs: number }>();
+  const tallyHook = (peer: PeerId, callStarted: number, startedMs: unknown) => {
+    const st = hookStats.get(peer) ?? { n: 0, startupMs: 0, hubMs: 0, maxStartupMs: 0 };
+    const startup = typeof startedMs === "number" && Number.isFinite(startedMs) ? Math.max(0, startedMs) : 0;
+    hookStats.set(peer, { n: st.n + 1, startupMs: st.startupMs + startup, hubMs: st.hubMs + (performance.now() - callStarted), maxStartupMs: Math.max(st.maxStartupMs, startup) });
+  };
+  const emitHookStats = (peer: PeerId) => {
+    const st = hookStats.get(peer);
+    if (!st) return;
+    event({ type: "hook_stats", peer, n: st.n, startupMs: Math.round(st.startupMs), hubMs: Math.round(st.hubMs), maxStartupMs: Math.round(st.maxStartupMs) });
+    hookStats.delete(peer);
+  };
   /**
    * Between native turns now: Claude stopped after its last tool call began (its channel going offline says nothing
    * about its session, whose hooks may still run); any other peer's adapter is not in a turn. The adapter's own state,
@@ -3168,7 +3298,8 @@ export async function startDaemon(opts: DaemonOptions) {
     }
     if ((h.event === "proposed" || h.event === "backlog pulled" || h.event === "catalog role changed") && (t.role ? catalog.roles.has(t.role) : h.event === "catalog role changed")) event({ type: "role", task: t.id, actor: h.by, stage: "assigned", roles: t.role ? [roleIdentity(catalog.roles.get(t.role)!)] : [] });
     event({ type: "task", id: t.id, event: h.event, by: h.by, state: t.state, owner: t.owner, reviewer: t.reviewer, class: t.class, ...(t.profile ? { profile: t.profile, profileClass: t.profileClass } : {}), ...(t.role ? { role: t.role, ...(catalog.roles.has(t.role) ? { roleIdentity: roleIdentity(catalog.roles.get(t.role)!) } : {}) } : {}), pii: tasks.isPii(t), ...(t.planningRevision ? { release: t.release ?? null, priority: t.priority ?? null, plannedStart: t.plannedStart ?? null, due: t.due ?? null } : {}), ...(h.reason ? { reason: h.reason } : {}) });
-    if (config.research.enabled && t.state === "approved" && (h.event === "approved" || h.event === "done")) recordResearch(t.id);
+    // #1277 AC6: a cancelled task is a terminal task too, and the guarded merge writes its receipt after the approval, so its result completes the record's merge block.
+    if (config.research.enabled && ((t.state === "approved" && (h.event === "approved" || h.event === "done" || h.event === "merge result")) || (t.state === "cancelled" && h.event === "cancelled"))) recordResearch(t.id);
     if (memoryStore && (t.state === "in_progress" || h.event === "done") && !tasks.isPii(t)) renewLeases(t);
     if ((h.event === "proposed" || h.event === "backlog pulled") && projections.enabled && turnLog) {
       const created = taskProposalAt(t);
@@ -3193,6 +3324,161 @@ export async function startDaemon(opts: DaemonOptions) {
   };
   const activityRings: Record<string, ActivityRing> = Object.fromEntries(SUPPORTED_PEERS.filter(peer => definitionOf(peer)?.capabilities?.watch).map(peer => [peer, new ActivityRing()]));
   const contextPii = (peer: PeerId) => !!turns.get(peer)?.private || board.peerTaskSignals(peer).some(task => !isClosedTaskState(task.state) && tasks.isPii(task));
+  const recordOwners = new WeakMap<PeerAdapter, { cwd: string; session(): string | undefined }>();
+  const recordInputs = new Map<PeerId, { owner: PeerAdapter | undefined; originals: readonly Envelope[]; tainted?: true }>();
+  const recordFrames = new Map<PeerId, { owner: PeerAdapter; turn: NonNullable<ReturnType<typeof turns.get>>; capture: RecordCapture }>();
+  function recordPolicy(cwd: string): { enabled: boolean; version: string } | undefined {
+    try {
+      if (opts.effectiveRecordPolicy) {
+        const policy = opts.effectiveRecordPolicy(cwd);
+        return policy && typeof policy.enabled === "boolean" && typeof policy.version === "string" && policy.version ? { enabled: policy.enabled, version: policy.version } : undefined;
+      }
+      const binding = captureBinding;
+      if (!binding || memoryProblem) return;
+      binding.assertCurrent();
+      const enabled = recordsEnabled(binding.home, cwd);
+      // This revision binds only the public flag; fresh configuredPolicy screens below bind current privacy policy.
+      return { enabled, version: enabled ? "records:true" : "records:false" };
+    }
+    catch { return; }
+  }
+  function recordPublic(text: string): boolean { return !looksSecret(text) && boundedSafe(text) && tasks.publicMetadataText(text); }
+  function recordPathDenied(path: string, cwd = opts.cwd): boolean { return isDenied(path, config.local.deny) || matchesPolicy(cwd, path, config.pii?.paths ?? [], true) || matchesPolicy(opts.cwd, resolve(cwd, path), config.pii?.paths ?? [], true); }
+  function recordInputAllowed(peer: PeerId, envs: readonly Envelope[]): boolean {
+    try { return !!envs.length && !reviewInputHeld(peer, envs) && !reviewObserverInput(peer) && !envs.some(env => env.private || isReviewObserverExcluded(env) || isInvocationKind(env) || remoteEnvelope(env) || env.to?.some(id => id.includes("@"))); }
+    catch { return false; }
+  }
+  function recordOwnerEligible(owner: PeerAdapter): boolean {
+    const recordPeerId = owner.id, input = recordInputs.get(recordPeerId), proxy = frontendProxyState(recordPeerId, owner);
+    if (proxy.present && (!proxy.port || proxy.port.attached)) return false;
+    return config.memory.enabled && !stopping && !recoveryActive() && !bus.isRecoveryHeld && recordOwners.has(owner) && bus.peers.get(recordPeerId) === owner
+      && membershipAllowed(recordPeerId) && owner.state === "busy" && !reviewOnlyPeer(recordPeerId) && !definitionOf(recordPeerId)?.reviewer && !contextPii(recordPeerId)
+      && !!input && !input.tainted && input.owner === owner && recordInputAllowed(recordPeerId, input.originals);
+  }
+  function noteRecordSteered(peer: PeerId, originals: readonly Envelope[]): void {
+    const input = recordInputs.get(peer), owner = bus.peers.get(peer);
+    if (!input) { recordInputs.set(peer, { owner, originals: [], tainted: true }); return; }
+    if (!input.tainted && (!owner || input.owner !== owner || !recordInputAllowed(peer, originals))) input.tainted = true;
+  }
+  function closeRecordFrame(peer: PeerId): void { recordFrames.get(peer)?.capture.close(); recordFrames.delete(peer); }
+  function bindRecordOwner(owner: PeerAdapter, cwd: string, session: () => string | undefined): void {
+    recordOwners.set(owner, { cwd, session });
+    owner.recordInstruction = () => {
+      if (!recordOwnerEligible(owner)) return;
+      const turn = turns.get(owner.id), bound = recordOwners.get(owner), prior = recordFrames.get(owner.id);
+      if (!turn || !bound) return;
+      if (prior?.owner === owner && prior.turn === turn) return prior.capture.instruction();
+      closeRecordFrame(owner.id);
+      const session = bound.session();
+      if (!session) return;
+      const effective = recordPolicy(cwd);
+      if (!effective?.enabled || !captureBinding || memoryProblem) return;
+      const binding = captureBinding, profile = memorySyncPolicyVersion(), revision = configRevision, generation = owner.sessionGeneration;
+      const current = () => {
+        if (!recordOwnerEligible(owner) || turns.get(owner.id) !== turn || bound.session() !== session || owner.sessionGeneration !== generation || configRevision !== revision || captureBinding !== binding || memoryProblem) return false;
+        const policy = recordPolicy(cwd);
+        if (policy?.enabled !== true || policy.version !== effective.version || memorySyncPolicyVersion() !== profile) return false;
+        try { binding.assertCurrent(); return memoryProjectFor(opts.cwd) === memoryProject; } catch { return false; }
+      };
+      const policy: RecordCapturePolicy = { records: true, current, project: memoryProject, cwd, peer: owner.id, turn: turn.id, session, at: new Date(turn.start).toISOString(), memoryDir: binding.home,
+        publicText: text => { try { return current() && configuredPolicy(binding.home, cwd).screenStandalone(text) && recordPublic(text) && current(); } catch { return false; } },
+        denyPath: path => recordPathDenied(path, cwd) };
+      const capture = new RecordCapture({ eligible: () => recordOwnerEligible(owner) && turns.get(owner.id) === turn, policy: () => current() ? policy : undefined,
+        observe: counts => { if (current()) log(`records capture accepted=${counts.accepted} dropped=${counts.dropped} bytes=${counts.bytes}`); } });
+      recordFrames.set(owner.id, { owner, turn, capture });
+      return capture.instruction();
+    };
+  }
+  function recordReadCwd(task?: Pick<BriefTask, "owner">): string {
+    const owner = task?.owner ? bus.peers.get(task.owner) : undefined;
+    return owner ? recordOwners.get(owner)?.cwd ?? opts.cwd : opts.cwd;
+  }
+  function recordReadAllowed(task?: BriefTask, cwd = recordReadCwd(task)): boolean {
+    try { return config.memory.enabled && !stopping && !recoveryActive() && !bus.isRecoveryHeld && !memoryProblem && !!captureBinding
+      && (task ? corpusBriefAllowed(task) : true) && recordPolicy(cwd)?.enabled === true; } catch { return false; }
+  }
+  function recordReadVersion(task?: BriefTask): string { const cwd = recordReadCwd(task); return JSON.stringify([memorySyncPolicyVersion(), cwd, recordPolicy(cwd)]); }
+  function readRecordSnapshot(task?: BriefTask, peer?: PeerId): import("../memory/brief.ts").RecordBriefSnapshot | undefined {
+    const selectedPeer = task?.owner ?? peer;
+    if (selectedPeer && (reviewOnlyPeer(selectedPeer) || contextPii(selectedPeer) || reviewObserverInput(selectedPeer))) return;
+    const context = task ?? (peer ? { owner: peer, title: "", refs: {} } : undefined), cwd = recordReadCwd(context), owner = selectedPeer ? bus.peers.get(selectedPeer) : undefined;
+    if (!recordReadAllowed(task, cwd)) return;
+    const version = recordReadVersion(context), binding = captureBinding!;
+    let store: CaptureStore | undefined;
+    try {
+      binding.assertCurrent(); if (memoryProjectFor(opts.cwd) !== memoryProject) return;
+      const policy = configuredPolicy(binding.home, cwd);
+      store = new CaptureStore({ memoryDir: binding.home, project: memoryProject, cwd, readOnly: true });
+      const snapshot = store.readBriefRecords(32);
+      if (!recordReadAllowed(task, cwd) || recordReadVersion(context) !== version) return;
+      const paths = task ? [...task.refs.paths ?? [], ...task.plan?.paths ?? []] : undefined;
+      const publicRow = (row: (typeof snapshot.rows)[number], currentPolicy: ReturnType<typeof configuredPolicy>) => row.event === "Record" && !row.subagent && Array.isArray(row.paths)
+        && currentPolicy.screenStandalone(row) && currentPolicy.screenStandalone(row.excerpt) && currentPolicy.screenStandalone(row.paths) && recordPublic(JSON.stringify(row))
+        && sanitize(row.excerpt) === row.excerpt && row.paths.every(anchor => typeof anchor === "string" && !recordPathDenied(anchor.split("#")[0]!, cwd));
+      const rows = snapshot.rows.filter(row => publicRow(row, policy)
+        && (!paths || row.paths.length === 0 || row.paths.some(anchor => paths.some(path => anchor === path || anchor.split("#")[0] === path))));
+      const current = (text?: string) => {
+        try {
+          if (selectedPeer && (bus.peers.get(selectedPeer) !== owner || reviewOnlyPeer(selectedPeer) || contextPii(selectedPeer) || reviewObserverInput(selectedPeer))) return false;
+          if (captureBinding !== binding || recordReadCwd(context) !== cwd || !recordReadAllowed(task, cwd) || recordReadVersion(context) !== version) return false;
+          binding.assertCurrent(); if (memoryProjectFor(opts.cwd) !== memoryProject) return false;
+          const fresh = configuredPolicy(binding.home, cwd);
+          return rows.every(row => publicRow(row, fresh)) && (text === undefined || typeof text === "string" && fresh.screenStandalone(text) && recordPublic(text));
+        } catch { return false; }
+      };
+      if (!current()) return;
+      return { rows, replaceable: generatedRecordNotes.matching([...new Set(rows.flatMap(row => row.paths))], 32), partial: snapshot.partial, current };
+    } catch { return; } finally { try { store?.close(); } catch { /* Read preference never changes the old brief. */ } }
+  }
+  function projectRecordRecall(peer: PeerId, original: string, tokens: number): import("../memory/recall.ts").RecordRecallProjection | undefined {
+    const header = "# [amem] recent curated context\n\n### Curated short-term notes\n";
+    if (typeof original !== "string" || original.length > 64 * 1024 || Buffer.byteLength(original) > 64 * 1024 || !original.startsWith(header) || original.includes("\r") || !Number.isSafeInteger(tokens) || tokens < 1) return;
+    const owner = bus.peers.get(peer), context: BriefTask = { owner: peer, title: "", refs: {} };
+    const allowed = () => bus.peers.get(peer) === owner && !reviewOnlyPeer(peer) && !contextPii(peer) && !reviewObserverInput(peer) && recordReadAllowed(undefined, recordReadCwd(context));
+    if (!allowed()) return;
+    const version = recordReadVersion(context), current = () => allowed() && recordReadVersion(context) === version;
+    if (!current()) return;
+    const body = original.slice(header.length).split("\n"), items: NativeItem[] = [], ids = new Set<string>(), protectedIds = new Set<string>();
+    const row = /^(mem:[a-f0-9]{32}) (decision|finding|contract|fail): /;
+    for (const line of body) {
+      const match = row.exec(line);
+      if (!match) { if (line.startsWith("mem:")) return; continue; }
+      const id = match[1]!;
+      if (ids.has(id) || items.length >= 32) return;
+      ids.add(id); items.push({ id, kind: match[2]!, line });
+      if (!generatedRecordNotes.get(id)) protectedIds.add(id);
+    }
+    const snapshot = readRecordSnapshot(undefined, peer);
+    let projectedText = original;
+    const projectionCurrent = () => current() && (snapshot?.current === undefined || snapshot.current(original) === true && snapshot.current(projectedText) === true);
+    if (!snapshot || !projectionCurrent()) return;
+    const staticBytes = Buffer.byteLength(original) - Buffer.byteLength(items.map(item => item.line).join("\n"));
+    const preferred = preferRecordItems(items, snapshot, 32, protectedIds, Math.max(0, tokens * 3 - staticBytes));
+    if (!projectionCurrent()) return;
+    const output: string[] = []; let index = 0;
+    for (const line of body) {
+      const match = row.exec(line);
+      if (!match) { output.push(line); continue; }
+      if (preferred.items.some(item => item.id === match[1])) {
+        while (index < preferred.items.length && !ids.has(preferred.items[index]!.id)) output.push(preferred.items[index++]!.line);
+        if (preferred.items[index]?.id !== match[1]) return;
+        output.push(line); index++;
+      } else {
+        while (index < preferred.items.length && !ids.has(preferred.items[index]!.id)) output.push(preferred.items[index++]!.line);
+      }
+    }
+    while (index < preferred.items.length) { const item = preferred.items[index++]!; if (ids.has(item.id)) return; output.push(item.line); }
+    const after = header + output.join("\n"); projectedText = after;
+    if (!projectionCurrent() || Buffer.byteLength(after) > Math.max(Buffer.byteLength(original), tokens * 3)) return;
+    return { before: original, after, records: preferred.records, current: projectionCurrent };
+  }
+  bus.onFinalAnswer = (peer, raw, input) => {
+    const frame = recordFrames.get(peer);
+    if (!frame || !recordOwnerEligible(frame.owner) || turns.get(peer) !== frame.turn || !recordInputAllowed(peer, input.out) || !recordInputAllowed(peer, input.originals)) return;
+    frame.capture.finish(raw);
+  };
+  bus.onFinalAnswerBytes = (peer, counts) => { const owner = bus.peers.get(peer); if (owner && recordOwnerEligible(owner)) log(`records forwarded before=${counts.before} after=${counts.after}`); };
+
   // Hoisted for the Tasks ports above; only the returned guard reads fully initialized daemon state.
   function controlWritePrivacyGuard(admittedAtReceive: boolean, inputPublicAtReceive: boolean, peer?: PeerId, taskId?: number) {
     return () => {
@@ -3400,28 +3686,32 @@ export async function startDaemon(opts: DaemonOptions) {
     notify: (line) => { notify(line); feedBudgetPauses(); },
   }, accountMembers, accountOf));
   budget.setRecoveryHold(recoveryActive());
-  // ponytail: a third full read of events.jsonl at startup (after nativeStopsSeen and claudeNativeUsageSeen). Measured at about 70 ms on the real
-  // 46 MB, 238k-line log, so it is not folded into one pass across startup. Ceiling: the log is never rotated, so the cost grows with it; when a
-  // read passes a few hundred ms, make one `readEvents` pass feed all three sets (or keep the resets in hub.db, the #683 U2 roll-up).
-  const startupEvents = readEvents(join(opts.stateDir, "events.jsonl"));
+  // Share the single streaming startup pass; quota, Kimi and token-window replay keep their existing predicates.
+  startupTimings.mark("budget");
+  const startupEvents = startupSeeds.events;
   budget.seedResets(startupEvents.flatMap(e => e.type === "quota_reset" ? [{ peer: e.peer, window: e.window, ...(e.resetsAt !== undefined ? { resetsAt: e.resetsAt } : {}) }] : []));
   // #285 phase 2: Kimi's consumption is the hub's own count of its session wire log (`src/adapters/kimi-wire-usage.ts`), not an ACP total.
+  const kimiEvents = new KimiEventWriter({ append: event, read: () => readEvents(join(opts.stateDir, "events.jsonl")) }, startupEvents);
   const kimiUsage = new KimiUsage({
     home: opts.kimiHome ?? process.env.KIMI_CODE_HOME ?? join(homedir(), ".kimi-code"),
     now: () => Date.now(),
     ceiling: () => config.budget.kimi_tokens_5h,
     session: peer => contextSession(peer),
-    record: (peer, row, counted) => {
-      addTokens(peer, counted);
-      event({ type: "usage", peer, source: "kimi_wire", id: row.id, measuredAt: new Date(row.at).toISOString(), inputTokens: row.inputOther, outputTokens: row.output,
-        cacheReadTokens: row.inputCacheRead, cacheWriteTokens: row.inputCacheCreation, totalTokens: kimiRowTotal(row),
-        ...taskAttribution(peer), ...(row.model ? { servedModel: row.model } : {}) });
+    schedule: opts.kimiUsageScheduler ?? ((delay, run) => {
+      const timer = setTimeout(run, delay); timer.unref?.();
+      return () => clearTimeout(timer);
+    }),
+    record: (peer, row, counted, attributed) => {
+      kimiEvents.write(peer, row, counted, attributed);
+      applyKimiTokens(peer, counted, attributed);
     },
     report: (peer, window) => budget.report(peer, [{ id: "tokens", kind: "count", used: window.used, resetsAt: window.resetsAt, source: `hub count, kimi wire log, of kimi_tokens_5h ${window.ceiling}` }]),
     forget: peer => budget.forget(peer, "tokens", "count"),
     notice: line => notify(line),
   });
+  startupCleanup.push(() => kimiUsage.stop());
   kimiUsage.seed(kimiSeedRows(startupEvents, Math.max(0, ...startupEvents.flatMap(e => e.type === "budget_resume" && definitionOf(e.peer)?.budget?.resetSoftTokensOnResume ? [Date.parse(e.at)] : []).filter(Number.isFinite))));
+  startupTimings.mark("usage_seed");
   /** Why a peer shows no number (no quota, nothing read yet): one line each, from the definition and the counters, never from a log's text. */
   const budgetPeerNotes = (): BudgetPeerNote[] => {
     const quota = budget.status();
@@ -3429,15 +3719,16 @@ export async function startDaemon(opts: DaemonOptions) {
     return budgetNotes({ peers, windows: peer => quota[accountOf(peer)]?.windows.length ?? 0, definition: peer => definitionOf(peer), softTokens: () => kimiUsage.status(),
       hubTokens5h: peer => hubTokenWindows.get(peer)?.sum(Date.now()) });
   };
-  /** A peer whose definition keeps host-owned soft token accounting (Kimi): its rows are read at a turn start (the floor), a turn end and a usage_update. */
+  /** A peer whose definition keeps host-owned soft token accounting (Kimi): its rows are read at a turn start (the floor), a turn end, a usage_update and a bounded delayed drain. */
   const softTokenPeer = (peer: PeerId): boolean => !!definitionOf(peer)?.budget?.resetSoftTokensOnResume;
-  const collectKimiUsage = (peer: PeerId): void => { if (!softTokenPeer(peer)) return; try { kimiUsage.collect(peer); } catch (error) { log(`kimi usage: ${(error as Error).name}`); } };
+  const collectKimiUsage = (peer: PeerId, terminal = false): void => { if (!softTokenPeer(peer)) return; try { kimiUsage.collect(peer, false, terminal); } catch (error) { log(`kimi usage: ${(error as Error).name}`); } };
   startupCleanup.push(() => budget.close());
   // #683 U2: events.jsonl folded into hub.db, a bounded pass at a time, so `usage` never rescans the log.
   const usageRollup = new UsageRollup(join(opts.stateDir, "hub.db"), join(opts.stateDir, "events.jsonl"));
   startupCleanup.push(() => usageRollup.close());
   const pollUsageRollup = () => { try { usageRollup.poll(); } catch (error) { log(`usage roll-up pass failed: ${(error as Error).message.slice(0, 120)}`); } };
   pollUsageRollup();
+  startupTimings.mark("usage_rollup");
   // Turns and their tokens for telemetry (issue #40). Turn ids carry the hub run, so they stay unique across restarts.
   const runId = Date.now().toString(36);
   let turnSeq = 0;
@@ -3447,11 +3738,14 @@ export async function startDaemon(opts: DaemonOptions) {
     const task = result.task === undefined ? undefined : board.get(result.task);
     return { ...result, ...(task && tasks.isPii(task) ? { pii: true as const } : {}) };
   };
-  const supervisionTurns = new Map<PeerId, { id: string; at: number; tokens?: number; session?: string }>();
+  const supervisionTurns = new Map<PeerId, { id: string; at: number; tokens?: number; session?: string; nativeTurn?: string }>();
   /** #1054: who started the turn a delivery begins. The person's message (console, `ahub say`, an acon send: from `user`, never the hub's own `answer` envelope) opens a run; ids only. */
   const pendingPersonDelivery = new Map<PeerId, { envelope: string; private: boolean }>();
+  /** A native turn whose transcript, not its hook payload, proved a person origin. Native prompt text is never available here, so the result stays private. */
+  const pendingNativePerson = new Set<PeerId>();
   bus.onDeliver = (peer, originals) => {
     if (peer.includes("@")) return;
+    recordInputs.set(peer, { owner: bus.peers.get(peer), originals: [...originals] });
     resetReviewObserverSessionIfChanged(peer);
     if (!presenceOnlyDelivery(originals)) {
       const pendingBefore = pendingReviewObserverInputs.get(peer), previous = pendingBefore ?? currentReviewObserverInputs.get(peer), reviewInputScoped = reviewInputHeld(peer, originals), turnId = turns.get(peer)?.id;
@@ -3579,7 +3873,7 @@ export async function startDaemon(opts: DaemonOptions) {
     supervisionTurns.set(peer, { id: turn?.id ?? `supervision-${randomUUID()}`, at: turn?.start ?? Date.now(), ...(turn?.tokens ? { tokens: turn.tokens } : {}), ...(contextSession(peer) ? { session: contextSession(peer) } : {}) });
   };
   bus.onPulled = (peer, originals) => { notePulledReviewInput(peer, originals); };
-  bus.onSteering = (peer, originals) => { noteSteeredReviewInput(peer, originals); };
+  bus.onSteering = (peer, originals) => { try { noteSteeredReviewInput(peer, originals); } finally { noteRecordSteered(peer, originals); } };
   bus.onDeliveryFailed = peer => {
     pendingDeliveryTask.delete(peer); pendingPersonDelivery.delete(peer); deliveredAwaitingTurn.delete(peer); supervisionTurns.delete(peer);
     const pending = pendingReviewObserverInputs.get(peer);
@@ -4014,9 +4308,20 @@ export async function startDaemon(opts: DaemonOptions) {
   const noQuotaPeer = (peer: PeerId): boolean => !!definitionOf(peer)?.budget?.noQuotaReason;
   const hubTokenWindow = (peer: PeerId): TokenWindow => hubTokenWindows.get(peer) ?? hubTokenWindows.set(peer, new TokenWindow(5 * 3_600_000)).get(peer)!;
   // Replayed through `seed`, which skips rows older than 5 h before inserting any: a long-lived project's whole log costs one pass, not one search per row.
+  startupTimings.mark("token_runtime");
   const seedNow = Date.now(), seedRows = new Map<PeerId, { at: number; n: number }[]>();
   for (const e of startupEvents) if (e.type === "tokens" && noQuotaPeer(e.peer)) (seedRows.get(e.peer) ?? seedRows.set(e.peer, []).get(e.peer)!).push({ at: Date.parse(e.at), n: e.n });
   for (const [peer, rows] of seedRows) hubTokenWindow(peer).seed(rows, seedNow);
+  const applyKimiTokens = (peer: PeerId, n: number, attributed: KimiRowAttribution): void => {
+    if (n > 0 && noQuotaPeer(peer)) hubTokenWindow(peer).add(Date.now(), Math.round(n));
+    const supervisionTurn = supervisionTurns.get(peer);
+    if (supervisionTurn && Number.isFinite(n) && n >= 0 && (supervisionTurn.nativeTurn ?? supervisionTurn.id) === attributed.turn) supervisionTurn.tokens = (supervisionTurn.tokens ?? 0) + n;
+    if (n > 0) {
+      const turn = turns.get(peer);
+      if (turn && turn.id === attributed.turn) turn.tokens += n;
+    }
+  };
+  startupTimings.mark("token_seed");
   const addTokens = (peer: PeerId, n: number, task?: number): number => {
     if (n > 0 && noQuotaPeer(peer)) hubTokenWindow(peer).add(Date.now(), Math.round(n));
     const supervisionTurn = supervisionTurns.get(peer);
@@ -4035,11 +4340,21 @@ export async function startDaemon(opts: DaemonOptions) {
   const claudeContextSeen = new Map<string, string>();
   const contextTailSeen = new Map<PeerId, string>();
   const retainedCliAudits = new Set<string>();
+  /**
+   * The period of the sweep that drains the CLI audit outbox (the interval below runs `drainCliAuditsNow` on it). A row is attributed to the peer's task only when it is at most this many
+   * periods old at the drain: an ordinary row is drained within one period, so fifteen leaves room for a slow sweep, while a row left by a stalled hub or an unreadable outbox is not matched to
+   * whatever task is open when it is finally read. The bound is derived from the period, so the two cannot drift apart.
+   */
+  const CLI_AUDIT_SWEEP_MS = 1000;
+  const CLI_AUDIT_FRESH_MS = 15 * CLI_AUDIT_SWEEP_MS;
   function drainCliAuditsNow(): void {
     for (const audit of drainCliAudits(opts.stateDir)) {
       const delegated = audit.outcome === "delegated";
       const refused = audit.outcome !== "run" && !delegated;
-      if (!event({ type: "agent_cli", peer: audit.peer, command: audit.command, refused, ...(delegated ? { delegated: true } : {}) })) {
+      // #1278: the audit row is written when the command runs and read here on a later sweep, so the peer's open tasks now may not be the ones then. A row older than the drain's own
+      // freshness bound is `unattributed` (what is known), never matched to whatever is open at drain time; a fresh one uses the rule `turn_end` uses.
+      const fresh = Date.now() - audit.at <= CLI_AUDIT_FRESH_MS && Date.now() >= audit.at;
+      if (!event({ type: "agent_cli", peer: audit.peer, command: audit.command, refused, ...(delegated ? { delegated: true } : {}), ...(fresh ? taskAttribution(audit.peer) : { attribution: "unattributed" as const }) })) {
         throw new Error("CLI audit event was not retained");
       }
       retainedCliAudits.add(audit.id); // Only after the event append succeeded.
@@ -4135,7 +4450,7 @@ export async function startDaemon(opts: DaemonOptions) {
         const reading = bound ? readNativeContext(definitionOf(claudePeer), c.context, bound, c.at) : undefined;
         if (reading) contexts.report(claudePeer, reading, bound);
       } catch { /* absent or unreadable native telemetry is unknown */ }
-    }, 1000),
+    }, CLI_AUDIT_SWEEP_MS),
     setInterval(() => budget.tick(), 30_000),
     setInterval(pollUsageRollup, 10_000),
     // #481 S7: band tiers are evaluated every five minutes, and only when the board changed since the last evaluation (the status
@@ -4159,6 +4474,10 @@ export async function startDaemon(opts: DaemonOptions) {
       void tasks.runSecurityScan().catch(error => log(`sdlc security scan failed: ${sanitize((error as Error).message).slice(0, 160)}`));
     }, opts.securityScanEveryMs ?? 3_600_000),
     setInterval(() => {
+      if (!stopping && !recoveryActive() && !bus.isRecoveryHeld) {
+        try { visuals.prune(config.visuals.retention_days, Date.now(), task => !!board.get(task)); }
+        catch { /* retention retries on the existing maintenance tick */ }
+      }
       if (!ready || !memoryBinding) return;
       const before = memoryProblem;
       memoryBinding.status(memoryStore);
@@ -4546,7 +4865,7 @@ export async function startDaemon(opts: DaemonOptions) {
   const conductedMutations = new Set(["hub_task_propose", "hub_task_accept", "hub_task_decline", "hub_task_done", "hub_review", "hub_checkpoint", "hub_remember"]);
   const taskOp = async (...args: Parameters<typeof taskOpBody>): Promise<string> => {
     const [by, op, input] = args;
-    if (readOnlyPeer(by) && !READ_ONLY_HUB_TOOLS.has(op)) throw new PreEffectToolRefusal("read-only instance cannot mutate hub state");
+    if (readOnlyPeer(by) && !READ_ONLY_HUB_TOOLS.has(op)) throw op === "hub_visual" ? visualOperational("role") : new PreEffectToolRefusal("read-only instance cannot mutate hub state");
     const sourceCurrent = op === "hub_source_read" ? sourceReadCurrent(by, args[3] ?? false, args[4] ?? false) : undefined;
     const nativeTurn = turns.get(by);
     const effectful = ownerToolEffect(op, input);
@@ -4569,13 +4888,13 @@ export async function startDaemon(opts: DaemonOptions) {
         const id = Number.isSafeInteger(proposed) && proposed! > 0 ? proposed : admittedId;
         auditConduct({ kind: "conduct", actor: by, action: op.slice(4), ...(id === undefined ? {} : { task: id }) });
       }
-      const hint = args[3] && op !== "hub_source_read" && op !== "hub_set_title" && op !== "hub_evidence_record" ? ownHeldHint(by) : "";
+      const hint = args[3] && op !== "hub_source_read" && op !== "hub_set_title" && op !== "hub_evidence_record" && op !== "hub_visual" && op !== "hub_visual_show" ? ownHeldHint(by) : "";
       return hint ? `${text}\n\n${hint}` : text;
     } catch (error) {
       if (reviewTool && traceId !== undefined) reviewerToolObservers.get(by)?.(traceId, reviewTool, error instanceof Error ? error.message : "review tool refused");
       if (nativeTurn && effectful && !(error instanceof PreEffectToolRefusal) && turns.get(by) === nativeTurn) nativeTurn.taskEffect = true;
       // Keep proven pre-effect refusal identity/code for native receipts; only add body-free metadata.
-      const hint = args[3] && op !== "hub_source_read" && op !== "hub_set_title" && op !== "hub_evidence_record" ? ownHeldHint(by) : "";
+      const hint = args[3] && op !== "hub_source_read" && op !== "hub_set_title" && op !== "hub_evidence_record" && op !== "hub_visual" && op !== "hub_visual_show" ? ownHeldHint(by) : "";
       if (hint && error instanceof Error) error.message += `\n\n${hint}`;
       throw error;
     } finally {
@@ -4741,7 +5060,197 @@ export async function startDaemon(opts: DaemonOptions) {
         catch (error) { finishInvocation(row, "refused", { reason: "the hub could not queue the request; nothing ran" }); throw new PreEffectToolRefusal(error instanceof Error ? error.message : "the request could not be queued"); }
         return JSON.stringify({ invocation: row.id, state: "queued", note: "the result arrives later as one message from the hub, addressed to you only; do not wait for it in this turn" });
   }
+  const visualUnavailable = () => new PreEffectToolRefusal("visual unavailable under the current privacy or project policy; use a public visual in an ordinary context and retry");
+  const visualOperational = (cause: "stopping" | "recovery" | "authority" | "role" | "membership" | "observer" | "storage" | "concurrency" | "screen" | "policy") => new PreEffectToolRefusal({
+    stopping: "visual unavailable: hub is stopping; wait for the hub to restart and retry",
+    recovery: "visual operation is held by controlled recovery; check ahub status, wait for recovery release and retry",
+    authority: "visual request authority changed; reconnect your current peer session and retry",
+    role: "visual publication requires remember capability and a writable peer role; ask the person to update the peer role or capability and retry",
+    membership: "visual peer is off roster; ask the person to enable it and retry",
+    observer: "visual publication is held by an open review observer scope; finish or settle the review and start an ordinary turn",
+    storage: "visual delivery storage is unavailable; inspect ahub status and retry after storage recovers",
+    concurrency: "visual generation, task or policy changed while checking; inspect current task/session and retry",
+    screen: "visual privacy screen is unavailable or returned no clear verdict; shorten the visual if it exceeds the screen limit, or restore the configured screen, check ahub status and retry",
+    policy: "visual file policy is unavailable; repair the project configuration and retry",
+  }[cause]);
+  type VisualFilePolicy = { pii: string[]; deny: string[] };
+  let visualPolicyCache: { key: string; value: VisualFilePolicy } | undefined;
+  // These two non-machine-local path policies use ordinary per-key local-over-shared precedence.
+  // Reading a candidate cannot relax accepted runtime restrictions until they are actually adopted.
+  const visualFilePolicy = (): VisualFilePolicy => {
+    try {
+      const texts = configSourceTexts(opts.cwd);
+      const key = JSON.stringify([texts["config.json"], texts["config.local.json"], config.pii?.paths ?? [], config.local.deny]);
+      if (visualPolicyCache?.key === key) return visualPolicyCache.value;
+      let pii: string[] = [], deny: string[] = [];
+      for (const name of CONFIG_FILES) {
+        if (texts[name] === null) continue;
+        const raw: unknown = JSON.parse(texts[name]!);
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw visualOperational("policy");
+        const input = raw as Record<string, unknown>;
+        if (input.pii !== undefined) {
+          const policies: Record<string, unknown> = { pii: input.pii };
+          validateRawConfig(policies, declarations, adapterCatalog);
+          const value = input.pii as Record<string, unknown>;
+          if (Object.hasOwn(value, "paths")) pii = policyPaths(value.paths, "pii.paths");
+        }
+        if (input.local !== undefined) {
+          if (!input.local || typeof input.local !== "object" || Array.isArray(input.local)) throw visualOperational("policy");
+          const value = input.local as Record<string, unknown>;
+          if (Object.hasOwn(value, "deny")) {
+            const localPolicy: Record<string, unknown> = { deny: value.deny }, policies: Record<string, unknown> = {};
+            policies.local = localPolicy;
+            validateRawConfig(policies, declarations, adapterCatalog);
+            deny = value.deny as string[];
+          }
+        }
+      }
+      const value = { pii: [...new Set([...(config.pii?.paths ?? []), ...pii])], deny: [...new Set([...config.local.deny, ...deny])] };
+      visualPolicyCache = { key, value }; return value;
+    } catch { throw visualOperational("policy"); }
+  };
+  const visualSafeText = (text: string, policy: VisualFilePolicy): boolean => boundedSafe(text) && tasks.publicMetadataText(text)
+    && !mentionsPrivatePath(text, [], [...policy.pii, ...policy.deny], opts.cwd);
+  const visualPathPublic = (path: string, policy: VisualFilePolicy): boolean => {
+    try {
+      const root = realPath(opts.cwd), typed = resolve(root, path);
+      const publicName = (value: string) => {
+        const name = relative(root, value);
+        return insideRoot(name) && !isHubWritePath(name) && !isDenied(name, policy.deny) && !isDenied(value, policy.deny)
+          && !matchesPolicy(root, name, policy.pii, true) && visualSafeText(name, policy);
+      };
+      return publicName(typed) && publicName(policyRealPath(typed));
+    } catch { return false; }
+  };
+  const visualTaskPublic = (task?: number, captured?: VisualFilePolicy): boolean => {
+    try {
+      const policy = captured ?? visualFilePolicy();
+      if (task === undefined) return true;
+      const current = board.get(task);
+      return !!current && !tasks.isPii(current) && [...(current.refs.paths ?? []), ...(current.plan?.paths ?? [])].every(path =>
+        visualPathPublic(path, policy));
+    } catch { return false; }
+  };
+  const visualPorts = (policy = visualFilePolicy()): DeliverablePorts => ({ cwd: opts.cwd, deny: policy.deny, private: path =>
+    !visualPathPublic(path, policy) });
+  const visualPublic = (record: VisualRecord | VisualSummary, policy?: VisualFilePolicy): boolean => {
+    try {
+      return !stopping && (record.task !== undefined || record.created >= Date.now() - config.visuals.retention_days * 86_400_000) && !turns.get(record.from)?.private && !contextPii(record.from) && visualTaskPublic(record.task, policy)
+        && visualSafeText(record.title, policy ?? visualFilePolicy()) && visualSafeText(record.from, policy ?? visualFilePolicy());
+    } catch { return false; }
+  };
+  const visualRecord = (id: unknown, captured?: VisualFilePolicy): VisualRecord | undefined => {
+    if (typeof id !== "string" || !new RegExp(VISUAL_ID_PATTERN).test(id)) return undefined;
+    try {
+      const policy = captured ?? visualFilePolicy(), record = visuals.get(id);
+      if (!record || !visualPublic(record, policy)) return undefined;
+      validateVisualPayload(record.payload, text => visualSafeText(text, policy));
+      const ports = visualPorts(policy);
+      for (const file of record.files) {
+        if (ports.private(file.path)) return undefined;
+      }
+      return record;
+    } catch { return undefined; }
+  };
+  const visualView = (record: VisualRecord) => ({ id: record.id, ...(record.task === undefined ? {} : { task: record.task }), from: record.from,
+    kind: record.kind, title: record.title, payload: record.payload, created: record.created });
+  const visualList = (task?: number): VisualSummary[] => {
+    try { const policy = visualFilePolicy(); return visuals.list({ ...(task === undefined ? {} : { task }), limit: 20 },
+      (record, paths) => visualPublic(record, policy) && paths.every(path => visualPathPublic(path, policy))); }
+    catch { return []; }
+  };
+  async function visualTool(by: PeerId, op: string, a: Record<string, unknown>, piiTurn: boolean): Promise<string> {
+    if (!a || typeof a !== "object" || Array.isArray(a)) throw new PreEffectToolRefusal("visual arguments must be an object; retry with the documented fields");
+    const authority = childToolAuthority.getStore();
+    const actor = (publishing: boolean) => {
+      if (stopping) throw visualOperational("stopping");
+      let current = false;
+      try { current = !authority || authority.by === by && authority.current(); } catch { /* stale authority */ }
+      if (!current) throw visualOperational("authority");
+      if (piiTurn || turns.get(by)?.private || contextPii(by)) throw visualUnavailable();
+      if (!membershipAllowed(by)) throw visualOperational("membership");
+      if (!publishing) return;
+      if (recoveryActive() || bus.isRecoveryHeld) throw visualOperational("recovery");
+      if (readOnlyPeer(by) || !may(by, "remember")) throw visualOperational("role");
+      if (reviewObserverHeld(by) || bus.lastDeliveredTo(by).some(isReviewObserverExcluded)) throw visualOperational("observer");
+      if (!bus.deliveryJournalAvailable()) throw visualOperational("storage");
+    };
+    actor(op !== "hub_visual_show");
+    if (op === "hub_visual_show") {
+      if (Object.keys(a).some(key => key !== "id")) throw new PreEffectToolRefusal("visual show takes only id; retry with a visual id");
+      const record = visualRecord(a.id, visualFilePolicy());
+      if (!record) throw visualUnavailable();
+      return JSON.stringify(visualView(record));
+    }
+    if (Object.keys(a).some(key => !["payload", "task", "to"].includes(key))) throw new PreEffectToolRefusal("visual has an unsupported field; use payload, task and to only");
+    if (a.task !== undefined && (!Number.isSafeInteger(a.task) || Number(a.task) < 1)) throw new PreEffectToolRefusal("visual task must be a positive integer; retry with a task id");
+    const task = a.task as number | undefined, before = task === undefined ? undefined : board.get(task);
+    if (task !== undefined && !before) throw new PreEffectToolRefusal("visual task is unavailable; choose an existing public task and retry");
+    const generation = connectionGeneration(by), turn = turns.get(by);
+    const policyVersion = (filePolicy: VisualFilePolicy) => JSON.stringify({ revision: configRevision, filePolicy, pii: config.pii, deny: config.local.deny, signals: activeRouting().signals, constraints: activeRouting().constraints, mlx: config.mlx, model: activeRouting().local.fixed_model });
+    const initialPolicy = visualFilePolicy(), policy = policyVersion(initialPolicy);
+    const current = (): VisualFilePolicy => {
+      actor(true);
+      const filePolicy = visualFilePolicy();
+      if (policyVersion(filePolicy) !== policy || connectionGeneration(by) !== generation || turns.get(by) !== turn)
+        throw visualOperational("concurrency");
+      if (task !== undefined) {
+        const now = board.get(task);
+        if (!before || !now || now.created !== before.created || now.updated !== before.updated || now.history.length !== before.history.length)
+          throw visualOperational("concurrency");
+      }
+      if (!visualTaskPublic(task, filePolicy)) throw visualUnavailable();
+      return filePolicy;
+    };
+    current();
+    const recipients = typeof a.to === "string" && a.to.length ? [a.to] : a.to;
+    if (a.to !== undefined && (!Array.isArray(recipients) || recipients.some(id => typeof id !== "string" || !id.length)))
+      throw new PreEffectToolRefusal("visual to must be a peer id or array of peer ids; retry with local recipients");
+    const to = a.to === undefined ? [USER] : Array.isArray(recipients) && recipients.length ? [...new Set(recipients as string[])] : bus.knownPeers().filter(id => !parseRemotePeerId(id));
+    if (to.some(id => id !== USER && (!bus.knownPeers().includes(id) || parseRemotePeerId(id)))) throw new PreEffectToolRefusal("visual recipient unavailable; choose a known local peer or user and retry");
+    const id = randomUUID(), priority = a.to === undefined ? "fyi" : "status";
+    const early = newEnvelope(by, `[visual ${id}]`, { priority, to, refs: { visual: id, ...(task === undefined ? {} : { task: String(task) }) } });
+    const preflight = (stub: Envelope, dry: boolean) => {
+      try { bus.checkRemotePublication(stub); } catch { throw new PreEffectToolRefusal("visual delivery unavailable; choose local recipients and retry"); }
+      const offRoster = bus.offRosterRecipients(stub).filter(peer => peer !== USER);
+      const audience = new Set(stub.to?.filter(peer => peer !== by && peer !== USER));
+      if (offRoster.length && offRoster.length === audience.size) throw new PreEffectToolRefusal("visual recipients are off roster; choose an available local peer and retry");
+      const hushed = bus.hushed(stub);
+      if (hushed.length && hushed.length === bus.audience(stub).length) throw new PreEffectToolRefusal("visual delivery is held by the current silence policy; wait for the hold to clear");
+      const effective = offRoster.length ? { ...stub, to: stub.to!.filter(peer => !offRoster.includes(peer)) } : stub;
+      const refused = dry
+        ? (by === USER || by === HUB || by === DIGEST || stub.priority === "fyi" ? undefined : limiter.peek(by, effective.to, effective.priority, effective.body))
+        : admit(effective);
+      if (refused) throw new PreEffectToolRefusal("visual delivery is rate limited; wait before retrying");
+    };
+    // No screen, image read, or consuming admission has occurred at this point.
+    preflight(early, true);
+    const input = validateVisualInput(a.payload, text => visualSafeText(text, initialPolicy));
+    if (tasks.screenOn()) {
+      const screen = opts.piiScreen ?? ((value: string) => screenPii(value, { ...(config.mlx.enabled === false ? {} : { device: () => ensureMlx(config.mlx) }), onCampus, omni, fixedModel: () => activeRouting().local.fixed_model }));
+      const verdict = await screen(JSON.stringify(input)).catch(() => undefined);
+      current();
+      if (verdict?.label === "pii") throw visualUnavailable();
+      if (verdict?.label !== "clear") throw visualOperational("screen");
+    }
+    const beforeRead = current(), resolved = await resolveVisualAssets(input, id, visualPorts(beforeRead));
+    const finalPolicy = current();
+    const payload = validateVisualPayload(resolved.payload, text => visualSafeText(text, finalPolicy));
+    const title = "title" in payload ? payload.title ?? "" : "caption" in payload ? payload.caption ?? "" : "";
+    const record: VisualRecord = { id, ...(task === undefined ? {} : { task }), from: by, kind: payload.kind, title, payload, files: resolved.files, created: Date.now() };
+    if (!visualPublic(record, finalPolicy) || resolved.files.some(file => !visualPathPublic(file.path, finalPolicy))) throw visualUnavailable();
+    const stub = newEnvelope(by, `[visual ${id}] ${payload.kind}: ${sanitize(title)}`, { priority, to, refs: { visual: id, ...(task === undefined ? {} : { task: String(task) }) } });
+    preflight(stub, false); // Recheck after every await; consume shared admission exactly once.
+    if (!recoveryActive() && !bus.isRecoveryHeld) visuals.prune(config.visuals.retention_days, Date.now(), task => !!board.get(task));
+    visuals.insert(record);
+    try {
+      event({ type: "visual", id, kind: payload.kind, bytes: Buffer.byteLength(JSON.stringify(payload)), files: resolved.files.length, ...(task === undefined ? {} : { task }) });
+      bus.publish(stub);
+    } catch { throw new Error(`visual ${id} was stored but its stub delivery failed; inspect the visual before posting again`); }
+    return `visual ${id}`;
+  }
   async function taskOpBody(by: PeerId, op: string, a: Record<string, any>, inProcess = false, piiTurn = false): Promise<string> {
+    if (op === "hub_visual" || op === "hub_visual_show") return visualTool(by, op, a, piiTurn);
     const reviewTurn = reviewObserverHeld(by) || bus.lastDeliveredTo(by).some(isReviewObserverExcluded);
     if (reviewTurn || op === "hub_review" && reviewCaptureExcluded(op, JSON.stringify(a))) progress.clearPeer(by);
     if (op === "hub_ask") {
@@ -5085,6 +5594,9 @@ export async function startDaemon(opts: DaemonOptions) {
         const completion = t.history.findLast(h => h.by === by && (h.event === "done" || h.event === "done (checking)"));
         if (!piiTurn && !reviewTurn && !tasks.isPii(t) && completion && !completion.withheld && typeof a.summary === "string" && completion.note?.startsWith(a.summary)) {
           citeMemory(by, a.summary, `summary:${t.id}:${t.history.indexOf(completion)}`, [newEnvelope(by, "", { refs: { task: String(t.id) } })]);
+          // #1279: the reasons of a spec acknowledgement are hub-screened text too, and one key per task keeps a repeat idempotent.
+          const reasons = Array.isArray(a.spec_ack) ? a.spec_ack.flatMap((row: unknown) => typeof (row as { reason?: unknown })?.reason === "string" ? [(row as { reason: string }).reason] : []).join("\n") : "";
+          if (reasons) citeMemory(by, reasons, `spec_ack:${t.id}:${t.history.indexOf(completion)}`, [newEnvelope(by, "", { refs: { task: String(t.id) } })]);
         }
         // A silent cohort (issue #107): the member that integrates is asked to check its work first; no done yet.
         const last = t.history.at(-1);
@@ -5098,10 +5610,25 @@ export async function startDaemon(opts: DaemonOptions) {
       case "hub_sdlc_record":
         await tasks.specStageGate(by, a.id, a.receipt); // #481 S1: a live spec edit-time check before a build stage
         return line(await tasks.recordSdlc(by, a.id, a.receipt));
-      case "hub_review":
-        return line(await tasks.review(by, a.id, a.verdict, a.note, a.unmet, a.head, a.coverage, a.findings));
-      case "hub_remember":
-        return tasks.remember(by, a);
+      case "hub_review": {
+        const reviewed = await tasks.review(by, a.id, a.verdict, a.note, a.unmet, a.head, a.coverage, a.findings);
+        // #1279: a verdict note that names a brief entry is a citation. The same exclusions as a done summary apply (a PII or review-observer turn, withheld text), and the key binds it to this verdict.
+        const verdict = reviewed.history.findLast(h => h.by === by && (h.event === "approved" || h.event === "changes_requested"));
+        if (!piiTurn && !reviewTurn && !tasks.isPii(reviewed) && verdict && !verdict.withheld && typeof a.note === "string" && a.note && verdict.note?.startsWith(a.note)) {
+          citeMemory(by, a.note, `review:${reviewed.id}:${reviewed.history.indexOf(verdict)}`, [newEnvelope(by, "", { refs: { task: String(reviewed.id) } })]);
+        }
+        return line(reviewed);
+      }
+      case "hub_remember": {
+        const { message: saved, outcome } = await tasks.rememberOutcome(by, a);
+        // #1279: a saved note that names another entry cites it. `tasks.remember` already refused a PII task, a private path and a secret, so only a note it saved gets here.
+        // #802: the structured outcome decides, never the reply wording. Only `not_saved` skips the citation: a candidate note held for a person's review was cited under the old wording test too, and stays so.
+        if (!piiTurn && !reviewTurn && typeof a.text === "string" && a.text && outcome !== "not_saved") {
+          const task = a.task !== undefined && Number.isSafeInteger(Number(a.task)) ? Number(a.task) : undefined;
+          citeMemory(by, a.text, `remember:${task ?? "none"}:${createHash("sha256").update(a.text).digest("hex").slice(0, 16)}`, task !== undefined ? [newEnvelope(by, "", { refs: { task: String(task) } })] : []);
+        }
+        return saved;
+      }
       case "hub_checkpoint": {
         const summary = String(a.summary ?? "").trim();
         if (!summary) throw new Error("summary is required");
@@ -5509,6 +6036,24 @@ export async function startDaemon(opts: DaemonOptions) {
   // Question text lives in hub.db and the envelope to the asking peer only: never a log line, an event, a notice or memory capture.
   const questionStore = new QuestionStore(join(opts.stateDir, "hub.db"));
   startupCleanup.push(() => questionStore.close());
+  const questionAttributions = new Map<string, TaskAttribution>();
+  /**
+   * The attribution of a question event. It is resolved ONLY when the question opens (`asked`, or `unavailable`, which has no set), by the rule `turn_end` uses, and cached by set. Every later event
+   * of a set repeats the cached answer. A set with no cached answer (the hub restarted while the question was open, which `QuestionDesk.repair` leaves answerable, or the bounded map evicted it)
+   * is `unattributed`: re-resolving it would put the person's answer, with its full latency, on whatever task the peer works on NOW, which is the read-time attribution this exists to prevent.
+   */
+  const withQuestionAttribution = (e: Extract<HubEvent, { type: "question" }>): HubEvent => {
+    let attribution = questionAttributions.get(e.set);
+    if (!attribution) {
+      if (e.event === "asked" || e.event === "unavailable") {
+        attribution = taskAttribution(e.peer);
+        if (e.set !== "-") { questionAttributions.set(e.set, attribution); if (questionAttributions.size > 512) questionAttributions.delete(questionAttributions.keys().next().value!); }
+      } else attribution = { attribution: "unattributed" };
+    }
+    // A closed question's entry is released; a pending one keeps it for its answer.
+    if (e.event === "answered" || e.event === "superseded" || e.event === "cancelled" || e.event === "expired") questionAttributions.delete(e.set);
+    return { ...e, ...attribution };
+  };
   const questionDesk = new QuestionDesk({
     store: questionStore, now: () => Date.now(),
     waitMs: peer => config.questions.wait_ms[definitionOf(peer)?.kind ?? peer] ?? definitionOf(peer)?.questionWaitMs ?? 45_000,
@@ -5519,7 +6064,10 @@ export async function startDaemon(opts: DaemonOptions) {
     isPrivate: (peer, task, piiTurn) => piiTurn === true || contextPii(peer) || (task !== undefined && (() => { const row = board.get(task); return !row || tasks.isPii(row); })()),
     held: () => stopping || recoveryActive() || bus.isRecoveryHeld,
     publish: env => { bus.publish(env); },
-    event: e => { event(e); if (e.type === "question" && e.event !== "asked" && e.event !== "pending" && e.event !== "unavailable") queueMicrotask(() => settleCheck(e.peer)); }, // #1054: a closed question may be the last thing a run waited on
+    // #1278: a question is attributed once, when it is asked, by the rule `turn_end` uses (the task of the delivery the peer is working on, else its single open task, else unattributed), and
+    // every later event of the same set carries that same answer: the person answers minutes later, when the peer's open tasks may have changed. The task a question names for itself is the
+    // peer's claim and is not used. An `unavailable` question has no set and is attributed on the spot.
+    event: e => { event(e.type === "question" ? withQuestionAttribution(e) : e); if (e.type === "question" && e.event !== "asked" && e.event !== "pending" && e.event !== "unavailable") queueMicrotask(() => settleCheck(e.peer)); }, // #1054: a closed question may be the last thing a run waited on
     peerKnown: peer => bus.peers.has(peer) || (bus.knownPeers().includes(peer) && membershipAllowed(peer)),
   });
   // #1053: expiry (`questions.ttl_s`), a changed native session, an envelope a refused publish still owes, and old settled rows. Pushed here, after the desk exists, like the other late timers.
@@ -5531,6 +6079,8 @@ export async function startDaemon(opts: DaemonOptions) {
   startupCleanup.push(() => completionStore.close());
   const runs = new RunTracker();
   const checkOwners = new Map<PeerId, number>();
+  const nativeBackgroundWaits = new Map<PeerId, ReturnType<typeof setTimeout>>();
+  const nativeBackgroundBackoff = new Map<PeerId, number>();
   /**
    * A delivery handed to the peer whose turn has not started yet: the bus has already taken it out of its queue and the peer is still idle, so neither the queue nor the busy state
    * shows the continuation in that window. Cleared at the turn start or a failed delivery. ponytail: bounded to 10 s, so a delivery that never starts a turn (an adapter that
@@ -5541,8 +6091,8 @@ export async function startDaemon(opts: DaemonOptions) {
   /** A turn of the open run ended in a failure the adapter reported: a closed fact, never its text. */
   const runFailed = (peer: PeerId): void => { try { runs.note(peer, { failed: true }); } catch { /* advisory */ } };
   const settles = (peer: PeerId): boolean => {
-    // A pull-only attach (Kimi's TUI) has no hub turn machinery and no signal; the definition declares `settle` for its headless form, which attaches as a hub peer.
-    return !!definitionOf(peer)?.settle && !peer.includes("@") && bus.peers.get(peer)?.pullOnly !== true;
+    // A pull-only native TUI earns a signal only through its launcher-bound native facts. An unattached pull-only peer still creates no run.
+    return !!definitionOf(peer)?.settle && !peer.includes("@") && (bus.peers.get(peer)?.pullOnly !== true || nativeHookLaunches.current(peer) !== undefined);
   };
   /** Deliveries queued for the peer that will start another turn: all of them but the hub's own `presence` preface (a `fyi` never reaches the queue). */
   // The bus drains its queue into a dispatching journal row before the idle state reaches this tap, so the in-memory queue alone would read empty while a continuation is already on its
@@ -5562,10 +6112,37 @@ export async function startDaemon(opts: DaemonOptions) {
   const checksOwnedBy = (peer: PeerId): number => (checkOwners.get(peer) ?? 0) + tasks.checksOwnedBy(peer);
   // The peer's OWN adapter state, not the displayed one (a pause shows a busy peer as paused, and its work goes on): an owned child or a continuation the adapter still runs keeps it busy.
   const ownedChildrenOf = (peer: PeerId): number => (bus.peers.get(peer)?.state === "busy" ? 1 : 0);
+  /**
+   * #1278: the task a run's completion belongs to, resolved when the run opens (its first turn) by the rule `turn_end` uses and read when it settles, by which time the peer's open tasks have
+   * moved on. In memory only: a run that a restart settles `interrupted` has lost it and reads `unattributed`, which is what is known.
+   */
+  const runAttributions = new Map<string, TaskAttribution>();
+  const nativeBackgroundOf = (peer: PeerId): number | null | undefined => {
+    const launch = nativeHookLaunches.current(peer), port = definitionOf(peer)?.hooks?.factsHook;
+    if (!launch?.session || !launch.transcript || !port) return undefined;
+    return port.read(launch.session, launch.transcript).background ?? null;
+  };
+  const completeNativeTurn = (peer: PeerId, launch: NativeHookLaunch, completion: NonNullable<NativeFactsTranscript["completion"]>): boolean => {
+    const owner = bus.peers.get(peer);
+    if (!launch.active || !isWsPeer(owner) || owner.state === "offline" || owner.sessionGeneration !== launch.generation || nativeHookLaunches.current(peer) !== launch) return false;
+    launch.completed = completion.id; launch.active = false;
+    turnEnded.set(peer, Date.now()); nativeCompletedAt.set(peer, Date.now()); tasks.cohorts.turnEnded(peer);
+    event({ type: "native_turn_end", peer, id: completion.id }); owner.nativeStopped(launch.session!);
+    const run = runs.get(peer);
+    if (completion.reason === "cancelled") {
+      if (run) { completionStore.dropRun(run.runTurn); runs.quietStop(peer); }
+    } else {
+      if (completion.reason === "failed") runFailed(peer);
+      try { if (run) { runs.signalled(peer); settleCheck(peer); } } catch { log(`completion settle for ${peer} failed`); }
+    }
+    return true;
+  };
   const completionDone = (peer: PeerId, run: Run, outcome: "done" | "failed" | "limit" | "interrupted"): void => {
     const made = completionStore.settle({ peer, runTurn: run.runTurn, lastTurn: run.lastTurn, startedAt: run.startedAt, ...(run.promptEnvelope ? { promptEnvelope: run.promptEnvelope } : {}), ...(run.replyEnvelope ? { replyEnvelope: run.replyEnvelope } : {}), private: run.private }, outcome, Date.now(), `cmp-${randomUUID().replaceAll("-", "").slice(0, 12)}`);
     if (!made) return;
-    event({ type: "completion", id: made.id, peer, outcome, ms: made.settledAt - made.startedAt });
+    const attribution = runAttributions.get(run.runTurn) ?? { attribution: "unattributed" as const };
+    runAttributions.delete(run.runTurn);
+    event({ type: "completion", id: made.id, peer, outcome, ms: made.settledAt - made.startedAt, ...attribution });
   };
   /**
    * The one settle check. It runs at every point the pending-work facts can change: a turn end, a queue change, a permission or question closing, a check ending. A run settles
@@ -5573,10 +6150,29 @@ export async function startDaemon(opts: DaemonOptions) {
    */
   const settleCheck = (peer: PeerId): void => {
     try {
+      const launch = nativeHookLaunches.current(peer), port = definitionOf(peer)?.hooks?.factsHook;
+      if (launch?.active && launch.session && launch.transcript && port) {
+        const completion = port.read(launch.session, launch.transcript).completion;
+        if (completion && completion.index > (launch.baseline ?? -1) && completion.id !== launch.completed) completeNativeTurn(peer, launch, completion);
+      }
       const run = runs.get(peer);
       if (!run || stopping) return;
-      const state = settleVerdict({ signal: run.signalled, queuedContinuations: queuedContinuations(peer), openPermissions: openPermissionsOf(peer), openQuestions: questionStore.openCount(peer), ownedChildren: ownedChildrenOf(peer), runningChecks: checksOwnedBy(peer), heldDeliveries: heldDeliveries(peer) });
-      if (state !== "settled") return;
+      const nativeBackground = nativeBackgroundOf(peer);
+      const state = settleVerdict({ signal: run.signalled, queuedContinuations: queuedContinuations(peer), openPermissions: openPermissionsOf(peer), openQuestions: questionStore.openCount(peer), ownedChildren: ownedChildrenOf(peer), runningChecks: checksOwnedBy(peer), heldDeliveries: heldDeliveries(peer), nativeBackground });
+      if (state !== "settled") {
+        // Native task notifications are optional observations. Re-read the inventory and final turn until both are settled or the run/launch ends.
+        // ponytail: a quiet peer backs off from 250 ms to 1 s while each read may scan a 16 MiB index and an 8 MiB wire tail. Upgrade: incremental offsets.
+        if ((launch?.active || nativeBackground === null || (nativeBackground ?? 0) > 0) && !nativeBackgroundWaits.has(peer)) {
+          const delay = nativeBackgroundBackoff.get(peer) ?? 250;
+          const timer = setTimeout(() => { nativeBackgroundWaits.delete(peer); settleCheck(peer); }, delay);
+          nativeBackgroundBackoff.set(peer, Math.min(1000, delay * 2));
+          nativeBackgroundWaits.set(peer, timer); timer.unref?.();
+        }
+        return;
+      }
+      const waiting = nativeBackgroundWaits.get(peer);
+      if (waiting) { clearTimeout(waiting); nativeBackgroundWaits.delete(peer); }
+      nativeBackgroundBackoff.delete(peer);
       // Persist FIRST and drop the in-memory run only after the store call returned: a write that throws (SQLite busy or locked) leaves the run open, so a later settle check retries it, and
       // the open-run row never outlives a run the daemon no longer tracks (a false `interrupted` after a restart, and a peer index that silently refuses the next run).
       // A budget pause stays a budget need (ahub budget): the run ends without a completion rather than reading as a result.
@@ -5886,7 +6482,11 @@ export async function startDaemon(opts: DaemonOptions) {
     join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", opts.cwd.replace(/[^a-zA-Z0-9]/g, "-"), `${sessionId}.jsonl`), path => pathEvidence(path, lstatSync));
   // Optional native usage: only the instance-fenced explicit Claude session is read.
   // IDs persist in telemetry, so a restart/resume never counts the same native message twice.
-  const claudeNativeUsageSeen = new Set(readEvents(join(opts.stateDir, "events.jsonl")).filter(e => e.type === "usage" && e.source === "claude_transcript").map(e => (e as { id: string }).id));
+  startupTimings.mark("services");
+  const claudeNativeUsageSeen = startupSeeds.claudeNativeUsageSeen;
+  startupTimings.mark("transcript_usage_seed");
+  const agyNativeUsageSeen = new Set(startupEvents.filter(e => e.type === "usage" && e.source === "agy_transcript").map(e => (e as { id: string }).id));
+  const agyTurnContext = new WeakMap<object, { hubTurnId?: string; baseline: number; attribution: TaskAttribution }>();
   const collectClaudeUsage = () => { for (const peer of channelPeers) {
     const session = claudeSession(peer);
     if (!session.sessionId || !session.transcriptPath) continue;
@@ -5922,6 +6522,151 @@ export async function startDaemon(opts: DaemonOptions) {
   // the newest `older` of them while they are empty, so an upgrade from such a hub verifies the board it was handed; a
   // filled one stays in the row and never matches.
   const ADDED_COLUMNS = [["deps", "[]"], ["plan", "{}"]] as const;
+  // Person-owned runtime choices are separate from reload-bound configuration and native serving evidence.
+  const modelBoundaries = new Map<string, { owner: PeerAdapter; token: object; turn?: object; nativeStarted?: true }>();
+  const modelUnsupported = (peer: string): RuntimeModelStatus["unsupported"] | undefined => {
+    const definition = definitionOf(peer), owner = bus.peers.get(peer);
+    if (definition && isFixedBuiltinDefinition(definition) && definition.transport === "acp") {
+      const state = owner ? modelAcpOwners.get(owner)?.modelOverrideState : undefined;
+      if (!definition.modelOverride?.acp || !state?.available) return {
+        reasonCode: "acp_setter_unavailable", kind: definition.kind, ...(state?.version ? { version: state.version } : {}),
+        reason: `unsupported live: ${definition.kind} ${state?.version ?? "unknown"} lacks a setter receipt or compat admission`,
+        nextStep: `restart this peer with ahub restart ${peer}`,
+      };
+    }
+    if (!definition || !isFixedBuiltinDefinition(definition) || !definition.modelOverride) return {
+      reasonCode: "unverified_setter", ...(definition ? { kind: definition.kind } : {}),
+      reason: `unsupported live: ${definition?.kind ?? "retained peer"} (version unverified) has no verified model setter`, nextStep: `restart this peer with ahub restart ${peer}`,
+    };
+    if (owner && !modelManagedOwners.has(owner)) return { reasonCode: "unmanaged_attachment", kind: definition.kind, reason: "unsupported live: this attachment has no verified live model setter", nextStep: `change the native setting or restart this peer with ahub restart ${peer}` };
+    return undefined;
+  };
+  const modelTokenAvailable = (peer: string, model: string): boolean => {
+    if (!definitionOf(peer)?.modelOverride?.acp) return true;
+    const owner = bus.peers.get(peer);
+    return !!owner && modelAcpOwners.get(owner)?.acceptsModelOverride(model) === true;
+  };
+  const modelFallback = (peer: string): { model?: string; source: Exclude<ModelSource, "override"> } => {
+    const declared = declarations[peer]?.model;
+    if (isNativeModelToken(declared)) return { model: declared, source: "instance" };
+    const owner = bus.peers.get(peer), model = owner ? modelLaunchModels.get(owner) : undefined;
+    if (model !== undefined) return { model, source: "launch" };
+    const baseline = owner ? modelAcpOwners.get(owner)?.modelOverrideState.baseline : undefined;
+    return { ...(baseline ? { model: baseline } : {}), source: "native default" };
+  };
+  const registerModelOwner = (owner: PeerAdapter): void => {
+    const definition = definitionOf(owner.id);
+    if (!definition || !isFixedBuiltinDefinition(definition) || !definition.modelOverride) return;
+    if (definition.modelOverride.acp && !modelAcpOwners.get(owner)?.modelOverrideState.available) return;
+    modelManagedOwners.add(owner);
+    try {
+      const launch = owner.recoveryMetadata?.()?.launch;
+      const model = launch && typeof launch === "object" && !Array.isArray(launch) ? (launch as Record<string, unknown>).model : undefined;
+      if (isNativeModelToken(model)) modelLaunchModels.set(owner, model);
+    } catch { /* No explicit launch evidence: leave native default unknown. Never read this hook on a poll. */ }
+  };
+  const runtimeModelRow = (peer: string) => modelLatches.status(peer, bus.peers.get(peer), modelFallback(peer), modelUnsupported(peer));
+  const MODEL_DISPLAY_ROWS_MAX = 512;
+  const runtimeModelRows = (): RuntimeModelStatus[] | undefined => {
+    const ids = new Set<string>();
+    const add = (id: string) => { if (PEER_ID.test(id)) ids.add(id); return ids.size <= MODEL_DISPLAY_ROWS_MAX; };
+    // Stop at the first overflow: existing legacy attachments are not admission-bounded by this display ceiling.
+    for (const id of SUPPORTED_PEERS) if (!add(id)) return undefined;
+    for (const id of configuredIds) if (!add(id)) return undefined;
+    for (const id of extraIds) if (!add(id)) return undefined;
+    for (const peer of restored?.peers ?? []) if (peer.externalInstance && !add(peer.id)) return undefined;
+    for (const id of externalInstanceIds) if (!add(id)) return undefined;
+    for (const id of externalRefusedRows.keys()) if (!add(id)) return undefined;
+    for (const id of bus.peers.keys()) if (!add(id)) return undefined;
+    for (const row of modelOverrides.list()) if (!add(row.peer)) return undefined;
+    return [...ids].sort().map(runtimeModelRow);
+  };
+  const runtimeModelProjection = () => {
+    try { const rows = runtimeModelRows(); if (rows) return { runtimeModels: rows }; }
+    catch { /* Model metadata failure is not whole-daemon status failure. The explicit list keeps its refusal. */ }
+    return { runtimeModels: [] as RuntimeModelStatus[], runtimeModelsUnavailable: true as const };
+  };
+  const modelSelection = (peer: string) => {
+    const owner = bus.peers.get(peer);
+    if (!owner || modelUnsupported(peer)) throw new Error("model selection has no current supported owner; inspect ahub status and restart the peer before retrying");
+    let boundary = modelBoundaries.get(peer);
+    if (!boundary || boundary.owner !== owner) {
+      if (boundary) modelLatches.forget(peer);
+      boundary = { owner, token: {}, ...(turns.get(peer) ? { turn: turns.get(peer) } : {}) };
+      modelBoundaries.set(peer, boundary);
+    }
+    const captured = boundary;
+    const selection = modelLatches.capture(peer, owner, captured.token, () => !stopping && bus.peers.get(peer) === owner
+      && modelBoundaries.get(peer) === captured && (!captured.turn || turns.get(peer) === captured.turn));
+    return { model: selection.model, applied: (nativeModel?: string) => { selection.applied(nativeModel); if (!stopping) writeStatus(); }, rejected: () => {
+      if (stopping || bus.peers.get(peer) !== owner || modelBoundaries.get(peer) !== captured || captured.nativeStarted
+        || captured.turn && turns.get(peer) !== captured.turn) return;
+      if (modelLatches.end(peer, captured.token, true)) { modelBoundaries.delete(peer); writeStatus(); }
+    } };
+  };
+  const acpModelSelection = (peer: string) => {
+    if (modelUnsupported(peer)) {
+      if (modelOverrides.get(peer)) throw new Error("retained model override has no current receipt-verified ACP setter; clear it with ahub model clear or restart a supported peer before retrying");
+      return undefined; // An unavailable optional setter must not break ordinary no-override ACP work.
+    }
+    return modelSelection(peer);
+  };
+  type ModelGrant = { source: "cli" | "dashboard"; scope: object | string; current: () => boolean; expiresAt?: number };
+  type ModelPreview = { peer: string; action: "set" | "clear"; model?: string; expiresAt: number; scope: object | string; source: "cli" | "dashboard";
+    revision: string; runtime: string; config: number; owner: PeerAdapter | undefined; generation: string | undefined; afterTurn: string | undefined };
+  const modelPreviews = new Map<string, ModelPreview>();
+  const MODEL_CONFIRM_MS = 60_000, MODEL_PREVIEWS_MAX = 64;
+  const modelFailure = (error: string) => ({ ok: false as const, error });
+  function modelCommand(input: Record<string, unknown>, grant: ModelGrant): Record<string, unknown> {
+    if (!grant.current()) return modelFailure("model changes are person-only and this authority expired; run ahub model in a person's terminal or reopen ahub ui --settings");
+    if (stopping || recoveryActive() || bus.isRecoveryHeld) return modelFailure("recovery or shutdown is holding model overrides; inspect ahub status and retry after release");
+    if (input.op === "list") {
+      const rows = runtimeModelRows();
+      return rows ? { ok: true, models: rows } : modelFailure("model list exceeds its display bound; close unused peer sessions and restart if needed, or clear unused overrides with ahub model clear, then list again");
+    }
+    let preview: ModelPreview;
+    if (input.op === "confirm") {
+      const token = typeof input.token === "string" ? input.token : "", retained = modelPreviews.get(token);
+      if (!retained || retained.scope !== grant.scope || retained.source !== grant.source || retained.expiresAt <= Date.now()) return modelFailure("model confirmation expired or belongs to another session; preview the model change again");
+      modelPreviews.delete(token); preview = retained;
+      if (preview.config !== configRevision || preview.revision !== modelOverrides.revision(preview.peer) || preview.owner !== bus.peers.get(preview.peer)
+        || preview.runtime !== JSON.stringify(runtimeModelRow(preview.peer)) || preview.generation !== connectionGeneration(preview.peer)
+        || preview.afterTurn !== turns.get(preview.peer)?.id) return modelFailure("peer, configuration or model choice changed after preview; refresh and preview the change again");
+    } else {
+      const action = input.op === "preview" ? input.action : input.op, peer = input.peer;
+      if ((action !== "set" && action !== "clear") || typeof peer !== "string" || !PEER_ID.test(peer)) return modelFailure("invalid model request; use model set <peer> <model> or model clear <peer>");
+      if (!definitionOf(peer) && !(action === "clear" && modelOverrides.get(peer))) return modelFailure("model peer is unknown; run ahub model list and choose a current or retained peer");
+      if (action === "set" && !isNativeModelToken(input.model)) return modelFailure("invalid native model token; use 1 to 128 ASCII letters, digits or ._:/@+- with an initial letter or digit");
+      const unsupported = modelUnsupported(peer);
+      if (action === "set" && unsupported) return modelFailure(`${unsupported.reason}; ${unsupported.nextStep}`);
+      if (action === "set" && !modelTokenAvailable(peer, input.model as string)) return modelFailure("requested model is not advertised by this receipt-verified ACP session; inspect native model choices and retry");
+      const expiresAt = Math.min(Date.now() + MODEL_CONFIRM_MS, grant.expiresAt ?? Infinity);
+      preview = { peer, action, ...(action === "set" ? { model: input.model as string } : {}), expiresAt, scope: grant.scope, source: grant.source,
+        revision: modelOverrides.revision(peer), runtime: JSON.stringify(runtimeModelRow(peer)), config: configRevision, owner: bus.peers.get(peer), generation: connectionGeneration(peer), afterTurn: turns.get(peer)?.id };
+      if (input.op === "preview") {
+        for (const [token, old] of modelPreviews) if (old.expiresAt <= Date.now()) modelPreviews.delete(token);
+        if (modelPreviews.size >= MODEL_PREVIEWS_MAX) return modelFailure("too many model previews remain open; wait a minute and preview again");
+        const token = randomUUID(); modelPreviews.set(token, preview);
+        return { ok: true, model: runtimeModelRow(peer), confirmation: { token, expiresAt, peer, action, previousModel: modelOverrides.get(peer)?.model ?? null,
+          nextModel: preview.model ?? null, appliesFrom: "next_turn", ...(preview.afterTurn ? { afterTurn: preview.afterTurn } : {}) } };
+      }
+      if (grant.source !== "cli") return modelFailure("dashboard model changes require preview and confirmation; preview the change again");
+    }
+    if (!grant.current()) return modelFailure("model authority expired before the write; reopen the person settings session and preview again");
+    const unsupported = modelUnsupported(preview.peer);
+    if (preview.action === "set" && unsupported) return modelFailure(`${unsupported.reason}; ${unsupported.nextStep}`);
+    if (preview.action === "set" && !modelTokenAvailable(preview.peer, preview.model!)) return modelFailure("requested model is not advertised by this receipt-verified ACP session; inspect native model choices and retry");
+    const previousModel = modelOverrides.get(preview.peer)?.model ?? null;
+    if (preview.action === "set") modelOverrides.set(preview.peer, preview.model!); else modelOverrides.clear(preview.peer);
+    const audited = event({ type: "model_change", peer: preview.peer, previousModel, model: preview.model ?? null, by: "person", source: grant.source,
+      appliesFrom: "next_turn", ...(preview.afterTurn ? { afterTurn: preview.afterTurn } : {}) });
+    writeStatus();
+    if (!audited) return { ok: false, saved: true, error: "model override was saved but its model_change audit could not be appended; run ahub model list before retrying and repair events.jsonl" };
+    return { ok: true, model: runtimeModelRow(preview.peer), appliesFrom: "next_turn", ...(preview.afterTurn ? { afterTurn: preview.afterTurn } : {}) };
+  }
+  const modelCommandSafe = (input: Record<string, unknown>, grant: ModelGrant): Record<string, unknown> => {
+    try { return modelCommand(input, grant); } catch { return modelFailure("model override state could not be read or written; inspect ahub status and hub.db before retrying"); }
+  };
   const integrity = (older = 0) => {
     const queues = Object.fromEntries(Object.keys(bus.snapshot(false).queues).sort().map((id) => [id, bus.queueIds(id)]));
     const boardState = board.list().sort((a, b) => a.id - b.id).map((t) => {
@@ -5937,7 +6682,11 @@ export async function startDaemon(opts: DaemonOptions) {
     const researchRunners = board.runnerReceiptIntegrity();
     const researchEvidence = board.researchEvidenceIntegrity();
     const reviewComments = board.reviewCommentsIntegrity();
-    return { queues, manualPaused: [...manualPaused].sort(), boardDigest: digest(boardState), budgetDigest: digest(budgetState), ...(research.campaigns || research.units ? { research } : {}), ...(researchDispatch.activations || researchDispatch.handoffs ? { researchDispatch } : {}), ...(researchExperiments.protocols || researchExperiments.attempts || researchExperiments.events || researchExperiments.observations ? { researchExperiments } : {}), ...(researchComparisons.plans || researchComparisons.approvals || researchComparisons.contexts ? { researchComparisons } : {}), ...(researchRunners.count ? { researchRunners } : {}), ...(researchEvidence.links || researchEvidence.revisions ? { researchEvidence } : {}), ...(reviewComments.comments || reviewComments.packages ? { reviewComments } : {}), ...(allExternalInstanceIds().length ? { externalBindingsDigest: digest(allExternalInstanceIds().sort().map(id => [id, (externalRefusedRows.has(id) ? externalBindings.get(id) : retainedExternalBinding(id)) ?? null])) } : {}) };
+    const modelState = modelOverrides.integrity();
+    const visualIntegrity = visuals.integrity();
+    if (!Number.isSafeInteger(visualIntegrity.count) || visualIntegrity.count < 0 || !/^[a-f0-9]{64}$/.test(visualIntegrity.digest))
+      throw new Error("visual recovery integrity unavailable; inspect the retained store before recovery");
+    return { queues, manualPaused: [...manualPaused].sort(), boardDigest: digest(boardState), budgetDigest: digest(budgetState), ...(modelState.count ? { modelOverrides: modelState } : {}), ...(research.campaigns || research.units ? { research } : {}), ...(researchDispatch.activations || researchDispatch.handoffs ? { researchDispatch } : {}), ...(researchExperiments.protocols || researchExperiments.attempts || researchExperiments.events || researchExperiments.observations ? { researchExperiments } : {}), ...(researchComparisons.plans || researchComparisons.approvals || researchComparisons.contexts ? { researchComparisons } : {}), ...(researchRunners.count ? { researchRunners } : {}), ...(researchEvidence.links || researchEvidence.revisions ? { researchEvidence } : {}), ...(reviewComments.comments || reviewComments.packages ? { reviewComments } : {}), ...(visualIntegrity.count ? { visuals: visualIntegrity } : {}), ...(allExternalInstanceIds().length ? { externalBindingsDigest: digest(allExternalInstanceIds().sort().map(id => [id, (externalRefusedRows.has(id) ? externalBindings.get(id) : retainedExternalBinding(id)) ?? null])) } : {}) };
   };
   /** The integrity in the shape `expected` was recorded in: the current one unless only an older shape matches. */
   const integrityAs = (expected: unknown) => {
@@ -6022,6 +6771,7 @@ export async function startDaemon(opts: DaemonOptions) {
     const deliveryFailures = bus.failedDeliveryCounts();
     const view = {
     ...(deliveryFailures ? { deliveryFailures } : {}),
+    ...runtimeModelProjection(),
     ...(queueBackpressure ? { queueBackpressure } : {}),
     ...(crashLines.length ? { crash: crashLines } : {}),
     projectId,
@@ -6068,7 +6818,7 @@ export async function startDaemon(opts: DaemonOptions) {
     ...(dashboard ? { uiOrigin: dashboard.origin } : {}),
     codexProxyPort: opts.codexProxyPort,
     peers: Object.fromEntries(
-      peerIds.map((id) => { const p = bus.peers.get(id); const summary = bus.queueSummary(id); const pressure = queueBackpressure?.peers[id]; const oldestQueuedAt = pressure ? pressure.oldestQueuedAt : summary.oldestQueuedAt; const context = contexts.view(id, contextSession(id), !!p && ["idle", "busy", "paused"].includes(bus.stateOf(id))); const statusNotice = isFixedBuiltinDefinition(definitionOf(id)) ? p?.statusNotice : undefined; const reviewObserverHoldNote = reviewObserverSessionIdentityHoldNote(id); return [id, { state: bus.stateOf(id), ...(includeAttentionItems && isExternalInstance(id) && !externalRefusedRows.has(id) && retainedExternalBinding(id) ? { externalInstance: retainedExternalBinding(id) } : {}), ...(!membershipAllowed(id) ? { rostered: false, rosterNote: "off roster" } : {}), ...permissionStatus(id, p), ...(statusNotice ? { statusNotice } : {}), ...(reviewObserverHoldNote ? { reviewObserverHoldNote } : {}), ...(context.source !== null || context.measuredAt !== null ? { context } : {}), queued: bus.queued(id), ...(p ? {} : { attached: false }), ...(includeAttentionItems && p?.standbySessions?.length ? { standbySessions: p.standbySessions } : {}), ...(declarations[id] && config.roles[id]?.includes("implementer") && definitionOf(id)?.transport === "claude-channel" ? { ownerIsolation: ownerIsolation[id] === true, ...(ownerIsolation[id] !== true ? { ownerIsolationNote: "terminal execution root not verified; owner admission refused" } : {}) } : {}), ...(summary.needsReview ? { needsReview: summary.needsReview } : {}), ...(summary.liveAccepted ? { liveAccepted: summary.liveAccepted, settlementNote: "awaiting adapter completion (Claude: correlated reply or hub_delivery_done); task state is independent" } : {}), ...queueHoldStatus(id, summary.heldBy), ...(typeof oldestQueuedAt === "number" ? { oldestQueuedAt } : {}), ...(bus.queuedImportant(id) ? { queuedImportant: bus.queuedImportant(id) } : {}), ...importantWaitingStatus(id, p), ...pausedNote(id), ...(reviewerUnavailable.has(id) ? { reviewerUnavailable: reviewerUnavailable.get(id) } : {}), ...jcodeModelSource(id), ...(reviewOnlyPeer(id) ? { reviewScope: reviewScopeOf(id) } : {}), ...(isLocalPeer(p) && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(isWsPeer(p) ? { ...(p.claiming ? { claiming: true } : {}), ...(definitionOf(id)?.transport === "claude-channel" && p.attached ? { attachMode: p.attachMode, attachEvidence: p.attachEvidence } : {}) } : {}), ...(isWsPeer(p) && p.pullOnly ? { pullOnly: true, toolsOnly: definitionOf(id)?.attach?.pullOnlyNotice ?? "tools-only: messages wait for hub_inbox; for pushes restart Claude with ahub claude", lastInboxAt: p.lastInboxAt ?? null } : {}), ...(isPiPeer(p) ? { requestedModel: p.getRequestedModel(), backends: modelRelays.get(id)?.status().backends ?? [] } : {}) }]; }),
+      peerIds.map((id) => { const p = bus.peers.get(id); const summary = bus.queueSummary(id); const pressure = queueBackpressure?.peers[id]; const oldestQueuedAt = pressure ? pressure.oldestQueuedAt : summary.oldestQueuedAt; const context = contexts.view(id, contextSession(id), !!p && ["idle", "busy", "paused"].includes(bus.stateOf(id))); const statusNotice = isFixedBuiltinDefinition(definitionOf(id)) ? p?.statusNotice : undefined; const reviewObserverHoldNote = reviewObserverSessionIdentityHoldNote(id); return [id, { state: bus.stateOf(id), ...(includeAttentionItems && isExternalInstance(id) && !externalRefusedRows.has(id) && retainedExternalBinding(id) ? { externalInstance: retainedExternalBinding(id) } : {}), ...(!membershipAllowed(id) ? { rostered: false, rosterNote: "off roster" } : {}), ...permissionStatus(id, p), ...(statusNotice ? { statusNotice } : {}), ...(reviewObserverHoldNote ? { reviewObserverHoldNote } : {}), ...(context.source !== null || context.measuredAt !== null ? { context } : {}), queued: bus.queued(id), ...(p ? {} : { attached: false }), ...(includeAttentionItems && p?.standbySessions?.length ? { standbySessions: p.standbySessions } : {}), ...(includeAttentionItems && p?.ownerAttachment ? { ownerAttachment: p.ownerAttachment } : {}), ...(declarations[id] && config.roles[id]?.includes("implementer") && definitionOf(id)?.transport === "claude-channel" ? { ownerIsolation: ownerIsolation[id] === true, ...(ownerIsolation[id] !== true ? { ownerIsolationNote: "terminal execution root not verified; owner admission refused" } : {}) } : {}), ...(summary.needsReview ? { needsReview: summary.needsReview } : {}), ...(summary.liveAccepted ? { liveAccepted: summary.liveAccepted, settlementNote: "awaiting adapter completion (Claude: correlated reply or hub_delivery_done); task state is independent" } : {}), ...queueHoldStatus(id, summary.heldBy), ...(typeof oldestQueuedAt === "number" ? { oldestQueuedAt } : {}), ...(bus.queuedImportant(id) ? { queuedImportant: bus.queuedImportant(id) } : {}), ...importantWaitingStatus(id, p), ...pausedNote(id), ...(reviewerUnavailable.has(id) ? { reviewerUnavailable: reviewerUnavailable.get(id) } : {}), ...jcodeModelSource(id), ...(reviewOnlyPeer(id) ? { reviewScope: reviewScopeOf(id) } : {}), ...(isLocalPeer(p) && p.lastServedBy ? { servedBy: p.lastServedBy } : {}), ...(isWsPeer(p) ? { ...(p.claiming ? { claiming: true } : {}), ...(definitionOf(id)?.transport === "claude-channel" && p.attached ? { attachMode: p.attachMode, attachEvidence: p.attachEvidence } : {}) } : {}), ...(isWsPeer(p) && p.pullOnly ? { pullOnly: true, toolsOnly: definitionOf(id)?.attach?.pullOnlyNotice ?? "tools-only: messages wait for hub_inbox; for pushes restart Claude with ahub claude", lastInboxAt: p.lastInboxAt ?? null } : {}), ...(isPiPeer(p) ? { requestedModel: p.getRequestedModel(), backends: modelRelays.get(id)?.status().backends ?? [] } : {}) }]; }),
     ),
     taskWip: tasks.wipBreakdown(peerIds),
     boardReadCapabilities: { releaseFilter: true, columnMetadata: true },
@@ -6460,6 +7210,7 @@ export async function startDaemon(opts: DaemonOptions) {
     uiEvents.push({ seq: ++uiSequence, event: e });
     if (uiEvents.length > 200) uiEvents.shift();
     if (e.t === "state") {
+      if (e.state === "offline") { modelBoundaries.delete(e.peer); modelLatches.forget(e.peer); }
       roomCommands.changed();
       log(`state ${e.peer} -> ${e.state}`);
       event({ type: "state", peer: e.peer, state: e.state });
@@ -6483,7 +7234,7 @@ export async function startDaemon(opts: DaemonOptions) {
         const delivery = pendingDeliveryTask.get(e.peer);
         pendingDeliveryTask.delete(e.peer);
         const attribution = taskAttribution(e.peer, delivery);
-        const id = `${e.peer}#${runId}.${++turnSeq}`;
+        const id = `${e.peer}#${runId}.${++turnSeq}`, startedAt = Date.now();
         // A turn of a peer with a PII task open is not snapshotted: what it writes would stay in git's object store until
         // gc. It is still recorded, without trees, so an overlapping turn's undo knows its changes are unknown.
         const pii = holdsPii(e.peer);
@@ -6499,7 +7250,11 @@ export async function startDaemon(opts: DaemonOptions) {
           writeScope = ownerWriteRoot(e.peer) === opts.cwd ? canonicalWriteScope(start.repo, start.budget) : true;
         } catch (error) { snapshotFailure(`the write scope of ${id}`, error); }
         const preparedRoles = preparedSessionRoleIdentities.get(e.peer)?.map(role => ({ ...role })) ?? null;
-        turns.set(e.peer, { id, capture, start: Date.now(), tokens: 0, writeTasks, branches, writeScope, deliveryTask: delivery, attribution, preparedRoles, ...(start ? { tree: start.tree, head: start.head, commit: start.commit, reflog: start.reflog, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
+        turns.set(e.peer, { id, capture, start: startedAt, tokens: 0, writeTasks, branches, writeScope, deliveryTask: delivery, attribution, preparedRoles, ...(start ? { tree: start.tree, head: start.head, commit: start.commit, reflog: start.reflog, snapshotMs: start.ms } : {}), ...(pii ? { private: true } : {}) });
+        const modelBoundary = modelBoundaries.get(e.peer);
+        if (modelBoundary && modelBoundary.owner === bus.peers.get(e.peer)) modelBoundary.turn = turns.get(e.peer);
+        const supervised = supervisionTurns.get(e.peer);
+        if (supervised?.id.startsWith("supervision-")) supervised.nativeTurn = id;
         const pendingReviewInput = pendingReviewObserverInputs.get(e.peer);
         if (pendingReviewInput) {
           pendingReviewInput.turnId = id; delete pendingReviewInput.awaitingTurn;
@@ -6520,16 +7275,23 @@ export async function startDaemon(opts: DaemonOptions) {
         try {
           deliveredAwaitingTurn.delete(e.peer);
           if (settles(e.peer)) {
-            const person = pendingPersonDelivery.get(e.peer);
+            const person = pendingPersonDelivery.get(e.peer), nativePerson = pendingNativePerson.delete(e.peer);
             pendingPersonDelivery.delete(e.peer);
-            const run = runs.turnStarted({ peer: e.peer, turn: id, at: Date.now(), personOriginated: person !== undefined, ...(person ? { promptEnvelope: person.envelope } : {}), private: person?.private === true || pii || holdsPii(e.peer) });
-            if (run) { if (run.runTurn === id) completionStore.openRun(run); else completionStore.touchRun(run); }
+            const run = runs.turnStarted({ peer: e.peer, turn: id, at: Date.now(), personOriginated: person !== undefined || nativePerson, ...(person ? { promptEnvelope: person.envelope } : {}), private: nativePerson || person?.private === true || pii || holdsPii(e.peer) });
+            if (run) {
+              if (run.runTurn === id) { completionStore.openRun(run); runAttributions.set(id, attribution); } else completionStore.touchRun(run);
+              // A run that never settles in this process would keep its entry; the table only ever holds the open runs, one per settling peer.
+              if (runAttributions.size > 256) runAttributions.delete(runAttributions.keys().next().value!);
+            }
           }
         } catch { log(`completion run start for ${e.peer} failed; no completion for this turn`); }
-        if (softTokenPeer(e.peer)) try { kimiUsage.turnStarted(e.peer); } catch { /* counting never costs a turn */ }
+        if (softTokenPeer(e.peer)) try { kimiUsage.turnStarted(e.peer, { id, startedAt, attribution }); } catch { /* counting never costs a turn */ }
       } else if (!busy && open) {
         collectKimiUsage(e.peer); // before the turn closes: its rows count toward the turn's tokens
+        if (softTokenPeer(e.peer)) try { kimiUsage.turnEnded(e.peer, open.id, Date.now()); } catch { /* counting never costs a turn */ }
+        closeRecordFrame(e.peer); recordInputs.delete(e.peer);
         turns.delete(e.peer);
+        modelBoundaries.delete(e.peer); modelLatches.end(e.peer);
         let afterTurn: (() => void) | undefined;
         let files: number | undefined;
         let writeProgress: boolean | undefined;
@@ -6605,9 +7367,10 @@ export async function startDaemon(opts: DaemonOptions) {
           // After the turn_end event: a notice delivered at once starts the peer's next turn, which must come after it.
           if (changed.length) afterTurn = () => detectConflicts(e.peer, open.id, open.start, changed);
         }
-        // A lost Claude channel/watchdog is not native completion; only its real Stop closes a counted turn.
-        if (definitionOf(e.peer)?.turnEnd !== "native-hook" || (nativeCompletedAt.get(e.peer) ?? -1) >= open.start) event({ type: "turn_end", peer: e.peer, turn: open.id, ms: Date.now() - open.start, ...open.attribution, preparedRoles: open.preparedRoles, ...(open.tokens ? { tokens: open.tokens } : {}), ...(files !== undefined ? { files, snapshotMs } : {}) });
-        if (definitionOf(e.peer)?.turnEnd !== "native-hook") { // Claude's native turn end is its Stop hook
+        // A lost Claude channel/watchdog is not native completion; only its real Stop closes a counted turn. A launcher-bound pull-only native turn follows the same rule.
+        const nativeFactsTurn = nativeHookLaunches.current(e.peer) !== undefined && bus.peers.get(e.peer)?.pullOnly === true;
+        if (nativeFactsTurn ? (nativeCompletedAt.get(e.peer) ?? -1) >= open.start : definitionOf(e.peer)?.turnEnd !== "native-hook" || (nativeCompletedAt.get(e.peer) ?? -1) >= open.start) event({ type: "turn_end", peer: e.peer, turn: open.id, ms: Date.now() - open.start, ...open.attribution, preparedRoles: open.preparedRoles, ...(open.tokens ? { tokens: open.tokens } : {}), ...(files !== undefined ? { files, snapshotMs } : {}) });
+        if (!nativeFactsTurn && definitionOf(e.peer)?.turnEnd !== "native-hook") { // Claude's native turn end is its Stop hook
           if ((bus.peers.get(e.peer)?.state ?? e.state) === "idle") queueMicrotask(() => finishSupervisionTurn(e.peer));
           turnEnded.set(e.peer, Date.now());
           tasks.cohorts.turnEnded(e.peer);
@@ -6622,7 +7385,7 @@ export async function startDaemon(opts: DaemonOptions) {
           try { tasks.recordOwnerTurn(e.peer, open.writeTasks, changed, !!open.taskEffect || !!open.effectsPending); } catch { /* advisory cannot fail native completion */ }
         }
       }
-      if (e.state === "offline" && softTokenPeer(e.peer)) { collectKimiUsage(e.peer); kimiUsage.drop(e.peer); }
+      if (e.state === "offline" && softTokenPeer(e.peer)) { collectKimiUsage(e.peer, true); kimiUsage.drop(e.peer); }
       // #636: a class-budget allowance belongs to the owner that earned it. A stopped, crashed or removed owner that later resumes the same native
       // session id starts from zero (a replaced adapter's own `offline` is muted, so a new owner also revokes where it is created).
       if (e.state === "offline") actionBudgets.revoke(e.peer);
@@ -6753,6 +7516,9 @@ export async function startDaemon(opts: DaemonOptions) {
     const timeoutMs = opts.permissionTimeoutMs ?? approvalTimeoutS * 1000;
     const createdAt = Date.now();
     const expiresAt = createdAt + timeoutMs;
+    // #1278: the task this request belongs to, resolved once when it opens by the rule `turn_end` and `tokens` use. The settle event reuses it, because the turn can have ended by then and the
+    // peer's open tasks changed. Ids and a closed rule name only; unattributed stays unattributed.
+    const requestAttribution = taskAttribution(req.peer);
     const publicTool = typeof req.tool === "string" && /^[A-Za-z][A-Za-z0-9_.:/-]{0,127}$/.test(req.tool) && !/\s/.test(req.tool) ? req.tool : undefined;
     log(`permission ${id} requested by ${req.peer} (${title.length} chars, shown on the console; cancelled after ${timeoutMs / 1000}s)`);
     // The tool name is for the desktop notice only: the console push keeps its shape.
@@ -6781,7 +7547,7 @@ export async function startDaemon(opts: DaemonOptions) {
         if (outcome === "expired") { try { notify(`permission ${id} from ${req.peer} was not answered within ${Math.round(timeoutMs / 1000)}s and was cancelled`); } catch { /* registry withdrawal already completed */ } }
         const latencyMs = Math.max(0, Date.now() - createdAt);
         const optionKind = option?.kind === "allow_once" || option?.kind === "allow_always" || option?.kind === "reject_once" || option?.kind === "reject_always" ? option.kind : undefined;
-        try { event({ type: "permission", id, peer: req.peer, event: outcome, latencyMs, ...(surface ? { surface } : {}), ...(optionKind ? { option: optionKind } : {}) }); } catch { try { log(`permission event recording failed at settlement for ${req.peer}`); } catch { /* settlement remains authoritative */ } }
+        try { event({ type: "permission", id, peer: req.peer, event: outcome, latencyMs, ...(surface ? { surface } : {}), ...(optionKind ? { option: optionKind } : {}), ...requestAttribution }); } catch { try { log(`permission event recording failed at settlement for ${req.peer}`); } catch { /* settlement remains authoritative */ } }
         try { notify(`permission ${id} from ${req.peer} ${outcome} option ${optionKind ?? "none"} by ${surface ?? "hub"} (${latencyMs}ms)`); } catch { /* no reporting failure strands the caller */ }
         for (const c of consoles) if (c.data.tail) { try { c.send(JSON.stringify({ t: "permission_closed", id, peer: req.peer, outcome: outcome === "expired" ? "cancelled" : outcome, ...(outcome === "expired" ? { reason: "expired" } : {}), latencyMs })); } catch { /* another surface can still observe the closure */ } }
         resolve({ outcome, ...(option ? { optionId: option.optionId, ...(surface ? { approvalId: id } : {}) } : {}) });
@@ -6793,7 +7559,7 @@ export async function startDaemon(opts: DaemonOptions) {
       timer = setTimeout(() => done(undefined, undefined, "expired"), timeoutMs);
       signal?.addEventListener("abort", aborted, { once: true });
       if (signal?.aborted) { aborted(); return; }
-      try { event({ type: "permission", id, peer: req.peer, event: "requested" }); } catch { /* optional observer */ }
+      try { event({ type: "permission", id, peer: req.peer, event: "requested", ...requestAttribution }); } catch { /* optional observer */ }
       for (const c of consoles) if (c.data.tail) { try { c.send(push); } catch { /* next tail gets the registered request */ } }
       if (config.approvals.notify) { try { desktop("agent-hub", `${req.peer} asks for approval${req.tool ? `: ${req.tool}` : ""} (ahub tail)`); } catch { /* optional desktop */ } }
     });
@@ -7205,6 +7971,8 @@ export async function startDaemon(opts: DaemonOptions) {
       if (instance?.jcode_home) { const refusal = jcodeHomeRefusal(peer, instance.jcode_home); if (refusal) return { ok: false, error: refusal }; }
       startCurrent?.();
       const jcode: JcodePeer = adapter!.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: permissionMode(peer), mcpServers: [], daemon: DAEMON_PORTS["owned-acp"]({ peer, command: config.jcode_cmd, home: instance?.jcode_home ?? config.jcode_home,
+        getModelOverride: () => acpModelSelection(peer),
+        ...(isFixedBuiltinDefinition(adapter) && adapter.modelOverride?.acp ? { modelPolicy: adapter.modelOverride.acp } : {}),
         providerProfile: (args.providerProfile ?? instance?.provider_profile ?? config.jcode_provider_profile) || undefined,
         ...(instance?.provider ? { provider: instance.provider } : {}),
         ...(args.model ?? instance?.model ? { launchModel: (args.model ?? instance?.model)! } : {}), ...(args.sessionId ? { resumeSessionId: args.sessionId } : {}), cwd: executionCwd, watchdogMs: config.watchdog_ms,
@@ -7225,9 +7993,10 @@ export async function startDaemon(opts: DaemonOptions) {
           event({ type: "usage", peer, source: "jcode_acp", id: `jcode:${runId}:${peer}:${++codexUsageSeq}`, inputTokens: usage.inputTokens, outputTokens: usage.outputTokens,
             ...(usage.cacheReadTokens !== undefined ? { cacheReadTokens: usage.cacheReadTokens } : {}), ...(usage.cacheWriteTokens !== undefined ? { cacheWriteTokens: usage.cacheWriteTokens } : {}), ...taskAttribution(peer) });
         } }) }) as JcodePeer;
+      if (isFixedBuiltinDefinition(adapter)) modelAcpOwners.set(jcode, jcode);
       jcodeLaunches.set(peer, jcode);
       recoveryTaskPreface(peer); await ensurePreface(peer); startCurrent?.();
-      try { startCurrent?.(); await jcode.start(); startCurrent?.(); await reconcileNativeStart(peer, jcode, startCurrent); }
+      try { startCurrent?.(); await jcode.start(); startCurrent?.(); registerModelOwner(jcode); bindRecordOwner(jcode, executionCwd, () => jcode.nativeSession); await reconcileNativeStart(peer, jcode, startCurrent); }
       catch { await jcode.stop().catch(() => {}); if (jcodeLaunches.get(peer) === jcode) jcodeLaunches.delete(peer); throw new Error("Jcode startup not verified; check native version, provider profile, MCP store and owned daemon (details withheld)"); }
       return { ok: true, policy: "unmanaged" };
     }
@@ -7240,6 +8009,8 @@ export async function startDaemon(opts: DaemonOptions) {
         isPrivateTurn: () => !!turns.get(peer)?.private || contextPii(peer),
         actionGate: acpActionGate(peer),
         cmd, kind: adapter.kind,
+        getModelOverride: () => acpModelSelection(peer),
+        ...(isFixedBuiltinDefinition(adapter) && adapter.modelOverride?.acp ? { modelPolicy: adapter.modelOverride.acp } : {}),
         toolCeilingMs: adapterTiming.acpToolCeilingMs(), activityBatchMs: adapterTiming.acpActivityBatchMs(),
         permissionMode: permissionMode(peer),
         ...(args.model ? { launchModel: args.model } : {}),
@@ -7275,10 +8046,12 @@ export async function startDaemon(opts: DaemonOptions) {
         mcpServers: [{ name: "agent-hub", command: "bun", args: ["run", SERVER_JS], env: Object.entries(toolEnv(peer, true)).map(([name, value]) => ({ name, value })) }],
         preamble: sessionRoleContract(peer),
       }) }) as AcpPeer;
+      if (isFixedBuiltinDefinition(adapter)) modelAcpOwners.set(kimi, kimi);
       recoveryTaskPreface(peer);
       await ensurePreface(peer); startCurrent?.();
       try {
-        startCurrent?.(); await kimi.start(); startCurrent?.();
+        startCurrent?.(); await kimi.start(); startCurrent?.(); registerModelOwner(kimi);
+        bindRecordOwner(kimi, executionCwd, () => kimi.nativeSession);
         await reconcileNativeStart(peer, kimi, startCurrent);
       } catch (error) { await kimi.stop().catch(stop => log(`kimi stop after a failed start: ${(stop as Error).message}`)); throw error; }
       return { ok: true };
@@ -7296,6 +8069,8 @@ export async function startDaemon(opts: DaemonOptions) {
       const externalLaunchId = externalBinding ? randomUUID() : undefined;
       if (externalLaunchId) for (const server of mcpServers) server.env.push({ name: "AGENTHUB_LAUNCH_ID", value: externalLaunchId });
       const acpOptions: AcpOptions = {
+        getModelOverride: () => acpModelSelection(peer),
+        ...(isFixedBuiltinDefinition(adapter) && adapter.modelOverride?.acp ? { modelPolicy: adapter.modelOverride.acp } : {}),
         toolCeilingMs: adapterTiming.acpToolCeilingMs(), activityBatchMs: adapterTiming.acpActivityBatchMs(),
         onActivity: item => activityRings[peer]?.append(item),
         isPrivateTurn: () => !!turns.get(peer)?.private || contextPii(peer),
@@ -7328,6 +8103,7 @@ export async function startDaemon(opts: DaemonOptions) {
       if (externalBinding && externalLaunchId) externalLaunches.set(peer, { owner, options: acpOptions, launchId: externalLaunchId, binding: externalBinding, workspace: externalWorkspace! });
       assertNativeProofPorts(adapter, owner);
       if (!isAcpPeer(owner) || owner.id !== peer || owner.deliveryOnly !== true || owner.hubOwned !== true || owner.form !== "headless") throw new Error("ACP factory did not return its bound native transport");
+      if (isFixedBuiltinDefinition(adapter)) modelAcpOwners.set(owner, owner);
       recoveryTaskPreface(peer); await ensurePreface(peer); startCurrent?.();
       try {
         if (externalBinding && (!membershipAllowed(peer) || externalWorkspaceIdentity(executionCwd) !== externalWorkspace || !sameExternalInstanceBinding(externalBinding, captureExternalBinding(peer, args.sessionId)))) throw new Error("external instance binding changed before native spawn");
@@ -7342,6 +8118,8 @@ export async function startDaemon(opts: DaemonOptions) {
           externalSessions.set(peer, receipt.sessionId);
           writeExternalInstanceRecord(opts.stateDir, externalBinding, receipt.sessionId);
         }
+        registerModelOwner(owner);
+        bindRecordOwner(owner, executionCwd, () => owner.nativeSession);
         await reconcileNativeStart(peer, owner, startCurrent);
       }
       catch (error) {
@@ -7359,6 +8137,11 @@ export async function startDaemon(opts: DaemonOptions) {
       actionBudgets.revoke(peer);
       startCurrent?.();
       const codex: CodexPeer = adapter!.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: permissionMode(peer), mcpServers: [], daemon: DAEMON_PORTS["codex-appserver"]({
+        getModelOverride: () => modelSelection(peer),
+        onNativeModelApplied: model => { if (!stopping && bus.peers.get(peer) === codex && isNativeModelToken(model)) {
+          try { modelLatches.observeNative(peer, codex, model); } catch { modelLatches.forget(peer); }
+          writeStatus();
+        } },
         admitAttach: () => membershipAllowed(peer),
         permissionMode: permissionMode(peer),
         ...(declarations[peer] ? { threadSandbox: () => isPlannerOnly(config.roles[peer] ?? []) ? declarations[peer]?.worktree ? "unavailable" as const : "read-only" as const : undefined } : {}),
@@ -7375,6 +8158,8 @@ export async function startDaemon(opts: DaemonOptions) {
         // #215: before the thread's first turn_start, so the planner can tell which turns belong to which thread.
         onThread: (thread, fresh) => { lastCodexThreads.set(peer, thread); event({ type: "native_thread", peer, thread, fresh }); },
         onTurn: (native) => {
+          const modelBoundary = modelBoundaries.get(peer);
+          if (modelBoundary && modelBoundary.owner === codex) modelBoundary.nativeStarted = true;
           const open = turns.get(peer);
           if (open) turnLog?.native(open.id, native);
           if (factsOn()) factSession(peer, codex.thread); // a new thread is unverified before its first item
@@ -7426,10 +8211,12 @@ export async function startDaemon(opts: DaemonOptions) {
         watchdogMs: config.watchdog_ms,
         log,
       }) }) as CodexPeer;
+      registerModelOwner(codex);
       recoveryTaskPreface(peer);
       await ensurePreface(peer); startCurrent?.();
       try {
         startCurrent?.(); await codex.start(); startCurrent?.();
+        bindRecordOwner(codex, executionCwd, () => codex.nativeSession);
         await reconcileNativeStart(peer, codex, startCurrent);
       } catch (error) { await codex.stop().catch(stop => log(`codex stop after a failed start: ${(stop as Error).message}`)); throw error; }
       const proxy = frontendProxyState(peer, codex);
@@ -7522,6 +8309,7 @@ export async function startDaemon(opts: DaemonOptions) {
       const routing = activeRouting();
       startCurrent?.();
       const pi: PiPeer = adapter!.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: permissionMode(peer), mcpServers: [], daemon: DAEMON_PORTS["pi-rpc"]({
+        getModelOverride: () => modelSelection(peer),
         cwd: executionCwd, stateDir: nativeRoot, ...(declarations[peer] ? { hubStateDir: opts.stateDir } : {}), cmd: config.pi.cmd, mode, backend,
         model: args.model,
         sessionId: args.sessionId, sessionFile: args.sessionFile,
@@ -7633,9 +8421,11 @@ export async function startDaemon(opts: DaemonOptions) {
         },
         watchdogMs: config.watchdog_ms, maxSteps: config.pi.max_steps, log,
       }) }) as PiPeer;
+      registerModelOwner(pi);
       recoveryTaskPreface(peer);
       await ensurePreface(peer); startCurrent?.();
       executionOwners.set(peer, { owner: pi, cwd: executionCwd });
+      if (pi.mode === "headless") bindRecordOwner(pi, executionCwd, () => pi.nativeSession);
       bus.add(pi);
       // The start's own error is the one reported; a stop that fails too is logged beside it (#115).
       try { startCurrent?.(); await pi.start(); } catch (error) {
@@ -7702,12 +8492,15 @@ export async function startDaemon(opts: DaemonOptions) {
       };
       startCurrent?.();
       const local: LocalPeer = adapter!.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: permissionMode(peer), mcpServers: [], daemon: DAEMON_PORTS["local-worker"]({
+        getModelOverride: () => modelSelection(peer),
         cwd: executionCwd,
         omni,
         onUsage: record => event({ type: "usage", peer, source: "omniroute", id: record.id, ...record.usage, ...taskAttribution(peer, record.task), requestedModel: record.requestedModel, ...(record.servedModel ? { servedModel: record.servedModel } : {}), ...(record.provider ? { provider: record.provider } : {}), measuredAt: record.at }),
         admitBudget: async (envs, unit) => tasks.admitExecutionEnvelopes(envs, peer, unit),
         ...(route ? { route } : {}),
         hubRoutes: () => activeRouting().hub_routes ?? {},
+        routeEvidencePublic: boundedSafe,
+        routeDecisionContext: () => ({ pii: contextPii(peer), private: turns.get(peer)?.private === true, excluded: reviewObserverHeld(peer) }),
         staySwitch: () => activeRouting(),
         onRoute: record => event({ type: "route", peer, ...record }),
         onAdvisor: record => event({ type: "advisor", peer, ...record }),
@@ -7741,11 +8534,13 @@ export async function startDaemon(opts: DaemonOptions) {
         maxSteps: config.local.max_steps,
         log,
       }) }) as LocalPeer;
+      registerModelOwner(local);
       localObserverSessionIds.set(local, () => local.observerSessionId);
       ownedReviewInputReleasePeers.add(local);
       recoveryTaskPreface(peer);
       await ensurePreface(peer); startCurrent?.();
       executionOwners.set(peer, { owner: local, cwd: executionCwd });
+      bindRecordOwner(local, executionCwd, () => local.observerSessionId);
       bus.add(local);
       startCurrent?.(); await local.start();
       return { ok: true, model: route ? `${route} (fallback ${routing.local.fixed_model})` : (args.model ?? routing.local.fixed_model) };
@@ -7764,6 +8559,7 @@ export async function startDaemon(opts: DaemonOptions) {
       if (selected !== "ask" && selected !== "ask-when-needed") return { ok: false, error: "Claude implementer refuses never-ask" };
       startCurrent?.();
       const implementer = adapter.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: selected, mcpServers: [], daemon: DAEMON_PORTS["claude-implementer"]({
+        getModelOverride: () => modelSelection(peer),
         cwd: executionCwd, stateDir: opts.stateDir, projectRoot: opts.cwd, instanceId, server: SERVER_JS,
         factsHook: join(import.meta.dir, "..", "cli", "facts-hook.ts"), systemPrompt: sessionRoleContract(peer), mode: selected, watchdogMs: config.watchdog_ms, ...(declarations[peer]?.model ? { model: declarations[peer].model } : {}),
         beforeInput: (context, envs) => beforeOwnedObserverInput(peer, implementer, context, envs),
@@ -7818,7 +8614,7 @@ export async function startDaemon(opts: DaemonOptions) {
         if (!currentRoot()) throw new Error("Claude implementer startup admission changed");
         recoveryTaskPreface(peer); await ensurePreface(peer); startCurrent?.();
         if (!currentRoot()) throw new Error("Claude implementer startup admission changed");
-        executionOwners.set(peer, { owner: implementer, cwd: executionCwd }); bus.add(implementer);
+        registerModelOwner(implementer); executionOwners.set(peer, { owner: implementer, cwd: executionCwd }); bus.add(implementer);
         return { ok: true };
       } catch (error) { await implementer.stop().catch(() => {}); throw error; }
     }
@@ -7831,6 +8627,7 @@ export async function startDaemon(opts: DaemonOptions) {
       const reviewPolicies = new Map<string, string>();
       startCurrent?.();
       const reviewer = adapter.start.create!({ instance: peer, projectRoot: opts.cwd, stateDir: opts.stateDir, kindConfig: config, permission: permissionMode(peer), mcpServers: [], daemon: DAEMON_PORTS["reviewer-print"]({
+        ...(isFixedBuiltinDefinition(adapter) && adapter.modelOverride && !adapter.modelOverride.acp ? { getModelOverride: () => modelSelection(peer) } : {}),
         backend, cwd: executionCwd,
         mcpConfig: JSON.stringify({ mcpServers: { "agent-hub": { command: process.execPath, args: ["run", SERVER_JS], env: toolEnv(peer, true) } } }),
         systemPrompt: sessionRoleContract(peer),
@@ -7897,7 +8694,7 @@ export async function startDaemon(opts: DaemonOptions) {
         return { ok: false, error: reason };
       }
       reviewerUnavailable.delete(peer);
-      executionOwners.set(peer, { owner: reviewer, cwd: executionCwd });
+      registerModelOwner(reviewer); executionOwners.set(peer, { owner: reviewer, cwd: executionCwd });
       reviewerToolObservers.set(peer, (task, tool, refusal) => {
         try { if (bus.peers.get(peer) === reviewer) reviewer.recordToolTrace(task, { tool, ...(refusal === undefined ? {} : { refusal }) }); }
         catch { /* Diagnostics never change a host tool's result or authority. */ }
@@ -8260,6 +9057,20 @@ export async function startDaemon(opts: DaemonOptions) {
     const start = input?.view === "memory" && query && query.codeNeighbours === true && typeof query.node === "string" && query.node.startsWith("symbol:") && Buffer.byteLength(query.node) <= 512 ? query.node : undefined;
     const code = start ? await memoryCode([start]).catch(() => unavailableMemoryCodeOverlay()) : undefined;
     const snapshot = uiSnapshot(after, input, session);
+    if (input?.visual !== undefined) {
+      const record = visualRecord(input.visual);
+      return { ...snapshot, visual: record ? visualView(record) : null };
+    }
+    if (input?.visualTask !== undefined) {
+      const task = input.visualTask;
+      return { ...snapshot, visuals: Number.isSafeInteger(task) && Number(task) > 0 ? visualList(Number(task)) : [] };
+    }
+    if (input?.visualAsset !== undefined) {
+      const match = typeof input.visualAsset === "string" ? /^([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}):(before|after)$/.exec(input.visualAsset) : null;
+      const record = match ? visualRecord(match[1]) : undefined;
+      const file = record?.files.find(file => file.asset === input.visualAsset);
+      return { ...snapshot, visualAsset: record && file ? { id: record.id, ...(record.task === undefined ? {} : { task: record.task }), from: record.from, created: record.created, file } : null };
+    }
     if (code && "memory" in snapshot && snapshot.memory && typeof snapshot.memory === "object") {
       const published = currentMemoryCode(code), tier = query?.tier === "goals" ? "goals" : query?.tier === "short" ? "short" : "long";
       const search = typeof query?.q === "string" ? query.q.toLowerCase() : undefined;
@@ -8343,11 +9154,13 @@ export async function startDaemon(opts: DaemonOptions) {
       projectId,
       instanceId,
       attention: attentionStatus.attentionInput,
+      ...runtimeModelProjection(),
       rooms: attentionStatus.rooms,
       pet,
       status: { peers: peerView, pendingRestart: allPendingRestart(), retainedConfig, taskWip: attentionStatus.taskWip, roleInfo: attentionStatus.roleInfo, ownerIsolation: attentionStatus.ownerIsolation, ownerIsolationNotes: attentionStatus.ownerIsolationNotes },
       boardCapabilities: { backlog: true },
       planningCapabilities: { enabled: true, wipPull: true, split: true },
+      visuals: visualList(),
       // #1144: source metadata only, including private records; never expose origins or stored text.
       sources: sourceRegistry.list().map(({ id, kind, bytes, sha256, added_at }) => ({ id, kind, bytes, hashPrefix: sha256.slice(0, 12), added_at })),
       releases: tasks.releaseList(USER),
@@ -9222,6 +10035,14 @@ export async function startDaemon(opts: DaemonOptions) {
       }
       case "setting":
         return settingsSet(a.key, a.value, authority, a.confirm, a.now, a.reason);
+      case "model_preview":
+      case "model_confirm": {
+        const current = () => session?.settings === true && session.liveTest !== true && typeof session.authorityId === "string"
+          && typeof session.settingsUntil === "number" && session.settingsUntil > Date.now();
+        if (!current()) return modelFailure("model changes require a current person settings session; reopen ahub ui --settings and preview again");
+        return modelCommandSafe(a.action === "model_preview" ? { op: "preview", action: a.modelAction, peer: a.peer, model: a.model } : { op: "confirm", token: a.token },
+          { source: "dashboard", scope: session!.authorityId!, expiresAt: session!.settingsUntil, current });
+      }
       case "setting_undo":
         return settingsUndo(authority, a.confirm, a.now, a.reason, a.key, a.undoDigest);
       case "setting_preview":
@@ -9306,6 +10127,13 @@ export async function startDaemon(opts: DaemonOptions) {
         ? `target lacks task_cancel; cancelled tasks: ${ids.map(id => `#${id}`).join(", ")}` : undefined;
     };
     const incompatibleRecoveryTarget = () => {
+      if ((!Array.isArray(msg.targetFeatures) || !msg.targetFeatures.includes("model_overrides")) && modelOverrides.hasRecords()) return "target lacks model_overrides; retained runtime model choices require a supporting daemon; clear them with ahub model clear or choose a supporting target";
+      if (!Array.isArray(msg.targetFeatures) || !msg.targetFeatures.includes("visuals")) {
+        try {
+          if (visuals.hasRecords()) return "target lacks visuals; retained visual records require a supporting daemon; choose a target with visuals";
+          if (rawVisualsPresent(opts.cwd)) return "target lacks visuals; explicit visuals configuration requires a supporting daemon; choose a target with visuals or remove the explicit configuration";
+        } catch { return "visuals compatibility is unknown; the store or configuration could not be read; inspect them or choose a target with visuals"; }
+      }
       if (config.specs.enabled && config.specs.review === "require" && (!Array.isArray(msg.targetFeatures) || !msg.targetFeatures.includes("design_specs"))) return "target lacks design_specs; specs.enabled is on and specs.review is require; use a supporting release or explicitly change specs.enabled/specs.review";
       if (board.hasConductorManualState() && (!Array.isArray(msg.targetFeatures) || !msg.targetFeatures.includes("conductor_recovery"))) return "target lacks conductor_recovery; open conductor manual-assignment intent cannot be preserved";
       if (allExternalInstanceIds().length && (!Array.isArray(msg.targetFeatures) || !["external_adapter_instances", "external_adapter_modules", "peer_instances"].every(feature => msg.targetFeatures.includes(feature)))) return "target lacks external_adapter_instances or its module/instance prerequisites";
@@ -9915,9 +10743,9 @@ export async function startDaemon(opts: DaemonOptions) {
     }
     const committedSourceProof = c.role === "tools" && msg.t === "recovery_authority" && msg.op === "verify" && recoveryCommitted
       && msg.binding?.operationId === recoveryOperationId && msg.binding?.sourceInstanceId === instanceId;
-    if (stopping && !committedSourceProof && msg.t !== "status" && msg.t !== "kill" && !(c.role === "console" && msg.t === "native_hook_launch" && msg.op === "end")) return void reply({ ok: false, error: "hub is stopping" });
+    if (stopping && !committedSourceProof && msg.t !== "status" && msg.t !== "kill" && !(c.role === "console" && msg.t === "native_hook_launch" && msg.op === "end")) return void reply({ ok: false, error: msg.t === "task" && (msg.op === "hub_visual" || msg.op === "hub_visual_show") ? visualOperational("stopping").message : "hub is stopping" });
     if (c.role === "peer" && c.detachedByPerson) return void reply({ t: msg.t, ok: false, error: "detached by the person; stop using this peer connection and tell the person; inspect ahub status before opening a fresh session" });
-    if (c.role !== "console" && c.peer && !membershipAllowed(c.peer)) return void reply({ ok: false, error: `${c.peer} is off roster` });
+    if (c.role !== "console" && c.peer && !membershipAllowed(c.peer)) return void reply({ ok: false, error: msg.t === "task" && (msg.op === "hub_visual" || msg.op === "hub_visual_show") ? visualOperational("membership").message : `${c.peer} is off roster` });
     if (c.role === "peer" && c.peer) {
       const currentPeer = bus.peers.get(c.peer);
       if (c.standbyId && currentPeer?.ownsSocket?.(sock) !== true) return void reply({ t: msg.t, ok: false, error: "peer is standing by; a person must request takeover" });
@@ -10288,7 +11116,7 @@ export async function startDaemon(opts: DaemonOptions) {
             }
             if (!sourcePackageDigest || plan.sourceDigest !== sourcePackageDigest && (plan.kind !== "upgrade" || plan.sourceDigest !== raw.targetDigest)) throw new RecoveryAuthorityError();
             current();
-            if (!event({ type: "agent_cli", peer: c.peer!, command: raw.kind, refused: false })) throw new RecoveryAuthorityError();
+            if (!event({ type: "agent_cli", peer: c.peer!, command: raw.kind, refused: false, ...taskAttribution(c.peer!) })) throw new RecoveryAuthorityError();
             current();
             issueConductorRecoveryAuthority(opts.stateDir, expected, fresh);
           } else {
@@ -10376,13 +11204,24 @@ export async function startDaemon(opts: DaemonOptions) {
       }
       case "native_hook_launch": {
         if (c.role !== "console" || typeof msg.peer !== "string" || !definitionOf(msg.peer)?.hooks?.factsHook) return void reply({ ok: false, error: "managed native launch requires the person and a supported hook adapter" });
-        if (msg.op === "end") return void reply({ ok: nativeHookLaunches.end(msg.peer, msg.launchId) });
+        if (msg.op === "end") {
+          const launch = nativeHookLaunches.get(msg.peer, msg.launchId);
+          if (!launch) return void reply({ ok: false });
+          const run = runs.get(msg.peer);
+          if (run) {
+            if (budget.record(msg.peer)) completionStore.dropRun(run.runTurn);
+            else completionDone(msg.peer, run, "interrupted");
+            runs.close(msg.peer);
+          }
+          return void reply({ ok: nativeHookLaunches.end(msg.peer, msg.launchId) });
+        }
         if (recoveryActive() || stopping) return void reply({ ok: false, error: "recovery or shutdown is holding native launches" });
         if (!membershipAllowed(msg.peer)) return void reply({ ok: false, error: "peer is off roster" });
         if (msg.op !== "begin") return void reply({ ok: false, error: "unknown native launch operation" });
+        if (msg.nativeHome !== undefined && (typeof msg.nativeHome !== "string" || !isAbsolute(msg.nativeHome) || msg.nativeHome.length > 4096 || /[\u0000-\u001f\u007f]/.test(msg.nativeHome))) return void reply({ ok: false, error: "native home must be an absolute control-free path" });
         const owner = bus.peers.get(msg.peer);
         if (owner && owner.state !== "offline") return void reply({ ok: false, error: "native peer is already attached; end it in its terminal first" });
-        try { return void reply({ ok: true, launchId: nativeHookLaunches.begin(msg.peer, sock).id, instanceId }); }
+        try { return void reply({ ok: true, launchId: nativeHookLaunches.begin(msg.peer, sock, typeof msg.nativeHome === "string" ? msg.nativeHome : undefined).id, instanceId }); }
         catch (error) { return void reply({ ok: false, error: (error as Error).message }); }
       }
       case "native_facts": {
@@ -10391,49 +11230,151 @@ export async function startDaemon(opts: DaemonOptions) {
         const launch = nativeHookLaunches.get(peer, msg.nativeLaunchId);
         const native = typeof msg.event === "string" ? port.decode(msg.event, msg.payload) : undefined;
         if (!launch || !native || !native.workspacePaths.every(root => { try { return realPath(root) === realPath(opts.cwd); } catch { return false; } })) return void reply({ ok: false });
+        if (launch.home && native.transcriptPath !== join(launch.home, "session_index.jsonl")) return void reply({ ok: false });
         if (launch.session && launch.session !== native.sessionId) return void reply({ ok: false });
         launch.session = native.sessionId;
         const owner = bus.peers.get(peer);
         if (!isWsPeer(owner) || owner.state === "offline" && !owner.claiming) return void reply({ ok: false });
         if (launch.generation && launch.generation !== owner.sessionGeneration) return void reply({ ok: false });
         launch.generation = owner.sessionGeneration;
+        launch.transcript = native.transcriptPath;
+        const callStarted = performance.now();
+        const tally = () => tallyHook(peer, callStarted, msg.startedMs);
         const current = () => !stopping && nativeHookLaunches.get(peer, msg.nativeLaunchId) === launch && bus.peers.get(peer) === owner && owner.sessionGeneration === launch.generation && owner.state !== "offline";
         // Preserve the start baseline at observation, even if native output is flushed before recall allows attach.
-        const readback = port.read(native.sessionId, native.transcriptPath);
+        // Skip transcript I/O on PostToolUse, PostInvocation, Stop, and active-turn PreToolUse with no pending fact offers (#1280).
+        const needsBaseline = (native.event === "PreInvocation" || native.event === "PreToolUse") && (!launch.active || native.event === "PreInvocation" && native.invocation === 0)
+          || native.event === "TurnStarted" || native.event === "Stop" || native.event === "StopFailure" || native.event === "Interrupt";
+        const needsAck = factsOn() && (native.event === "SessionStart" || native.event === "PreInvocation" || native.event === "PreToolUse" && factsFor(peer).pending(peer).length > 0);
+        const since = launch.transcriptPath === native.transcriptPath && launch.transcriptOffset !== undefined ? { sinceOffset: launch.transcriptOffset } : {};
+        const readback: ReturnType<typeof port.read> = needsBaseline
+          ? port.read(native.sessionId, native.transcriptPath, since)
+          : needsAck
+            ? port.read(native.sessionId, native.transcriptPath, { completion: false, ...since })
+            : { factIds: [] };
+        // ponytail: an unacknowledged fact row followed by >4 MiB of output before the next readback hits the 4 MiB lookback cap in readAgyTranscript.
+        const acknowledge = (read: ReturnType<typeof port.read>, turnCtx?: { hubTurnId?: string; baseline: number; attribution: TaskAttribution }) => {
+          for (const u of read.usage ?? []) {
+            if (agyNativeUsageSeen.has(u.id)) continue;
+            agyNativeUsageSeen.add(u.id);
+            const producedByTurn = !!turnCtx && u.index > turnCtx.baseline;
+            const attr: TaskAttribution = producedByTurn ? turnCtx.attribution : { attribution: "unattributed" };
+            if (u.totalTokens > 0) {
+              if (noQuotaPeer(peer)) hubTokenWindow(peer).add(Date.now(), Math.round(u.totalTokens));
+              const supervisionTurn = supervisionTurns.get(peer);
+              if (producedByTurn && supervisionTurn && turnCtx.hubTurnId && supervisionTurn.id === turnCtx.hubTurnId) {
+                supervisionTurn.tokens = (supervisionTurn.tokens ?? 0) + u.totalTokens;
+              }
+              event({ type: "tokens", peer, n: u.totalTokens, ...attr });
+              const openTurn = turns.get(peer);
+              if (producedByTurn && openTurn && turnCtx.hubTurnId && openTurn.id === turnCtx.hubTurnId) {
+                openTurn.tokens += u.totalTokens;
+              }
+            }
+            event({ type: "usage", peer, source: "agy_transcript", id: u.id, inputTokens: u.inputTokens, outputTokens: u.outputTokens, cacheReadTokens: u.cacheReadTokens, totalTokens: u.totalTokens, ...attr, ...(u.at ? { measuredAt: u.at } : {}) });
+          }
+          if (factsOn()) {
+            factSession(peer, native.sessionId);
+            for (const id of read.factIds) acked(peer, id, "native-hook");
+          }
+          if (read.size !== undefined && read.scannedFrom !== undefined) {
+            const prev = launch.transcriptPath === native.transcriptPath ? (launch.transcriptOffset ?? 0) : 0;
+            if (read.scannedFrom <= prev) {
+              launch.transcriptPath = native.transcriptPath;
+              launch.transcriptOffset = read.size;
+            }
+          }
+        };
         const apply = () => {
           if (!current()) return void reply({ ok: false });
-          if (factsOn()) { factSession(peer, native.sessionId); for (const id of readback.factIds) acked(peer, id, "native-hook"); }
-          if (native.event === "PreInvocation" || native.event === "PreToolUse") {
-            if (!launch.active || native.event === "PreInvocation" && native.invocation === 0) { launch.active = true; launch.turn = crypto.randomUUID(); launch.baseline = readback.completion?.index ?? -1; }
+          if (native.event === "TurnStarted") {
+            const started = readback.started;
+            if (!started) return void reply({ ok: false });
+            if (launch.active && launch.turn === started.id) return void reply({ ok: true });
+            if (readback.completion && readback.completion.index >= started.index) return void reply({ ok: true });
+            launch.active = true; launch.turn = started.id; launch.baseline = started.index - 1;
+            pendingNativePerson.delete(peer);
+            if (started.origin === "user") pendingNativePerson.add(peer);
             activeAt.set(peer, Date.now()); owner.nativeStarted(native.sessionId);
           }
-          if (native.event === "Stop") {
-            if (!launch.active || !native.fullyIdle || native.terminationReason !== "NO_TOOL_CALL") return void reply({ ok: false });
-            // Native output can be flushed after its Stop command returns. Acknowledge observation, then wait for
-            // a fresh completion row while the same launcher/session/socket generation still owns the turn.
-            const turn = launch.turn, baseline = launch.baseline ?? -1;
+          owner.bindNativeSession(native.sessionId);
+          const startsTurn = (native.event === "PreInvocation" || native.event === "PreToolUse") && (!launch.active || native.event === "PreInvocation" && native.invocation === 0);
+          if (native.event === "PreInvocation" || native.event === "PreToolUse") {
+            if (startsTurn) {
+              // Credit any leftover rows read at turn start to the preceding turn that produced them, never the new turn.
+              acknowledge(readback, agyTurnContext.get(launch));
+              launch.active = true; launch.turn = crypto.randomUUID(); launch.baseline = readback.completion?.index ?? -1;
+              activeAt.set(peer, Date.now()); owner.nativeStarted(native.sessionId);
+              agyTurnContext.set(launch, { hubTurnId: turns.get(peer)?.id, baseline: launch.baseline, attribution: taskAttribution(peer) });
+            } else {
+              activeAt.set(peer, Date.now()); owner.nativeStarted(native.sessionId);
+              const activeCtx = { hubTurnId: turns.get(peer)?.id ?? agyTurnContext.get(launch)?.hubTurnId, baseline: launch.baseline ?? -1, attribution: taskAttribution(peer) };
+              agyTurnContext.set(launch, activeCtx);
+              acknowledge(readback, activeCtx);
+            }
+          } else if (native.event !== "Stop") {
+            const activeCtx = launch.active ? { hubTurnId: turns.get(peer)?.id ?? agyTurnContext.get(launch)?.hubTurnId, baseline: launch.baseline ?? -1, attribution: taskAttribution(peer) } : agyTurnContext.get(launch);
+            if (launch.active && activeCtx) agyTurnContext.set(launch, activeCtx);
+            acknowledge(readback, activeCtx);
+          }
+          const stopCtx = { hubTurnId: turns.get(peer)?.id ?? agyTurnContext.get(launch)?.hubTurnId, baseline: launch.baseline ?? -1, attribution: taskAttribution(peer) };
+          agyTurnContext.set(launch, stopCtx);
+          if (native.event === "Stop" && native.terminationReason !== undefined) {
+            if (!launch.active || native.fullyIdle !== true) return void reply({ ok: false });
+            const terminalReason = ({ USER_CANCELED: "user_canceled", ERROR: "error", MAX_INVOCATIONS: "max_invocations", MAX_FORCED_INVOCATIONS: "max_forced_invocations", MAX_TOKEN_BUDGET_EXCEEDED: "max_token_budget_exceeded", TERMINAL_STEP_TYPE: "terminal_step_type", TERMINAL_CUSTOM_HOOK: "terminal_custom_hook" } as const)[native.terminationReason];
+            if (terminalReason) {
+              acknowledge(port.read(native.sessionId, native.transcriptPath, { completion: false, ...since }), stopCtx);
+              launch.active = false; turnEnded.set(peer, Date.now()); tasks.cohorts.turnEnded(peer);
+              tally(); emitHookStats(peer);
+              event({ type: "native_turn_end", peer, reason: terminalReason }); owner.nativeStopped(native.sessionId);
+              // #1054: pull-only agy opens no run (`settles(peer)` is false); if a future native-hook peer does, settle an open run by its closed reason.
+              try {
+                const run = runs.get(peer);
+                if (run) {
+                  if (terminalReason === "user_canceled") { completionDone(peer, run, "interrupted"); runs.close(peer); }
+                  else { runs.note(peer, terminalReason === "error" || terminalReason === "terminal_step_type" || terminalReason === "terminal_custom_hook" ? { failed: true } : { limit: true }); runs.signalled(peer); settleCheck(peer); }
+                }
+              } catch { log(`completion settle for ${peer} failed`); }
+              return void reply({ ok: true });
+            }
+            if (native.terminationReason !== "NO_TOOL_CALL") return void reply({ ok: false });
+            tally();
+          }
+          if (native.event === "Stop" || native.event === "StopFailure" || native.event === "Interrupt") {
+            if (!launch.active || native.event === "Stop" && native.terminationReason !== undefined && native.fullyIdle !== true) return void reply({ ok: false });
+            // A hook is only the candidate. The final native turn and prompt rows, correlated by id and reason, are the completion evidence.
+            const turn = launch.turn, baseline = launch.baseline ?? -1, expected = native.event === "StopFailure" ? "failed" : native.event === "Interrupt" ? "cancelled" : "completed";
             reply({ ok: true, pending: true });
             void (async () => {
               const deadline = Date.now() + 2000;
               let delay = 5;
-              // ponytail: an unverified Stop may re-read up to 4 MiB per poll within this 2 s wait.
-              // Upgrade: cache unchanged transcript evidence within the wait.
+              let lastStat: { size: number; mtimeMs: number } | undefined;
               while (current() && launch.active && launch.turn === turn) {
-                const completion = port.read(native.sessionId, native.transcriptPath).completion;
-                if (completion && completion.index > baseline && completion.id !== launch.completed) {
-                  launch.completed = completion.id; launch.active = false;
-                  turnEnded.set(peer, Date.now()); nativeCompletedAt.set(peer, Date.now()); tasks.cohorts.turnEnded(peer);
-                  event({ type: "native_turn_end", peer, id: completion.id }); owner.nativeStopped(native.sessionId);
-                  try { if (runs.get(peer)) { runs.signalled(peer); settleCheck(peer); } } catch { log(`completion settle for ${peer} failed`); } // #1054: the verified native Stop
+                const pollSince = launch.transcriptPath === native.transcriptPath && launch.transcriptOffset !== undefined ? { sinceOffset: launch.transcriptOffset } : {};
+                const polled = port.read(native.sessionId, native.transcriptPath, { ...(lastStat ? { unchanged: lastStat } : {}), ...pollSince });
+                if (polled.size !== undefined && polled.mtimeMs !== undefined) lastStat = { size: polled.size, mtimeMs: polled.mtimeMs };
+                acknowledge(polled, stopCtx);
+                const completion = polled.completion;
+                if (completion && completion.index > baseline && completion.id !== launch.completed && (completion.reason ?? "completed") === expected) {
+                  completeNativeTurn(peer, launch, completion);
+                  emitHookStats(peer);
                   return;
                 }
-                if (Date.now() >= deadline) { notify(`${peer}: native completion could not be verified; it stays busy until a verified turn end or detach`); return; }
+                if (Date.now() >= deadline) { settleCheck(peer); emitHookStats(peer); notify(`${peer}: native completion could not be verified; it stays busy until a verified turn end or detach`); return; }
                 await Bun.sleep(delay); delay = Math.min(50, delay * 2);
               }
             })().catch(() => log("managed native completion unavailable"));
             return;
           }
-          const offered = factsOn() && (native.event === "PreInvocation" || native.event === "SessionStart") ? offerFor(peer, native.toolUseId ?? `${native.sessionId}:invocation`) : undefined;
+          if (native.event === "TaskStarted") activeAt.set(peer, Date.now());
+          if (native.event === "TaskStarted" || native.event === "Notification") { nativeBackgroundBackoff.delete(peer); settleCheck(peer); }
+          queueMicrotask(tally);
+          const offeredFacts = factsOn() && (native.event === "PreInvocation" || native.event === "SessionStart") ? offerFor(peer, native.toolUseId ?? `${native.sessionId}:invocation`) : undefined;
+          // #1280 P2: agy is pull-only, so a model boundary is the one place the hub can tell it mail waits. Counts only, never a body or sender.
+          const modelBoundary = native.event === "PreInvocation" || native.event === "SessionStart";
+          const waiting = bus.queued(peer), important = bus.queuedImportant(peer);
+          const inboxHint = modelBoundary && waiting ? `[agent-hub: ${waiting} message(s) waiting${important ? ` (${important} important)` : ""}; call hub_inbox]` : undefined;
+          const offered = offeredFacts || inboxHint ? { ...(offeredFacts ?? {}), text: [offeredFacts?.text, inboxHint].filter(Boolean).join("\n") } : undefined;
           // The decoded native read (agy view_file or read_file, as `Read`) is a peer fact: its target is observed before it runs and the
           // view moves after it. Nothing is offered here: agy's hook encodes an offer only on SessionStart/PreInvocation.
           if (factsOn() && native.event === "PreToolUse") factsFor(peer).preTool(peer, native.toolUseId, native.tool, native.input);
@@ -10460,11 +11401,7 @@ export async function startDaemon(opts: DaemonOptions) {
         const toolUseId = typeof msg.toolUseId === "string" && msg.toolUseId ? msg.toolUseId.slice(0, 128) : undefined;
         const sessionId = typeof msg.sessionId === "string" && msg.sessionId ? msg.sessionId.slice(0, 128) : undefined;
         const callStarted = performance.now();
-        const tally = (peer: PeerId) => {
-          const st = hookStats.get(peer) ?? { n: 0, startupMs: 0, hubMs: 0, maxStartupMs: 0 };
-          const startup = typeof msg.startedMs === "number" && Number.isFinite(msg.startedMs) ? Math.max(0, msg.startedMs) : 0;
-          hookStats.set(peer, { n: st.n + 1, startupMs: st.startupMs + startup, hubMs: st.hubMs + (performance.now() - callStarted), maxStartupMs: Math.max(st.maxStartupMs, startup) });
-        };
+        const tally = (peer: PeerId) => tallyHook(peer, callStarted, msg.startedMs);
         try {
           const peer = c.peer;
           if (definitionOf(peer)?.start.daemonPort === "claude-implementer") {
@@ -10539,10 +11476,7 @@ export async function startDaemon(opts: DaemonOptions) {
                 event({ type: "native_turn_end", peer, id });
                 try { if (runs.get(peer)) { runs.signalled(peer); settleCheck(peer); } } catch { log(`completion settle for ${peer} failed`); } // #1054: the verified native Stop
               }
-              turnEnded.set(peer, Date.now()); tasks.cohorts.turnEnded(peer); tally(peer);
-              const st = hookStats.get(peer)!;
-              event({ type: "hook_stats", peer, n: st.n, startupMs: Math.round(st.startupMs), hubMs: Math.round(st.hubMs), maxStartupMs: Math.round(st.maxStartupMs) });
-              hookStats.delete(peer);
+              turnEnded.set(peer, Date.now()); tasks.cohorts.turnEnded(peer); tally(peer); emitHookStats(peer);
               if (id && nativePeer) nativePeer.nativeStopped(sessionId!);
               if (factsOn()) { factSession(peer, sessionId); readbacks(peer, claudeTranscript(sessionId, msg.transcriptPath, peer)); }
             };
@@ -10937,7 +11871,7 @@ export async function startDaemon(opts: DaemonOptions) {
       case "ui_snapshot":
         if (c.role !== "console") return void reply({ ok: false, error: "ui_snapshot is a console command" });
         if (!Number.isSafeInteger(msg.after ?? 0) || (msg.after ?? 0) < 0) return void reply({ ok: false, error: "invalid cursor" });
-        void uiMemorySnapshot(msg.after ?? 0, msg.memory !== undefined || msg.reviewRefresh === true || dashboardView(msg.view) ? { ...(msg.memory !== undefined ? { memory: msg.memory } : {}), ...(msg.reviewRefresh === true && msg.reviewTask !== undefined ? { reviewTask: msg.reviewTask, reviewRefresh: true } : {}), ...(dashboardView(msg.view) ? { view: msg.view } : {}) } : undefined).then(value => reply(value), () => reply({ ok: false, error: "memory view unavailable" }));
+        void uiMemorySnapshot(msg.after ?? 0, msg.memory !== undefined || msg.reviewRefresh === true || dashboardView(msg.view) || msg.visual !== undefined || msg.visualTask !== undefined || msg.visualAsset !== undefined ? { ...(msg.visual !== undefined ? { visual: msg.visual } : {}), ...(msg.visualTask !== undefined ? { visualTask: msg.visualTask } : {}), ...(msg.visualAsset !== undefined ? { visualAsset: msg.visualAsset } : {}), ...(msg.memory !== undefined ? { memory: msg.memory } : {}), ...(msg.reviewRefresh === true && msg.reviewTask !== undefined ? { reviewTask: msg.reviewTask, reviewRefresh: true } : {}), ...(dashboardView(msg.view) ? { view: msg.view } : {}) } : undefined).then(value => reply(value), () => reply({ ok: false, error: "memory view unavailable" }));
         return;
       case "ui_action":
         if (c.role !== "console") return void reply({ ok: false, error: "ui_action is a console command" });
@@ -10956,6 +11890,9 @@ export async function startDaemon(opts: DaemonOptions) {
         if (c.role !== "console") return void reply({ ok: false, error: "autonomy is a person-only command; run ahub autonomy in a person's terminal" });
         void autonomyCommand(msg.action, msg.environment, msg.confirmed, msg.confirmation).then(reply, () => reply({ ok: false, error: "project autonomy could not be changed" }));
         return;
+      case "model":
+        if (c.role !== "console") return void reply(modelFailure("model overrides are person-only; run ahub model in a person's terminal"));
+        return void reply(modelCommandSafe(msg, { source: "cli", scope: c, current: () => c.authed === true && !c.closed && c.role === "console" && sock.readyState === WebSocket.OPEN }));
       case "settings_get":
         if (c.role !== "console") {
           try { const current = publicReadCurrent(sock); current(); const view = publicSettingsView(); current(); return void reply({ ok: true, ...view }); }
@@ -11058,7 +11995,7 @@ export async function startDaemon(opts: DaemonOptions) {
         // #601: ahub study is the person's. A tools connection (any agent) may use the hub_study_* tools, never these op names, whatever Tasks would answer.
         if (String(msg.op).startsWith("study_") && c.role !== "console") return void reply({ t: "task", ok: false, error: "ahub study draft, revise, approve and close are console commands; agents use the hub_study_* tools" });
         if (c.toolsOwner && !IMPLEMENTER_HUB_TOOL_NAMES.includes(String(msg.op))) return void reply({ t: "task", ok: false, error: "tool is not available to this Claude implementer child" });
-        if (recoveryActive() && recoveryPhase !== "preparing" && String(msg.op) !== "hub_checkpoint") return void reply({ t: "task", ok: false, error: "recovery is holding mutations" });
+        if (recoveryActive() && recoveryPhase !== "preparing" && String(msg.op) !== "hub_checkpoint") return void reply({ t: "task", ok: false, error: msg.op === "hub_visual" || msg.op === "hub_visual_show" ? visualOperational("recovery").message : "recovery is holding mutations" });
         if (c.role === "tools" && c.peer && Object.hasOwn(CONDUCTOR_TASK_OPS, String(msg.op))) {
           // #933: a console task op the conductor may run: admitted (role recheck and one audit row) before Tasks sees it; Tasks asks `operational` again.
           let current: () => void;
@@ -11322,6 +12259,7 @@ export async function startDaemon(opts: DaemonOptions) {
   }
   async function stopOnce(): Promise<void> {
     stopping = true;
+    kimiUsage.stop();
     controlWriteTelemetry?.stop();
     const roomsStopped = roomCommands.stop().catch(() => { log("room shutdown failed; inspect ahub room status after restart"); });
     tasks.stopQueuePressureRechecks();
@@ -11385,9 +12323,12 @@ export async function startDaemon(opts: DaemonOptions) {
       executionBudget.close();
       syncStop.abort(); // a sync in flight kills its git step and ends before the store closes
       await syncRun?.catch(() => undefined);
+      for (const peer of recordFrames.keys()) closeRecordFrame(peer); recordInputs.clear(); generatedRecordNotes.clear();
       memory.close();
       candidates?.close();
       memoryStore?.close();
+      modelPreviews.clear(); modelOverrides.close();
+      visuals.close();
       board.close();
       turnLog?.close();
       server.stop(true);
@@ -11429,6 +12370,7 @@ export async function startDaemon(opts: DaemonOptions) {
   // #1054: a run a restart cut short settles `interrupted`, once. Every process of the earlier run is gone by now, and the unique run turn makes repeated restarts yield one completion.
   reconstructRuns();
   ready = true;
+  startupTimings.mark("ready");
   controlWriteTelemetry?.start();
   void handoffCatchUp();
   // #733: the periodic catch-up and the descriptor watch. Unref'd, cleared with the other intervals at stop; each pass is guarded by `stopping` and never overlaps another.
@@ -11479,6 +12421,8 @@ export async function startDaemon(opts: DaemonOptions) {
   // #843 AC3: at hub start, after the roster and the control socket exist; never awaited, so a slow probe delays no start.
   void sweepAgentDrift();
   // #515b: the loopback ports of the two egress proxies, for a host-only test that connects to the proxy this daemon actually started. Ports only: no list, no authority.
+  startupTimings.mark("post_ready");
+  log(startupTimings.finish());
   return { bus, token, port: server.port as number, egressPorts: () => ({ bash: egress?.port, web: webEgress?.port }), bandEvaluations: () => bandEvaluations, sdlcFileReads: () => sdlcFileReads, stop, stopped: new Promise<void>((r) => (onStop = r)) };
   } finally {
     if (!ready) for (const cleanup of startupCleanup.reverse()) { try { await cleanup(); } catch { /* preserve startup error */ } }