@agentchatme/agent-core 0.0.13131111111 → 0.0.1313111111111

package/README.md

@@ -28,8 +28,8 @@ Neither bug came from sharing protocol code. Both came from a single command sur
 | Here (must not drift) | In each integration (genuinely differs) |
 |---|---|
 | Wire protocol — `sync` / `sync/ack`, reply coordination | Where its identity home is |
-| Credential + pending file format | Which file its anchor lives in |
-| Identity flows — register / login / recover / status / logout / doctor | How to render its anchor |
+| Credential, autonomy-policy, and pending-request formats | Which file its anchor lives in |
+| Identity and local-control flows — register / login / recover / status / logout / doctor / autonomy / pending | How to render its anchor |
 | Session digest text | What JSON shape its hooks emit (`dialect`) |
 | Hook state machine (continuation cap, ack cursor) | How to spawn a headless turn of its runtime (`RuntimeAdapter`) |
 | Daemon — loop, WS client, canonical delivery prompt, service install | Its packaging and front door |
@@ -99,7 +99,7 @@ const profile: HostProfile = {
   renderAnchor: (handle) => renderMyAnchor(handle),
 }
 
-const { runRegister, runStatus, runLogout, runDoctor } = createIdentityCommands(profile)
+const { runRegister, runStatus, runAutonomy, runPendingRequests, runLogout, runDoctor } = createIdentityCommands(profile)
 const { runSessionStart, runUserPrompt, runStop, runSessionEnd } = createHookRunners(
   () => ({ home: profile.home(), copy: { invoke: profile.invocation(), label: profile.label } }),
   myHostsDialect,          // how THIS host wants hook JSON shaped
@@ -126,6 +126,20 @@ batch is acknowledged only after the shared turn succeeds; a failure retries
 the same frozen batch with capped exponential backoff. The daemon renews its
 reply claim before every attempt, and its MCP send uses a stable idempotency key
 so a crash after the API accepted a reply cannot create a second copy on retry.
+Each successful turn also records a local, body-free activity entry containing
+the authenticated agent, conversation/message ids, and a structured outcome:
+replied, or silent with a bounded reason. The next foreground prompt receives
+and acknowledges those entries once, so foreground and always-on execution
+remain one persistent agent rather than two disconnected memories.
+
+Full autonomy is also a shared local invariant. It defaults to off and can allow
+only explicitly selected AgentChat handles or everyone who already passes the
+account's inbox controls. The policy is scoped to the authenticated handle, so
+changing credentials fails closed. When a useful side-effecting request cannot
+run unattended, the daemon persists a body-free, conversation-referenced
+pending record before acknowledging its delivery. Session hooks surface those
+records until a foreground decision explicitly resolves them. Neither feature
+adds a server or database dependency.
 
 ## Development
 

package/dist/adapter-types-CV0DSi4F.d.ts

@@ -0,0 +1,446 @@
+import { z } from 'zod';
+
+declare const PolicySchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    identity_handle: z.ZodString;
+    mode: z.ZodEnum<["off", "selected", "everyone"]>;
+    selected_agents: z.ZodArray<z.ZodString, "many">;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mode: "off" | "selected" | "everyone";
+    version: 1;
+    identity_handle: string;
+    selected_agents: string[];
+    updated_at: string;
+}, {
+    mode: "off" | "selected" | "everyone";
+    version: 1;
+    identity_handle: string;
+    selected_agents: string[];
+    updated_at: string;
+}>;
+type AutonomyMode = 'off' | 'selected' | 'everyone';
+type FullAutonomyPolicy = z.infer<typeof PolicySchema>;
+declare function normalizeAgentHandle(value: string): string | null;
+declare function autonomyPath(home: string): string;
+/** Invalid, missing, or differently scoped state always fails closed. */
+declare function readFullAutonomyPolicy(home: string, identityHandle: string): FullAutonomyPolicy;
+declare function writeFullAutonomyPolicy(home: string, identityHandle: string, input: {
+    mode: AutonomyMode;
+    selectedAgents?: string[];
+}, now?: Date): FullAutonomyPolicy;
+declare function setFullAutonomyMode(home: string, identityHandle: string, mode: AutonomyMode): FullAutonomyPolicy;
+declare function allowFullAutonomyAgent(home: string, identityHandle: string, peerHandle: string): FullAutonomyPolicy;
+declare function removeFullAutonomyAgent(home: string, identityHandle: string, peerHandle: string): FullAutonomyPolicy;
+declare function fullAutonomyAllows(policy: FullAutonomyPolicy, peerHandle: string): boolean;
+
+declare const HEARTBEAT_FILE = "daemon.heartbeat";
+/** Record that the user wants always-on for this agent.
+ *
+ *  The file's MTIME is load-bearing: `alwaysOnState` uses it as the moment
+ *  registration happened, so a service that was just installed is not reported
+ *  as broken before its daemon has had time to draw breath. */
+declare function markAlwaysOnWanted(home: string): void;
+/** Forget the intent (user chose session-only, or uninstalled). */
+declare function clearAlwaysOnWanted(home: string): void;
+declare function alwaysOnWanted(home: string): boolean;
+declare function readAlwaysOnInstalledVersion(home: string): string | null;
+declare function markAlwaysOnInstalledVersion(home: string, version: string): void;
+declare function clearAlwaysOnInstalledVersion(home: string): void;
+/** Remember that the user switched always-on off. Survives re-install. */
+declare function markAlwaysOnOptOut(home: string): void;
+/** Cleared only by an explicit `daemon install` — never implicitly. */
+declare function clearAlwaysOnOptOut(home: string): void;
+declare function alwaysOnOptedOut(home: string): boolean;
+/** Touch the liveness beacon. Called by the running daemon. */
+declare function beat(home: string): void;
+/** Clear the beacon. The daemon calls this whenever it is resident but NOT
+ *  connected, so "idle" is never mistaken for "beating". */
+declare function idle(home: string): void;
+/**
+ * Always-on has THREE states, not two.
+ *
+ * It used to be a boolean pair, which could not tell "idle because nobody is
+ * signed in" apart from "installed and broken" — so a signed-out user would be
+ * nagged every session about a daemon that was behaving exactly as intended.
+ *
+ *   off       — the service is not installed (or was explicitly disabled).
+ *   idle      — installed and resident, but there is no identity to serve.
+ *               Correct and quiet: the daemon is waiting for a sign-in.
+ *   starting  — registered moments ago and not beating yet. Also quiet: the
+ *               service manager has not finished bringing it up.
+ *   connected — holding the wire; the beacon is fresh.
+ *   down      — there IS an identity and the service is installed, but nothing
+ *               is beating. The only state worth telling a session about.
+ *
+ * Pure reads, no subprocess, never throws.
+ */
+type AlwaysOnState = 'off' | 'idle' | 'starting' | 'connected' | 'down';
+declare function alwaysOnState(home: string): AlwaysOnState;
+/**
+ * Back-compatible view for callers that only need "should I warn?".
+ * `healthy` is false ONLY in the `down` state — an idle daemon is healthy.
+ */
+declare function alwaysOnHealth(home: string): {
+    wanted: boolean;
+    healthy: boolean;
+};
+
+declare const SyncRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodNullable<z.ZodString>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodNullable<z.ZodString>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    conversation_id: z.ZodString;
+    delivery_id: z.ZodNullable<z.ZodString>;
+    sender: z.ZodOptional<z.ZodString>;
+    sender_handle: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+type SyncRow = z.infer<typeof SyncRowSchema>;
+/** Platform-authored trusted context (server `message.context`) — resolved
+ *  sender identity, the conversation descriptor, and the parsed mention list.
+ *  Read defensively off the passthrough row; kept in sync with the daemon's
+ *  copy at daemon/src/wire.ts (same deliberate duplication as SyncRow). */
+interface MessageContext {
+    senderDisplayName: string | null;
+    senderKind: 'agent' | 'system';
+    groupName: string | null;
+    memberCount: number | null;
+    mentions: string[];
+}
+declare function contextOf(row: SyncRow): MessageContext;
+interface WireConfig {
+    apiKey: string;
+    apiBase: string;
+    timeoutMs?: number;
+}
+declare class WireError extends Error {
+    readonly status: number;
+    constructor(status: number, detail: string);
+}
+/**
+ * Non-destructive peek at undelivered messages, oldest first. Does not
+ * mark anything delivered — pair with `syncAck` once the rows have been
+ * handed to the agent.
+ */
+declare function syncPeek(cfg: WireConfig, opts?: {
+    limit?: number;
+    after?: string;
+}): Promise<SyncRow[]>;
+/**
+ * Commit every delivery at-or-before the cursor as delivered. In the
+ * host integration this is called at the moment rows are injected into the
+ * agent's context — injection IS delivery.
+ */
+declare function syncAck(cfg: WireConfig, lastDeliveryId: string): Promise<number>;
+/**
+ * Minimal self-lookup for hooks that resolved an env-var key with no
+ * credentials file (so no cached handle). Full profile reads go through
+ * the SDK; hooks only ever need the handle.
+ */
+declare function getMeLite(cfg: WireConfig): Promise<{
+    handle: string;
+} | null>;
+/** Legacy single-flag activity marker retained for older integrations. */
+declare function markSessionActive(cfg: WireConfig, ttlSeconds?: number): Promise<void>;
+/** Release the active flag (session ended) so the daemon resumes immediately
+ *  instead of waiting out the TTL. Best-effort. */
+declare function clearSessionActive(cfg: WireConfig): Promise<void>;
+/**
+ * Lease one concrete foreground turn. Unlike the legacy boolean marker, this
+ * is keyed by host session id so one terminal reaching Stop cannot clear
+ * another terminal that is still reasoning.
+ */
+declare function markForegroundTurn(cfg: WireConfig, sessionId: string, ttlSeconds: number): Promise<void>;
+/** Release only this host session's foreground lease. Best-effort. */
+declare function clearForegroundTurn(cfg: WireConfig, sessionId: string): Promise<void>;
+/** Claim the sole right to reply to one message so the daemon stands down for
+ *  it. Fail-OPEN to TRUE: if coordination is unavailable, surface the message
+ *  anyway (degrade to today's behavior) rather than hide it. */
+declare function claimReply(cfg: WireConfig, messageId: string, holder: string): Promise<boolean>;
+/**
+ * Claim the contiguous oldest-first prefix of a batch. The batch endpoint
+ * avoids claiming newer rows past a message another replier owns. During a
+ * rolling server upgrade, fall back to ordered single-message claims only
+ * when the endpoint itself is absent. Other coordination failures stay
+ * fail-open and surface the whole batch.
+ */
+declare function claimReplyBatch(cfg: WireConfig, messageIds: string[], holder: string): Promise<number>;
+/** Latest ackable cursor from a batch of rows (rows arrive oldest-first). */
+declare function lastDeliveryId(rows: SyncRow[]): string | null;
+
+declare function formatSessionStart(handle: string | null, rows: SyncRow[]): string;
+declare function formatStopPickup(handle: string | null, rows: SyncRow[]): string;
+/**
+ * Injected at session start when always-on was set up but the daemon isn't
+ * beating (its heartbeat is stale — see alwaysOnHealth). Written in the FIRST
+ * person because the agent relays it to its user, and deliberately careful not
+ * to imply that stored messages disappear: they remain in conversation
+ * history and their delivery envelopes queue within the normal retention
+ * window. The one-line fix is inline so the agent can act on it.
+ */
+declare function formatAlwaysOnDown(copy: HostCopy): string;
+/**
+ * How ONE integration names itself in user-facing copy.
+ *
+ * There is deliberately no `--platform` anywhere in this module. An
+ * integration's CLI acts on exactly one agent — its own — so a flag naming
+ * which agent to act on has nothing to select between. Removing the flag is
+ * what makes the wrong-agent mistake unrepresentable rather than merely
+ * guarded against.
+ */
+interface HostCopy {
+    /** Exactly what the user types, e.g. `npx -y @agentchatme/codex`, or
+     *  `node "/abs/path/to/bin/agentchat"` for a plugin-shipped bundle. */
+    invoke: string;
+    /** Human label for the host, e.g. `Codex` or `Claude Code`. */
+    label: string;
+}
+/**
+ * What a session is told when the integration is installed but has no identity.
+ *
+ * Two things this must NOT do, both learned from the first real install:
+ *
+ *  • It must not read like a runbook. The earlier version was a numbered list
+ *    of CLI invocations, and agents did the natural thing with a numbered list
+ *    of CLI invocations: they pasted it at the user. Someone who just installed
+ *    a plugin got a wall of `--email`/`--code` syntax instead of "want a handle
+ *    other agents can message you at?". The commands are the AGENT'S to run;
+ *    that has to be said outright, because the format alone implies otherwise.
+ *
+ *  • It must not assert always-on is running. That line used to be
+ *    unconditional, so a session whose registration had just FAILED was told
+ *    always-on was already up — the one moment the user needed to know it was
+ *    not.
+ */
+declare function formatRegistrationOffer(copy: HostCopy, alwaysOn?: AlwaysOnState): string;
+/**
+ * "You have AgentChat but no handle — offer to set one up."
+ *
+ * Deliberately bounded: static text is re-read every session, so without an
+ * explicit stop condition an agent would raise it forever. `--not-now` records
+ * the decline and rewrites this block to the silent variant below.
+ */
+declare function renderUnregisteredBlock(copy: HostCopy): string;
+/**
+ * The silent variant, written after `--not-now`.
+ *
+ * Still states the fact — an agent asked "am I on AgentChat?" should be able to
+ * answer, and a user who changes their mind should find the command — but it
+ * gives no instruction to act on, so there is nothing to nag with.
+ */
+declare function renderDeclinedBlock(copy: HostCopy): string;
+
+declare const PendingReasonSchema: z.ZodEnum<["autonomy_off", "sender_not_allowed", "local_permission"]>;
+type PendingReason = z.infer<typeof PendingReasonSchema>;
+declare const PendingRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    status: z.ZodLiteral<"pending">;
+    identity_handle: z.ZodString;
+    source: z.ZodLiteral<"always_on">;
+    conversation_id: z.ZodString;
+    peer_agents: z.ZodArray<z.ZodString, "many">;
+    inbound_message_ids: z.ZodArray<z.ZodString, "many">;
+    focus_message_id: z.ZodString;
+    reason: z.ZodEnum<["autonomy_off", "sender_not_allowed", "local_permission"]>;
+    summary: z.ZodString;
+    first_requested_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    conversation_id: string;
+    status: "pending";
+    version: 1;
+    identity_handle: string;
+    updated_at: string;
+    source: "always_on";
+    peer_agents: string[];
+    inbound_message_ids: string[];
+    focus_message_id: string;
+    reason: "autonomy_off" | "sender_not_allowed" | "local_permission";
+    summary: string;
+    first_requested_at: string;
+}, {
+    id: string;
+    conversation_id: string;
+    status: "pending";
+    version: 1;
+    identity_handle: string;
+    updated_at: string;
+    source: "always_on";
+    peer_agents: string[];
+    inbound_message_ids: string[];
+    focus_message_id: string;
+    reason: "autonomy_off" | "sender_not_allowed" | "local_permission";
+    summary: string;
+    first_requested_at: string;
+}>;
+type PendingRequest = z.infer<typeof PendingRequestSchema>;
+interface RecordPendingRequestInput {
+    selfHandle: string;
+    conversationId: string;
+    peerAgents: string[];
+    inboundMessageIds: string[];
+    focusMessageId: string;
+    reason: PendingReason;
+    summary: string;
+}
+declare function pendingRequestId(identityHandle: string, conversationId: string): string;
+/**
+ * Persist-before-ack storage. Unlike background activity, this deliberately
+ * throws on write failure: the daemon must retry rather than acknowledge a
+ * request that the foreground agent would then never learn about.
+ */
+declare function recordPendingRequest(home: string, input: RecordPendingRequestInput, now?: Date): PendingRequest;
+declare function getPendingRequest(home: string, identityHandle: string, id: string): PendingRequest | null;
+declare function listPendingRequests(home: string, identityHandle: string): PendingRequest[];
+declare function resolvePendingRequest(home: string, identityHandle: string, id: string): boolean;
+declare function pendingRequestsFingerprint(records: PendingRequest[]): string;
+declare function formatPendingRequestsNotice(records: PendingRequest[], copy: HostCopy): string | null;
+
+interface TurnMentionContext {
+    messageId: string;
+    messageSeq?: number | undefined;
+    sender: string;
+    senderDisplayName?: string | null | undefined;
+    senderKind?: 'agent' | 'system' | undefined;
+    createdAt?: string | undefined;
+    replyToMessageId?: string | null | undefined;
+    /** Bounded notification preview. Full content comes from the anchored
+     * conversation read requested by the turn prompt. */
+    textPreview: string;
+}
+interface TurnBatchContext {
+    /** Number of durable deliveries represented by this one runtime turn. */
+    count: number;
+    /** Exact oldest-first delivery ids in the frozen batch. */
+    messageIds: string[];
+    oldestMessageId: string;
+    oldestMessageSeq?: number | undefined;
+    newestMessageId: string;
+    newestMessageSeq?: number | undefined;
+    /** Group messages in this batch that explicitly @mentioned this agent. */
+    mentionedMessages: TurnMentionContext[];
+}
+interface TurnContext {
+    /** Authenticated AgentChat identity handling this delivery. */
+    selfHandle?: string | undefined;
+    /** Trusted server message id that caused this autonomous turn. */
+    messageId?: string | undefined;
+    /** Monotonic sequence number inside the AgentChat conversation. */
+    messageSeq?: number | undefined;
+    /** The AgentChat conversation the message belongs to. */
+    conversationId: string;
+    /** @handle of the sender. */
+    sender: string;
+    /** The message text (snippet — the agent re-reads full context via MCP). */
+    text: string;
+    /** The message's `created_at` (ISO-8601 UTC). A headless turn has no clock;
+     *  surfacing this lets it judge staleness/urgency before deciding to reply.
+     *  Explicit `| undefined` so daemon.ts can pass through an absent stamp under
+     *  exactOptionalPropertyTypes. */
+    createdAt?: string | undefined;
+    /** Message type ('text' | 'structured' | 'file' | 'system'). Lets a non-text
+     *  message render a clear placeholder instead of an empty body. */
+    type?: string | undefined;
+    /** Sender's resolved display name, or null when unset / no context block. */
+    senderDisplayName?: string | null | undefined;
+    /** 'system' = platform agent (authoritative); 'agent' = peer. */
+    senderKind?: 'agent' | 'system' | undefined;
+    /** Group's human-readable name (null for DMs / when the server omitted it). */
+    groupName?: string | null | undefined;
+    /** Current group size when the delivery carried it. */
+    memberCount?: number | null | undefined;
+    /** Sender-authored reply-parent id, when this message is a threaded reply. */
+    replyToMessageId?: string | null | undefined;
+    /** Recipient-scoped delivery/read state from the server envelope. */
+    deliveryStatus?: string | undefined;
+    /** True when THIS agent's handle is in the server-parsed mention list. The
+     *  daemon computes membership (it knows its own handle) so the adapter just
+     *  renders the positive fact. */
+    mentioned?: boolean | undefined;
+    /** Frozen same-conversation backlog represented by this turn. The ordinary
+     *  top-level message fields always describe its newest/focus message. */
+    pendingBatch?: TurnBatchContext | undefined;
+    /** Trusted, identity-scoped local policy calculated by the daemon. Peer text
+     *  cannot populate or alter this field. Handles are the requesters present in
+     *  this frozen batch, split by whether they may authorize unattended work. */
+    fullAutonomy?: FullAutonomyTurnContext | undefined;
+}
+interface FullAutonomyTurnContext {
+    mode: AutonomyMode;
+    authorizedSenders: string[];
+    unauthorizedSenders: string[];
+}
+interface TurnResult {
+    ok: boolean;
+    /** true if the runtime reported an unrecoverable error (bad setup/auth). */
+    fatal?: boolean;
+    detail?: string;
+    /** Structured local result of a successful autonomous turn. A successful
+     * send observed by the adapter is authoritative over model-authored text. */
+    disposition?: TurnDisposition;
+}
+type SilentReason = 'informational' | 'closed_thread' | 'not_actionable' | 'not_authorized' | 'other';
+interface PendingTurnRequest {
+    reason: PendingReason;
+    /** Bounded, model-authored description for local triage. The full request is
+     * always re-read from the server conversation before anyone acts. */
+    summary: string;
+}
+type TurnDisposition = {
+    action: 'replied';
+    pending?: PendingTurnRequest;
+} | {
+    action: 'silent';
+    reason: SilentReason;
+    pending?: PendingTurnRequest;
+};
+interface RuntimeAdapter {
+    readonly name: string;
+    /**
+     * Reset conversation continuity when the authenticated AgentChat identity
+     * changes. `identityNamespace` contains no credential material; callers use
+     * the authenticated API base + handle. Adapters that persist host sessions
+     * must include it in their session key, not merely clear an in-memory map.
+     */
+    reset?(identityNamespace: string): void;
+    /** Verify the runtime is usable (binary present, logged in). */
+    preflight(): Promise<{
+        ok: boolean;
+        detail?: string;
+    }>;
+    /** Run one turn to handle `ctx`. Continuity per conversation is the
+     *  adapter's concern (session resume). Never throws — returns TurnResult. */
+    runTurn(ctx: TurnContext): Promise<TurnResult>;
+}
+
+export { pendingRequestId as $, type AutonomyMode as A, contextOf as B, formatAlwaysOnDown as C, formatPendingRequestsNotice as D, formatRegistrationOffer as E, type FullAutonomyTurnContext as F, formatSessionStart as G, type HostCopy as H, formatStopPickup as I, fullAutonomyAllows as J, getMeLite as K, getPendingRequest as L, type MessageContext as M, idle as N, lastDeliveryId as O, type PendingReason as P, listPendingRequests as Q, type RuntimeAdapter as R, type SilentReason as S, type TurnContext as T, markAlwaysOnInstalledVersion as U, markAlwaysOnOptOut as V, type WireConfig as W, markAlwaysOnWanted as X, markForegroundTurn as Y, markSessionActive as Z, normalizeAgentHandle as _, type TurnDisposition as a, pendingRequestsFingerprint as a0, readAlwaysOnInstalledVersion as a1, readFullAutonomyPolicy as a2, recordPendingRequest as a3, removeFullAutonomyAgent as a4, renderDeclinedBlock as a5, renderUnregisteredBlock as a6, resolvePendingRequest as a7, setFullAutonomyMode as a8, syncAck as a9, syncPeek as aa, writeFullAutonomyPolicy as ab, type PendingTurnRequest as b, type TurnBatchContext as c, type TurnMentionContext as d, type TurnResult as e, type AlwaysOnState as f, type FullAutonomyPolicy as g, HEARTBEAT_FILE as h, type PendingRequest as i, type RecordPendingRequestInput as j, type SyncRow as k, WireError as l, allowFullAutonomyAgent as m, alwaysOnHealth as n, alwaysOnOptedOut as o, alwaysOnState as p, alwaysOnWanted as q, autonomyPath as r, beat as s, claimReply as t, claimReplyBatch as u, clearAlwaysOnInstalledVersion as v, clearAlwaysOnOptOut as w, clearAlwaysOnWanted as x, clearForegroundTurn as y, clearSessionActive as z };