gestalt-mobile 0.17.2 → 0.18.0

package/dist/server/server/features/agent-activity/model.js

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const states = [
+    'blocked',
+    'awaitingHuman',
+    'working',
+    'awaitingAgent',
+    'idle',
+    'disconnected',
+];
+export function createAgentActivitySnapshot(sessionId, observedAt) {
+    return Object.freeze({
+        sessionId,
+        root: Object.freeze({
+            state: 'disconnected',
+            reason: 'unknown',
+            observedAt,
+            lastActivityAt: observedAt,
+        }),
+        subagents: Object.freeze([]),
+        aggregateSubagents: 'idle',
+        confidence: 'stale',
+    });
+}
+/** Pure reducer: authoritative facts win; an observed heartbeat never makes an active actor idle. */
+export function projectAgentActivity(current, fact) {
+    if (fact.sessionId !== current.sessionId || !validTimestamp(fact.occurredAt))
+        return current;
+    // Notifications can replay or arrive out of order. Never let an older fact
+    // regress an actor's authoritative state.
+    if (Date.parse(fact.occurredAt) < Date.parse(current.root.observedAt))
+        return current;
+    // A shared app-server stream includes spawned threads. Only a known root
+    // thread may change root state; child-thread facts are mapped to that child.
+    if (fact.threadId && current.rootThreadId && fact.threadId !== current.rootThreadId) {
+        const child = current.subagents.find((candidate) => candidate.threadId === fact.threadId);
+        if (!child)
+            return current;
+        const childFact = { ...fact };
+        delete childFact.threadId;
+        return projectAgentActivity(current, {
+            ...childFact,
+            childId: child.id,
+            kind: 'collaboration',
+            childStatus: fact.status,
+        });
+    }
+    const observedAt = later(current.root.observedAt, fact.occurredAt);
+    const root = {
+        ...current.root,
+        observedAt,
+        lastActivityAt: later(current.root.lastActivityAt, fact.occurredAt),
+    };
+    const children = new Map(current.subagents.map((child) => [child.id, child]));
+    if (fact.kind === 'turnStarted')
+        Object.assign(root, { state: 'working', reason: 'turnActive' });
+    if (fact.kind === 'threadStarted')
+        applyStatus(root, fact.status);
+    if (fact.kind === 'turnCompleted' && root.state !== 'awaitingHuman')
+        Object.assign(root, { state: 'idle', reason: 'turnCompleted' });
+    if (fact.kind === 'interactionPending')
+        Object.assign(root, {
+            state: 'awaitingHuman',
+            reason: fact.attentionReason ?? 'pendingInteraction',
+        });
+    if (fact.kind === 'interactionResolved' && root.state === 'awaitingHuman')
+        Object.assign(root, fact.hasPendingInteraction
+            ? { state: 'awaitingHuman', reason: fact.attentionReason ?? 'pendingInteraction' }
+            : { state: 'working', reason: 'turnActive' });
+    if (fact.kind === 'processExited')
+        Object.assign(root, { state: 'disconnected', reason: 'processExited' });
+    if (fact.kind === 'threadStatus')
+        applyStatus(root, fact.status);
+    if (fact.kind === 'collaboration') {
+        // Older servers may omit experimental child metadata. That is a capability
+        // downgrade, not evidence that the root process disappeared.
+        if (!fact.childId)
+            root.reason = 'missingCollaborationMetadata';
+        else {
+            const before = children.get(fact.childId);
+            const child = Object.freeze({
+                id: fact.childId,
+                ...(fact.childThreadId
+                    ? { threadId: fact.childThreadId }
+                    : before?.threadId
+                        ? { threadId: before.threadId }
+                        : {}),
+                ...(fact.childNickname
+                    ? { nickname: fact.childNickname }
+                    : before?.nickname
+                        ? { nickname: before.nickname }
+                        : {}),
+                ...(fact.childRole ? { role: fact.childRole } : before?.role ? { role: before.role } : {}),
+                state: childState(fact.childStatus, fact.collaborationAction, before?.state),
+                reason: childReason(fact.childStatus, fact.collaborationAction),
+                observedAt: fact.occurredAt,
+                lastActivityAt: later(before?.lastActivityAt ?? fact.occurredAt, fact.occurredAt),
+            });
+            children.set(fact.childId, child);
+            if (fact.collaborationAction === 'wait' && root.state === 'working')
+                Object.assign(root, { state: 'awaitingAgent', reason: 'collaborationWait' });
+        }
+    }
+    const subagents = Object.freeze([...children.values()].sort((a, b) => a.id.localeCompare(b.id)));
+    const next = Object.freeze({
+        sessionId: current.sessionId,
+        ...(current.rootThreadId || (fact.kind === 'threadStarted' && fact.threadId)
+            ? { rootThreadId: current.rootThreadId ?? fact.threadId }
+            : {}),
+        root: Object.freeze(root),
+        subagents,
+        aggregateSubagents: aggregate(subagents),
+        confidence: current.confidence,
+    });
+    return same(current, next) ? current : next;
+}
+export function withActivityConfidence(snapshot, confidence) {
+    return snapshot.confidence === confidence ? snapshot : Object.freeze({ ...snapshot, confidence });
+}
+/** Process loss revokes child identities; recovery must repopulate them from a fresh list read. */
+export function clearAgentActivityChildren(snapshot) {
+    if (snapshot.subagents.length === 0 && snapshot.aggregateSubagents === 'idle')
+        return snapshot;
+    return Object.freeze({
+        ...snapshot,
+        subagents: Object.freeze([]),
+        aggregateSubagents: 'idle',
+    });
+}
+function applyStatus(root, status) {
+    if (status === 'error' || status === 'systemError' || status === 'failed')
+        Object.assign(root, { state: 'blocked', reason: 'agentError' });
+    else if (status === 'notLoaded')
+        Object.assign(root, { state: 'disconnected', reason: 'processExited' });
+    else if (status === 'idle' || status === 'completed')
+        Object.assign(root, { state: 'idle', reason: 'turnCompleted' });
+    else if (status === 'active' || status === 'working')
+        Object.assign(root, { state: 'working', reason: 'turnActive' });
+}
+function childState(status, action, previous = 'working') {
+    if (status === 'error' || status === 'failed' || status === 'systemError')
+        return 'blocked';
+    if (status === 'completed' || status === 'idle' || action === 'close_agent')
+        return 'idle';
+    // `wait` belongs to the caller/root; it does not rewrite the child which may
+    // still be working.  A child can explicitly report its own waiting status.
+    if (status === 'disconnected' || status === 'notLoaded')
+        return 'disconnected';
+    return previous === 'idle' && action === 'resume_agent'
+        ? 'working'
+        : status === 'working' || status === 'active'
+            ? 'working'
+            : previous;
+}
+function childReason(status, action) {
+    if (status === 'error' || status === 'failed' || status === 'systemError')
+        return 'agentError';
+    if (status === 'disconnected' || status === 'notLoaded')
+        return 'processExited';
+    if (action === 'wait')
+        return 'collaborationWait';
+    if (status === 'completed' || status === 'idle' || action === 'close_agent')
+        return 'turnCompleted';
+    return 'turnActive';
+}
+function aggregate(children) {
+    return states.find((state) => children.some((child) => child.state === state)) ?? 'idle';
+}
+function validTimestamp(value) {
+    return !Number.isNaN(Date.parse(value));
+}
+function later(left, right) {
+    return Date.parse(right) > Date.parse(left) ? right : left;
+}
+function same(left, right) {
+    return JSON.stringify(semantic(left)) === JSON.stringify(semantic(right));
+}
+function semantic(snapshot) {
+    return {
+        sessionId: snapshot.sessionId,
+        rootThreadId: snapshot.rootThreadId,
+        confidence: snapshot.confidence,
+        root: { state: snapshot.root.state, reason: snapshot.root.reason },
+        subagents: snapshot.subagents.map((child) => ({
+            id: child.id,
+            threadId: child.threadId,
+            nickname: child.nickname,
+            role: child.role,
+            state: child.state,
+            reason: child.reason,
+        })),
+        aggregateSubagents: snapshot.aggregateSubagents,
+    };
+}

package/dist/server/server/features/agent-activity/registry.js

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createAgentActivitySnapshot, clearAgentActivityChildren, projectAgentActivity, withActivityConfidence, } from './model.js';
+/** Session-local read model. Scheduling and reconciliation are injected ports. */
+export class AgentActivityRegistry {
+    publish;
+    options;
+    #snapshots = new Map();
+    #timers = new Map();
+    #generation = new Map();
+    #inFlight = new Map();
+    constructor(publish, options = {}) {
+        this.publish = publish;
+        this.options = options;
+    }
+    snapshot(sessionId, now) {
+        return this.#snapshots.get(sessionId) ?? createAgentActivitySnapshot(sessionId, now);
+    }
+    observe(fact) {
+        const current = this.snapshot(fact.sessionId, fact.occurredAt);
+        const next = withActivityConfidence(projectAgentActivity(current, fact), fact.kind === 'collaboration' && !fact.childId ? 'stale' : 'fresh');
+        if (next !== current) {
+            this.#snapshots.set(fact.sessionId, next);
+            this.publish(next, fact.occurredAt);
+        }
+        this.#generation.set(fact.sessionId, (this.#generation.get(fact.sessionId) ?? 0) + 1);
+        this.#armStaleness(fact.sessionId);
+        return next;
+    }
+    reconciling(sessionId, occurredAt) {
+        return this.#qualify(sessionId, occurredAt, 'reconciling');
+    }
+    disconnected(sessionId, occurredAt) {
+        this.suspend(sessionId);
+        const current = this.snapshot(sessionId, occurredAt);
+        const next = withActivityConfidence(clearAgentActivityChildren(projectAgentActivity(current, { sessionId, occurredAt, kind: 'processExited' })), 'stale');
+        if (next !== current) {
+            this.#snapshots.set(sessionId, next);
+            this.publish(next, occurredAt);
+        }
+        return next;
+    }
+    suspend(sessionId) {
+        this.#timers.get(sessionId)?.();
+        this.#timers.delete(sessionId);
+        this.#generation.set(sessionId, (this.#generation.get(sessionId) ?? 0) + 1);
+        // The RPC cannot be cancelled, but a restart must not coalesce onto its
+        // obsolete promise. Generation guards suppress its eventual result.
+        this.#inFlight.delete(sessionId);
+    }
+    reconciled(sessionId, occurredAt) {
+        return this.#qualify(sessionId, occurredAt, 'fresh');
+    }
+    refresh(sessionId) {
+        if (!this.options.reconcile)
+            return Promise.resolve();
+        const existing = this.#inFlight.get(sessionId);
+        if (existing)
+            return existing;
+        const generation = (this.#generation.get(sessionId) ?? 0) + 1;
+        this.#generation.set(sessionId, generation);
+        const running = this.#attempt(sessionId, generation, 1).finally(() => {
+            if (this.#inFlight.get(sessionId) === running)
+                this.#inFlight.delete(sessionId);
+        });
+        this.#inFlight.set(sessionId, running);
+        return running;
+    }
+    /** Replaces the observed direct-child set; absent children are disconnected. */
+    childrenReconciled(sessionId, occurredAt, children) {
+        let next = this.snapshot(sessionId, occurredAt);
+        const seen = new Set(children.map((child) => child.id));
+        for (const child of children)
+            next = projectAgentActivity(next, {
+                sessionId,
+                occurredAt,
+                kind: 'collaboration',
+                childId: child.id,
+                childThreadId: child.id,
+                ...(child.status ? { childStatus: child.status } : {}),
+                ...(child.nickname ? { childNickname: child.nickname } : {}),
+                ...(child.role ? { childRole: child.role } : {}),
+            });
+        for (const child of next.subagents)
+            if (!seen.has(child.id))
+                next = projectAgentActivity(next, {
+                    sessionId,
+                    occurredAt,
+                    kind: 'collaboration',
+                    childId: child.id,
+                    childStatus: 'notLoaded',
+                });
+        // A malformed/unknown `thread/list` row is not proof that a child is
+        // healthy. Preserve it as disconnected but keep the aggregate qualified
+        // only as stale until a later authoritative read succeeds.
+        next = withActivityConfidence(next, children.some((child) => child.qualified === false) ? 'stale' : 'fresh');
+        const current = this.snapshot(sessionId, occurredAt);
+        if (next !== current) {
+            this.#snapshots.set(sessionId, next);
+            this.publish(next, occurredAt);
+        }
+        return next;
+    }
+    dispose(sessionId) {
+        this.#snapshots.delete(sessionId);
+        this.#timers.get(sessionId)?.();
+        this.#timers.delete(sessionId);
+        this.#generation.delete(sessionId);
+        this.#inFlight.delete(sessionId);
+    }
+    #armStaleness(sessionId) {
+        if (!this.options.schedule || !this.options.reconcile)
+            return;
+        this.#timers.get(sessionId)?.();
+        this.#timers.set(sessionId, this.options.schedule(() => void this.refresh(sessionId), this.options.staleAfterMs ?? 30_000));
+    }
+    async #attempt(sessionId, generation, attempt) {
+        if (this.#generation.get(sessionId) !== generation)
+            return;
+        this.#timers.delete(sessionId);
+        const now = this.options.now?.() ?? new Date().toISOString();
+        this.reconciling(sessionId, now);
+        try {
+            await this.options.reconcile?.(sessionId);
+            if (this.#generation.get(sessionId) === generation)
+                this.reconciled(sessionId, this.options.now?.() ?? now);
+        }
+        catch {
+            if (this.#generation.get(sessionId) !== generation)
+                return;
+            const delays = this.options.retryDelaysMs ?? [1_000, 5_000, 15_000];
+            if (attempt >=
+                Math.min(this.options.maxReconcileAttempts ?? delays.length + 1, delays.length + 1)) {
+                this.options.diagnostic?.(sessionId, 'reconcileExhausted');
+                this.disconnected(sessionId, this.options.now?.() ?? now);
+                return;
+            }
+            this.#timers.set(sessionId, this.options.schedule(() => void this.#attempt(sessionId, generation, attempt + 1), delays[attempt - 1]));
+        }
+    }
+    #qualify(sessionId, occurredAt, confidence, fact) {
+        const current = this.snapshot(sessionId, occurredAt);
+        const next = fact
+            ? withActivityConfidence(projectAgentActivity(current, { sessionId, occurredAt, ...fact }), confidence)
+            : withActivityConfidence(current, confidence);
+        if (next !== current) {
+            this.#snapshots.set(sessionId, next);
+            this.publish(next, occurredAt);
+        }
+        return next;
+    }
+}

package/dist/server/server/features/autopilot/application/policy.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export const AUTOPILOT_PROMPT_VERSION = 'v1';
+export const AUTOPILOT_CONTINUATION_PROMPT = 'Inspect the active supervised Org Plan. Invoke gestalt_org_plan_attention only for a decision-table blocker; otherwise immediately perform the next legal lifecycle action. Do not send a status-only response.';
+export const defaultAutopilotPolicy = Object.freeze({
+    quiescenceMs: 1_000,
+    staleAfterMs: 30_000,
+    retryLimit: 3,
+    backoffMs: (attempt) => Math.min(60_000, 1_000 * 2 ** Math.max(0, attempt)),
+    promptVersion: AUTOPILOT_PROMPT_VERSION,
+});
+export function executionComplete(plan) {
+    return (plan.executionComplete ??
+        plan.steps.every((step) => step.state === 'DONE' &&
+            step.reviewStatus === 'REVIEWED' &&
+            step.children.every((child) => child.state === 'DONE')));
+}
+/** A deliberately pure, exhaustive safety gate. Adapters may only enact this result. */
+export function decideAutopilot(input) {
+    const { state, plan, activity, hasPendingInteraction, now, policy } = input;
+    if (!state.requestedEnabled)
+        return { kind: 'disable', reason: 'manualDisabled' };
+    if (!plan)
+        return { kind: 'disable', reason: 'planRequired' };
+    if (executionComplete(plan))
+        return { kind: 'complete' };
+    if (hasPendingInteraction || input.hasActiveAttention || state.state === 'attentionRequired')
+        return { kind: 'requestAttention', reason: 'attentionRequired' };
+    if ((input.planIdentity && state.planIdentity && input.planIdentity !== state.planIdentity) ||
+        (input.planFingerprint &&
+            state.planFingerprint &&
+            input.planFingerprint !== state.planFingerprint))
+        return { kind: 'observe' };
+    if (!activity || activity.confidence !== 'fresh')
+        return { kind: 'reconcile' };
+    if (Date.parse(now) - Date.parse(activity.root.lastActivityAt) > policy.staleAfterMs)
+        return { kind: 'reconcile' };
+    if (activity.root.state !== 'idle' || activity.aggregateSubagents !== 'idle')
+        return activity.aggregateSubagents === 'disconnected'
+            ? { kind: 'reconcile' }
+            : { kind: 'observe' };
+    // The outcome is intentionally interpreted only through durable lack of plan
+    // progress: a failed or unknown automatic turn may retry within the same
+    // bounded budget, while a completed turn with no fingerprint change does too.
+    if (state.consecutiveNoProgress >= policy.retryLimit &&
+        ['completed', 'failed', 'unknown', undefined].includes(input.lastTurnOutcome))
+        return { kind: 'requestAttention', reason: 'noPlanProgress' };
+    return {
+        kind: 'scheduleContinuation',
+        at: new Date(Date.parse(now) + policy.backoffMs(state.consecutiveNoProgress)).toISOString(),
+    };
+}

package/dist/server/server/features/autopilot/application/ports.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};