@adhdev/daemon-core 0.9.82-rc.46 → 0.9.82-rc.460

package/src/providers/manual-attendance.ts

@@ -0,0 +1,105 @@
+/**
+ * ManualAttendanceTracker — provider-agnostic "is a human driving this session
+ * right now" signal, used to suppress auto-approve while the user is taking
+ * manual control of a session from the dashboard.
+ *
+ * Why this exists
+ * ---------------
+ * When `autoApprove` is on, an approval modal is auto-dismissed within a few
+ * hundred ms of appearing. For a background mesh worker that is exactly the
+ * desired delegated behavior. But for a session the user is actively watching
+ * and operating (a base-node / foreground session), the auto-fire closes the
+ * modal before the human can pick a button — and likewise fights their use of
+ * the controlbar. The fix is to give the human a short quiet window: while they
+ * are attending the session by hand, auto-approve holds; once they go idle it
+ * resumes.
+ *
+ * The tracker holds only a timestamp. The *signal* — which commands count as
+ * "a human attending" — is decided by the caller (the command handler), and is
+ * the same set for every provider: foreground tab selection (select_session /
+ * open_panel), controlbar use (invoke_provider_script / set_mode / change_model
+ * / set_thought_level), manual approval (resolve_action) and manual terminal
+ * input (pty_input). Notably NOT send_chat, which is also how a coordinator
+ * delegates a task to a worker — counting it would wrongly suppress the
+ * worker's delegated auto-approve.
+ *
+ * Because a background worker never receives any of those attending commands,
+ * it is never "attended", so its delegated auto-approve is unaffected. The
+ * mechanism is therefore provider-common AND preserves worker auto-approve
+ * without any per-provider branching.
+ */
+
+/**
+ * How long after the last manual interaction auto-approve stays suppressed.
+ *
+ * Trade-off: long enough that after foregrounding a session's tab the user has
+ * a realistic chance to act on an incoming approval (the auto-approve settle
+ * window is only ~600ms, so a human cannot out-race it), yet short enough that
+ * a session left unattended — e.g. a worker tab the user briefly peeked at —
+ * resumes auto-approving within about a minute. Re-armed on every attending
+ * command, so a user who keeps interacting keeps the window fresh.
+ */
+export const AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS = 60_000;
+
+export class ManualAttendanceTracker {
+    private lastInteractionAt = 0;
+
+    constructor(private readonly suppressMs: number = AUTO_APPROVE_MANUAL_ATTENDANCE_SUPPRESS_MS) {}
+
+    /** Record that a human just drove this session by hand. */
+    note(now = Date.now()): void {
+        this.lastInteractionAt = now;
+    }
+
+    /** True while a manual interaction is recent enough to suppress auto-approve. */
+    isAttended(now = Date.now()): boolean {
+        return this.lastInteractionAt > 0 && (now - this.lastInteractionAt) < this.suppressMs;
+    }
+
+    /**
+     * Milliseconds remaining in the current suppression window, or 0 when not
+     * attended. Used to re-arm a re-check timer so auto-approve fires the moment
+     * the window lapses even if the PTY/agent has since gone silent.
+     */
+    remainingMs(now = Date.now()): number {
+        if (this.lastInteractionAt <= 0) return 0;
+        return Math.max(0, this.suppressMs - (now - this.lastInteractionAt));
+    }
+}
+
+/**
+ * The session-scoped commands that count as "a human is attending this session
+ * by hand". Shared so the command handler and any forward path agree on one
+ * definition. Deliberately excludes send_chat (coordinator task delegation) and
+ * pure read commands (read_chat / list_chats — passive polling, not driving).
+ */
+export const MANUAL_ATTENDANCE_COMMANDS: ReadonlySet<string> = new Set([
+    'select_session',
+    'open_panel',
+    'invoke_provider_script',
+    'set_mode',
+    'change_model',
+    'set_thought_level',
+    'resolve_action',
+    'pty_input',
+]);
+
+/**
+ * The subset of {@link MANUAL_ATTENDANCE_COMMANDS} that are PASSIVE view-only
+ * actions — foregrounding a session's tab / opening its panel. They convey "I am
+ * looking at this session", not "I am driving it", and carry no user input.
+ *
+ * For a foreground (base-node) session these still attend: a user who
+ * foregrounds their own session should get the quiet window so an incoming
+ * approval stays visible for them to act on. But for a DELEGATED worker session
+ * a passive peek must NOT attend — a coordinator merely opening a worker's panel
+ * to watch progress would otherwise suppress that worker's delegated
+ * auto-approve for the whole window (secondary cause, #137). The per-instance
+ * hook decides: it drops a passive stamp only when the session is a delegated
+ * worker, so explicit input (controlbar / resolve_action / pty_input) still
+ * attends a worker and a foreground session is unaffected.
+ */
+export const MANUAL_ATTENDANCE_PASSIVE_VIEW_COMMANDS: ReadonlySet<string> = new Set([
+    'select_session',
+    'open_panel',
+]);

package/src/providers/native-history/antigravity-claim-registry.ts

@@ -0,0 +1,131 @@
+/**
+ * antigravity-claim-registry — daemon-local conversation ownership map.
+ *
+ * Antigravity CLI writes each conversation into its own per-session SQLite db
+ * at ~/.gemini/antigravity-cli/conversations/<uuid>.db. But before a daemon
+ * session has resolved its provider session id, the discovery resolver used to
+ * fall back to "the newest .db on disk by mtime". Two sessions started within a
+ * few ms of each other on ONE daemon therefore both grabbed the SAME newest
+ * store — so one session's injected prompt and the other's assistant completion
+ * cross-routed, and an unrelated turn completed the wrong task (RCA: a
+ * coordinator session ended up reading the owner's conversation .db, and the
+ * coordinator's own injected instruction was absent from the bound store).
+ *
+ * This registry records which live daemon session currently owns a given
+ * conversation uuid. The discovery resolver (dispatcher.resolveAntigravityPath)
+ * consults it to:
+ *   (1) never hand a conversation already owned by a DIFFERENT live session to
+ *       an as-yet-unbound one — two sessions can never resolve to the same .db;
+ *   (2) LOCK a session to the first conversation it binds, so a later, newer
+ *       .db on disk cannot re-bind an already-bound session on a subsequent
+ *       mtime-ordered read.
+ *
+ * Ownership is keyed by a per-session owner token (see antigravityOwnerToken)
+ * that BOTH the resolver and the provider instance derive identically from the
+ * same inputs (workspace + spawn time, or the instance id), so the instance can
+ * release its claims deterministically on shutdown.
+ *
+ * A claim not refreshed within CLAIM_STALE_MS is treated as abandoned — a
+ * safety net for a session that died without an explicit release. Live sessions
+ * poll native history far more frequently than this window, so an active owner
+ * never lapses; only a crashed/leaked owner's claim ages out.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+'use strict';
+
+interface ConversationClaim {
+  owner: string;
+  /** Last time this owner (re)confirmed the claim. Only consulted by the
+   *  stale-claim safety net; an active owner refreshes it on every resolve. */
+  refreshedAtMs: number;
+}
+
+const claimsByUuid = new Map<string, ConversationClaim>();
+
+/** A claim older than this with no refresh is reclaimable (owner presumed dead). */
+export const CLAIM_STALE_MS = 10 * 60 * 1000;
+
+function normalizeUuid(uuid: string): string {
+  return String(uuid || '').trim().toLowerCase();
+}
+
+/**
+ * Derive the per-session owner token. Both the dispatcher (from the read input:
+ * workspace + sessionStartedAtMs) and the provider instance (from its
+ * workingDir + startedAt, or its instanceId) call this with the same inputs so
+ * claims and releases line up. Returns '' when there is no stable identity to
+ * key on (e.g. a workspace-less discovery with no spawn time) — the caller then
+ * skips claiming but the exclusion checks still run against existing claims.
+ */
+export function antigravityOwnerToken(
+  workspace: string,
+  sessionStartedAtMs: number,
+  instanceId?: string,
+): string {
+  const iid = typeof instanceId === 'string' ? instanceId.trim() : '';
+  if (iid) return `iid:${iid}`;
+  if (typeof sessionStartedAtMs === 'number' && sessionStartedAtMs > 0) {
+    const ws = String(workspace || '').trim().toLowerCase();
+    return `spawn:${ws}:${sessionStartedAtMs}`;
+  }
+  return '';
+}
+
+/**
+ * Claim `uuid` for `owner`. Succeeds (and refreshes) when the conversation is
+ * unclaimed, already owned by this owner, or held by a stale (abandoned) owner.
+ * Fails when a DIFFERENT live owner holds it. Returns whether `owner` holds the
+ * claim after the call.
+ */
+export function claimAntigravityConversation(uuid: string, owner: string, now: number = Date.now()): boolean {
+  const key = normalizeUuid(uuid);
+  if (!key || !owner) return false;
+  const existing = claimsByUuid.get(key);
+  if (existing && existing.owner !== owner && (now - existing.refreshedAtMs) < CLAIM_STALE_MS) {
+    return false;
+  }
+  claimsByUuid.set(key, { owner, refreshedAtMs: now });
+  return true;
+}
+
+/** True when `uuid` is held by a live owner OTHER than `owner`. */
+export function isAntigravityConversationClaimedByOther(uuid: string, owner: string, now: number = Date.now()): boolean {
+  const key = normalizeUuid(uuid);
+  if (!key) return false;
+  const existing = claimsByUuid.get(key);
+  if (!existing) return false;
+  if (existing.owner === owner) return false;
+  return (now - existing.refreshedAtMs) < CLAIM_STALE_MS;
+}
+
+/** The live owner of `uuid`, or undefined when unclaimed or stale. */
+export function antigravityConversationOwner(uuid: string, now: number = Date.now()): string | undefined {
+  const key = normalizeUuid(uuid);
+  if (!key) return undefined;
+  const existing = claimsByUuid.get(key);
+  if (!existing) return undefined;
+  if ((now - existing.refreshedAtMs) >= CLAIM_STALE_MS) return undefined;
+  return existing.owner;
+}
+
+/** Release a single conversation, only if held by `owner` (or `owner` empty). */
+export function releaseAntigravityConversation(uuid: string, owner?: string): void {
+  const key = normalizeUuid(uuid);
+  if (!key) return;
+  const existing = claimsByUuid.get(key);
+  if (existing && (!owner || existing.owner === owner)) claimsByUuid.delete(key);
+}
+
+/** Release every conversation held by `owner` (called on session shutdown). */
+export function releaseAntigravityOwner(owner: string): void {
+  if (!owner) return;
+  for (const [key, claim] of claimsByUuid) {
+    if (claim.owner === owner) claimsByUuid.delete(key);
+  }
+}
+
+/** Test-only: wipe all claims so each test starts from a clean registry. */
+export function __resetAntigravityClaimRegistry(): void {
+  claimsByUuid.clear();
+}