instar 1.3.371 → 1.3.373

package/.claude/skills/autonomous/hooks/autonomous-stop-hook.sh

@@ -542,6 +542,122 @@ if [[ "$STATE_SESSION" != "$HOOK_SESSION" ]]; then
   record_session_id "$HOOK_SESSION"
 fi
 
+# ── IDLE_BACKOFF — consecutive quick stops back off before re-injecting the frame ──
+# Every block-decision below re-feeds the FULL frame + context to the model. When the
+# session is idle/holding (nothing actionable), stops arrive back-to-back (~4s apart)
+# and the loop re-injects thousands of tokens ~15×/min, all night — the 2026-06-06
+# rapid-idle-refire waste. Backoff: measure the agent's ACTIVE time since the last
+# re-injection (gap = stop arrival − last resume; slept time never counts toward the
+# gap, so a long sleep can't masquerade as productive work). gap < QUICK_SECS ⇒ an
+# idle cycle ⇒ the consecutive counter rises ⇒ tiered sleep (3+ quick stops → T1 30s,
+# 6+ → T2 120s, 10+ → T3 300s) BEFORE the next re-injection. Any real work makes the
+# gap long and resets the counter to zero — productive loops never wait at all.
+# RESPONSIVENESS: the sleep polls every POLL_SECS and breaks EARLY on (a) a new
+# inbound message for this topic, (b) the emergency-stop flag, (c) the state file
+# vanishing (stop/stop-all) — a user message cuts the wait to ≤POLL_SECS.
+# SAFETY (fail-toward-noise, never toward strand): the total sleep self-clamps to a
+# third of THIS hook's own registered Stop timeout, read live from settings.json —
+# a host-killed Stop hook fails OPEN and strands the loop, which is categorically
+# worse than refire noise. Unreadable/missing timeout ⇒ conservative 20s cap; codex
+# registrations (.codex/hooks.json, different timeout semantics) ⇒ same 20s cap.
+BACKOFF_STATE="${STATE_FILE%.md}.backoff.json"
+BACKOFF_SLEPT=0
+if [[ "${INSTAR_HOOK_BACKOFF_DISABLE:-0}" != "1" ]]; then
+  BK_QUICK_SECS="${INSTAR_HOOK_BACKOFF_QUICK_SECS:-120}"
+  BK_T1="${INSTAR_HOOK_BACKOFF_T1:-30}"
+  BK_T2="${INSTAR_HOOK_BACKOFF_T2:-120}"
+  BK_T3="${INSTAR_HOOK_BACKOFF_T3:-300}"
+  BK_POLL="${INSTAR_HOOK_BACKOFF_POLL_SECS:-5}"
+
+  # Self-clamp: never sleep past a third of the registered hook timeout.
+  BK_MAX="${INSTAR_HOOK_BACKOFF_MAX_SLEEP:-}"
+  if [[ -z "$BK_MAX" ]]; then
+    if [[ "$IS_CODEX" == "1" ]]; then
+      BK_MAX=20
+    else
+      BK_REG_TIMEOUT=$(python3 -c "
+import json
+try:
+    s = json.load(open('.claude/settings.json'))
+    for grp in (s.get('hooks', {}).get('Stop') or []):
+        for h in (grp.get('hooks') or []):
+            if 'autonomous-stop-hook.sh' in (h.get('command') or ''):
+                t = h.get('timeout')
+                print(int(t) if isinstance(t, (int, float)) and t > 0 else '')
+                raise SystemExit
+except SystemExit:
+    pass
+except Exception:
+    pass
+" 2>/dev/null || echo "")
+      if [[ "$BK_REG_TIMEOUT" =~ ^[0-9]+$ ]] && [[ $BK_REG_TIMEOUT -ge 60 ]]; then
+        BK_MAX=$(( BK_REG_TIMEOUT / 3 ))
+      else
+        BK_MAX=20
+      fi
+    fi
+  fi
+
+  # Read sidecar (per-topic). A new run (different started_at) resets the counter.
+  BK_PREV_RESUMED=$(jq -r '.lastResumedAt // 0' "$BACKOFF_STATE" 2>/dev/null || echo 0)
+  BK_PREV_QUICK=$(jq -r '.quickStops // 0' "$BACKOFF_STATE" 2>/dev/null || echo 0)
+  BK_PREV_RUN=$(jq -r '.runStartedAt // ""' "$BACKOFF_STATE" 2>/dev/null || echo "")
+  [[ "$BK_PREV_RESUMED" =~ ^[0-9]+$ ]] || BK_PREV_RESUMED=0
+  [[ "$BK_PREV_QUICK" =~ ^[0-9]+$ ]] || BK_PREV_QUICK=0
+  if [[ "$BK_PREV_RUN" != "$STARTED_AT" ]]; then
+    BK_PREV_RESUMED=0; BK_PREV_QUICK=0
+  fi
+
+  BK_NOW=$(date +%s)
+  BK_GAP=-1
+  BK_QUICK=0
+  if [[ $BK_PREV_RESUMED -gt 0 ]]; then
+    BK_GAP=$(( BK_NOW - BK_PREV_RESUMED ))
+    if [[ $BK_GAP -lt $BK_QUICK_SECS ]]; then
+      BK_QUICK=$(( BK_PREV_QUICK + 1 ))
+    fi
+  fi
+
+  BK_SLEEP=0
+  if   [[ $BK_QUICK -ge 10 ]]; then BK_SLEEP=$BK_T3
+  elif [[ $BK_QUICK -ge 6  ]]; then BK_SLEEP=$BK_T2
+  elif [[ $BK_QUICK -ge 3  ]]; then BK_SLEEP=$BK_T1
+  fi
+  [[ $BK_SLEEP -gt $BK_MAX ]] && BK_SLEEP=$BK_MAX
+
+  if [[ $BK_SLEEP -gt 0 ]]; then
+    bk_inbound_latest() { ls -t .instar/telegram-inbound/msg-"${REPORT_TOPIC:-none}"-* 2>/dev/null | head -1; }
+    BK_MARK_IN=$(bk_inbound_latest)
+    while [[ $BACKOFF_SLEPT -lt $BK_SLEEP ]]; do
+      BK_CHUNK=$(( BK_SLEEP - BACKOFF_SLEPT ))
+      [[ $BK_CHUNK -gt $BK_POLL ]] && BK_CHUNK=$BK_POLL
+      sleep "$BK_CHUNK"
+      BACKOFF_SLEPT=$(( BACKOFF_SLEPT + BK_CHUNK ))
+      [[ -f ".instar/autonomous-emergency-stop" ]] && break
+      [[ ! -f "$STATE_FILE" ]] && break
+      [[ "$(bk_inbound_latest)" != "$BK_MARK_IN" ]] && break
+    done
+    echo "[autonomous] idle backoff: quickStops=$BK_QUICK gap=${BK_GAP}s slept=${BACKOFF_SLEPT}s (cap=${BK_MAX}s)" >&2
+
+    # Re-check terminal conditions that may have arrived during the sleep.
+    if [[ ! -f "$STATE_FILE" ]]; then
+      rm -f "$BACKOFF_STATE" 2>/dev/null || true
+      echo "[autonomous] state file removed during idle backoff — allowing exit" >&2
+      exit 0
+    fi
+    if [[ -f ".instar/autonomous-emergency-stop" ]]; then
+      emit "🛑 Autonomous mode: Emergency stop detected (during idle backoff)."
+      notify_terminal_stop "🛑 My autonomous run on \"$(goal_snippet)\" was stopped (emergency stop)."
+      rm -f "$STATE_FILE" "$BACKOFF_STATE" 2>/dev/null || true
+      exit 0
+    fi
+  fi
+
+  BK_RESUMED=$(date +%s)
+  printf '{"runStartedAt":"%s","lastResumedAt":%s,"quickStops":%s,"lastSleepSecs":%s}\n' \
+    "$STARTED_AT" "$BK_RESUMED" "$BK_QUICK" "$BACKOFF_SLEPT" > "$BACKOFF_STATE" 2>/dev/null || true
+fi
+
 # ── Continue the job: increment iteration, feed the task back. ────────
 NEXT_ITERATION=$((ITERATION + 1))
 

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA6SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAuxDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA4iTtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA6SH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAuxDD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwpTtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -2367,6 +2367,13 @@ export async function startServer(options) {
         // same explicit replication gate; undefined = dark (verb answers
         // 'disabled', merge layer returns own rows only).
         let commitmentReplicaStore;
+        // P1.5b owner-routed mutation (§3.4): the owner-side replay window, the
+        // forwarder-side durable intent queue, and the route-facing forward fn.
+        // All undefined while dark.
+        let commitmentOpKeyWindow;
+        let pendingMutationLedger;
+        let _commitmentReFire;
+        let forwardCommitmentMutate;
         {
             const cjCfg = config.multiMachine?.coherenceJournal;
             const cjEnabled = cjCfg?.enabled ?? !!config.developmentAgent;
@@ -9957,6 +9964,23 @@ export async function startServer(options) {
                                 return { ok: false, reason: 'working-set disabled' };
                             return workingSetPullServer.handle(cmd);
                         },
+                        // COMMITMENTS-COHERENCE-SPEC §3.4 — owner-side apply for the
+                        // owner-routed mutation. opKey window first (replay returns the
+                        // recorded verdict, applies nothing); the UNCHANGED state machine
+                        // re-validates; the opKey records AFTER the store write (§4.5 —
+                        // a crash between resolves as idempotent-noop on the re-fire).
+                        'commitment-mutate': async (cmd) => {
+                            const c = cmd;
+                            if (!commitmentOpKeyWindow || !commitmentTracker)
+                                return { ok: false, reason: 'commitment-mutate disabled' };
+                            const mutMod = await import('../core/CommitmentMutation.js');
+                            const replay = commitmentOpKeyWindow.check(c.payload.opKey);
+                            if (replay)
+                                return { verdict: replay.verdict, ...(replay.status ? { status: replay.status } : {}), replayed: true };
+                            const outcome = await mutMod.applyOwnerMutation(commitmentTracker, c.payload);
+                            commitmentOpKeyWindow.record(c.payload.opKey, outcome);
+                            return outcome;
+                        },
                         // COMMITMENTS-COHERENCE-SPEC §3.2 — serve OWN commitment records
                         // as seq-windowed delta pages. Registered always (lockstep with
                         // the union+RBAC edits); answers 'disabled' until the replication
@@ -10243,7 +10267,81 @@ export async function startServer(options) {
                                     stateDir: config.stateDir,
                                     logger: (m) => console.log(pc.dim(`  [commitments-sync] ${m}`)),
                                 });
-                                console.log(pc.dim('  [commitments-sync] replica store wired (serve + receive + advert)'));
+                                // P1.5b: opKey window + pending-mutation ledger + forward fn.
+                                const mutMod = await import('../core/CommitmentMutation.js');
+                                const csCfg2 = config.multiMachine?.coherenceJournal?.commitments;
+                                commitmentOpKeyWindow = new mutMod.OpKeyWindow({
+                                    stateDir: config.stateDir,
+                                    ttlDays: csCfg2?.opKeyTtlDays,
+                                });
+                                pendingMutationLedger = new mutMod.PendingMutationLedger({
+                                    stateDir: config.stateDir,
+                                    ttlDays: csCfg2?.pendingMutationTtlDays,
+                                    maxPerCommitment: csCfg2?.maxPendingOpsPerCommitment,
+                                    maxPerOwner: csCfg2?.maxPendingOpsPerOwner,
+                                    onExpired: (rec) => {
+                                        void telegram?.createAttentionItem({
+                                            id: `CMT-MUT-EXPIRED-${rec.payload.opKey}`,
+                                            title: `A queued commitment ${rec.payload.op} was never applied`,
+                                            summary: `The ${rec.payload.op} for ${rec.payload.origin}::${rec.payload.id} stayed queued for the full retention window (${rec.attempts} attempts) — its home machine never returned. Re-issue it once that machine is back.`,
+                                            category: 'agent-health',
+                                            priority: 'NORMAL',
+                                            lane: 'agent-health',
+                                            sourceContext: 'commitments-coherence',
+                                        }).catch(() => { });
+                                    },
+                                    logger: (m) => console.log(pc.dim(`  [commitment-mutate] ${m}`)),
+                                });
+                                const sendMutate = async (ownerMachineId, payload) => {
+                                    const url = peerUrl(ownerMachineId);
+                                    const queue = async (reason) => {
+                                        await pendingMutationLedger.enqueue(payload);
+                                        return { kind: 'queued', reason };
+                                    };
+                                    if (!url)
+                                        return queue('owner unreachable (no known URL)');
+                                    try {
+                                        const res = await meshClient.send({ machineId: ownerMachineId, url }, { type: 'commitment-mutate', payload }, 0);
+                                        if (res.ok && res.result && typeof res.result === 'object' && 'verdict' in res.result) {
+                                            await pendingMutationLedger.clear(payload.opKey);
+                                            return { kind: 'verdict', outcome: res.result };
+                                        }
+                                        if (!res.ok && (res.status === 501 || res.status === 403)) {
+                                            // Mutating-verb mixed-version honesty (§3.4): an old
+                                            // owner queues durably + the caller answers honestly.
+                                            return queue(`owner runs an older version (HTTP ${res.status}) — applies after it updates`);
+                                        }
+                                        return queue(`owner answered unexpectedly (HTTP ${res.status})`);
+                                    }
+                                    catch (e) {
+                                        // Timeout/transport = AMBIGUOUS (B24): queue with the SAME
+                                        // opKey — if the owner did apply, the re-fire returns the
+                                        // recorded verdict (idempotent-noop), never a double-apply.
+                                        return queue(`owner unreachable (${e instanceof Error ? e.message : String(e)}) — queued, confirming on its return`);
+                                    }
+                                };
+                                forwardCommitmentMutate = sendMutate;
+                                // Re-fire on the owner's return: ride the SAME presence seam
+                                // the working-set drain uses; sequential, fresh envelopes.
+                                const reFireForOwner = async (ownerMachineId) => {
+                                    if (!pendingMutationLedger)
+                                        return;
+                                    const pending = await pendingMutationLedger.pendingForOwner(ownerMachineId);
+                                    for (const rec of pending) {
+                                        const r = await sendMutate(ownerMachineId, rec.payload);
+                                        if (r.kind === 'verdict')
+                                            continue; // cleared inside sendMutate
+                                        await pendingMutationLedger.recordAttempt(rec.payload.opKey);
+                                    }
+                                };
+                                _commitmentReFire = reFireForOwner;
+                                // TTL sweep rides the working-set 10-min timer cadence.
+                                const cmtSweepTimer = setInterval(() => {
+                                    void pendingMutationLedger?.sweepExpired().catch(() => { });
+                                }, 600_000);
+                                if (typeof cmtSweepTimer.unref === 'function')
+                                    cmtSweepTimer.unref();
+                                console.log(pc.dim('  [commitments-sync] replica store wired (serve + receive + advert + owner-routed mutation)'));
                             }
                             catch (e) { /* @silent-fallback-ok: commitments-sync construction failure degrades to local-only commitments — never blocks boot (COMMITMENTS-COHERENCE-SPEC §4) */
                                 commitmentReplicaStore = undefined;
@@ -10489,6 +10587,13 @@ export async function startServer(options) {
                             return undefined;
                         return nested[machineId] ?? Object.values(nested)[0];
                     };
+                    // Returning-peer hook (one compact dep keeps the wiring-test window
+                    // intact): working-set pending-pull drain (§3.4) + queued
+                    // commitment-mutate re-fire (P1.5b §3.4). Both no-op while dark.
+                    const onPeerBack = (machineId) => {
+                        workingSetPullCoordinator?.onPeerRecorded(machineId);
+                        void _commitmentReFire?.(machineId).catch(() => { });
+                    };
                     const peerPresencePuller = new presenceMod.PeerPresencePuller({
                         selfMachineId: meshSelfId,
                         listPeers: () => meshIdMgr
@@ -10497,7 +10602,7 @@ export async function startServer(options) {
                             .map((m) => ({ machineId: m.machineId, url: peerUrl(m.machineId) })),
                         recordHeartbeat: (obs) => { machinePoolRegistry?.recordHeartbeat(obs); },
                         log: (line) => console.log(pc.dim(`  [peer-presence] ${line}`)),
-                        onPeerRecorded: (machineId) => workingSetPullCoordinator?.onPeerRecorded(machineId), // working-set re-arm (§3.4); no-op when dark
+                        onPeerRecorded: (m) => onPeerBack(m), // ws re-arm + queued-commitment re-fire; no-op when dark
                         fetchPeerCapacity: async (machineId, url) => {
                             const res = await meshClient.send({ machineId, url }, { type: 'session-status' }, 0);
                             if (res.ok && res.result && typeof res.result === 'object') {
@@ -10791,7 +10896,7 @@ export async function startServer(options) {
         catch (err) {
             console.log(pc.dim(`  [session-pool] rollout gate not wired: ${err instanceof Error ? err.message : String(err)}`));
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, rateLimitSentinel, releaseReadinessSentinel: releaseReadinessSentinel ?? undefined, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, leaseTransport, onLeasePullRequest: () => leaseCoordinatorRef?.currentLease() ?? null, liveTailReceiver, handoffWireTransport, onHandoffBegin, onHandoffInitiate: handoffInitiate, handoffInProgress: handoffSentinelInProgress, messageLedger, currentInboundByTopic, replyMarkerTransport, onReplyMarker: messageLedger ? (marker) => { const m = marker; messageLedger.applyRemoteReplyMarker(m.dedupeKey, { platform: m.platform, replyIdempotencyKey: m.replyIdempotencyKey, epoch: m.epoch, topic: m.topic ?? null }); } : undefined, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, conversationStore, warrantsReplyGate, collaborationSurfacer, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, completionEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, machinePoolRegistry, meshRpcDispatcher, workingSetPullCoordinator, commitmentReplicaStore, sessionOwnershipRegistry, topicPinStore: _topicPinStore ?? undefined, secretSync: _secretSyncHandle ?? undefined, meshSelfId: _meshSelfId ?? undefined, resolveRouterUrl: _resolveRouterUrl ?? undefined, resolvePeerUrls: _resolvePeerUrls ?? undefined, sessionPoolE2EResultStore, proxyCoordinator, topicIntentStore, topicIntentArcCheck, usherSignalStore, intelligence: sharedIntelligence ?? undefined, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, briefDeps, workingMemory, taskFlowRegistry, threadlineFlowBridge, sessionReaper, agentWorktreeReaper, mcpProcessReaper, geminiLoopRunner, sleepController, agentActivityState, reapLog, sleepWakeDetector, unjustifiedStopGate, stopGateDb, stopNotifier });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, rateLimitSentinel, releaseReadinessSentinel: releaseReadinessSentinel ?? undefined, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, sessionRefresh: _sessionRefresh ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, leaseTransport, onLeasePullRequest: () => leaseCoordinatorRef?.currentLease() ?? null, liveTailReceiver, handoffWireTransport, onHandoffBegin, onHandoffInitiate: handoffInitiate, handoffInProgress: handoffSentinelInProgress, messageLedger, currentInboundByTopic, replyMarkerTransport, onReplyMarker: messageLedger ? (marker) => { const m = marker; messageLedger.applyRemoteReplyMarker(m.dedupeKey, { platform: m.platform, replyIdempotencyKey: m.replyIdempotencyKey, epoch: m.epoch, topic: m.topic ?? null }); } : undefined, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, conversationStore, warrantsReplyGate, collaborationSurfacer, threadResumeMap, topicLinkageHandler: topicLinkageHandler ?? undefined, threadlineRelayClient, threadlineReplyWaiters, listenerManager: listenerManager ?? undefined, responseReviewGate, messagingToneGate, outboundDedupGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, completionEvaluator, unifiedTrust, liveConfig, sharedStateLedger, ledgerSessionRegistry, worktreeManager, oidcEnrolledRepos: parallelDevConfig?.oidcEnrolledRepos, initiativeTracker, projectRoundRunner, projectDriftChecker, machineHeartbeat, machinePoolRegistry, meshRpcDispatcher, workingSetPullCoordinator, commitmentReplicaStore, forwardCommitmentMutate, sessionOwnershipRegistry, topicPinStore: _topicPinStore ?? undefined, secretSync: _secretSyncHandle ?? undefined, meshSelfId: _meshSelfId ?? undefined, resolveRouterUrl: _resolveRouterUrl ?? undefined, resolvePeerUrls: _resolvePeerUrls ?? undefined, sessionPoolE2EResultStore, proxyCoordinator, topicIntentStore, topicIntentArcCheck, usherSignalStore, intelligence: sharedIntelligence ?? undefined, telegramBridgeConfig, telegramBridge: telegramBridge ?? undefined, threadlineObservability, briefDeps, workingMemory, taskFlowRegistry, threadlineFlowBridge, sessionReaper, agentWorktreeReaper, mcpProcessReaper, geminiLoopRunner, sleepController, agentActivityState, reapLog, sleepWakeDetector, unjustifiedStopGate, stopGateDb, stopNotifier });
         // Boot-recovery (tunnel-failure-resilience spec Part 6): if the agent
         // died mid-relay-episode, the persisted tunnel.json carries
         // rotationPending=true. Rotate the dashboard PIN + authToken BEFORE