Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
fix(capture): a Remote Control session is saved as the owner's, not agent-launched
garrytan4049c3403262
diff --git a/docs/architecture/key-files/core-services-1-continued.md b/docs/architecture/key-files/core-services-1-continued.mdindex cb2792afcc..6e5a3a076f 100644--- a/docs/architecture/key-files/core-services-1-continued.md+++ b/docs/architecture/key-files/core-services-1-continued.md@@ -12,7 +12,7 @@ The content-repair judgment tier under `src/core/content-repair/`, then the Retr- `src/core/context/` — Retrieval Reflex (Layer 1). `entity-salience.ts`: pure, zero-LLM, precision-biased `extractCandidates(text)` (capitalized runs + `@handles`, STOPWORDS + soft COMMON_WORDS + sentence-start guard, deterministic, capped; a lowercase weak pass additionally emits `weak: true` candidates — lowercase words ≥3 chars on a separate `MAX_WEAK_CANDIDATES=32` budget that never evicts strong candidates — which downstream may resolve through the alias arm ONLY) + `extractCandidatesFromWindow(turns)` (merges per-turn extraction across the last N turns by normalizeAlias form with occurrence/newest-turn/user-mention metadata; salience-ordered — recency > frequency > user-role — so the cap drops stale assistant chatter first). `retrieval-reflex.ts`: `resolveEntitiesToPointers(engine, sourceId, candidates, opts)` — alias arm (`resolveAliases`, caught per-arm for pre-v110 brains) + exact title/slug-suffix arm (real slugs are namespaced `people/x` but `slugify` drops the prefix) + two lexical identity arms behind `opts.lexicalArms` (kill switch: config `retrieval_reflex_lexical_arms` / env `GBRAIN_RETRIEVAL_REFLEX_LEXICAL_ARMS`, default on): weak lowercase candidates probe the ALIAS arm ONLY (never title/slug-suffix, where ordinary lowercase words would fabricate pointers) and require GLOBAL uniqueness across all sources in play; the surname arm resolves a strong single capitalized token ≥3 chars via a `lower(title) LIKE '% <token>'` predicate on the same query, with exact-arm precedence and ambiguity counted over ALL person rows carrying the surname — ambiguity in either arm injects nothing; pointers carry `source_id`/`arm`/`confidence`/`matchedNorm` (`ARM_CONFIDENCE` alias 0.9 / title 0.8 / title-surname 0.72 (deliberately above the volunteer layer's 0.70 gate, below title) / slug-suffix 0.6 lives next to the arm definitions; arm-2 provenance classified in JS since the combined OR can't report which predicate matched); opts: `sourceIds?` federated scope (alias arm loops per source, arm 2 uses `source_id = ANY`), `suppression?` ('slug-and-title' default; 'slug-only' REQUIRED under windowing — the title rule would suppress every entity merely mentioned in a prior window turn), ambient-channel event logging is DELIVERY-side, not in-resolver — `logDeliveredReflexPointers(engine, pointers)` fires only once a block is actually handed to the consumer (serve's resolve-IPC `onDelivered` hook post-write; `buildReflexAddition` post-timeout on the direct rung), so abandoned/timed-out blocks never pollute the volunteered-vs-used stats; its event write is registered synchronously before return so the CLI background-work drain cannot miss it; synopsis runs through `stripTakesFence`/`stripFactsFence` (the same privacy boundary `get_page` applies) so private facts never reach the prompt; `visibility: private` (and derived-private) pages never resolve on any arm unless the caller passes `excludePrivate: false` (default true, the remote-search predicate `privatePagesFilterFragment`; only `volunteer_context` widens, via `resolveExcludePrivatePages` for a trusted local caller — gbrain-evals N8-1/N8-2, pinned by `test/reflex-private-visibility.test.ts`); capped at `MAX_POINTERS`. `reflex.ts`: the orchestrator + engine-aware resolver ladder (host `resolveEntities` → PGLite serve IPC → Postgres cached process-singleton → disabled), zero-candidate fast path, fail-open + timeout, heartbeat write for the doctor check, `reflexEnabled(cfg)` (file/env gate, default ON; DB-plane does NOT gate — `assemble()` is sync); windowed extraction when `windowTurns` present and `retrieval_reflex_window_turns` (default 4; 1 = single-turn behavior) > 1 — switches suppression to slug-only; accept-side reflex-channel logging fires after the per-turn timeout admits the block (direct-Postgres rung only — IPC logs server-side at delivery; host-injected resolvers are a documented gap). `resolve-ipc.ts`: local unix-socket resolve protocol (client + server) so PGLite resolves through the single connection `gbrain serve` holds (a second opener would hit the exclusive lock; a subprocess would force-steal it past the 5-min staleness window and crash). Wired into both serve transports via `src/mcp/resolve-ipc-binding.ts` (engine-uniform; socket + secret keyed off `hash12(database_url)` under `~/.gbrain/run`, cleaned up on shutdown). A lean read-only Postgres serve binds the `read` socket kind instead (#7612); `hookResolveSocketForConfig` falls back to it after the source socket, and a `delegation: true` caller never targets it. Doctor surface: `retrieval_reflex_health` in `src/commands/doctor/checks/verbs-reflex.ts` (reads the heartbeat for truthful runtime status; categorized in `doctor-categories.ts`) + `volunteer_channels` (engine-aware sibling: groups `context_volunteer_events` by channel over 7 days so operators see which push channels — reflex/op/watch/claude-code/codex — actually fire; info-only; the LOCAL doctor runs it brain-wide while the remote report path threads the caller's source scope, so a source-bound token never sees other sources' activity counts/timestamps; counts are reconciled against the hook heartbeat over the same 7-day window — a mostly-degraded week gets a CAUTION note, since a server-side delivery count isn't proof of injection; quiet-channel guidance is engine-aware — Postgres brains are told the hook lane is quiet by design rather than to chase registration — and walks both quiet classes (installed-but-unregistered vs registered-but-quiet; the check can't inspect registration itself); pre-v117 tolerant, and transient DB errors are reported as such, never as an old schema; pinned by `test/doctor-volunteer-channels.test.ts`). Config: `retrieval_reflex` + `retrieval_reflex_max_pointers` + `retrieval_reflex_window_turns` + `retrieval_reflex_lexical_arms` in `src/core/config.ts` (env `GBRAIN_RETRIEVAL_REFLEX_WINDOW_TURNS`, `GBRAIN_RETRIEVAL_REFLEX_LEXICAL_ARMS`). `volunteer.ts`: `parseWindow` (lenient `user:`/`assistant:` prefixes, unprefixed → one user turn), `volunteerContext` (extract → resolve → +0.05 multi-turn/newest-turn boost → `min_confidence` 0.7 gate → cap 3/5; deterministic rationale strings, never raw conversation text; slug-only suppression), `volunteerUsageStats` (per-arm/channel precision from the `pages.last_retrieved_at > volunteered_at` join — APPROXIMATE: the 5-min last-retrieved throttle causes false negatives, unrelated reads false positives). `volunteer-events.ts`: `insertVolunteerEvents` (ONE multi-row parameterized INSERT), `logVolunteerEventsFireAndForget` + bounded drain registered as the `volunteer-events` background-work sink (order 4), `purgeStaleVolunteerEvents` (90-day GC, called from the dream cycle's purge phase). Policy layer ships as the `retrieval-reflex` recipe (`recipes/retrieval-reflex/`). Pinned by `test/context/entity-salience.test.ts`, `test/retrieval-reflex.test.ts`, `test/retrieval-reflex-pre-v110.test.ts`, `test/context/resolve-ipc.test.ts`, `test/doctor-retrieval-reflex.test.ts`, `test/volunteer-context.test.ts`, `test/e2e/volunteer-context-postgres.test.ts`. Checkpoint-compaction modules in this dir: `corpus-segments.ts` — engine-free content-addressed compaction segments (`<session>.seg-<hash24>.txt`, idempotent by name; parsers accept 12–64 hex), the hash-keyed per-session ledger (atomic tmp+rename, fail-open, entry order = the only ordinal), `sliceBoundaryWindow`/`splitByBoundaries`, the redacted `renderSegmentText` (a segment is NEVER written unscanned — unlike the session-end full write, which degrades-and-writes), exact-set `coverageComplete`/`decideCorpusMode` (count equality can be fooled by a duplicated boundary), the compact-time `bankCompactSegment` step (per-step deadline degrades, segment-then-ledger crash order), the openclaw tail boundary reader (`readOpenclawBoundaryTail`, delegates mapping to the adapter's exported `mapOpenclawLine`; also returns turn-stamped `toolCalls`/`toolCallTurnIndexes` for the Memorable receipt — name-only v1, `input: null` by design until an observation run characterizes OpenClaw's args field), and orphan-sidecar/aged-ledger GC — pinned by `test/corpus-segments.test.ts`. `checkpoint-harvest.ts` — the serve-side prompt harvest of a segment: bounded FIFO (cap 8, 60s abort), sweep-shared claim fencing, capability-then-kill-switch gates, `signal.aborted` POST-check (the pipeline returns partials on abort; an aborted run writes nothing and stays retryable), receipt sidecar before idempotent manifest publish (source-scoped `getPage` verification — a link that resolves to nothing is never banked), `.ingested` last, explicit `shutdownCheckpointHarvest()` called by serve BEFORE `engine.disconnect()` (the background-work drain is CLI-exit-only by contract), a writeback turn whose facts preflight finds the canonical writer busy (`writer_lock_unavailable`, before any model call) re-queued after 5, 15 and 45 s (`writer_busy_requeued`; the retry skips admission, a pending retry dedups a re-schedule as `already_queued`, shutdown clears pending retries) while a compact segment's busy refusal stays an error the sweep resumes, and error reasons that keep the error's code or `reason` within the 48-char reason-code shape (`operationerror:writer_lock_unavailable`), the first failure of each reason logged to stderr once per serve run — pinned by `test/checkpoint-harvest.serial.test.ts`. `hook-heartbeat.ts` — the hooks telemetry JSONL extracted from hook.ts (hook.ts re-exports; serve-side writers never import the command module); allowlist carries the checkpoint `segment`/`inserted`/`duplicate`/`links` count-only fields. `session-state.ts` also carries the v132 `checkpoint_manifest` helpers (`getCheckpointManifest`/`appendCheckpointManifest`: newest-first, dedup-by-slug, cap 20, seg-hash completion key, fail-open on pre-v132 schema) — pinned by `test/checkpoint-manifest.test.ts`. `sensitivity-scan.ts` + `compile-view.ts` — the compile-context stack: composed detector (secret-scan + ordered `PII_PATTERNS` + path/blocklist families + operator pattern file; uniform `.gbrain-scan-allow` fingerprint escape hatch; CONTENT hits drop an entry, CONFIG/loader failures THROW so the caller aborts without writing) and the deterministic compiled-view builder (recency decay anchored to the newest candidate `updated_at`, never wall-clock; total-order (score desc, slug asc); source-scoped listPages/getPage reads that skip op-layer write-backs and pass `excludePrivate: true` on every arm, so private pages never reach the compiled file; whole-file `packToBudget` math that never passes a <=0 budget) — pinned by `test/sensitivity-scan.test.ts` + `test/compile-view.test.ts` + `test/e2e/compile-context-pglite.test.ts`; the CLI shell is `src/commands/compile-context.ts` (targets claude-code|codex|openclaw, AGENTS.md managed-marker splice that throws on damaged markers, atomic writes, `--check` recompile-and-compare exit codes; the guide is `docs/guides/checkpoint-compaction.md`). It also owns the whole Memorable seam's engine-free plumbing: the session-receipt JSONL (`session-receipts.jsonl`, `appendSessionReceipt` — dedup by post-redaction `content_hash` so a resumed session neither duplicates its receipt nor re-fires the relay; tail-rewrite compaction triggered by the 32 MB byte ceiling alone — the read fires exactly when the pass will act, with the 2000-line budget enforced inside the pass — and a `skipCompaction` seam the openclaw compact() lane sets unconditionally: the hook lane is the ONE receipts compactor, so two processes can never race the read-filter-rename rewrite); ONE bounded adaptive `readJsonlTail` reader shared by `lastReceiptMatches`, `lastRelayResult` and `readSessionReceiptsTail` (a receipt line can exceed the 1 MB window — the window doubles rather than reading "empty"); `maybeTrimRelayResults` (BOTH capture lanes trim the child-appended `memorable-relay.jsonl` — an openclaw-only host has no hook lane, and converging newest-keeping trims make concurrent trims safe: mtime-stale preferred, hard 8 MB force backstop, line-boundary cut keeping the newest lines — the child appends open-by-path, so the residual loss window is one in-flight write); the CONSENT STAMP (`memorable-consent.json`, 0600, written ONLY by config-set's disclosure flow — deliberately outside config.json, which the external CLI full-file-rewrites; scope-bound to the disclosure sha256 + `MEMORABLE_CAPTURE_HARNESSES`, so widening the capture surface invalidates old stamps); `memorableGateAllowed(cfg)` ({allowed, reason: kill_switch|disabled|disclosure_missing} — one reason vocabulary for hook, context-engine and doctor); `memorableConsentEvidence()` (the CLI-side opt-in read fail-closed from ~/.memorable/config.json, dated provisional spec note, GBRAIN_MEMORABLE_CONFIG test seam); `redactedToolCallsJson` (the security-load-bearing span-filter + highEntropy redaction, ONE implementation for both capture lanes; string LEAVES are redacted raw before serialization — scanning the serialized JSON would let quoted secrets through via \" escaping — with a post-serialization re-scan as belt-and-braces); `recordAndRelayReceipt` (per-receipt harness scope-binding first — a harness outside `MEMORABLE_CAPTURE_HARNESSES` is refused with `memorable_harness_undisclosed` → receipt → prior-run outcome surfacing with the child's reason clamped via the shared `clampRelayCause` (32 chars, so the 16-char prefix keeps composites inside the 48-char reason bound) and appended LAST → consent evidence → `resolveMemorableBin` → detached spawn; never throws; `spawnFn` test seam); and `priorRelayFailure`, which surfaces the PREVIOUS relay run's self-reported exit status so a relay that records nothing is never reported healthy. `resolveMemorableBin` does the pre-spawn PATH/`MEMORABLE_BIN` resolution so a missing CLI is a named heartbeat reason rather than a silent async ENOENT. #6195: `entity-salience.extractCandidates` also emits lowercase 2-3-word weak n-grams (`multiToken`, own budget `MAX_WEAK_NGRAM_CANDIDATES` = 16, never across punctuation, never all stopwords/common words) that ride the exact weak-alias fold, and `retrieval-reflex` arm 2.6 (`weak-title`, 0.72, behind `lexicalArms`, private pages hidden by default) matches them to the exact title of a person/company/organization page whose title is globally unique; single lowercase words stay alias-only.- `src/core/context/hook-heartbeat.ts` — the hooks telemetry plane under `<gbrain home>/integrations/hooks/` (`heartbeat.jsonl`, `status.json`, session receipts, the memorable relay log; directories 0700, appends 0600). Entries hold counters, durations and codes only: `HEARTBEAT_ALLOWED_KEYS` is the full key allowlist CI greps the fixture against, and includes `pattern` (scanner pattern name), `fingerprint` (`sha256:<16 hex>`) and `hint` (fixed text) for refusals. `near_duplicate` is the shadow count on the `writeback_dedup` event that `facts/capture-dedup.ts` appends (lane in `reason`, exact drops in `duplicate`). `relayRefusalHeartbeat(hit)` builds the line `context-engine.ts` writes when its high-entropy re-scan refuses a memorable relay (`event: relay`, `outcome: degraded`, `reason: secret_scan_refused`); the receipt and relay are skipped for that compaction window and the checkpoint is kept. `memorableGateAllowed` gates the relay lane; span redaction runs `redactFindings` with `highEntropy: true`. Tests: `test/context-engine-checkpoint.serial.test.ts`.- `src/core/context/seat.ts` — seat identity for captured sessions (#4618), engine-free. `resolveSeat` returns the lowercased `GBRAIN_SEAT` label when it matches `SEAT_LABEL_RE` (`^[a-z0-9][a-z0-9._-]{0,63}$`), else `home-<8 hex>` over the realpath of the harness home (Claude Code: the directory holding `projects/` in the transcript path, then `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `~/.claude`; codex: `CODEX_HOME` or `~/.codex`; OpenClaw: the agent directory holding `sessions/`), so no raw path reaches frontmatter; `GBRAIN_SEAT=off` (the opt-out) resolves to null and nothing is recorded. `writeSeatSidecar` writes `<sessionId>.seat.json` (`{version: 1, seat, seat_source, hook_lane, harness, first_seen}`, 0600, tmp+rename) unless one exists, reporting `seat_conflict` when the existing seat differs; `readSeatSidecar` accepts only a valid v1 record. `SEAT_REASON_HINTS` holds the fixed heartbeat hints. The sidecar name and its GC live in `corpus-segments.ts` (`seatFileName`, `SEAT_SIDECAR_SUFFIX`).-- `src/core/context/session-speaker.ts` — who wrote a captured session's user turns (#8064), engine-free. `resolveSessionSpeaker` reads `GBRAIN_SESSION_AGENT` (a label: agent; `off`: skip banking; `owner`: no detection; invalid: agent `agent`), else `detectAgentLaunched` over `readProcessAncestry` (Linux /proc, else `ps`; 12 levels, 300 ms): the nearest claude/codex process runs headless (`-p`/`--print`, `exec`) and another claude/codex process is an ancestor, principal `agent-launched`. `bankAsSpeaker` writes `<sessionId>.speaker.json` (`{version: 1, principal, source, harness, first_seen}`, 0600, first write wins) before the hook's compact, stop and session-end banking; a write failure banks nothing (`speaker_write_failed`), `off` records `capture_opt_out`. `corpusFileSpeaker`/`speakerOf` give the capture lanes (checkpoint-harvest, sweep) the `speaker` they pass to `runFactsPipeline`, which saves user and unattributed claims as `other` (`asAgentSpoken`), adds `speakerContextNote` to the context (`facts/speaker-context.ts`, also used by the managed facts batch) and names the agent in the extractor prompt. Name and GC: `speakerFileName`, `SPEAKER_SIDECAR_SUFFIX` in `corpus-segments.ts`. Pinned by `test/agent-session-speaker-8064.serial.test.ts`.+- `src/core/context/session-speaker.ts` — who wrote a captured session's user turns (#8064), engine-free. `resolveSessionSpeaker` reads `GBRAIN_SESSION_AGENT` (a label: agent; `off`: skip banking; `owner`: no detection; invalid: agent `agent`), else `detectAgentLaunched` over `readProcessAncestry` (Linux /proc, else `ps`; 12 levels, 300 ms): the nearest claude/codex process runs headless (`-p`/`--print`, `exec`) and another claude/codex process is an ancestor, principal `agent-launched`; #8080: when that next harness ancestor is a `claude remote-control` server (subcommand `remote-control`/`rc`/`remote`/`sync`/`bridge` right after the binary or node entry script) and the session carries the bridge's `--sdk-url`, the session is the owner's. `bankAsSpeaker` writes `<sessionId>.speaker.json` (`{version: 1, principal, source, harness, first_seen}`, 0600, first write wins) before the hook's compact, stop and session-end banking; a write failure banks nothing (`speaker_write_failed`), `off` records `capture_opt_out`. `corpusFileSpeaker`/`speakerOf` give the capture lanes (checkpoint-harvest, sweep) the `speaker` they pass to `runFactsPipeline`, which saves user and unattributed claims as `other` (`asAgentSpoken`), adds `speakerContextNote` to the context (`facts/speaker-context.ts`, also used by the managed facts batch) and names the agent in the extractor prompt. Name and GC: `speakerFileName`, `SPEAKER_SIDECAR_SUFFIX` in `corpus-segments.ts`. Pinned by `test/agent-session-speaker-8064.serial.test.ts`.- `src/core/context/ipc-path.ts` — engine-free local socket discovery and private Unix fallback when the complete role-specific address exceeds 103 UTF8 bytes. Hashes the physical parent plus basename under a fixed OS temporary root, verifies ownership/0700 directory/0600 client socket without following fallback symlinks, and retains a native binding claim through actual server close. Existing Unix socket accessibility is rechecked even when a runtime reports ENOENT; permission/resource probe failures never authorize stale takeover; on Windows a PGLite data-dir socket (`.gbrain-<kind>.sock`) over afunix's 107 UTF-8 bytes moves to `%USERPROFILE%\.gbrain\run\<kind>-<hash12(canonical data dir, case-folded)>.sock` (`windowsLocalIpcSocketPath`, the Postgres run-dir scheme; the secret stays in the data dir), and `localIpcPathTooLong` reports a resolved path still over the platform budget, which `ipc-path-too-long.ts` turns into the typed `ipc_path_too_long` serve log line and doctor `ipc_socket_path` warning (#6573; `test/ipc-path-windows-fallback-6573.test.ts` on every OS, the native bind and 20-cycle stability probe in `test/windows-ipc-long-path-6573.serial.test.ts` on windows-latest); Windows named pipes retain a native Global mutex through actual close; `windows-ipc.ts` normalizes namespace prefixes while native Windows Unicode casing defines the mutex identity. `test/local-ipc-path.test.ts` covers concurrent real processes, SIGKILL recovery, active-connection shutdown, aliases and unsafe paths. The published CLI smoke also uses a long Unicode datastore path.- `src/core/entities/near-name.ts` — Flag-only near-name matcher for #2942 (never merges, never writes `entity_identities`; `entity-identity.ts` stays manual-only). `classifyNearName` returns `same` (normalized-equal after corporate suffixes, or a strong `name-variants.ts` shape), `typo` (Damerau distance 1 on 3–64 normalized characters) or `acronym` (one word equals a multi-word name's initials, at most one letter different). Candidates come from symmetric one-deletion keys plus initials keys, so recall is complete for those kinds; past `NEAR_NAME_MAX_KEYS_PER_SHARD` the index splits into shards by key hash (a pair shares a key, so it lands whole in one shard). `loadEntityNames` reads one source's fact-entity pages plus the source pack's linkable types, leaving out private pages for callers that exclude them. Pinned by `test/review-lists.test.ts`.diff --git a/docs/guides/ambient-writeback.md b/docs/guides/ambient-writeback.mdindex 0f704298bf..375b1f9e34 100644--- a/docs/guides/ambient-writeback.md+++ b/docs/guides/ambient-writeback.md@@ -310,7 +310,9 @@ GBRAIN_SESSION_AGENT=fleet-worker claude -p "$(render-brief task-42)"as agent-launched when its harness process runs headless (`claude -p` or`--print`, `codex exec`) and another `claude` or `codex` process is one ofits ancestors. Its claims are saved as agent `agent-launched`'s. A headless-session you start yourself from a terminal is still yours. Detection reads the+session you start yourself from a terminal is still yours, and so is a session+a `claude remote-control` server hosts for you (a worker that session launches+is still agent-launched). Detection reads theprocess table and can miss a launcher that detaches its workers, and it neverfires for a launcher that is not itself claude or codex (a cron job, a scriptor a daemon running `claude -p`). For those the variable is the only signal,diff --git a/src/core/context/session-speaker.ts b/src/core/context/session-speaker.tsindex 1c6b7fbc1d..a52bf5f463 100644--- a/src/core/context/session-speaker.ts+++ b/src/core/context/session-speaker.ts@@ -17,7 +17,8 @@* Unset: detection (`detectAgentLaunched`) — a headless harness process* (claude `-p`/`--print`, codex `exec`) with a claude or codex process* among its ancestors. Headless alone is not enough: the owner scripting- * `claude -p` is still the owner.+ * `claude -p` is still the owner. A `claude remote-control` server is not such+ * an ancestor: each session it hosts is headless but typed by the owner.** Sidecar `<sessionId>.speaker.json` (0600, tmp+rename) beside the corpus* files, written BEFORE any corpus file of the session; the first record is@@ -73,16 +74,29 @@ function headless(harness: 'claude' | 'codex', args: readonly string[]): booleanreturn args.slice(1).some((a) => a === 'exec' || a === 'e');}+/** `claude remote-control` and its aliases, read only right after the native binary or the node entry script. */+const REMOTE_CONTROL_SUBCOMMANDS = new Set(['remote-control', 'rc', 'remote', 'sync', 'bridge']);++function remoteControlHost(args: readonly string[]): boolean {+ if (harnessOfArgs(args) !== 'claude') return false;+ const entry = harnessOfArgs(args.slice(0, 1)) === 'claude' ? 0 : 1;+ return REMOTE_CONTROL_SUBCOMMANDS.has(args[entry + 1] ?? '');+}+/*** True when the nearest harness process in `ancestry` (nearest first) runs- * headless and another claude or codex process sits above it.+ * headless and another claude or codex process sits above it, unless that+ * process is a `claude remote-control` server hosting it (`--sdk-url`).*/export function detectAgentLaunched(ancestry: readonly AncestorProcess[]): boolean {const at = ancestry.findIndex((p) => harnessOfArgs(p.args) !== null);if (at < 0) return false;const harness = harnessOfArgs(ancestry[at].args)!;if (!headless(harness, ancestry[at].args)) return false;- return ancestry.slice(at + 1).some((p) => harnessOfArgs(p.args) !== null);+ const launcher = ancestry.slice(at + 1).find((p) => harnessOfArgs(p.args) !== null);+ if (!launcher) return false;+ const hosted = ancestry[at].args.some((a) => a === '--sdk-url' || a.startsWith('--sdk-url='));+ return !(hosted && remoteControlHost(launcher.args));}function linuxParent(pid: number): AncestorProcess & { ppid: number } | null {diff --git a/test/agent-session-speaker-8064.serial.test.ts b/test/agent-session-speaker-8064.serial.test.tsindex 59819c5ac7..1f9f0f23d7 100644--- a/test/agent-session-speaker-8064.serial.test.ts+++ b/test/agent-session-speaker-8064.serial.test.ts@@ -84,6 +84,23 @@ describe('resolveSessionSpeaker', () => {.toEqual({ kind: 'agent', principal: 'agent-launched', source: 'detected' });expect(resolveSessionSpeaker({ env: {}, ancestry: () => [WORKER] })).toEqual({ kind: 'owner' });});++ test('#8080: a Remote Control session is the owner\'s; a worker it launches is still an agent\'s', () => {+ const session: AncestorProcess = { pid: 30, args: ['/usr/local/bin/claude', '--print', '--sdk-url', 'https://api.example.com/sessions/s1', '--input-format', 'stream-json'] };+ for (const sub of ['remote-control', 'rc', 'remote', 'sync', 'bridge']) {+ expect(detectAgentLaunched([session, { pid: 31, args: ['/usr/local/bin/claude', sub, '--spawn=worktree'] }])).toBe(false);+ }+ const nodeHost: AncestorProcess = { pid: 32, args: ['node', '/x/node_modules/@anthropic-ai/claude-code/cli.js', 'remote-control'] };+ expect(detectAgentLaunched([session, nodeHost])).toBe(false);+ expect(resolveSessionSpeaker({ env: {}, ancestry: () => [session, nodeHost] })).toEqual({ kind: 'owner' });+ expect(detectAgentLaunched([WORKER, SHELL, session, nodeHost])).toBe(true);+ expect(detectAgentLaunched([{ pid: 4, args: ['/opt/codex', 'exec', 'task'] }, session, nodeHost])).toBe(true);+ expect(detectAgentLaunched([WORKER, { pid: 33, args: ['/usr/local/bin/claude', '--remote-control'] }])).toBe(true);+ expect(detectAgentLaunched([WORKER, { pid: 34, args: ['/usr/local/bin/claude', '--verbose', 'remote-control'] }])).toBe(true);+ expect(detectAgentLaunched([WORKER, { pid: 35, args: ['/usr/local/bin/claude', '-p', 'remote-control'] }])).toBe(true);+ expect(detectAgentLaunched([WORKER, { pid: 36, args: ['/opt/codex', 'remote-control'] }])).toBe(true);+ expect(detectAgentLaunched([WORKER, { pid: 37, args: ['/usr/local/bin/claude', 'sync'] }])).toBe(true);+ });});describe('hook banking with a session speaker', () => {