@adhdev/daemon-core 0.9.82-rc.269 → 0.9.82-rc.270

package/dist/mesh/mesh-events-utils.d.ts

@@ -3,6 +3,37 @@ export declare function readNonEmptyString(value: unknown): string;
 export declare function readRecord(value: unknown): Record<string, unknown> | undefined;
 export declare function canonicalDaemonId(value: unknown): string;
 export declare function sameDaemonId(a: unknown, b: unknown): boolean;
+/**
+ * The relay-safety metadata a worker session must carry so that its completion /
+ * generating events route back to the coordinator proactively (without waiting for
+ * a mesh_read_chat reconcile). meshCoordinatorDaemonId is the routing anchor the
+ * core forwarder (injectMeshSystemMessage) keys on to pick a remote coordinator
+ * target; meshNodeFor/meshNodeId identify the worker, and launchedByCoordinator is
+ * the delegation proof. See resolveWorkerDelegateRouting().
+ */
+export interface MeshWorkerRelayStamp {
+    meshNodeFor?: string;
+    meshNodeId?: string;
+    meshCoordinatorDaemonId?: string;
+    launchedByCoordinator?: boolean;
+}
+/**
+ * Build the relay-safety stamp from a dispatch's meshContext, only including fields
+ * the session does not already carry. Returns undefined when there is nothing new to
+ * stamp, so callers can skip a no-op updateSettings() write.
+ *
+ * This closes the remote-session relay gap: a worker session reached by a dispatch
+ * that carries coordinatorDaemonId (mesh_send_task / queue assignment over P2P) gets
+ * the coordinator anchor persisted onto its settings at dispatch time, even if it was
+ * not launched via mesh_launch_session. Without the stamp the forwarder cannot resolve
+ * a remote coordinator and the completion event sits in the pending queue until a
+ * read_chat-triggered reconcile drains it.
+ */
+export declare function buildMeshWorkerRelayStamp(currentSettings: Record<string, unknown> | undefined, meshContext: {
+    meshId?: unknown;
+    nodeId?: unknown;
+    coordinatorDaemonId?: unknown;
+} | undefined): MeshWorkerRelayStamp | undefined;
 export declare function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string;
 export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;

package/dist/providers/spec/fsm-driver.d.ts

@@ -186,6 +186,7 @@ export declare class FsmDriver implements ISpecDriver {
     constructor(opts: SpecDriverOpts);
     subscribe(listener: (ev: DashboardEvent) => void): () => void;
     start(): void;
+    private scheduleSpawnPrime;
     dispatch(cmd: DashboardCommand): void;
     snapshot(): string;
     getCursorPosition(): {

package/dist/providers/spec/fsm-types.d.ts

@@ -66,6 +66,21 @@ export interface CliSpecV4 {
     spawn_args?: string[];
     env?: Record<string, string>;
     cli_version_range?: string;
+    /**
+     * Optional raw byte sequences written to the PTY once, shortly after spawn,
+     * to prime a TUI that gates its input handling on a terminal event the
+     * daemon would otherwise never emit. The canonical case is a focus-event
+     * TUI (Ink `useStdin`/`useFocus`, e.g. antigravity's `agy`) that enables
+     * focus reporting (`CSI ?1004h`) and treats its input box as unfocused —
+     * silently dropping the first programmatic write — until it receives a
+     * focus-in event (`ESC [ I`). Declaring `[""]` here wakes the input
+     * stream on spawn so the first delegated message lands without a manual
+     * keystroke. CLIs that do not focus-gate input simply omit this field; the
+     * engine writes nothing extra for them, so it stays CLI-agnostic.
+     */
+    send_on_spawn?: string[];
+    /** Delay (ms) after spawn before writing `send_on_spawn`. Default 250. */
+    send_on_spawn_delay_ms?: number;
     send_message: {
         submit_key: string;
         delay_ms_before_submit?: number;

package/dist/providers/spec/types.d.ts

@@ -75,19 +75,34 @@ export interface NativeHistoryMessageMap {
     timestamp_ms?: string;
     kind?: string;
 }
+export interface AnchorContext {
+    prev?: string;
+    next?: string;
+    prev_flags?: string;
+    next_flags?: string;
+}
 export interface SectionDef {
     from_top?: Size;
     from_bottom?: Size;
     until?: string;
-    anchor?: string;
+    /**
+     * Anchor regex(es). A single string anchors on the first/last matching line
+     * (per `anchor_last`). An array is an OR-set: every candidate line is one
+     * that matches ANY entry; with `anchor_last` the LAST such line across all
+     * patterns wins, otherwise the FIRST. This lets one section capture two
+     * different shapes — e.g. a box-divider modal AND a divider-less modal whose
+     * only stable landmark is the question line above its numbered choices.
+     */
+    anchor?: string | string[];
     anchor_flags?: string;
     anchor_last?: boolean;
-    anchor_context?: {
-        prev?: string;
-        next?: string;
-        prev_flags?: string;
-        next_flags?: string;
-    };
+    /**
+     * Context guard(s) for the anchor. A single object applies to every anchor
+     * pattern. An array is matched positionally against an `anchor` array (entry
+     * i guards anchor i); a positional `undefined`/null entry means "no guard"
+     * for that anchor. A scalar `anchor` ignores array form beyond index 0.
+     */
+    anchor_context?: AnchorContext | (AnchorContext | null)[];
     lines?: number;
     until_regex?: string;
     until_regex_flags?: string;

package/dist/repo-mesh-types.d.ts

@@ -99,6 +99,17 @@ export interface RepoMeshPolicy {
      * watch-the-agents behavior; hidden sessions remain discoverable and manually openable.
      */
     spawnedSessionVisibility?: RepoMeshSpawnedSessionVisibility;
+    /**
+     * Whether worker sessions the coordinator dispatches should auto-approve agent
+     * approval modals (tool/command prompts) without firing a user-facing approval
+     * notification. Delegated workers are coordinator-driven, so a human should not
+     * have to approve each one; defaults to true. Set to false to make delegated
+     * worker sessions stop at approval modals like an interactive session.
+     * Stamped into the worker launch settings envelope as `autoApprove`, which wins
+     * over the global per-provider-type autoApprove config via the settings merge.
+     * A node policy may override this per-node (RepoMeshNodePolicy.delegatedWorkerAutoApprove).
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * What to do with delegated session-host records for a node when it is removed.
      * Defaults to 'preserve' so completed work can be reviewed later and live
@@ -129,6 +140,11 @@ export interface RepoMeshNodePolicy {
     maxConcurrentSessions?: number;
     /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
     providerPriority?: string[];
+    /**
+     * Per-node override for RepoMeshPolicy.delegatedWorkerAutoApprove. When set, takes
+     * precedence over the mesh-level policy for worker sessions launched onto this node.
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * Optional associated/external repos that must be checked alongside this node.
      * These are explicit policy/config entries only; Repo Mesh does not auto-discover
@@ -152,6 +168,14 @@ export interface RepoMeshNodePolicy {
     initSubmodulesOnClone?: boolean;
 }
 export declare const DEFAULT_MESH_POLICY: RepoMeshPolicy;
+/**
+ * Resolve whether a delegated worker session launched onto `nodePolicy` (within a mesh
+ * governed by `meshPolicy`) should auto-approve. Precedence: node override → mesh policy
+ * → default true. The result is stamped into the worker launch settings envelope as
+ * `autoApprove`; it wins over the global per-provider-type autoApprove config because the
+ * launch path merges the envelope as a settingsOverride on top of the provider defaults.
+ */
+export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null): boolean;
 export interface RepoMeshNodeCapabilities {
     platform?: string;
     packageManagers?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.269",
+  "version": "0.9.82-rc.270",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.269",
+    "@adhdev/mesh-shared": "0.9.82-rc.270",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -45,6 +45,7 @@ import { buildSessionEntries } from '../status/builders.js';
 import { registerMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, type PendingMeshCoordinatorEvent } from '../mesh/mesh-events.js';
 import { getRecentUnroutableDeliveries } from '../mesh/mesh-routing.js';
+import { buildMeshWorkerRelayStamp } from '../mesh/mesh-events-utils.js';
 import { buildMeshHostRequiredFailure, normalizeMeshDaemonRole, resolveMeshHostStatus } from '../mesh/mesh-host-ownership.js';
 import { fastForwardMeshNode } from '../mesh/mesh-fast-forward.js';
 import { analyzeMeshRefineNodeChangeArea, orderMeshRefineBatchNodes } from '../mesh/mesh-refine-batch.js';
@@ -5307,6 +5308,34 @@ export class DaemonCommandRouter {
                 return this.deps.cliManager.handleCliCommand(cmd, args);
             }
             case 'agent_command': {
+                // Relay-safety stamp: a dispatch carrying meshContext.coordinatorDaemonId
+                // (mesh_send_task / queue assignment over P2P) is the worker daemon's chance
+                // to persist the coordinator routing anchor onto the target session BEFORE the
+                // turn runs. Without meshCoordinatorDaemonId on the session, the core forwarder
+                // (injectMeshSystemMessage) cannot resolve a remote coordinator target, so the
+                // completion event sits in the pending queue until a read_chat reconcile drains
+                // it. Stamping here makes a reused/relaunched remote session relay-safe at
+                // dispatch time even when it was not launched via mesh_launch_session.
+                {
+                    const dispatchSessionId = readStringValue(args?.targetSessionId, (args as any)?.sessionId, (args as any)?.instanceId);
+                    const dispatchMeshContext = args?.meshContext as Record<string, unknown> | undefined;
+                    if (dispatchSessionId && dispatchMeshContext) {
+                        try {
+                            const inst = this.deps.instanceManager.getInstance(dispatchSessionId);
+                            if (inst && typeof inst.updateSettings === 'function') {
+                                const stamp = buildMeshWorkerRelayStamp(
+                                    inst.getState?.()?.settings as Record<string, unknown> | undefined,
+                                    {
+                                        meshId: dispatchMeshContext.meshId,
+                                        nodeId: dispatchMeshContext.nodeId,
+                                        coordinatorDaemonId: dispatchMeshContext.coordinatorDaemonId,
+                                    },
+                                );
+                                if (stamp) inst.updateSettings(stamp);
+                            }
+                        } catch { /* best-effort — dispatch still proceeds without the stamp */ }
+                    }
+                }
                 const agentResult = await this.deps.cliManager.handleCliCommand(cmd, args);
                 // Bug C fix (part 2): when dispatching a task to a mesh node session, override
                 // the dispatch acknowledgement risk reason to 'bootstrap_still_running' when

package/src/index.ts

@@ -132,7 +132,7 @@ export type {
   RepoMeshLedgerStatus,
   MeshAsyncJobLifecycle,
 } from './repo-mesh-types.js';
-export { DEFAULT_MESH_POLICY } from './repo-mesh-types.js';
+export { DEFAULT_MESH_POLICY, resolveDelegatedWorkerAutoApprove } from './repo-mesh-types.js';
 
 // ── Git Surface ──
 export * from './git/index.js';

package/src/mesh/mesh-events-coordinator.ts

@@ -13,6 +13,7 @@ import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent } from './mesh-routing.js';
+import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -302,7 +303,24 @@ export function tryAssignQueueTask(
     try {
         const inst = components.instanceManager.getInstance(sessionId);
         if (inst && typeof inst.updateSettings === 'function') {
-            inst.updateSettings({ meshNodeFor: meshId, meshNodeId: nodeId, launchedByCoordinator: true });
+            // Adopting a (possibly manually-opened) local session as a worker: apply the
+            // delegated-worker auto-approve policy here too, so a session that was launched
+            // without autoApprove still auto-approves once the coordinator dispatches a task
+            // to it (the "approval notification fires only for certain delegated sessions"
+            // case). updateSettings preserves runtime mesh keys; passing autoApprove keeps it.
+            //
+            // This local-dispatch branch also runs on the coordinator daemon for a co-located
+            // session, so the coordinator daemon id IS this daemon's id. Stamp it alongside
+            // the node identity so the session is fully relay-safe (meshCoordinatorDaemonId is
+            // the anchor the forwarder keys on), matching what mesh_launch_session stamps.
+            const localDaemonId = readNonEmptyString(loadConfig().machineId);
+            inst.updateSettings({
+                meshNodeFor: meshId,
+                meshNodeId: nodeId,
+                launchedByCoordinator: true,
+                autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
+                ...(localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {}),
+            });
         }
     } catch { /* best-effort — dispatch still proceeds */ }
 
@@ -666,6 +684,10 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                         meshNodeFor: meshId,
                         meshNodeId: nodeId,
                         spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || 'hidden',
+                        // Coordinator-dispatched worker: auto-approve unless mesh/node policy
+                        // opts out (default true). Lands in settingsOverride and beats the
+                        // global per-provider-type autoApprove config (see shouldAutoApprove).
+                        autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
                         launchedByCoordinator: true,
                         autoLaunchedForQueueTaskId: task.id,
                     },
@@ -1343,6 +1365,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                                     meshNodeFor: args.meshId,
                                     meshNodeId: node.id,
                                     spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || 'hidden',
+                                    // Coordinator-dispatched recovery relaunch: same auto-approve
+                                    // policy as the primary worker launch path.
+                                    autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
                                     launchedByCoordinator: true,
                                 }
                             }).catch((e: any) => LOG.error('MeshRecovery', `Failed to auto-relaunch session for ${node.id}: ${e?.message}`));

package/src/mesh/mesh-events-utils.ts

@@ -30,6 +30,65 @@ export function sameDaemonId(a: unknown, b: unknown): boolean {
     return ca !== '' && ca === cb;
 }
 
+/**
+ * The relay-safety metadata a worker session must carry so that its completion /
+ * generating events route back to the coordinator proactively (without waiting for
+ * a mesh_read_chat reconcile). meshCoordinatorDaemonId is the routing anchor the
+ * core forwarder (injectMeshSystemMessage) keys on to pick a remote coordinator
+ * target; meshNodeFor/meshNodeId identify the worker, and launchedByCoordinator is
+ * the delegation proof. See resolveWorkerDelegateRouting().
+ */
+export interface MeshWorkerRelayStamp {
+    meshNodeFor?: string;
+    meshNodeId?: string;
+    meshCoordinatorDaemonId?: string;
+    launchedByCoordinator?: boolean;
+}
+
+/**
+ * Build the relay-safety stamp from a dispatch's meshContext, only including fields
+ * the session does not already carry. Returns undefined when there is nothing new to
+ * stamp, so callers can skip a no-op updateSettings() write.
+ *
+ * This closes the remote-session relay gap: a worker session reached by a dispatch
+ * that carries coordinatorDaemonId (mesh_send_task / queue assignment over P2P) gets
+ * the coordinator anchor persisted onto its settings at dispatch time, even if it was
+ * not launched via mesh_launch_session. Without the stamp the forwarder cannot resolve
+ * a remote coordinator and the completion event sits in the pending queue until a
+ * read_chat-triggered reconcile drains it.
+ */
+export function buildMeshWorkerRelayStamp(
+    currentSettings: Record<string, unknown> | undefined,
+    meshContext: {
+        meshId?: unknown;
+        nodeId?: unknown;
+        coordinatorDaemonId?: unknown;
+    } | undefined,
+): MeshWorkerRelayStamp | undefined {
+    if (!meshContext) return undefined;
+    const settings = currentSettings && typeof currentSettings === 'object' ? currentSettings : {};
+    const stamp: MeshWorkerRelayStamp = {};
+
+    const meshId = readNonEmptyString(meshContext.meshId);
+    if (meshId && !readNonEmptyString(settings.meshNodeFor)) stamp.meshNodeFor = meshId;
+
+    const nodeId = readNonEmptyString(meshContext.nodeId);
+    if (nodeId && !readNonEmptyString(settings.meshNodeId)) stamp.meshNodeId = nodeId;
+
+    const coordinatorDaemonId = readNonEmptyString(meshContext.coordinatorDaemonId);
+    if (coordinatorDaemonId && !readNonEmptyString(settings.meshCoordinatorDaemonId)) {
+        stamp.meshCoordinatorDaemonId = coordinatorDaemonId;
+    }
+
+    // A dispatch from a coordinator is itself proof of delegation; stamp it when the
+    // session is being given any mesh routing context but has no marker yet.
+    if ((meshId || nodeId || coordinatorDaemonId) && settings.launchedByCoordinator !== true) {
+        stamp.launchedByCoordinator = true;
+    }
+
+    return Object.keys(stamp).length > 0 ? stamp : undefined;
+}
+
 export function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string {
     return readNonEmptyString(event.targetSessionId)
         || readNonEmptyString(event.sessionId)

package/src/providers/spec/evaluator.ts

@@ -8,7 +8,7 @@
 'use strict';
 
 import type {
-    SectionDef, Condition, RegexCondition,
+    SectionDef, AnchorContext, Condition, RegexCondition,
     ChangedCondition, AllCondition, AnyCondition,
     ExtractTitle, ExtractButtons,
 } from './types.js';
@@ -52,20 +52,44 @@ export function resolveSections(
 
         if (sec.anchor !== undefined) {
             try {
-                const re = new RegExp(sec.anchor, sec.anchor_flags ?? '');
-                const prevRe = sec.anchor_context?.prev !== undefined
-                    ? new RegExp(sec.anchor_context.prev, sec.anchor_context.prev_flags ?? '') : null;
-                const nextRe = sec.anchor_context?.next !== undefined
-                    ? new RegExp(sec.anchor_context.next, sec.anchor_context.next_flags ?? '') : null;
-                const matches = (i: number) =>
-                    re.test(lines[i])
-                    && (prevRe === null || (i > 0 && prevRe.test(lines[i - 1])))
-                    && (nextRe === null || (i < total - 1 && nextRe.test(lines[i + 1])));
+                // Normalize anchor + context into parallel candidate lists. A
+                // scalar anchor becomes a single-entry array; a single context
+                // object applies to every entry; an array context is positional.
+                // Candidates are tried IN ORDER as independent passes: the first
+                // pattern that finds any line wins. This keeps a scalar anchor's
+                // behavior identical, and lets an array express a preferred shape
+                // (e.g. a box divider) with later entries as fallbacks (e.g. a
+                // divider-less modal anchored on its question line) — the
+                // fallback only takes over when the preferred pattern is absent.
+                const anchorPatterns = Array.isArray(sec.anchor) ? sec.anchor : [sec.anchor];
+                const sharedCtx: AnchorContext | null = Array.isArray(sec.anchor_context)
+                    ? null
+                    : (sec.anchor_context ?? null);
+                const ctxList: (AnchorContext | null)[] = Array.isArray(sec.anchor_context)
+                    ? sec.anchor_context
+                    : anchorPatterns.map(() => sharedCtx);
+                const candidates = anchorPatterns.map((pattern, k) => {
+                    const ctx = ctxList[k] ?? null;
+                    return {
+                        re: new RegExp(pattern, sec.anchor_flags ?? ''),
+                        prevRe: ctx?.prev !== undefined
+                            ? new RegExp(ctx.prev, ctx.prev_flags ?? '') : null,
+                        nextRe: ctx?.next !== undefined
+                            ? new RegExp(ctx.next, ctx.next_flags ?? '') : null,
+                    };
+                });
+                const matchesCandidate = (c: typeof candidates[number], i: number) =>
+                    c.re.test(lines[i])
+                    && (c.prevRe === null || (i > 0 && c.prevRe.test(lines[i - 1])))
+                    && (c.nextRe === null || (i < total - 1 && c.nextRe.test(lines[i + 1])));
                 let idx = -1;
-                if (sec.anchor_last) {
-                    for (let i = total - 1; i >= 0; i--) { if (matches(i)) { idx = i; break; } }
-                } else {
-                    for (let i = 0; i < total; i++) { if (matches(i)) { idx = i; break; } }
+                for (const c of candidates) {
+                    if (sec.anchor_last) {
+                        for (let i = total - 1; i >= 0; i--) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                    } else {
+                        for (let i = 0; i < total; i++) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                    }
+                    if (idx !== -1) break;
                 }
                 if (idx !== -1) {
                     from = idx;

package/src/providers/spec/fsm-driver.ts

@@ -246,11 +246,27 @@ export class FsmDriver implements ISpecDriver {
         this.stateEnteredAt = now;
         this.prevStateAt = now;
         this.adapter.start();
+        // Prime focus-gated TUIs (see CliSpecV4.send_on_spawn). Written once,
+        // shortly after spawn, so the input stream is awake before the first
+        // delegated message — without this, a focus-event CLI like antigravity
+        // drops the first programmatic write until a manual keystroke.
+        this.scheduleSpawnPrime();
         // The initial state may have a purely time-based exit (elapsed_ms);
         // schedule a wake so we leave it even if the PTY goes quiet.
         this.scheduleWakeForState();
     }
 
+    private scheduleSpawnPrime(): void {
+        const seqs = this.spec.send_on_spawn;
+        if (!Array.isArray(seqs) || seqs.length === 0) return;
+        const delay = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
+        setTimeout(() => {
+            for (const seq of seqs) {
+                if (typeof seq === 'string' && seq.length > 0) this.adapter.send_keys(seq);
+            }
+        }, delay);
+    }
+
     dispatch(cmd: DashboardCommand): void {
         switch (cmd.kind) {
             case 'send_message': this.handleSendMessage(cmd.text); return;
@@ -440,6 +456,18 @@ export class FsmDriver implements ISpecDriver {
             // that's already satisfied doesn't wait for the next PTY frame.
             this.emitStateChanged(forceEmit);
             this.scheduleWakeForState();
+            // Drain queued sends on the SAME frame the machine reaches "ready".
+            // The first delegated message is queued in pendingSends until the
+            // FSM first enters a non-initial idle state (the prompt is drawn).
+            // That readiness is normally reached BY a transition (e.g.
+            // signing_in→idle / starting→idle) — and an idle state has no
+            // pending time-condition, so scheduleWakeForState() arms no timer
+            // and, agy being quiet at the prompt, no further PTY frame arrives.
+            // Without this call the queued first message would strand here
+            // forever (the "first input never processed" bug). maybeMarkReady is
+            // idempotent (guarded by readySeenOnce) so calling it on both
+            // branches is safe.
+            this.maybeMarkReady();
             return;
         }
 

package/src/providers/spec/fsm-types.ts

@@ -130,6 +130,21 @@ export interface CliSpecV4 {
     spawn_args?: string[];
     env?: Record<string, string>;
     cli_version_range?: string;
+    /**
+     * Optional raw byte sequences written to the PTY once, shortly after spawn,
+     * to prime a TUI that gates its input handling on a terminal event the
+     * daemon would otherwise never emit. The canonical case is a focus-event
+     * TUI (Ink `useStdin`/`useFocus`, e.g. antigravity's `agy`) that enables
+     * focus reporting (`CSI ?1004h`) and treats its input box as unfocused —
+     * silently dropping the first programmatic write — until it receives a
+     * focus-in event (`ESC [ I`). Declaring `[""]` here wakes the input
+     * stream on spawn so the first delegated message lands without a manual
+     * keystroke. CLIs that do not focus-gate input simply omit this field; the
+     * engine writes nothing extra for them, so it stays CLI-agnostic.
+     */
+    send_on_spawn?: string[];
+    /** Delay (ms) after spawn before writing `send_on_spawn`. Default 250. */
+    send_on_spawn_delay_ms?: number;
     send_message: {
         submit_key: string;
         delay_ms_before_submit?: number;

package/src/providers/spec/types.ts

@@ -104,19 +104,35 @@ export interface NativeHistoryMessageMap {
 // Section definition
 // ─────────────────────────────────────────────────────────────────────────────
 
+export interface AnchorContext {
+    prev?: string;
+    next?: string;
+    prev_flags?: string;
+    next_flags?: string;
+}
+
 export interface SectionDef {
     from_top?: Size;
     from_bottom?: Size;
     until?: string;             // section id OR regex (starts with ^)
-    anchor?: string;
+    /**
+     * Anchor regex(es). A single string anchors on the first/last matching line
+     * (per `anchor_last`). An array is an OR-set: every candidate line is one
+     * that matches ANY entry; with `anchor_last` the LAST such line across all
+     * patterns wins, otherwise the FIRST. This lets one section capture two
+     * different shapes — e.g. a box-divider modal AND a divider-less modal whose
+     * only stable landmark is the question line above its numbered choices.
+     */
+    anchor?: string | string[];
     anchor_flags?: string;
     anchor_last?: boolean;
-    anchor_context?: {
-        prev?: string;
-        next?: string;
-        prev_flags?: string;
-        next_flags?: string;
-    };
+    /**
+     * Context guard(s) for the anchor. A single object applies to every anchor
+     * pattern. An array is matched positionally against an `anchor` array (entry
+     * i guards anchor i); a positional `undefined`/null entry means "no guard"
+     * for that anchor. A scalar `anchor` ignores array form beyond index 0.
+     */
+    anchor_context?: AnchorContext | (AnchorContext | null)[];
     lines?: number;
     until_regex?: string;
     until_regex_flags?: string;

package/src/repo-mesh-types.ts

@@ -120,6 +120,17 @@ export interface RepoMeshPolicy {
      * watch-the-agents behavior; hidden sessions remain discoverable and manually openable.
      */
     spawnedSessionVisibility?: RepoMeshSpawnedSessionVisibility;
+    /**
+     * Whether worker sessions the coordinator dispatches should auto-approve agent
+     * approval modals (tool/command prompts) without firing a user-facing approval
+     * notification. Delegated workers are coordinator-driven, so a human should not
+     * have to approve each one; defaults to true. Set to false to make delegated
+     * worker sessions stop at approval modals like an interactive session.
+     * Stamped into the worker launch settings envelope as `autoApprove`, which wins
+     * over the global per-provider-type autoApprove config via the settings merge.
+     * A node policy may override this per-node (RepoMeshNodePolicy.delegatedWorkerAutoApprove).
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * What to do with delegated session-host records for a node when it is removed.
      * Defaults to 'preserve' so completed work can be reviewed later and live
@@ -152,6 +163,11 @@ export interface RepoMeshNodePolicy {
     maxConcurrentSessions?: number;
     /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
     providerPriority?: string[];
+    /**
+     * Per-node override for RepoMeshPolicy.delegatedWorkerAutoApprove. When set, takes
+     * precedence over the mesh-level policy for worker sessions launched onto this node.
+     */
+    delegatedWorkerAutoApprove?: boolean;
     /**
      * Optional associated/external repos that must be checked alongside this node.
      * These are explicit policy/config entries only; Repo Mesh does not auto-discover
@@ -184,11 +200,32 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
     spawnedSessionVisibility: 'visible',
+    delegatedWorkerAutoApprove: true,
     sessionCleanupOnNodeRemove: 'preserve',
     autoFastForward: { enabled: true },
     maxTaskRetries: 1,
 };
 
+/**
+ * Resolve whether a delegated worker session launched onto `nodePolicy` (within a mesh
+ * governed by `meshPolicy`) should auto-approve. Precedence: node override → mesh policy
+ * → default true. The result is stamped into the worker launch settings envelope as
+ * `autoApprove`; it wins over the global per-provider-type autoApprove config because the
+ * launch path merges the envelope as a settingsOverride on top of the provider defaults.
+ */
+export function resolveDelegatedWorkerAutoApprove(
+    meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null,
+    nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null,
+): boolean {
+    if (typeof nodePolicy?.delegatedWorkerAutoApprove === 'boolean') {
+        return nodePolicy.delegatedWorkerAutoApprove;
+    }
+    if (typeof meshPolicy?.delegatedWorkerAutoApprove === 'boolean') {
+        return meshPolicy.delegatedWorkerAutoApprove;
+    }
+    return true;
+}
+
 // ─── Capabilities ───────────────────────────────
 
 export interface RepoMeshNodeCapabilities {