A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
scope client env to sessions so herdr extensions see the right pane (#303)
ktf4cfde0c768d
diff --git a/packages/coding-agent/src/core/agent-session-runtime.ts b/packages/coding-agent/src/core/agent-session-runtime.tsindex 9822e4f28b..3fe935a5d3 100644--- a/packages/coding-agent/src/core/agent-session-runtime.ts+++ b/packages/coding-agent/src/core/agent-session-runtime.ts@@ -87,6 +87,7 @@ function extractUserMessageText(content: string | Array<{ type: string; text?: s*/export class AgentSessionRuntime implements SubagentRuntimeHost {private rebindSession?: (session: AgentSession) => Promise<void>;+ private runtimeEnvScope?: <T>(fn: () => Promise<T>) => Promise<T>;private beforeSessionInvalidate?: () => void;private subagentRuntimeHost?: SubagentRuntimeHost;private subagentRuntimes = new Map<string, AgentSessionRuntime>();@@ -142,6 +143,19 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {this.rebindSession = rebindSession;}+ /**+ * Host-installed scope wrapping every runtime rebuild (new/switch/fork/+ * import and subagent creation), during which extensions re-load. The+ * daemon uses it to apply the session's client env for load-time captures.+ */+ setRuntimeEnvScope(scope?: <T>(fn: () => Promise<T>) => Promise<T>): void {+ this.runtimeEnvScope = scope;+ }++ private scopedBuild<T>(fn: () => Promise<T>): Promise<T> {+ return this.runtimeEnvScope ? this.runtimeEnvScope(fn) : fn();+ }+setSubagentRuntimeHost(host?: SubagentRuntimeHost): void {this.subagentRuntimeHost = host;this.bindRuntimeHost();@@ -260,37 +274,39 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {if (options.parentSession.sessionFile) {sessionManager.newSession({ parentSession: options.parentSession.sessionFile });}- const runtime = await createAgentSessionRuntime(this.createRuntime, {- cwd: sessionManager.getCwd(),- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "startup" },- sessionConfig: this.sessionConfig,- sessionOptions: {- model: options.model,- thinkingLevel: options.thinkingLevel,- scopedModels: options.scopedModels,- initialActiveToolNames: options.activeToolNames,- allowedToolNames: options.allowedToolNames,- customTools: options.customTools,- includeGoals: options.includeGoals,- rlmDepth: options.rlmDepth,- rlmMaxDepth: options.rlmMaxDepth,- rlmSessionDir: options.sessionDir,- rlmParentNodeId: options.rlmParentNodeId,- },- runtimeMetadata: {- kind: "subagent",- createdAt: Date.now(),- parentSessionId: options.parentSession.sessionId,- parentSessionFile: options.parentSession.sessionFile,- rlmChildId: options.id,- rlmParentNodeId: options.rlmParentNodeId,- prompt: options.prompt,- spawnCode: options.spawnCode,- sessionDir: options.sessionDir,- },- });+ const runtime = await this.scopedBuild(() =>+ createAgentSessionRuntime(this.createRuntime, {+ cwd: sessionManager.getCwd(),+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "startup" },+ sessionConfig: this.sessionConfig,+ sessionOptions: {+ model: options.model,+ thinkingLevel: options.thinkingLevel,+ scopedModels: options.scopedModels,+ initialActiveToolNames: options.activeToolNames,+ allowedToolNames: options.allowedToolNames,+ customTools: options.customTools,+ includeGoals: options.includeGoals,+ rlmDepth: options.rlmDepth,+ rlmMaxDepth: options.rlmMaxDepth,+ rlmSessionDir: options.sessionDir,+ rlmParentNodeId: options.rlmParentNodeId,+ },+ runtimeMetadata: {+ kind: "subagent",+ createdAt: Date.now(),+ parentSessionId: options.parentSession.sessionId,+ parentSessionFile: options.parentSession.sessionFile,+ rlmChildId: options.id,+ rlmParentNodeId: options.rlmParentNodeId,+ prompt: options.prompt,+ spawnCode: options.spawnCode,+ sessionDir: options.sessionDir,+ },+ }),+ );this.subagentRuntimes.set(options.id, runtime);try {await runtime.session.bindExtensions({});@@ -352,13 +368,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {assertSessionCwdExists(sessionManager, this.cwd);await this.teardownCurrent("resume", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: sessionManager.getCwd(),- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: sessionManager.getCwd(),+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);await this.finishSessionReplacement(options?.withSession);return { cancelled: false };@@ -383,13 +401,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {await this.teardownCurrent("new", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: this.cwd,- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "new", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: this.cwd,+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "new", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);if (options?.setup) {await options.setup(this.session.sessionManager);@@ -438,13 +458,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {sessionManager.newSession({ parentSession: currentSessionFile });await this.teardownCurrent("fork", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: this.cwd,- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: this.cwd,+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);await this.finishSessionReplacement(options?.withSession);return { cancelled: false, selectedText };@@ -458,13 +480,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {const sessionManager = SessionManager.open(forkedSessionPath, sessionDir);await this.teardownCurrent("fork", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: sessionManager.getCwd(),- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: sessionManager.getCwd(),+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);await this.finishSessionReplacement(options?.withSession);return { cancelled: false, selectedText };@@ -478,13 +502,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {}await this.teardownCurrent("fork", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: this.cwd,- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: this.cwd,+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);await this.finishSessionReplacement(options?.withSession);return { cancelled: false, selectedText };@@ -523,13 +549,15 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {assertSessionCwdExists(sessionManager, this.cwd);await this.teardownCurrent("resume", sessionManager.getSessionFile());this.apply(- await this.createRuntime({- cwd: sessionManager.getCwd(),- agentDir: this.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile },- sessionConfig: this.sessionConfig,- }),+ await this.scopedBuild(() =>+ this.createRuntime({+ cwd: sessionManager.getCwd(),+ agentDir: this.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile },+ sessionConfig: this.sessionConfig,+ }),+ ),);await this.finishSessionReplacement();return { cancelled: false };diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.tsindex 2ebb6b444e..18f72d9899 100644--- a/packages/coding-agent/src/core/agent-session.ts+++ b/packages/coding-agent/src/core/agent-session.ts@@ -596,6 +596,7 @@ export class AgentSession {// Extension systemprivate _extensionRunner!: ExtensionRunner;+ private _execEnvProvider?: () => Record<string, string | undefined> | undefined;private _turnIndex = 0;private _resourceLoader: ResourceLoader;@@ -4213,6 +4214,17 @@ export class AgentSession {return this.settingsManager.getCompactionEnabled();}+ /**+ * Set the provider for extra env vars merged over process.env in extension+ * pi.exec() subprocesses. The function is read at exec time, so a host (e.g.+ * the daemon) can update the underlying value per attach without rebinding.+ */+ setExecEnvProvider(provider: (() => Record<string, string | undefined> | undefined) | undefined): void {+ this._execEnvProvider = provider;+ const extensions = this._resourceLoader.getExtensions();+ extensions.runtime.getExecEnv = provider;+ }+async bindExtensions(bindings: ExtensionBindings): Promise<void> {if (bindings.uiContext !== undefined) {this._extensionUIContext = bindings.uiContext;@@ -4561,6 +4573,12 @@ export class AgentSession {extensionsResult.runtime.flagValues.set(name, value);}}+ // Re-apply on (re)build so the provider survives /reload. Guarded: the+ // runtime object can be shared across sessions from one ResourceLoader+ // (RLM children), so a provider-less session must not wipe the owner's.+ if (this._execEnvProvider) {+ extensionsResult.runtime.getExecEnv = this._execEnvProvider;+ }this._extensionRunner = new ExtensionRunner(extensionsResult.extensions,diff --git a/packages/coding-agent/src/core/exec.ts b/packages/coding-agent/src/core/exec.tsindex 40f0453df7..a96ded7b20 100644--- a/packages/coding-agent/src/core/exec.ts+++ b/packages/coding-agent/src/core/exec.ts@@ -15,6 +15,11 @@ export interface ExecOptions {timeout?: number;/** Working directory */cwd?: string;+ /**+ * Extra env vars merged over the parent process env for this command.+ * A key with an undefined value is unset in the child.+ */+ env?: Record<string, string | undefined>;}/**@@ -27,6 +32,21 @@ export interface ExecResult {killed: boolean;}+function mergeExecEnv(env?: Record<string, string | undefined>): NodeJS.ProcessEnv | undefined {+ if (!env) {+ return undefined;+ }+ const merged: NodeJS.ProcessEnv = { ...process.env };+ for (const [key, value] of Object.entries(env)) {+ if (value === undefined) {+ delete merged[key];+ } else {+ merged[key] = value;+ }+ }+ return merged;+}+/*** Execute a shell command and return stdout/stderr/code.* Supports timeout and abort signal.@@ -42,6 +62,9 @@ export async function execCommand(cwd,shell: false,stdio: ["ignore", "pipe", "pipe"],+ // Merge per-call env over the parent env so callers can scope vars+ // (e.g. herdr pane identity) without mutating the shared process.env.+ env: mergeExecEnv(options?.env),});let stdout = "";diff --git a/packages/coding-agent/src/core/extensions/loader.ts b/packages/coding-agent/src/core/extensions/loader.tsindex 4f107bac85..d974d5c79d 100644--- a/packages/coding-agent/src/core/extensions/loader.ts+++ b/packages/coding-agent/src/core/extensions/loader.ts@@ -265,7 +265,11 @@ function createExtensionAPI(exec(command: string, args: string[], options?: ExecOptions) {runtime.assertActive();- return execCommand(command, args, options?.cwd ?? cwd, options);+ // Read the host-supplied env at call time so per-session vars (e.g.+ // herdr pane identity) are current, then let an explicit options.env win.+ const sessionEnv = runtime.getExecEnv?.();+ const env = sessionEnv || options?.env ? { ...sessionEnv, ...options?.env } : undefined;+ return execCommand(command, args, options?.cwd ?? cwd, { ...options, env });},getActiveTools(): string[] {diff --git a/packages/coding-agent/src/core/extensions/types.ts b/packages/coding-agent/src/core/extensions/types.tsindex 81d6c34f4a..f1c2dff968 100644--- a/packages/coding-agent/src/core/extensions/types.ts+++ b/packages/coding-agent/src/core/extensions/types.ts@@ -1376,6 +1376,14 @@ export type SetLabelHandler = (entryId: string, label: string | undefined) => vo*/export interface ExtensionRuntimeState {flagValues: Map<string, boolean | string>;+ /**+ * Extra env vars merged over process.env for pi.exec() subprocesses (an+ * undefined value unsets the key in the child). Read at call time (not load+ * time) so a host can scope per-session vars — e.g. the daemon supplying+ * each session's herdr pane identity — without mutating the shared+ * process.env. Returns undefined to use the parent env unchanged.+ */+ getExecEnv?: () => Record<string, string | undefined> | undefined;/** Provider registrations queued during extension loading, processed when runner binds */pendingProviderRegistrations: Array<{ name: string; config: ProviderConfig; extensionPath: string }>;/** Throws when this extension instance is stale after runtime replacement. */diff --git a/packages/coding-agent/src/main.ts b/packages/coding-agent/src/main.tsindex 83689093cf..6b5c401128 100644--- a/packages/coding-agent/src/main.ts+++ b/packages/coding-agent/src/main.ts@@ -54,6 +54,7 @@ import { SessionManager } from "./core/session-manager.js";import { SettingsManager } from "./core/settings-manager.js";import { printTimings, resetTimings, time } from "./core/timings.js";import { runMigrations, showDeprecationWarnings } from "./migrations.js";+import { collectDaemonClientEnv } from "./modes/daemon/daemon-protocol.js";import {type AgentConnection,createInteractiveModeLocalSessionHost,@@ -950,6 +951,7 @@ async function createDaemonInteractiveConnection(options: {const attach = async (summary: SessionSummary) => {const connection = await DaemonAgentConnection.attach(client, getDaemonSummaryActiveSessionId(summary), {closeClientOnDispose: true,+ sendClientEnv: true,});return { connection, summary };};@@ -974,6 +976,7 @@ async function createDaemonInteractiveConnection(options: {config: options.config,sessionPath: options.sessionPath,continueRecent: options.continueRecent,+ env: collectDaemonClientEnv(),});if (!response.success) {throw new Error(response.error);diff --git a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.tsindex 2dd51d1917..0ee9cb7a9f 100644--- a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts+++ b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts@@ -10,6 +10,7 @@ import type { SessionStats } from "../../core/session-stats.js";import type { DaemonClient } from "../daemon/daemon-client.js";import { deserializeDaemonError } from "../daemon/daemon-errors.js";import {+ collectDaemonClientEnv,type DaemonAttachResult,type DaemonCommand,type DaemonDeleteSavedSessionResult,@@ -59,6 +60,13 @@ export const DAEMON_REFINE_REQUEST_TIMEOUT_MS = 10 * 60 * 1000;export interface DaemonAgentConnectionOptions {closeClientOnDispose?: boolean;+ /**+ * Send this client's allowlisted env (herdr pane identity) with attach so+ * an env-less session (e.g. cron-created) adopts it. Set only by the+ * primary interactive connection — the daemon adopts-if-absent, never+ * rebinds, so watchers must not send env at all.+ */+ sendClientEnv?: boolean;}/**@@ -111,6 +119,7 @@ export class DaemonAgentConnection implements AgentConnection {supportsExtensionUi: true,clientId: this.clientId,capabilities: ["attach_snapshot", "event_sequence", "extension_ui", "slim_attach"],+ env: this.options.sendClientEnv ? collectDaemonClientEnv() : undefined,resumeCursor:this.lastEventSequence === undefined? undefineddiff --git a/packages/coding-agent/src/modes/daemon/active-session-state.ts b/packages/coding-agent/src/modes/daemon/active-session-state.tsindex 6f396cc5ba..b55ad1900b 100644--- a/packages/coding-agent/src/modes/daemon/active-session-state.ts+++ b/packages/coding-agent/src/modes/daemon/active-session-state.ts@@ -23,6 +23,14 @@ export interface ActiveSessionState {unsubscribe?: () => void;/** Latest background status summary, surfaced in the agents view. */summaryState?: AgentStatus;+ /**+ * Client env (e.g. herdr pane identity), merged over process.env for this+ * session's pi.exec() subprocesses. Bound when the runtime is created (or+ * adopted from the first env-carrying create that reuses an env-less+ * session); never overwritten after that — watchers also attach, and+ * extensions capture identity at load. Subagents inherit the parent's.+ */+ clientEnv?: Record<string, string>;}export interface ActiveSessionExtensionUiRequest {diff --git a/packages/coding-agent/src/modes/daemon/daemon-client-env.ts b/packages/coding-agent/src/modes/daemon/daemon-client-env.tsnew file mode 100644index 0000000000..857a4d123e--- /dev/null+++ b/packages/coding-agent/src/modes/daemon/daemon-client-env.ts@@ -0,0 +1,97 @@+import { DAEMON_CLIENT_ENV_KEYS } from "./daemon-protocol.js";++/** Re-filter client-sent env to the allowlist; the socket peer is untrusted. */+export function filterClientEnv(env?: Record<string, string>): Record<string, string> | undefined {+ if (!env) {+ return undefined;+ }+ const filtered: Record<string, string> = {};+ for (const key of DAEMON_CLIENT_ENV_KEYS) {+ if (env[key] !== undefined) {+ filtered[key] = env[key];+ }+ }+ return Object.keys(filtered).length > 0 ? filtered : undefined;+}++// The daemon's own allowlisted env, captured at startup before any env window+// can mutate process.env.+const baseClientEnv: Record<string, string | undefined> = {};+for (const key of DAEMON_CLIENT_ENV_KEYS) {+ baseClientEnv[key] = process.env[key];+}++/**+ * Exec env for a session's subprocesses: pins every allowlisted key to the+ * session's value (unset when the client didn't send it), or to the daemon's+ * startup value for env-less sessions. Pinning makes subprocess env+ * independent of any env window another session has open at spawn time.+ */+export function execEnvForSession(clientEnv?: Record<string, string>): Record<string, string | undefined> {+ const source = clientEnv ?? baseClientEnv;+ const env: Record<string, string | undefined> = {};+ for (const key of DAEMON_CLIENT_ENV_KEYS) {+ env[key] = source[key];+ }+ return env;+}++// Shared/exclusive lock: env windows are exclusive (they mutate process.env),+// env-less loads are shared — they run concurrently with each other but never+// inside an env window, so they can't capture another session's identity.+let lastExclusive: Promise<unknown> = Promise.resolve();+const activeShared = new Set<Promise<unknown>>();++/**+ * Run fn with the client's env applied to process.env, restoring afterwards.+ * Extensions capture vars like HERDR_PANE_ID synchronously at module load, so+ * they must be in process.env while the session loads its extensions; after+ * this window the session's exec env covers subprocess reads.+ */+export async function withClientEnv<T>(env: Record<string, string> | undefined, fn: () => Promise<T>): Promise<T> {+ if (!env) {+ const gate = lastExclusive;+ const run = (async () => {+ await gate.catch(() => undefined);+ return fn();+ })();+ const tracked = run.catch(() => undefined);+ activeShared.add(tracked);+ void tracked.then(() => activeShared.delete(tracked));+ return run;+ }+ const prior = lastExclusive;+ // Snapshot synchronously: shareds arriving later gate on this window via+ // lastExclusive, so waiting for them here would deadlock.+ const sharedAtRequest = [...activeShared];+ const run = (async () => {+ await prior.catch(() => undefined);+ await Promise.all(sharedAtRequest);+ const previous = new Map<string, string | undefined>();+ // Pin the full allowlist (unsetting keys the client didn't send) so a+ // partially-forwarded env can't mix with the daemon's ambient values —+ // mirroring execEnvForSession.+ for (const key of DAEMON_CLIENT_ENV_KEYS) {+ previous.set(key, process.env[key]);+ const value = env[key];+ if (value === undefined) {+ delete process.env[key];+ } else {+ process.env[key] = value;+ }+ }+ try {+ return await fn();+ } finally {+ for (const [key, value] of previous) {+ if (value === undefined) {+ delete process.env[key];+ } else {+ process.env[key] = value;+ }+ }+ }+ })();+ lastExclusive = run.catch(() => undefined);+ return run;+}diff --git a/packages/coding-agent/src/modes/daemon/daemon-extension-binding.ts b/packages/coding-agent/src/modes/daemon/daemon-extension-binding.tsindex 9dd2835769..f2e99eada5 100644--- a/packages/coding-agent/src/modes/daemon/daemon-extension-binding.ts+++ b/packages/coding-agent/src/modes/daemon/daemon-extension-binding.ts@@ -10,6 +10,7 @@ import type { SubagentRuntimeHost } from "../../core/rlm-runtime.js";import { createAgentConnectionState } from "../agent-connection/snapshot.js";import { type Theme, theme } from "../interactive/theme/theme.js";import type { ActiveSessionState } from "./active-session-state.js";+import { execEnvForSession, withClientEnv } from "./daemon-client-env.js";import {type DaemonExtensionUIResponse,type DaemonOutbound,@@ -48,6 +49,11 @@ export async function bindActiveSessionState(): Promise<void> {const session = state.runtime.session;+ session.setExecEnvProvider(() => execEnvForSession(state.clientEnv));+ // Every runtime rebuild (new/switch/fork/import, subagent spawn) re-loads+ // extensions, which capture client env synchronously at that moment.+ state.runtime.setRuntimeEnvScope((fn) => withClientEnv(state.clientEnv, fn));+state.unsubscribe?.();state.runtime.setSubagentRuntimeHost(callbacks.subagentRuntimeHost);state.unsubscribe = session.subscribe((event) => {@@ -103,7 +109,9 @@ function createCommandContextActions(state: ActiveSessionState): ExtensionComman},switchSession: async (sessionPath, options) => state.runtime.switchSession(sessionPath, options),reload: async () => {- await state.runtime.session.reload();+ // Reload re-evaluates extension modules, which capture client env+ // (e.g. herdr pane identity) synchronously at load.+ await withClientEnv(state.clientEnv, () => state.runtime.session.reload());},};}diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.tsindex a2461b1a52..9d98837a8b 100644--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts@@ -84,6 +84,7 @@ import {type DaemonSocketClient,resolveActiveSessionState,} from "./active-session-state.js";+import { filterClientEnv, withClientEnv } from "./daemon-client-env.js";import { serializeDaemonError } from "./daemon-errors.js";import { bindActiveSessionState } from "./daemon-extension-binding.js";import {@@ -344,9 +345,28 @@ export class AgentDaemon {cleanupDaemonSocketPath(this.socketPath);}+ /**+ * Adopt env for a session that has none, propagating to subagents spawned+ * before adoption (their exec-env providers read state.clientEnv live).+ * Never overwrites an existing identity.+ */+ private adoptClientEnv(state: ActiveSessionState, env?: Record<string, string>): void {+ if (!env || state.clientEnv) {+ return;+ }+ state.clientEnv = env;+ for (const child of this.sessions.values()) {+ const metadata = child.runtime.metadata;+ if (metadata.kind === "subagent" && metadata.parentActiveSessionId === state.activeSessionId) {+ this.adoptClientEnv(child, env);+ }+ }+ }+private async addRuntime(runtime: AgentSessionRuntime,name?: string,+ clientEnv?: Record<string, string>,onStateCreated?: (state: ActiveSessionState) => void,): Promise<ActiveSessionState> {const state: ActiveSessionState = {@@ -355,6 +375,7 @@ export class AgentDaemon {clients: new Set(),extensionUiRequests: new Map(),lastEventSequence: 0,+ clientEnv,};if (name) {state.runtime.session.setSessionName(name);@@ -405,6 +426,7 @@ export class AgentDaemon {const cwd = resolve(config.cwd);const agentDir = config.agentDir;+ const clientEnv = filterClientEnv(command.env);const cwdOverride = command.config?.cwd ? resolve(command.config.cwd) : undefined;const sessionPath = command.sessionPath? await resolveDaemonSessionPath(command.sessionPath, cwd, config.sessionDir)@@ -419,79 +441,89 @@ export class AgentDaemon {if (existing) {// A live runtime already owns this session file; reuse it instead of// starting a second runtime that would interleave writes to one file.+ // clientEnv adopts the first offered identity (e.g. a pane opening a+ // cron-created session) but never overwrites one: extensions captured+ // the creator's identity at load, and swapping it would only make+ // pi.exec disagree with those captures.if (command.name) {existing.runtime.session.setSessionName(command.name);}+ this.adoptClientEnv(existing, clientEnv);this.rebindCronJobsToState(existing);return existing;}let stateRef: ActiveSessionState | undefined;- const runtime = await createAgentSessionRuntime(this.options.createRuntime, {- cwd: sessionManager.getCwd(),- agentDir,- sessionManager,- sessionConfig: config,- sessionOptions: {- customTools: [- ...createAgentHeartbeatToolDefinitions({- getHeartbeat: () => {+ // Extensions capture client env (e.g. herdr pane identity) synchronously+ // while the runtime loads them, so it must be in process.env for the+ // duration; withClientEnv restores it after.+ const runtime = await withClientEnv(clientEnv, () =>+ createAgentSessionRuntime(this.options.createRuntime, {+ cwd: sessionManager.getCwd(),+ agentDir,+ sessionManager,+ sessionConfig: config,+ sessionOptions: {+ customTools: [+ ...createAgentHeartbeatToolDefinitions({+ getHeartbeat: () => {+ if (!stateRef) {+ throw new Error("Heartbeat state is not ready for this session yet");+ }+ return this.cronStore.getHeartbeat(stateRef.activeSessionId);+ },+ }),+ ],+ rlmHeartbeatController: {+ listRlmHeartbeats: (listOptions) => {if (!stateRef) {- throw new Error("Heartbeat state is not ready for this session yet");+ throw new Error("RLM heartbeat state is not ready for this session yet");}- return this.cronStore.getHeartbeat(stateRef.activeSessionId);+ return this.cronStore.listRlmHeartbeats(stateRef.activeSessionId, listOptions);+ },+ createRlmHeartbeat: (input) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.createRlmHeartbeatForState(stateRef, input);+ },+ updateRlmHeartbeat: (input) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.updateRlmHeartbeatForState(stateRef, input);+ },+ deleteRlmHeartbeat: (id) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.deleteRlmHeartbeatForState(stateRef, id);},- }),- ],- rlmHeartbeatController: {- listRlmHeartbeats: (listOptions) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.cronStore.listRlmHeartbeats(stateRef.activeSessionId, listOptions);- },- createRlmHeartbeat: (input) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.createRlmHeartbeatForState(stateRef, input);- },- updateRlmHeartbeat: (input) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.updateRlmHeartbeatForState(stateRef, input);- },- deleteRlmHeartbeat: (id) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.deleteRlmHeartbeatForState(stateRef, id);- },- },- agentMessageController: {- listAgents: () => {- if (!stateRef) {- throw new Error("Agent message state is not ready for this session yet");- }- return this.createAgentMessageListResult(stateRef);},- sendAgentMessage: (input) => {- if (!stateRef) {- throw new Error("Agent message state is not ready for this session yet");- }- return this.sendAgentSessionMessage({- targetSelector: input.target,- message: input.message,- fromState: stateRef,- deliveryMode: input.deliveryMode,- origin: "agent",- });+ agentMessageController: {+ listAgents: () => {+ if (!stateRef) {+ throw new Error("Agent message state is not ready for this session yet");+ }+ return this.createAgentMessageListResult(stateRef);+ },+ sendAgentMessage: (input) => {+ if (!stateRef) {+ throw new Error("Agent message state is not ready for this session yet");+ }+ return this.sendAgentSessionMessage({+ targetSelector: input.target,+ message: input.message,+ fromState: stateRef,+ deliveryMode: input.deliveryMode,+ origin: "agent",+ });+ },},+ agentObserveController: this.createAgentObserveController(() => stateRef),},- agentObserveController: this.createAgentObserveController(() => stateRef),- },- });- return this.addRuntime(runtime, command.name, (state) => {+ }),+ );+ return this.addRuntime(runtime, command.name, clientEnv, (state) => {stateRef = state;});};@@ -503,10 +535,13 @@ export class AgentDaemon {const sessionKey = resolve(sessionFile);const pending = this.openingSessions.get(sessionKey);if (pending) {+ // Same as the reuse path above: adopt-if-absent, never overwrite the+ // identity the racing creator's extensions already captured.const state = await pending;if (command.name) {state.runtime.session.setSessionName(command.name);}+ this.adoptClientEnv(state, clientEnv);this.rebindCronJobsToState(state);return state;}@@ -846,65 +881,68 @@ export class AgentDaemon {sessionManager.newSession({ parentSession: options.parentSession.sessionFile });}let stateRef: ActiveSessionState | undefined;- const runtime = await createAgentSessionRuntime(this.options.createRuntime, {- cwd: sessionManager.getCwd(),- agentDir: parentState.runtime.services.agentDir,- sessionManager,- sessionStartEvent: { type: "session_start", reason: "startup" },- sessionConfig: parentState.runtime.runtimeConfig,- sessionOptions: {- model: options.model,- thinkingLevel: options.thinkingLevel,- scopedModels: options.scopedModels,- initialActiveToolNames: options.activeToolNames,- allowedToolNames: options.allowedToolNames,- customTools: options.customTools,- includeGoals: options.includeGoals,- rlmHeartbeatController: {- listRlmHeartbeats: (listOptions) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.cronStore.listRlmHeartbeats(stateRef.activeSessionId, listOptions);- },- createRlmHeartbeat: (input) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.createRlmHeartbeatForState(stateRef, input);- },- updateRlmHeartbeat: (input) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.updateRlmHeartbeatForState(stateRef, input);- },- deleteRlmHeartbeat: (id) => {- if (!stateRef) {- throw new Error("RLM heartbeat state is not ready for this session yet");- }- return this.deleteRlmHeartbeatForState(stateRef, id);+ // Subagents inherit the parent's client env (e.g. herdr pane identity).+ const runtime = await withClientEnv(parentState.clientEnv, () =>+ createAgentSessionRuntime(this.options.createRuntime, {+ cwd: sessionManager.getCwd(),+ agentDir: parentState.runtime.services.agentDir,+ sessionManager,+ sessionStartEvent: { type: "session_start", reason: "startup" },+ sessionConfig: parentState.runtime.runtimeConfig,+ sessionOptions: {+ model: options.model,+ thinkingLevel: options.thinkingLevel,+ scopedModels: options.scopedModels,+ initialActiveToolNames: options.activeToolNames,+ allowedToolNames: options.allowedToolNames,+ customTools: options.customTools,+ includeGoals: options.includeGoals,+ rlmHeartbeatController: {+ listRlmHeartbeats: (listOptions) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.cronStore.listRlmHeartbeats(stateRef.activeSessionId, listOptions);+ },+ createRlmHeartbeat: (input) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.createRlmHeartbeatForState(stateRef, input);+ },+ updateRlmHeartbeat: (input) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.updateRlmHeartbeatForState(stateRef, input);+ },+ deleteRlmHeartbeat: (id) => {+ if (!stateRef) {+ throw new Error("RLM heartbeat state is not ready for this session yet");+ }+ return this.deleteRlmHeartbeatForState(stateRef, id);+ },},+ rlmDepth: options.rlmDepth,+ rlmMaxDepth: options.rlmMaxDepth,+ rlmSessionDir: options.sessionDir,+ rlmParentNodeId: options.rlmParentNodeId,},- rlmDepth: options.rlmDepth,- rlmMaxDepth: options.rlmMaxDepth,- rlmSessionDir: options.sessionDir,- rlmParentNodeId: options.rlmParentNodeId,- },- runtimeMetadata: {- kind: "subagent",- createdAt: Date.now(),- parentActiveSessionId: parentState.activeSessionId,- parentSessionId: options.parentSession.sessionId,- parentSessionFile: options.parentSession.sessionFile,- rlmChildId: options.id,- rlmParentNodeId: options.rlmParentNodeId,- prompt: options.prompt,- spawnCode: options.spawnCode,- sessionDir: options.sessionDir,- },- });- await this.addRuntime(runtime, undefined, (state) => {+ runtimeMetadata: {+ kind: "subagent",+ createdAt: Date.now(),+ parentActiveSessionId: parentState.activeSessionId,+ parentSessionId: options.parentSession.sessionId,+ parentSessionFile: options.parentSession.sessionFile,+ rlmChildId: options.id,+ rlmParentNodeId: options.rlmParentNodeId,+ prompt: options.prompt,+ spawnCode: options.spawnCode,+ sessionDir: options.sessionDir,+ },+ }),+ );+ await this.addRuntime(runtime, undefined, parentState.clientEnv, (state) => {stateRef = state;});return runtime;@@ -1144,6 +1182,7 @@ export class AgentDaemon {}client.capabilities = normalizeClientCapabilities(command.capabilities, command.supportsExtensionUi);client.supportsExtensionUi = client.capabilities.has("extension_ui");+ this.adoptClientEnv(state, filterClientEnv(command.env));state.clients.add(client);client.attachedActiveSessionIds.add(state.activeSessionId);const result = this.createAttachResult(client, state, command);@@ -1559,7 +1598,9 @@ export class AgentDaemon {case "reload": {const state = this.getSessionState(command.activeSessionId);- await state.runtime.session.reload();+ // Reload re-evaluates extension modules, which capture client env+ // (e.g. herdr pane identity) synchronously at load.+ await withClientEnv(state.clientEnv, () => state.runtime.session.reload());return success(command.id, "reload");}diff --git a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts b/packages/coding-agent/src/modes/daemon/daemon-protocol.tsindex fcdb9bc589..febfe15887 100644--- a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts+++ b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts@@ -70,6 +70,43 @@ export interface DaemonAttachClientMetadata {resumeCursor?: DaemonResumeCursor;}+/**+ * Client-side env vars forwarded to the daemon so extensions can reach them+ * (e.g. HERDR_PANE_ID/HERDR_SOCKET_PATH that herdr sets per pane). The daemon+ * scopes these to the created session and merges them over process.env for+ * that session's pi.exec() subprocesses — it does not mutate the daemon's own+ * env. Carried on create only: attach must not rebind a session's identity,+ * since watchers (agents view, subagent viewers) also attach.+ */+export interface DaemonClientEnv {+ env?: Record<string, string>;+}++/**+ * The allowlist of env vars a client may forward. One shared list because it+ * is the wire contract: clients filter before sending and the daemon+ * re-filters on receipt (the socket peer is untrusted).+ */+export const DAEMON_CLIENT_ENV_KEYS = [+ "HERDR_ENV",+ "HERDR_PANE_ID",+ "HERDR_SOCKET_PATH",+ "HERDR_TAB_ID",+ "HERDR_WORKSPACE_ID",+] as const;++/** Collect the allowlisted env vars from the client process for the create command. */+export function collectDaemonClientEnv(source: NodeJS.ProcessEnv = process.env): Record<string, string> | undefined {+ const env: Record<string, string> = {};+ for (const key of DAEMON_CLIENT_ENV_KEYS) {+ const value = source[key];+ if (value !== undefined) {+ env[key] = value;+ }+ }+ return Object.keys(env).length > 0 ? env : undefined;+}+export interface DaemonReplayInfo {status: DaemonReplayStatus;fromSequence?: DaemonEventSequence;@@ -151,20 +188,24 @@ export interface DaemonAttachResult {export type DaemonCommand =| { id?: string; type: "list"; all?: boolean; cwd?: string; sessionDir?: string }| { id?: string; type: "list_saved_sessions"; activeSessionId: string; scope: AgentConnectionSavedSessionScope }- | {+ | ({id?: string;type: "create";sessionPath?: string;continueRecent?: boolean;name?: string;config?: AgentSessionRuntimeConfig;- }+ } & DaemonClientEnv)+ // Attach env is adopt-if-absent only: it fills identity for env-less+ // sessions (e.g. cron-created) but never rebinds one, since watchers+ // (agents view, subagent viewers) also attach.| ({id?: string;type: "attach";activeSessionId: string;supportsExtensionUi?: boolean;- } & DaemonAttachClientMetadata)+ } & DaemonAttachClientMetadata &+ DaemonClientEnv)| { id?: string; type: "detach"; activeSessionId?: string }| { id?: string; type: "kill"; activeSessionId: string }| { id?: string; type: "rename"; activeSessionId: string; name: string }diff --git a/packages/coding-agent/test/daemon-client-env.test.ts b/packages/coding-agent/test/daemon-client-env.test.tsnew file mode 100644index 0000000000..4e1162a418--- /dev/null+++ b/packages/coding-agent/test/daemon-client-env.test.ts@@ -0,0 +1,121 @@+import { describe, expect, it } from "vitest";+import { execEnvForSession, filterClientEnv, withClientEnv } from "../src/modes/daemon/daemon-client-env.js";++describe("filterClientEnv", () => {+ it("keeps only allowlisted keys", () => {+ expect(filterClientEnv({ HERDR_PANE_ID: "w1:p1", PATH: "/evil", HERDR_ENV: "1" })).toEqual({+ HERDR_PANE_ID: "w1:p1",+ HERDR_ENV: "1",+ });+ });++ it("returns undefined for missing or empty env", () => {+ expect(filterClientEnv(undefined)).toBeUndefined();+ expect(filterClientEnv({})).toBeUndefined();+ expect(filterClientEnv({ PATH: "/evil" })).toBeUndefined();+ });+});++describe("withClientEnv", () => {+ it("applies env during fn, unsetting omitted allowlisted keys, and restores afterwards", async () => {+ process.env.HERDR_PANE_ID = "original";+ process.env.HERDR_WORKSPACE_ID = "ambient";+ delete process.env.HERDR_TAB_ID;+ let seenPane: string | undefined;+ let seenTab: string | undefined;+ let seenWorkspace: string | undefined = "unset";+ await withClientEnv({ HERDR_PANE_ID: "w2:p1", HERDR_TAB_ID: "t1" }, async () => {+ seenPane = process.env.HERDR_PANE_ID;+ seenTab = process.env.HERDR_TAB_ID;+ seenWorkspace = process.env.HERDR_WORKSPACE_ID;+ });+ expect(seenPane).toBe("w2:p1");+ expect(seenTab).toBe("t1");+ // The daemon's ambient value must not mix into a partial client env.+ expect(seenWorkspace).toBeUndefined();+ expect(process.env.HERDR_PANE_ID).toBe("original");+ expect(process.env.HERDR_TAB_ID).toBeUndefined();+ expect(process.env.HERDR_WORKSPACE_ID).toBe("ambient");+ delete process.env.HERDR_PANE_ID;+ delete process.env.HERDR_WORKSPACE_ID;+ });++ it("restores even when fn throws", async () => {+ process.env.HERDR_PANE_ID = "original";+ await expect(+ withClientEnv({ HERDR_PANE_ID: "w2:p1" }, async () => {+ throw new Error("boom");+ }),+ ).rejects.toThrow("boom");+ expect(process.env.HERDR_PANE_ID).toBe("original");+ delete process.env.HERDR_PANE_ID;+ });++ it("serializes overlapping windows so envs never mix", async () => {+ delete process.env.HERDR_PANE_ID;+ const seen: Array<string | undefined> = [];+ const slow = withClientEnv({ HERDR_PANE_ID: "a" }, async () => {+ await new Promise((r) => setTimeout(r, 20));+ seen.push(process.env.HERDR_PANE_ID);+ });+ const fast = withClientEnv({ HERDR_PANE_ID: "b" }, async () => {+ seen.push(process.env.HERDR_PANE_ID);+ });+ await Promise.all([slow, fast]);+ expect(seen).toEqual(["a", "b"]);+ expect(process.env.HERDR_PANE_ID).toBeUndefined();+ });++ it("runs fn directly without env", async () => {+ let ran = false;+ await withClientEnv(undefined, async () => {+ ran = true;+ });+ expect(ran).toBe(true);+ });++ it("env-less loads never run inside an env window", async () => {+ delete process.env.HERDR_PANE_ID;+ let seenByEnvless: string | undefined = "unset";+ const windowed = withClientEnv({ HERDR_PANE_ID: "a" }, async () => {+ await new Promise((r) => setTimeout(r, 20));+ });+ const envless = withClientEnv(undefined, async () => {+ seenByEnvless = process.env.HERDR_PANE_ID;+ });+ await Promise.all([windowed, envless]);+ expect(seenByEnvless).toBeUndefined();+ });++ it("execEnvForSession pins keys independent of active env windows", async () => {+ const baseline = execEnvForSession();+ await withClientEnv({ HERDR_PANE_ID: "window-only" }, async () => {+ // An env-less session's exec env is the daemon's startup base, not+ // whatever another session's window put in process.env.+ expect(execEnvForSession()).toStrictEqual(baseline);+ // A session with env gets exactly its values; missing keys are unset.+ expect(execEnvForSession({ HERDR_PANE_ID: "w9:p9" })).toStrictEqual({+ HERDR_ENV: undefined,+ HERDR_PANE_ID: "w9:p9",+ HERDR_SOCKET_PATH: undefined,+ HERDR_TAB_ID: undefined,+ HERDR_WORKSPACE_ID: undefined,+ });+ });+ });++ it("env windows wait for in-flight env-less loads", async () => {+ delete process.env.HERDR_PANE_ID;+ const order: string[] = [];+ const envless = withClientEnv(undefined, async () => {+ await new Promise((r) => setTimeout(r, 20));+ order.push(`envless:${process.env.HERDR_PANE_ID}`);+ });+ const windowed = withClientEnv({ HERDR_PANE_ID: "b" }, async () => {+ order.push(`windowed:${process.env.HERDR_PANE_ID}`);+ });+ await Promise.all([envless, windowed]);+ expect(order).toEqual(["envless:undefined", "windowed:b"]);+ expect(process.env.HERDR_PANE_ID).toBeUndefined();+ });+});diff --git a/packages/coding-agent/test/daemon-mode.test.ts b/packages/coding-agent/test/daemon-mode.test.tsindex 2839812c48..e620f20a3b 100644--- a/packages/coding-agent/test/daemon-mode.test.ts+++ b/packages/coding-agent/test/daemon-mode.test.ts@@ -2163,6 +2163,53 @@ describe("daemon mode helpers", () => {}});+ it("adopts client env on session reuse only when the session has none", async () => {+ const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-env-"));+ try {+ const sessionPath = join(tempDir, "session.jsonl");+ const createRuntime = vi.fn(async (options: Parameters<CreateAgentSessionRuntimeFactory>[0]) => {+ return {+ session: makeRuntimeSession(options.sessionManager),+ extensionsResult: { extensions: [], errors: [], runtime: {} } as unknown as Awaited<+ ReturnType<CreateAgentSessionRuntimeFactory>+ >["extensionsResult"],+ services: { cwd: options.cwd, agentDir: options.agentDir } as Awaited<+ ReturnType<CreateAgentSessionRuntimeFactory>+ >["services"],+ diagnostics: [],+ };+ });+ const daemon = new AgentDaemon(join(tempDir, "daemon.sock"), {+ defaultSessionConfig: { agentDir: tempDir, cwd: tempDir, sessionDir: tempDir },+ createRuntime,+ });+ const create = (+ daemon as unknown as {+ createRuntime(command: Extract<DaemonCommand, { type: "create" }>): Promise<ActiveSessionState>;+ }+ ).createRuntime.bind(daemon);++ // Created env-less (e.g. by a cron job), then opened by an env-carrying+ // client: the session adopts the client's allowlisted identity.+ const state = await create({ type: "create", sessionPath });+ expect(state.clientEnv).toBeUndefined();+ const adopted = await create({+ type: "create",+ sessionPath,+ env: { HERDR_PANE_ID: "w1:p1", PATH: "/evil" },+ });+ expect(adopted).toBe(state);+ expect(state.clientEnv).toEqual({ HERDR_PANE_ID: "w1:p1" });++ // A later client with a different env must not rebind the identity+ // that extensions already captured.+ await create({ type: "create", sessionPath, env: { HERDR_PANE_ID: "w2:p9" } });+ expect(state.clientEnv).toEqual({ HERDR_PANE_ID: "w1:p1" });+ } finally {+ rmSync(tempDir, { recursive: true, force: true });+ }+ });+it("makes daemon host controllers available during session_start extension binding", async () => {const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-controller-race-"));try {@@ -2897,6 +2944,7 @@ function makeRuntimeSession(setSubagentRuntimeHost: vi.fn(),subscribe: vi.fn(() => vi.fn()),bindExtensions: vi.fn(async () => {}),+ setExecEnvProvider: vi.fn(),setSessionName: vi.fn(),dispose: vi.fn(),abort: vi.fn(async () => {}),