@agentchatme/agent-core 0.0.131311111111 → 0.0.1313111111112

package/dist/index.d.ts

@@ -1,126 +1,18 @@
+import { H as HostCopy, a as TurnDisposition, f as PendingRequest } from './adapter-types-C_kf-KtV.js';
+export { g as AlwaysOnState, A as AutonomyMode, h as FullAutonomyPolicy, i as HEARTBEAT_FILE, M as MessageContext, P as PendingReason, j as PendingReviewMirrorRecord, k as RecordPendingRequestInput, l as RecordedPendingRequest, m as SyncRow, W as WireConfig, n as WireError, o as allowFullAutonomyAgent, p as alwaysOnHealth, q as alwaysOnOptedOut, r as alwaysOnState, s as alwaysOnWanted, t as autonomyPath, u as beat, v as claimReply, w as claimReplyBatch, x as clearAlwaysOnInstalledVersion, y as clearAlwaysOnOptOut, z as clearAlwaysOnWanted, B as clearForegroundTurn, C as clearSessionActive, D as contextOf, E as formatAlwaysOnDown, G as formatPendingRequestsNotice, I as formatPendingRequestsSystemMessage, J as formatRegistrationOffer, K as formatSessionStart, L as formatStopPickup, N as fullAutonomyAllows, O as getMeLite, Q as getPendingRequest, U as idle, V as lastDeliveryId, X as listPendingRequests, Y as markAlwaysOnInstalledVersion, Z as markAlwaysOnOptOut, _ as markAlwaysOnWanted, $ as markForegroundTurn, a0 as markSessionActive, a1 as normalizeAgentHandle, a2 as pendingRequestId, a3 as pendingRequestsFingerprint, a4 as readAlwaysOnInstalledVersion, a5 as readFullAutonomyPolicy, a6 as recordPendingRequest, a7 as recordPendingRequestWithStatus, a8 as removeFullAutonomyAgent, a9 as renderDeclinedBlock, aa as renderUnregisteredBlock, ab as resolvePendingRequest, ac as setFullAutonomyMode, ad as syncAck, ae as syncPeek, af as syncPendingReviewMirror, ag as writeFullAutonomyPolicy } from './adapter-types-C_kf-KtV.js';
 import { z } from 'zod';
 import { spawn, spawnSync } from 'node:child_process';
 
 /** Low-cardinality identity attached to every coding-agent API operation. */
 declare const CODING_AGENTS_CLIENT_IDENTITY: {
     readonly name: "coding_agents";
-    readonly version: "0.0.131311111111";
+    readonly version: "0.0.1313111111112";
 };
 /** Headers for raw HTTP and WebSocket transports that bypass the SDK. */
 declare const CODING_AGENTS_CLIENT_HEADERS: Readonly<Record<string, string>>;
 
 /** Published package version, kept in lockstep with package.json by tests. */
-declare const VERSION = "0.0.131311111111";
-
-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 const VERSION = "0.0.1313111111112";
 
 declare const DEFAULT_API_BASE = "https://api.agentchat.me";
 declare const CredentialsSchema: z.ZodObject<{
@@ -195,16 +87,19 @@ declare const StateSchema: z.ZodObject<{
         updated_at: z.ZodString;
         pending_ack: z.ZodOptional<z.ZodString>;
         pending_ack_requires_continuation: z.ZodOptional<z.ZodBoolean>;
+        pending_notice_fingerprint: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
         pending_ack_requires_continuation?: boolean | undefined;
+        pending_notice_fingerprint?: string | undefined;
     }, {
         continuations: number;
         updated_at: string;
         pending_ack?: string | undefined;
         pending_ack_requires_continuation?: boolean | undefined;
+        pending_notice_fingerprint?: string | undefined;
     }>>>;
     last_offer_at: z.ZodOptional<z.ZodString>;
     offer_declined_at: z.ZodOptional<z.ZodString>;
@@ -214,6 +109,7 @@ declare const StateSchema: z.ZodObject<{
         updated_at: string;
         pending_ack?: string | undefined;
         pending_ack_requires_continuation?: boolean | undefined;
+        pending_notice_fingerprint?: string | undefined;
     }>;
     last_offer_at?: string | undefined;
     offer_declined_at?: string | undefined;
@@ -223,6 +119,7 @@ declare const StateSchema: z.ZodObject<{
         updated_at: string;
         pending_ack?: string | undefined;
         pending_ack_requires_continuation?: boolean | undefined;
+        pending_notice_fingerprint?: string | undefined;
     }> | undefined;
     last_offer_at?: string | undefined;
     offer_declined_at?: string | undefined;
@@ -241,6 +138,8 @@ declare function resetSession(home: string, sessionKey: string): void;
 declare function setPendingAck(home: string, sessionKey: string, cursor: string, now?: Date, requiresContinuation?: boolean): void;
 /** Read-and-clear the pending cursor for a session (completed-turn boundary). */
 declare function takePendingAck(home: string, sessionKey: string, now?: Date): string | null;
+declare function pendingNoticeNeeded(home: string, sessionKey: string, fingerprint: string): boolean;
+declare function recordPendingNotice(home: string, sessionKey: string, fingerprint: string, now?: Date): void;
 declare function shouldOfferRegistration(home: string, now?: Date): boolean;
 declare function recordRegistrationOffer(home: string, now?: Date): void;
 /**
@@ -257,120 +156,6 @@ declare function offerDeclined(home: string): boolean;
 /** Cleared when an identity is established, so a later logout asks again. */
 declare function clearOfferDeclined(home: string): void;
 
-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 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 ANCHOR_START = "<!-- agentchat:start -->";
 declare const ANCHOR_END = "<!-- agentchat:end -->";
 /** The default identity block. Integrations whose host wants richer copy
@@ -426,10 +211,16 @@ interface HookContext {
 interface SessionStartResult {
     /** Text to inject into the session, or null for "say nothing". */
     context: string | null;
+    /** Deterministic text for the host's user-visible hook surface. */
+    notification: string | null;
+    /** Record the notice only after the integration printed it successfully. */
+    stage: () => void;
 }
 interface UserPromptResult {
     /** Text to add to this prompt, or null when the inbox has nothing new. */
     context: string | null;
+    /** Deterministic text for the host's user-visible hook surface. */
+    notification: string | null;
     /**
      * Persist the surfaced cursor locally. Call only after the host has accepted
      * `context`; the following Stop is the first boundary allowed to ACK it.
@@ -462,8 +253,8 @@ declare function sessionEnd(ctx: HookContext, input: HookInput): Promise<void>;
  * between them would be one more place to pick the wrong one.
  */
 interface HookDialect {
-    sessionStartOutput(context: string): Record<string, unknown>;
-    userPromptOutput(context: string): Record<string, unknown>;
+    sessionStartOutput(context: string, notification: string | null): Record<string, unknown>;
+    userPromptOutput(context: string, notification: string | null): Record<string, unknown>;
     stopOutput(reason: string): Record<string, unknown>;
     printJson(payload: Record<string, unknown>): void;
 }
@@ -551,6 +342,17 @@ interface RegisterOpts {
 interface DoctorOpts {
     fix?: boolean;
 }
+interface AutonomyCommandOpts {
+    action?: string;
+    handle?: string;
+    yes?: boolean;
+    json?: boolean;
+}
+interface PendingCommandOpts {
+    action?: string;
+    id?: string;
+    json?: boolean;
+}
 interface IdentityCommands {
     runRegister(opts: RegisterOpts): Promise<number>;
     runLogin(opts: {
@@ -565,6 +367,8 @@ interface IdentityCommands {
     runStatus(opts: {
         json?: boolean;
     }): Promise<number>;
+    runAutonomy(opts: AutonomyCommandOpts): Promise<number>;
+    runPendingRequests(opts: PendingCommandOpts): Promise<number>;
     runLogout(): number;
     runDoctor(opts?: DoctorOpts): Promise<number>;
 }
@@ -591,6 +395,44 @@ interface LockHandle {
 }
 declare function acquireLeaderLock(home: string): LockHandle | null;
 
+interface DaemonActivity {
+    id: string;
+    recorded_at: string;
+    self_handle: string;
+    source: 'always_on';
+    conversation_id: string;
+    peer_agents: string[];
+    inbound_message_ids: string[];
+    outcome: TurnDisposition;
+}
+interface RecordDaemonActivityInput {
+    selfHandle: string;
+    conversationId: string;
+    peerAgents: string[];
+    inboundMessageIds: string[];
+    outcome: TurnDisposition;
+}
+declare function recordDaemonActivity(home: string, input: RecordDaemonActivityInput): DaemonActivity | null;
+declare function peekDaemonActivities(home: string, limit?: number): DaemonActivity[];
+declare function ackDaemonActivities(home: string, ids: string[]): void;
+declare function formatDaemonActivities(records: DaemonActivity[]): string | null;
+
+interface NotificationPlan {
+    command: string;
+    args: string[];
+}
+/** Exported for deterministic cross-platform tests; no command is run here. */
+declare function pendingNotificationPlan(record: PendingRequest, runtimeOs?: NodeJS.Platform): NotificationPlan | null;
+/** Best-effort local alert. A desktop-notification failure never affects ACK. */
+declare function notifyPendingRequest(record: PendingRequest): void;
+
+/**
+ * Stable id for one installed integration. It distinguishes two machines that
+ * intentionally sign in to the same AgentChat agent without teaching the
+ * server anything about hostnames, operating systems, or local paths.
+ */
+declare function installationId(home: string): string;
+
 /**
  * Enough to ADDRESS an already-installed service. Removing one or reading its
  * status needs only its name — deliberately a narrower type than install, so
@@ -678,4 +520,4 @@ declare function readJsonFile<T>(filePath: string): T | null;
 declare const spawnCommand: typeof spawn;
 declare const spawnCommandSync: typeof spawnSync;
 
-export { ANCHOR_END, ANCHOR_START, type AlwaysOnState, type AnchorAction, CODING_AGENTS_CLIENT_HEADERS, CODING_AGENTS_CLIENT_IDENTITY, type Credentials, DEFAULT_API_BASE, type DoctorCheck, type DoctorOpts, HEARTBEAT_FILE, type HookContext, type HookDialect, type HookInput, type HookRunners, type HookState, type HostCopy, type HostProfile, type IdentityCommands, type LockHandle, type ManualCopy, type MessageContext, type PendingRegistration, type Plan, type RegisterOpts, type ResolvedIdentity, type ServiceOpts, type ServiceRef, type SessionStartResult, type StopResult, type SyncRow, type UserPromptResult, VERSION, type Verdict, type WireConfig, WireError, absoluteUtc, acquireLeaderLock, alwaysOnHealth, alwaysOnOptedOut, alwaysOnState, alwaysOnWanted, anchorLabelOf, atomicCopyFile, atomicWriteFile, beat, claimReply, claimReplyBatch, clearAlwaysOnInstalledVersion, clearAlwaysOnOptOut, clearAlwaysOnWanted, clearCredentials, clearForegroundTurn, clearOfferDeclined, clearPending, clearSessionActive, contextOf, createHookRunners, createIdentityCommands, credentialsPath, formatAlwaysOnDown, formatRegistrationOffer, formatSessionStart, formatStopPickup, formatWhen, getContinuations, getMeLite, hasAnchorAt, hooksDisabled, idle, installService, lastDeliveryId, launchdPlist, log, markAlwaysOnInstalledVersion, markAlwaysOnOptOut, markAlwaysOnWanted, markForegroundTurn, markSessionActive, offerDeclined, pendingPath, planForTest, readAlwaysOnInstalledVersion, readAnchorHandleAt, readAnchorHandleFrom, readCredentials, readHookInput, readJsonFile, readPending, readState, recordContinuation, recordOfferDeclined, recordRegistrationOffer, relativeAge, relativeWhen, removeAnchorAt, renderAnchorBlock, renderDeclinedBlock, renderManual, renderUnregisteredBlock, resetSession, resolveIdentity, serviceDefinitionCurrent, serviceInstalled, serviceStatus, sessionEnd, sessionStart, setPendingAck, shouldOfferRegistration, spawnCommand, spawnCommandSync, statePath, stop, stripAnchorBlock, syncAck, syncPeek, systemdQuote, systemdUnit, takePendingAck, uninstallService, upsertAnchorBlock, userPrompt, writeAnchor, writeCredentials, writePending, writeState, xmlEscape };
+export { ANCHOR_END, ANCHOR_START, type AnchorAction, type AutonomyCommandOpts, CODING_AGENTS_CLIENT_HEADERS, CODING_AGENTS_CLIENT_IDENTITY, type Credentials, DEFAULT_API_BASE, type DaemonActivity, type DoctorCheck, type DoctorOpts, type HookContext, type HookDialect, type HookInput, type HookRunners, type HookState, HostCopy, type HostProfile, type IdentityCommands, type LockHandle, type ManualCopy, type NotificationPlan, type PendingCommandOpts, type PendingRegistration, PendingRequest, type Plan, type RecordDaemonActivityInput, type RegisterOpts, type ResolvedIdentity, type ServiceOpts, type ServiceRef, type SessionStartResult, type StopResult, type UserPromptResult, VERSION, type Verdict, absoluteUtc, ackDaemonActivities, acquireLeaderLock, anchorLabelOf, atomicCopyFile, atomicWriteFile, clearCredentials, clearOfferDeclined, clearPending, createHookRunners, createIdentityCommands, credentialsPath, formatDaemonActivities, formatWhen, getContinuations, hasAnchorAt, hooksDisabled, installService, installationId, launchdPlist, log, notifyPendingRequest, offerDeclined, peekDaemonActivities, pendingNoticeNeeded, pendingNotificationPlan, pendingPath, planForTest, readAnchorHandleAt, readAnchorHandleFrom, readCredentials, readHookInput, readJsonFile, readPending, readState, recordContinuation, recordDaemonActivity, recordOfferDeclined, recordPendingNotice, recordRegistrationOffer, relativeAge, relativeWhen, removeAnchorAt, renderAnchorBlock, renderManual, resetSession, resolveIdentity, serviceDefinitionCurrent, serviceInstalled, serviceStatus, sessionEnd, sessionStart, setPendingAck, shouldOfferRegistration, spawnCommand, spawnCommandSync, statePath, stop, stripAnchorBlock, systemdQuote, systemdUnit, takePendingAck, uninstallService, upsertAnchorBlock, userPrompt, writeAnchor, writeCredentials, writePending, writeState, xmlEscape };