@hivemagnus/ardent-studio 0.0.0-stage → 0.1.0

package/dist/clients/magnus.d.ts

@@ -0,0 +1,851 @@
+import { z } from 'zod';
+import { type SseMessage } from './sse.js';
+import type { ServiceTokenProvider } from './service-token.js';
+export declare const ACTING_SUBJECT_HEADER = "x-acting-subject";
+export declare class MagnusError extends Error {
+    readonly status: number;
+    readonly code: string;
+    name: string;
+    constructor(message: string, status: number, code: string);
+}
+export interface AgentRefParts {
+    nodeId: string;
+    profile: string;
+}
+export declare function parseAgentRef(ref: string): AgentRefParts;
+export declare function agentRef(nodeId: string, profile: string): string;
+export interface CallContext {
+    /** The Oathweave subject of the person this call acts for. Omit for Studio's own background work. */
+    actingSubject?: string | undefined;
+    signal?: AbortSignal | undefined;
+}
+export declare const magnusArdentProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    backend: z.ZodNullable<z.ZodEnum<{
+        llamacpp: "llamacpp";
+        codex: "codex";
+    }>>;
+    apiPort: z.ZodNullable<z.ZodNumber>;
+    running: z.ZodBoolean;
+    a2aEnabled: z.ZodBoolean;
+    channels: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    error: z.ZodNullable<z.ZodString>;
+    nodeId: z.ZodString;
+    nodeName: z.ZodString;
+    hostname: z.ZodString;
+    installationVersion: z.ZodNullable<z.ZodString>;
+    reachable: z.ZodBoolean;
+}, z.core.$strip>;
+export type MagnusArdentProfile = z.infer<typeof magnusArdentProfileSchema>;
+export declare const magnusArdentInstallationSchema: z.ZodObject<{
+    installed: z.ZodBoolean;
+    version: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    profiles: z.ZodArray<z.ZodObject<{
+        error: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        id: z.ZodString;
+        backend: z.ZodNullable<z.ZodEnum<{
+            llamacpp: "llamacpp";
+            codex: "codex";
+        }>>;
+        running: z.ZodBoolean;
+        apiPort: z.ZodNullable<z.ZodNumber>;
+        a2aEnabled: z.ZodBoolean;
+        channels: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    }, z.core.$strip>>;
+    checkedAt: z.ZodString;
+    nodeId: z.ZodString;
+    nodeName: z.ZodString;
+    hostname: z.ZodString;
+    reachable: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        studio: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type MagnusArdentInstallation = z.infer<typeof magnusArdentInstallationSchema>;
+export declare const ardentTaskStateSchema: z.ZodEnum<{
+    unknown: "unknown";
+    failed: "failed";
+    partial: "partial";
+    queued: "queued";
+    running: "running";
+    cancelled: "cancelled";
+    input_required: "input_required";
+    completed: "completed";
+}>;
+export declare const ardentTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    caller: z.ZodString;
+    context: z.ZodString;
+    session_id: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodString;
+    content_hash: z.ZodString;
+    idempotency_key: z.ZodNullable<z.ZodString>;
+    backend: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        failed: "failed";
+        partial: "partial";
+        queued: "queued";
+        running: "running";
+        cancelled: "cancelled";
+        input_required: "input_required";
+        completed: "completed";
+    }>;
+    result: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    deadline_ms: z.ZodNumber;
+    created_ms: z.ZodNumber;
+    updated_ms: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ardentTaskEventSchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    task_id: z.ZodString;
+    kind: z.ZodString;
+    detail: z.ZodOptional<z.ZodUnknown>;
+    created_ms: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ardentStatusSchema: z.ZodObject<{
+    version: z.ZodString;
+    profile: z.ZodString;
+    backend: z.ZodString;
+    tasks: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ardentMemoryStatusSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ready: "ready";
+        degraded: "degraded";
+    }>;
+    agent_id: z.ZodString;
+    workspace_id: z.ZodString;
+    retrieval: z.ZodNullable<z.ZodString>;
+    storage: z.ZodNullable<z.ZodString>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ardentSkillSchema: z.ZodObject<{
+    name: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$loose>;
+/** Admission of task-submit, mission-submit and preview-submit: durable acceptance, never completion. */
+export declare const ardentAcceptedTaskSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    state: z.ZodString;
+}, z.core.$strip>;
+/** Profile resources released Magnus lets a caller read (routes/ardent.ts allow-list). */
+export type ArdentResource = 'openapi' | 'status' | 'profile' | 'config' | 'config/schema' | 'providers' | 'channels' | 'peers' | 'peers/config' | 'memory/status' | 'skills' | 'sessions' | 'tasks' | `tasks/${string}` | `tasks/${string}/events` | `sessions/${string}/messages` | 'identity/soul' | 'identity/identity' | 'identity/soul/history' | 'identity/identity/history' | `tasks/${string}/artifacts` | `artifacts/${string}/manifest` | 'development';
+/** Actions released Magnus accepts on POST …/action (an ADMIN person; a service identity gets the Studio subset below). */
+export declare const RELEASED_ACTIONS: readonly ["profile-create", "config-validate", "config-save", "peer-validate", "peer-save", "identity-save", "identity-restore", "provider-test", "channel-test", "peer-test", "memory-search", "task-submit", "task-cancel", "skill-set", "service-start", "service-stop", "service-restart", "package-install", "context-stage", "context-adopt", "context-rollback"];
+/**
+ * Actions added for Ardent Project Studio. session-open needs studio >= 1, skill-install studio >= 3 and a
+ * Magnus with a HiveSkills registry, the others studio >= 2 and Ardent 2.2.0.
+ */
+export declare const STUDIO_ACTIONS: readonly ["session-open", "mission-submit", "task-pause", "task-resume", "preview-submit", "development-note", "skill-install"];
+export type MagnusArdentAction = typeof RELEASED_ACTIONS[number] | typeof STUDIO_ACTIONS[number];
+/**
+ * Agent changes Magnus runs for a service identity only with x-acting-subject naming a linked Magnus
+ * ADMIN (Magnus ARDENT_SERVICE_ADMIN_ACTIONS). Without one: 403 ACTING_ADMIN_REQUIRED; an unlinked
+ * subject: 403 ACTING_SUBJECT_UNLINKED. A stale revision answers 409 CONFLICT. Reading config needs
+ * the same acting ADMIN.
+ */
+export declare const ARDENT_SERVICE_ADMIN_ACTIONS: readonly ["identity-save", "skill-set", "config-save", "skill-install"];
+/**
+ * The only configuration values a service's config-save may change (Magnus ARDENT_SERVICE_CONFIG_PATHS).
+ * A change anywhere else answers 403 CONFIG_PATH_FORBIDDEN. An array is one value.
+ */
+export declare const ARDENT_SERVICE_CONFIG_PATHS: readonly ["execution.backend", "providers.llamacpp.model", "providers.llamacpp.request_timeout_seconds", "providers.llamacpp.context_window_tokens", "providers.llamacpp.max_output_tokens", "providers.llamacpp.reasoning_effort", "providers.codex.model", "skills.enabled", "artifacts.max_bytes"];
+export type ArdentServiceConfigPath = typeof ARDENT_SERVICE_CONFIG_PATHS[number];
+/**
+ * Whether Magnus lets the Studio service identity run service-restart. It does not: a service may run
+ * only the session, task, mission, preview, development and ARDENT_SERVICE_ADMIN_ACTIONS actions, so a
+ * profile restart stays a person's act in the Magnus console.
+ */
+export declare const ARDENT_SERVICE_CAN_RESTART = false;
+/** Node agent Studio levels (Magnus ARDENT_STUDIO_CAPABILITY). */
+export declare const ARDENT_STUDIO_CAPABILITY: {
+    readonly bridge: 1;
+    readonly missions: 2;
+    readonly skillInstall: 3;
+};
+/** Journal event kinds Ardent 2.2.0 adds. Others appear too; readers accept unknown kinds. */
+export declare const ARDENT_STUDIO_EVENT_KINDS: readonly ["mission", "team_handoff", "team_ask_user", "team_propose_decision", "artifact_registered", "development_note", "team_result", "team_result_rejected", "pause_requested", "paused", "resumed", "preview"];
+export declare const ardentSessionContextSchema: z.ZodEnum<{
+    direct: "direct";
+    mission: "mission";
+    preview: "preview";
+}>;
+export type ArdentSessionContext = z.infer<typeof ardentSessionContextSchema>;
+/** GET …/identity/soul and …/identity/identity, and the identity-save answer. */
+export declare const ardentIdentityFileSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        soul: "soul";
+        identity: "identity";
+    }>;
+    name: z.ZodString;
+    text: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strip>;
+export type ArdentIdentityFile = z.infer<typeof ardentIdentityFileSchema>;
+/** GET …/config: the raw config.yaml and its revision (the base for skill-set and config-save). Secrets appear only as environment variable names. */
+export declare const ardentConfigFileSchema: z.ZodObject<{
+    revision: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type ArdentConfigFile = z.infer<typeof ardentConfigFileSchema>;
+/** The skill-set and config-save answer: the new configuration revision. The change applies once the profile restarts. */
+export declare const ardentConfigSavedSchema: z.ZodObject<{
+    revision: z.ZodString;
+    activation_required: z.ZodBoolean;
+}, z.core.$strip>;
+export type ArdentConfigSaved = z.infer<typeof ardentConfigSavedSchema>;
+/** action identity-save */
+export declare const ardentIdentityEditSchema: z.ZodObject<{
+    text: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strict>;
+/** action skill-set: revision is the configuration revision. */
+export declare const ardentSkillEditSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    revision: z.ZodString;
+}, z.core.$strict>;
+export declare const ardentSkillTargetSchema: z.ZodString;
+/**
+ * action skill-install (Magnus ardentSkillInstallSchema): a HiveSkills catalog release that Magnus fetches,
+ * checks against the catalog digest and installs onto the profile; with enable, the configuration revision.
+ */
+export declare const ardentSkillInstallSchema: z.ZodObject<{
+    source: z.ZodLiteral<"hiveskills">;
+    name: z.ZodString;
+    version: z.ZodString;
+    channel: z.ZodOptional<z.ZodEnum<{
+        stable: "stable";
+        canary: "canary";
+    }>>;
+    enable: z.ZodOptional<z.ZodBoolean>;
+    revision: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** The skill-install answer. A failed enable leaves the skill installed, with enable_error saying why. */
+export declare const ardentSkillInstallResultSchema: z.ZodObject<{
+    source: z.ZodLiteral<"hiveskills">;
+    name: z.ZodString;
+    version: z.ZodString;
+    sha256: z.ZodString;
+    files: z.ZodNumber;
+    changed: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+    revision: z.ZodNullable<z.ZodString>;
+    enable_error: z.ZodNullable<z.ZodString>;
+    activation_required: z.ZodBoolean;
+}, z.core.$strip>;
+export type ArdentSkillInstallResult = z.infer<typeof ardentSkillInstallResultSchema>;
+/** action config-save: the whole config.yaml and the configuration revision it replaces. */
+export declare const ardentConfigEditSchema: z.ZodObject<{
+    text: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strict>;
+/** action session-open */
+export declare const ardentSessionOpenSchema: z.ZodObject<{
+    key: z.ZodString;
+    reset: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodEnum<{
+        direct: "direct";
+        mission: "mission";
+        preview: "preview";
+    }>>;
+}, z.core.$strict>;
+export declare const ardentSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    caller: z.ZodString;
+    context: z.ZodString;
+    key: z.ZodString;
+    created_ms: z.ZodNumber;
+    updated_ms: z.ZodNumber;
+}, z.core.$strip>;
+/** action task-submit */
+export declare const ardentTaskSubmitSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    idempotency_key: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Ardent TeamMission 1.0 (src/team-contract.ts). */
+export declare const ardentTeamMissionSchema: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    parent_task: z.ZodNullable<z.ZodString>;
+    constraints: z.ZodArray<z.ZodString>;
+    allowed_actions: z.ZodArray<z.ZodEnum<{
+        deploy: "deploy";
+        observe: "observe";
+        analyze: "analyze";
+        create_artifact: "create_artifact";
+        create_draft: "create_draft";
+        reversible_change: "reversible_change";
+        external_publish: "external_publish";
+        destructive_response: "destructive_response";
+    }>>;
+    resources: z.ZodArray<z.ZodString>;
+    deadline: z.ZodNumber;
+    acceptance_criteria: z.ZodArray<z.ZodString>;
+    expected_artifacts: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type ArdentTeamMission = z.infer<typeof ardentTeamMissionSchema>;
+export declare const ARDENT_CONTEXT_ITEMS_MAX_BYTES: number;
+export declare const ardentContextItemSchema: z.ZodObject<{
+    title: z.ZodString;
+    mime: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type ArdentContextItem = z.infer<typeof ardentContextItemSchema>;
+/** action mission-submit (the whole action body is at most 200 KB). The session must have context mission. */
+export declare const ardentMissionSubmitSchema: z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    objective: z.ZodString;
+    mission: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        parent_task: z.ZodNullable<z.ZodString>;
+        constraints: z.ZodArray<z.ZodString>;
+        allowed_actions: z.ZodArray<z.ZodEnum<{
+            deploy: "deploy";
+            observe: "observe";
+            analyze: "analyze";
+            create_artifact: "create_artifact";
+            create_draft: "create_draft";
+            reversible_change: "reversible_change";
+            external_publish: "external_publish";
+            destructive_response: "destructive_response";
+        }>>;
+        resources: z.ZodArray<z.ZodString>;
+        deadline: z.ZodNumber;
+        acceptance_criteria: z.ZodArray<z.ZodString>;
+        expected_artifacts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    context_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        mime: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+    }, z.core.$strict>>>;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    idempotency_key: z.ZodString;
+}, z.core.$strict>;
+export type ArdentMissionSubmit = z.infer<typeof ardentMissionSubmitSchema>;
+/** action preview-submit (at most 300 KB). Needs x-acting-subject. */
+export declare const ardentPreviewOverridesSchema: z.ZodObject<{
+    soul: z.ZodOptional<z.ZodString>;
+    identity: z.ZodOptional<z.ZodString>;
+    skills_enabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ardentPreviewSubmitSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    overrides: z.ZodOptional<z.ZodObject<{
+        soul: z.ZodOptional<z.ZodString>;
+        identity: z.ZodOptional<z.ZodString>;
+        skills_enabled: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    session_id: z.ZodOptional<z.ZodString>;
+    idempotency_key: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ArdentPreviewSubmit = z.infer<typeof ardentPreviewSubmitSchema>;
+/** action development-note. Needs x-acting-subject. */
+export declare const ardentDevelopmentNoteSchema: z.ZodObject<{
+    kind: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodString;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            url: "url";
+            task: "task";
+            identity: "identity";
+            note: "note";
+            artifact: "artifact";
+            memory: "memory";
+            skill: "skill";
+        }>;
+        ref: z.ZodString;
+    }, z.core.$strict>>>;
+    author: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        operator: "operator";
+    }>>;
+}, z.core.$strict>;
+export declare const ardentDevelopmentRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    agent_ref: z.ZodString;
+    kind: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodString;
+    author: z.ZodEnum<{
+        agent: "agent";
+        operator: "operator";
+        runtime: "runtime";
+    }>;
+    epistemic: z.ZodEnum<{
+        agent_reported: "agent_reported";
+        operator_reported: "operator_reported";
+        observed: "observed";
+    }>;
+    before_sha256: z.ZodNullable<z.ZodString>;
+    after_sha256: z.ZodNullable<z.ZodString>;
+    sources: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        ref: z.ZodString;
+    }, z.core.$strip>>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+export type ArdentDevelopmentRecord = z.infer<typeof ardentDevelopmentRecordSchema>;
+export declare const ardentDevelopmentPageSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agent_ref: z.ZodString;
+        kind: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodString;
+        author: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+            runtime: "runtime";
+        }>;
+        epistemic: z.ZodEnum<{
+            agent_reported: "agent_reported";
+            operator_reported: "operator_reported";
+            observed: "observed";
+        }>;
+        before_sha256: z.ZodNullable<z.ZodString>;
+        after_sha256: z.ZodNullable<z.ZodString>;
+        sources: z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            ref: z.ZodString;
+        }, z.core.$strip>>;
+        created_at: z.ZodString;
+    }, z.core.$strip>>;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** actions task-pause and task-resume. A finished task answers 409. */
+export declare const ardentTaskPauseStateSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    state: z.ZodString;
+    admission: z.ZodEnum<{
+        paused: "paused";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+/** Ardent artifact manifest 1.0 (key fields; Ardent adds others). */
+export declare const ardentArtifactManifestSchema: z.ZodObject<{
+    schema_version: z.ZodString;
+    name: z.ZodString;
+    mime: z.ZodString;
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+    revision: z.ZodNumber;
+    supersedes_sha256: z.ZodNullable<z.ZodString>;
+    acceptance_status: z.ZodEnum<{
+        partial: "partial";
+        unreviewed: "unreviewed";
+        rejected: "rejected";
+        approved: "approved";
+    }>;
+    created_at: z.ZodNumber;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type ArdentArtifactManifest = z.infer<typeof ardentArtifactManifestSchema>;
+export declare const ardentArtifactRecordSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    superseded_by_sha256: z.ZodNullable<z.ZodString>;
+    manifest: z.ZodObject<{
+        schema_version: z.ZodString;
+        name: z.ZodString;
+        mime: z.ZodString;
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+        revision: z.ZodNumber;
+        supersedes_sha256: z.ZodNullable<z.ZodString>;
+        acceptance_status: z.ZodEnum<{
+            partial: "partial";
+            unreviewed: "unreviewed";
+            rejected: "rejected";
+            approved: "approved";
+        }>;
+        created_at: z.ZodNumber;
+        expires_at: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const ardentTaskArtifactsSchema: z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        superseded_by_sha256: z.ZodNullable<z.ZodString>;
+        manifest: z.ZodObject<{
+            schema_version: z.ZodString;
+            name: z.ZodString;
+            mime: z.ZodString;
+            sha256: z.ZodString;
+            size: z.ZodNumber;
+            revision: z.ZodNumber;
+            supersedes_sha256: z.ZodNullable<z.ZodString>;
+            acceptance_status: z.ZodEnum<{
+                partial: "partial";
+                unreviewed: "unreviewed";
+                rejected: "rejected";
+                approved: "approved";
+            }>;
+            created_at: z.ZodNumber;
+            expires_at: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** task.text: the current step's visible reply text (on connect and when a step starts). task.delta appends to it. Never replayed. */
+export declare const ardentTaskTextEventSchema: z.ZodObject<{
+    step: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+/** task.event: one journal event; its SSE id is the sequence to resume after. */
+export declare const ardentTaskJournalEventSchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    task_id: z.ZodString;
+    kind: z.ZodString;
+    detail: z.ZodOptional<z.ZodUnknown>;
+    created_ms: z.ZodNumber;
+}, z.core.$strip>;
+/** task.done: the final task record. */
+export declare const ardentTaskDoneEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodString;
+    result: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type ArdentTaskEvent = z.infer<typeof ardentTaskEventSchema>;
+/** An Emberpath alias or an OpenAI-compatible endpoint and model. Never credentials. */
+export declare const ardentAgentModelSchema: z.ZodUnion<readonly [z.ZodObject<{
+    emberpath_alias: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    base_url: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strict>]>;
+export declare const ardentAgentDeployRequestSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    profile: z.ZodString;
+    apiPort: z.ZodOptional<z.ZodNumber>;
+    soul_md: z.ZodString;
+    identity_md: z.ZodString;
+    model: z.ZodUnion<readonly [z.ZodObject<{
+        emberpath_alias: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        base_url: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>]>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hivemem: z.ZodLiteral<true>;
+    artifacts_max_bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type NewAgentRequest = z.input<typeof ardentAgentDeployRequestSchema>;
+export declare const ardentAgentStepSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        skipped: "skipped";
+    }>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    receipt: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const agentOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        hivemem: "hivemem";
+        deploy: "deploy";
+    }>;
+    nodeId: z.ZodString;
+    profile: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            running: "running";
+            succeeded: "succeeded";
+            skipped: "skipped";
+        }>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        finishedAt: z.ZodNullable<z.ZodString>;
+        receipt: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodNullable<z.ZodString>;
+    createdBy: z.ZodString;
+    attempts: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    completedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export type MagnusAgentOperation = z.infer<typeof agentOperationSchema>;
+export interface MagnusClientOptions {
+    baseUrl: string;
+    tokens: Pick<ServiceTokenProvider, 'token' | 'invalidate'>;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare class MagnusClient {
+    private readonly options;
+    private readonly request;
+    private readonly baseUrl;
+    constructor(options: MagnusClientOptions);
+    /** Every Magnus-managed Ardent profile across the fleet. */
+    listProfiles(context?: CallContext): Promise<MagnusArdentProfile[]>;
+    listInstallations(context?: CallContext): Promise<MagnusArdentInstallation[]>;
+    getInstallation(nodeId: string, context?: CallContext): Promise<MagnusArdentInstallation>;
+    /** Read an allow-listed Ardent management resource through Magnus. */
+    resource(ref: string, resource: ArdentResource, context?: CallContext & {
+        query?: {
+            after?: number | string;
+            limit?: number;
+            kind?: string;
+            context?: ArdentSessionContext;
+        };
+    }): Promise<unknown>;
+    status(ref: string, context?: CallContext): Promise<{
+        version: string;
+        profile: string;
+        backend: string;
+        tasks: number;
+    }>;
+    memoryStatus(ref: string, context?: CallContext): Promise<{
+        status: "ready" | "degraded";
+        agent_id: string;
+        workspace_id: string;
+        retrieval: string | null;
+        storage: string | null;
+        reason: string | null;
+    }>;
+    task(ref: string, taskId: string, context?: CallContext): Promise<{
+        id: string;
+        caller: string;
+        context: string;
+        session_id: string | null;
+        prompt: string;
+        content_hash: string;
+        idempotency_key: string | null;
+        backend: string;
+        state: "unknown" | "failed" | "partial" | "queued" | "running" | "cancelled" | "input_required" | "completed";
+        result: string | null;
+        error: string | null;
+        deadline_ms: number;
+        created_ms: number;
+        updated_ms: number;
+    }>;
+    skills(ref: string, context?: CallContext): Promise<Array<z.infer<typeof ardentSkillSchema>>>;
+    taskEvents(ref: string, taskId: string, after?: number, context?: CallContext): Promise<{
+        sequence: number;
+        task_id: string;
+        kind: string;
+        created_ms: number;
+        detail?: unknown;
+    }[]>;
+    identity(ref: string, kind: 'soul' | 'identity', context?: CallContext): Promise<ArdentIdentityFile>;
+    /** The profile's config.yaml and its revision. Needs an acting Magnus ADMIN. */
+    config(ref: string, context?: CallContext): Promise<ArdentConfigFile>;
+    /** Artifact bytes, buffered (Magnus caps them; see MAGNUS_AGENT_ARDENT_ARTIFACT_MAX_BYTES). Prefer artifactStream for large files. */
+    artifact(ref: string, sha256: string, context?: CallContext): Promise<Uint8Array>;
+    /** Artifact bytes as Magnus streams them, never buffered here. The caller verifies the digest. */
+    artifactStream(ref: string, sha256: string, context?: CallContext): Promise<{
+        body: ReadableStream<Uint8Array>;
+        size: number | undefined;
+    }>;
+    /** Run a management action through Magnus's audited action route. */
+    action(ref: string, action: MagnusArdentAction, input?: {
+        target?: string;
+        body?: unknown;
+    }, context?: CallContext): Promise<unknown>;
+    /** A direct task. The prompt is at most 16000 characters; the idempotency key is a UUID; a session (studio >= 1) carries the conversation. */
+    submitTask(ref: string, body: z.input<typeof ardentTaskSubmitSchema>, context?: CallContext): Promise<{
+        task_id: string;
+        state: string;
+    }>;
+    cancelTask(ref: string, taskId: string, context?: CallContext): Promise<unknown>;
+    memorySearch(ref: string, query: string, context?: CallContext): Promise<unknown>;
+    /** Ardent rejects a stale revision with 409, so concurrent edits never overwrite each other. */
+    saveIdentity(ref: string, kind: 'soul' | 'identity', body: {
+        text: string;
+        revision: string;
+    }, context?: CallContext): Promise<ArdentIdentityFile>;
+    /** Each change answers the next configuration revision: chain it into the next skill-set or config-save. */
+    setSkill(ref: string, name: string, body: {
+        enabled: boolean;
+        revision: string;
+    }, context?: CallContext): Promise<ArdentConfigSaved>;
+    /**
+     * Install a HiveSkills catalog release (studio >= 3). Magnus answers 503 HIVESKILLS_UNCONFIGURED without a registry,
+     * 409 SKILL_VERSION_UNAVAILABLE or SKILL_CONFLICT, and 422 SKILL_ARCHIVE_INVALID; a Magnus that predates the action
+     * answers 400 "Invalid Ardent action".
+     */
+    installSkill(ref: string, body: z.input<typeof ardentSkillInstallSchema>, context?: CallContext): Promise<ArdentSkillInstallResult>;
+    /** Magnus refuses (403 CONFIG_PATH_FORBIDDEN) a text that changes anything outside ARDENT_SERVICE_CONFIG_PATHS. */
+    saveConfig(ref: string, body: {
+        text: string;
+        revision: string;
+    }, context?: CallContext): Promise<ArdentConfigSaved>;
+    /** The node agent's Studio level for a node: 0 when it reports none. */
+    studioLevel(nodeId: string, context?: CallContext): Promise<number>;
+    /** Open (or reopen: the same key answers the same session) an Ardent session. studio >= 1; a context needs studio >= 2. */
+    openSession(ref: string, body: z.input<typeof ardentSessionOpenSchema>, context?: CallContext): Promise<{
+        id: string;
+        caller: string;
+        context: string;
+        key: string;
+        created_ms: number;
+        updated_ms: number;
+    }>;
+    /** Submit a team mission in a session opened with context mission. studio >= 2. */
+    submitMission(ref: string, body: z.input<typeof ardentMissionSubmitSchema>, context?: CallContext): Promise<{
+        task_id: string;
+        state: string;
+    }>;
+    /** Pause at the next step boundary. studio >= 2; a finished task answers 409. */
+    pauseTask(ref: string, taskId: string, context?: CallContext): Promise<{
+        task_id: string;
+        state: string;
+        admission: "paused" | "open";
+    }>;
+    resumeTask(ref: string, taskId: string, context?: CallContext): Promise<{
+        task_id: string;
+        state: string;
+        admission: "paused" | "open";
+    }>;
+    /** A side-effect-free preview task with draft overrides. studio >= 2; needs the acting person. */
+    submitPreview(ref: string, body: z.input<typeof ardentPreviewSubmitSchema>, context: CallContext): Promise<{
+        task_id: string;
+        state: string;
+    }>;
+    /** Record a development note. studio >= 2; needs the acting person. */
+    addDevelopmentNote(ref: string, body: z.input<typeof ardentDevelopmentNoteSchema>, context: CallContext): Promise<{
+        id: string;
+        agent_ref: string;
+        kind: string;
+        title: string;
+        body: string;
+        author: "agent" | "operator" | "runtime";
+        epistemic: "agent_reported" | "operator_reported" | "observed";
+        before_sha256: string | null;
+        after_sha256: string | null;
+        sources: {
+            kind: string;
+            ref: string;
+        }[];
+        created_at: string;
+    }>;
+    /** Artifact manifests a task registered, oldest first. studio >= 2. */
+    taskArtifacts(ref: string, taskId: string, context?: CallContext): Promise<{
+        task_id: string;
+        superseded_by_sha256: string | null;
+        manifest: {
+            [x: string]: unknown;
+            schema_version: string;
+            name: string;
+            mime: string;
+            sha256: string;
+            size: number;
+            revision: number;
+            supersedes_sha256: string | null;
+            acceptance_status: "partial" | "unreviewed" | "rejected" | "approved";
+            created_at: number;
+            expires_at?: number | undefined;
+        };
+    }[]>;
+    /** One artifact manifest. studio >= 2. */
+    artifactManifest(ref: string, sha256: string, context?: CallContext): Promise<{
+        task_id: string;
+        superseded_by_sha256: string | null;
+        manifest: {
+            [x: string]: unknown;
+            schema_version: string;
+            name: string;
+            mime: string;
+            sha256: string;
+            size: number;
+            revision: number;
+            supersedes_sha256: string | null;
+            acceptance_status: "partial" | "unreviewed" | "rejected" | "approved";
+            created_at: number;
+            expires_at?: number | undefined;
+        };
+    }>;
+    /** Portable development records, cursor-paginated. studio >= 2. */
+    development(ref: string, query?: {
+        after?: string;
+        limit?: number;
+        kind?: string;
+    }, context?: CallContext): Promise<{
+        records: {
+            id: string;
+            agent_ref: string;
+            kind: string;
+            title: string;
+            body: string;
+            author: "agent" | "operator" | "runtime";
+            epistemic: "agent_reported" | "operator_reported" | "observed";
+            before_sha256: string | null;
+            after_sha256: string | null;
+            sources: {
+                kind: string;
+                ref: string;
+            }[];
+            created_at: string;
+        }[];
+        next: string | null;
+    }>;
+    /**
+     * Follow a task's journal and live reply text (GET …/tasks/:id/stream, piped unbuffered by
+     * Magnus). Yields task.event (resumable, id = journal sequence), task.text, task.delta and
+     * task.done. Ardent ends a stream after 60 seconds; reconnect with `after`.
+     */
+    streamTask(ref: string, taskId: string, options?: CallContext & {
+        after?: number;
+    }): AsyncGenerator<SseMessage>;
+    /** Magnus New Agent deploy operation. Magnus runs it only when the acting person is a Magnus ADMIN. */
+    createAgent(body: NewAgentRequest, context: CallContext): Promise<{
+        operationId: string;
+    }>;
+    /** Step receipts of a New Agent or Enable HiveMem operation. */
+    agentOperation(operationId: string, context?: CallContext): Promise<{
+        [x: string]: unknown;
+        id: string;
+        kind: "hivemem" | "deploy";
+        nodeId: string;
+        profile: string;
+        status: "failed" | "running" | "succeeded";
+        steps: {
+            name: string;
+            status: "pending" | "failed" | "running" | "succeeded" | "skipped";
+            startedAt: string | null;
+            finishedAt: string | null;
+            receipt: Record<string, unknown> | null;
+            error: string | null;
+        }[];
+        error: string | null;
+        createdBy: string;
+        attempts: number;
+        createdAt: string;
+        updatedAt: string;
+        completedAt: string | null;
+    }>;
+    /** Live operation updates: `operation` events, then one `done`. */
+    streamAgentOperation(operationId: string, options?: CallContext): AsyncGenerator<SseMessage>;
+    /** Resume a failed operation from its first unfinished step. Needs an acting ADMIN. */
+    resumeAgentOperation(operationId: string, context: CallContext): Promise<{
+        operationId: string;
+    }>;
+    private json;
+    private send;
+    private fail;
+}