@hivemagnus/ardent-studio 0.1.0 → 0.1.1

package/dist/agents/operations.d.ts

@@ -12,7 +12,7 @@ export declare function operationView(record: AgentOperationRecord, operation: M
     kind: "hivemem" | "deploy";
     status: "failed" | "running" | "succeeded";
     steps: {
-        name: string;
+        name: "profile-create" | "config-save" | "skill-set" | "service-start" | "service-restart" | "profile-check" | "identity-soul" | "identity-identity" | "hivemem-enroll" | "ready-probe";
         status: "pending" | "failed" | "running" | "succeeded" | "skipped";
         started_at: string | null;
         finished_at: string | null;

package/dist/agents/operations.js

@@ -3,7 +3,7 @@
 // its step receipts as `agent.operation.updated` events, from Magnus's operation stream, or by
 // polling when the stream fails. Running operations are picked up again after a restart.
 import { setTimeout as delay } from 'node:timers/promises';
-import { agentOperationSchema } from '../clients/magnus.js';
+import { ardentAgentOperationSchema } from '../clients/magnus.js';
 /** An operation as the browser sees it. */
 export function operationView(record, operation) {
     return {
@@ -71,7 +71,7 @@ export class OperationRelay {
                 for await (const message of this.magnus.streamAgentOperation(id, { signal })) {
                     if (message.event !== 'operation' && message.event !== 'done')
                         continue;
-                    const parsed = agentOperationSchema.safeParse(JSON.parse(message.data));
+                    const parsed = ardentAgentOperationSchema.safeParse(JSON.parse(message.data));
                     if (parsed.success && this.apply(id, parsed.data))
                         return;
                 }

package/dist/clients/magnus.d.ts

@@ -1,6 +1,9 @@
+import { ARDENT_SERVICE_CONFIG_PATHS, ardentAgentDeployRequestSchema, ardentAgentOperationSchema, ardentConfigFileSchema, ardentConfigSavedSchema, ardentContextItemSchema, ardentDevelopmentNoteSchema, ardentDevelopmentRecordSchema, ardentIdentityFileSchema, ardentMissionSubmitSchema, ardentPreviewSubmitSchema, ardentServiceProfileSchema, ardentSessionContextSchema, ardentSessionOpenSchema, ardentSkillInstallResultSchema, ardentSkillInstallSchema, ardentTaskJournalEventSchema, ardentTeamMissionSchema } from '@hivemagnus/magnus-contracts/ardent-service';
 import { z } from 'zod';
 import { type SseMessage } from './sse.js';
 import type { ServiceTokenProvider } from './service-token.js';
+export { ARDENT_SERVICE_ADMIN_ACTIONS, ARDENT_SERVICE_CONFIG_PATHS, ARDENT_STUDIO_CAPABILITY, ARDENT_STUDIO_EVENT_KINDS, ardentAgentOperationSchema, ardentTaskDoneEventSchema, ardentTaskJournalEventSchema, ardentTaskTextEventSchema, ardentTeamMissionSchema, } from '@hivemagnus/magnus-contracts/ardent-service';
+export { ARDENT_CONTEXT_ITEMS_MAX_BYTES } from '@hivemagnus/magnus-contracts/browser';
 export declare const ACTING_SUBJECT_HEADER = "x-acting-subject";
 export declare class MagnusError extends Error {
     readonly status: number;
@@ -19,25 +22,11 @@ export interface CallContext {
     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 type MagnusArdentProfile = z.infer<typeof ardentServiceProfileSchema>;
+/**
+ * GET /ardent/installations and /ardent/installations/{nodeId}. The service contract answers these
+ * as records, so Studio reads only the fields it uses (Magnus ArdentFleetInstallationSchema).
+ */
 export declare const magnusArdentInstallationSchema: z.ZodObject<{
     installed: z.ZodBoolean;
     version: z.ZodNullable<z.ZodString>;
@@ -101,13 +90,6 @@ export declare const ardentTaskSchema: z.ZodObject<{
     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;
@@ -129,13 +111,8 @@ 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';
+/** Profile resources Magnus lets a service identity read (the resource note of ardentServiceRoutes). */
+export type ArdentResource = 'status' | 'profile' | 'skills' | 'memory/status' | 'sessions' | `sessions/${string}/messages` | 'tasks' | `tasks/${string}` | `tasks/${string}/events` | 'identity/soul' | 'identity/identity' | 'config' | `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"];
 /**
@@ -144,18 +121,7 @@ export declare const RELEASED_ACTIONS: readonly ["profile-create", "config-valid
  */
 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"];
+/** A configuration value a service's config-save may change (ARDENT_SERVICE_CONFIG_PATHS); anything else answers 403 CONFIG_PATH_FORBIDDEN. */
 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
@@ -163,433 +129,23 @@ export type ArdentServiceConfigPath = typeof ARDENT_SERVICE_CONFIG_PATHS[number]
  * 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<{
+export type ArdentDevelopmentRecord = z.infer<typeof ardentDevelopmentRecordSchema>;
+export type ArdentTaskEvent = z.infer<typeof ardentTaskJournalEventSchema>;
+export type NewAgentRequest = z.input<typeof ardentAgentDeployRequestSchema>;
+export type MagnusAgentOperation = z.infer<typeof ardentAgentOperationSchema>;
+/** action task-submit: the prompt is at most 16000 characters and the idempotency key a UUID. */
+declare const ardentTaskSubmitSchema: 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>>;
+    idempotency_key: z.ZodString;
     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'>;
@@ -673,7 +229,6 @@ export declare class MagnusClient {
         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;
@@ -818,14 +373,13 @@ export declare class MagnusClient {
     }>;
     /** 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;
+            name: "profile-create" | "config-save" | "skill-set" | "service-start" | "service-restart" | "profile-check" | "identity-soul" | "identity-identity" | "hivemem-enroll" | "ready-probe";
             status: "pending" | "failed" | "running" | "succeeded" | "skipped";
             startedAt: string | null;
             finishedAt: string | null;
@@ -835,6 +389,18 @@ export declare class MagnusClient {
         error: string | null;
         createdBy: string;
         attempts: number;
+        request: {
+            apiPort: number | null;
+            model: {
+                emberpath_alias: string;
+            } | {
+                base_url: string;
+                model: string;
+            } | null;
+            skills: string[];
+            hivemem: boolean;
+            artifacts_max_bytes: number | null;
+        };
         createdAt: string;
         updatedAt: string;
         completedAt: string | null;

package/dist/clients/magnus.js

@@ -3,19 +3,22 @@
 // for, forwards that person's Oathweave subject in x-acting-subject so Magnus can check
 // and audit both. ArdentStudio never talks to nodes or Ardent directly and holds no Ardent token.
 //
-// Released Magnus 2.1.x serves the profile, installation, resource and action routes. The Studio
-// routes (sessions, task streams, streamed artifacts, New Agent, missions, pause, previews,
-// development) are typed here from Magnus's `packages/contracts/src/ardent-service.ts`
-// (`ardentServiceRoutes`) and `browser.ts`, because the published @hivemagnus/magnus-contracts
-// does not contain them yet. Switch these local schemas to that package once a release ships them.
-// The agent changes (identity-save, skill-set, config-save and reading config) need an acting
-// Magnus ADMIN in x-acting-subject; their shapes are typed here from the same file.
-// A node agent reports `capabilities.studio`: 1 for sessions, streams and artifacts, 2 for missions,
-// pause and resume, previews and development; below that Magnus answers 409 AGENT_UPGRADE_REQUIRED.
+// The routes, action bodies and answers come from @hivemagnus/magnus-contracts/ardent-service
+// (`ardentServiceRoutes`, the routes a linked service identity may call), pinned to the Magnus
+// release Studio is built against. Only shapes that contract leaves open are typed here: the
+// installation (which it answers as a record) and the Ardent management resources it relays as-is.
+// The agent changes (identity-save, skill-set, config-save, skill-install and reading config) need an
+// acting Magnus ADMIN in x-acting-subject (ARDENT_SERVICE_ADMIN_ACTIONS).
+// A node agent reports `capabilities.studio` (ARDENT_STUDIO_CAPABILITY): 1 for sessions, streams and
+// artifacts, 2 for missions, pause and resume, previews and development, 3 for skill-install; below
+// that Magnus answers 409 AGENT_UPGRADE_REQUIRED.
+import { ARDENT_ACTING_SUBJECT_HEADER, ardentAgentDeployRequestSchema, ardentAgentOperationSchema, ardentConfigEditSchema, ardentConfigFileSchema, ardentConfigSavedSchema, ardentDevelopmentNoteSchema, ardentDevelopmentPageSchema, ardentDevelopmentRecordSchema, ardentIdentityEditSchema, ardentIdentityFileSchema, ardentMissionSubmitSchema, ardentPreviewSubmitSchema, ardentServiceProfileSchema, ardentServiceSessionSchema, ardentServiceSkillSetRequestSchema, ardentServiceTaskSubmitRequestSchema, ardentSessionOpenSchema, ardentSkillEditSchema, ardentSkillInstallResultSchema, ardentSkillInstallSchema, ardentTaskAdmissionSchema, ardentTaskArtifactsSchema, ardentArtifactRecordSchema, ardentTaskJournalEventSchema, ardentTaskPauseStateSchema, } from '@hivemagnus/magnus-contracts/ardent-service';
 import { z } from 'zod';
 import { parseSse } from './sse.js';
 import { trimTrailingSlashes } from '../url.js';
-export const ACTING_SUBJECT_HEADER = 'x-acting-subject';
+export { ARDENT_SERVICE_ADMIN_ACTIONS, ARDENT_SERVICE_CONFIG_PATHS, ARDENT_STUDIO_CAPABILITY, ARDENT_STUDIO_EVENT_KINDS, ardentAgentOperationSchema, ardentTaskDoneEventSchema, ardentTaskJournalEventSchema, ardentTaskTextEventSchema, ardentTeamMissionSchema, } from '@hivemagnus/magnus-contracts/ardent-service';
+export { ARDENT_CONTEXT_ITEMS_MAX_BYTES } from '@hivemagnus/magnus-contracts/browser';
+export const ACTING_SUBJECT_HEADER = ARDENT_ACTING_SUBJECT_HEADER;
 export class MagnusError extends Error {
     status;
     code;
@@ -36,27 +39,15 @@ export function parseAgentRef(ref) {
 export function agentRef(nodeId, profile) {
     return `${nodeId}~${profile}`;
 }
-// ── Shapes of the released Magnus routes (packages/contracts ardent.ts, routes/ardent.ts) ──
-export const magnusArdentProfileSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    backend: z.enum(['llamacpp', 'codex']).nullable(),
-    apiPort: z.number().int().nullable(),
-    running: z.boolean(),
-    a2aEnabled: z.boolean(),
-    channels: z.record(z.string(), z.boolean()),
-    error: z.string().nullable(),
-    nodeId: z.string(),
-    nodeName: z.string(),
-    hostname: z.string(),
-    installationVersion: z.string().nullable(),
-    reachable: z.boolean(),
-});
+/**
+ * GET /ardent/installations and /ardent/installations/{nodeId}. The service contract answers these
+ * as records, so Studio reads only the fields it uses (Magnus ArdentFleetInstallationSchema).
+ */
 export const magnusArdentInstallationSchema = z.object({
     installed: z.boolean(),
     version: z.string().nullable(),
     owner: z.string(),
-    profiles: z.array(magnusArdentProfileSchema.pick({ id: true, name: true, backend: true, apiPort: true, running: true, a2aEnabled: true, channels: true, error: true })),
+    profiles: z.array(ardentServiceProfileSchema.pick({ id: true, name: true, backend: true, apiPort: true, running: true, a2aEnabled: true, channels: true, error: true })),
     checkedAt: z.string(),
     nodeId: z.string(),
     nodeName: z.string(),
@@ -66,22 +57,19 @@ export const magnusArdentInstallationSchema = z.object({
     /** The node agent's Studio level (ARDENT_STUDIO_CAPABILITY). Absent on agents that predate it. */
     capabilities: z.object({ studio: z.number().int().min(0).optional() }).loose().optional(),
 });
-// Ardent management shapes, as Ardent's OpenAPI document defines them.
+// Ardent management shapes, as Ardent's OpenAPI document defines them. Magnus relays these resources unchanged.
 export const ardentTaskStateSchema = z.enum(['queued', 'running', 'input_required', 'completed', 'partial', 'failed', 'cancelled', 'unknown']);
 export const ardentTaskSchema = z.object({
     id: z.string(), caller: z.string(), context: z.string(), session_id: z.string().nullable(), prompt: z.string(), content_hash: z.string(),
     idempotency_key: z.string().nullable(), backend: z.string(), state: ardentTaskStateSchema, result: z.string().nullable(), error: z.string().nullable(),
     deadline_ms: z.number(), created_ms: z.number(), updated_ms: z.number(),
 });
-export const ardentTaskEventSchema = z.object({ sequence: z.number().int(), task_id: z.string(), kind: z.string(), detail: z.unknown().optional(), created_ms: z.number() });
 export const ardentStatusSchema = z.object({ version: z.string(), profile: z.string(), backend: z.string(), tasks: z.number().int() });
 export const ardentMemoryStatusSchema = z.object({
     status: z.enum(['ready', 'degraded']), agent_id: z.string(), workspace_id: z.string(),
     retrieval: z.string().nullable(), storage: z.string().nullable(), reason: z.string().nullable(),
 });
 export const ardentSkillSchema = z.object({ name: z.string(), enabled: z.boolean() }).loose();
-/** Admission of task-submit, mission-submit and preview-submit: durable acceptance, never completion. */
-export const ardentAcceptedTaskSchema = z.object({ task_id: z.string(), state: z.string() });
 /** Actions released Magnus accepts on POST …/action (an ADMIN person; a service identity gets the Studio subset below). */
 export const RELEASED_ACTIONS = ['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',
@@ -91,201 +79,18 @@ export const RELEASED_ACTIONS = ['profile-create', 'config-validate', 'config-sa
  * Magnus with a HiveSkills registry, the others studio >= 2 and Ardent 2.2.0.
  */
 export const STUDIO_ACTIONS = ['session-open', 'mission-submit', 'task-pause', 'task-resume', 'preview-submit', 'development-note', 'skill-install'];
-/**
- * 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 const ARDENT_SERVICE_ADMIN_ACTIONS = ['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 const ARDENT_SERVICE_CONFIG_PATHS = [
-    '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',
-];
 /**
  * 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 const ARDENT_SERVICE_CAN_RESTART = false;
-/** Node agent Studio levels (Magnus ARDENT_STUDIO_CAPABILITY). */
-export const ARDENT_STUDIO_CAPABILITY = { bridge: 1, missions: 2, skillInstall: 3 };
-/** Journal event kinds Ardent 2.2.0 adds. Others appear too; readers accept unknown kinds. */
-export const ARDENT_STUDIO_EVENT_KINDS = ['mission', 'team_handoff', 'team_ask_user', 'team_propose_decision', 'artifact_registered', 'development_note',
-    'team_result', 'team_result_rejected', 'pause_requested', 'paused', 'resumed', 'preview'];
-const utf8Length = (value) => Buffer.byteLength(value, 'utf8');
-const guid = z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-const digest = z.string().regex(/^[a-f0-9]{64}$/);
-const boundedId = z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/);
-const missionText = (bytes) => z.string().trim().min(1).refine(value => utf8Length(value) <= bytes, `Exceeds ${bytes} bytes`);
-const missionTexts = (minimum = 0) => z.array(missionText(1000)).min(minimum).max(32).refine(value => new Set(value).size === value.length, 'Duplicate entries');
-export const ardentSessionContextSchema = z.enum(['direct', 'mission', 'preview']);
-/** GET …/identity/soul and …/identity/identity, and the identity-save answer. */
-export const ardentIdentityFileSchema = z.object({ kind: z.enum(['soul', 'identity']), name: z.string(), text: z.string(), revision: digest });
-/** 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 const ardentConfigFileSchema = z.object({ revision: digest, text: z.string() });
-/** The skill-set and config-save answer: the new configuration revision. The change applies once the profile restarts. */
-export const ardentConfigSavedSchema = z.object({ revision: digest, activation_required: z.boolean() });
-/** action identity-save */
-export const ardentIdentityEditSchema = z.object({ text: z.string().min(1).max(128 * 1024), revision: digest }).strict();
-/** action skill-set: revision is the configuration revision. */
-export const ardentSkillEditSchema = z.object({ enabled: z.boolean(), revision: digest }).strict();
-export const ardentSkillTargetSchema = z.string().regex(/^[A-Za-z0-9_-]{1,100}$/);
-/**
- * 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 const ardentSkillInstallSchema = z.object({
-    source: z.literal('hiveskills'),
-    name: z.string().regex(/^[a-z0-9][a-z0-9-]{1,62}$/),
-    version: z.string().max(64).regex(/^v?\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?$/i),
-    channel: z.enum(['stable', 'canary']).optional(),
-    enable: z.boolean().optional(),
-    revision: digest.optional(),
-}).strict().refine(value => !value.enable || value.revision !== undefined, { message: 'enable needs the configuration revision', path: ['revision'] });
-/** The skill-install answer. A failed enable leaves the skill installed, with enable_error saying why. */
-export const ardentSkillInstallResultSchema = z.object({
-    source: z.literal('hiveskills'), name: z.string(), version: z.string(), sha256: digest, files: z.number().int(),
-    changed: z.boolean(), enabled: z.boolean(), revision: digest.nullable(), enable_error: z.string().nullable(), activation_required: z.boolean(),
-});
-/** action config-save: the whole config.yaml and the configuration revision it replaces. */
-export const ardentConfigEditSchema = z.object({ text: z.string().min(1).max(200_000), revision: digest }).strict();
-/** action session-open */
-export const ardentSessionOpenSchema = z.object({ key: z.string().trim().min(1).max(256), reset: z.boolean().optional(), context: ardentSessionContextSchema.optional() }).strict();
-export const ardentSessionSchema = z.object({ id: guid, caller: z.string(), context: z.string(), key: z.string(), created_ms: z.number(), updated_ms: z.number() });
-/** action task-submit */
-export const ardentTaskSubmitSchema = z.object({ prompt: z.string().trim().min(1).max(16_000), idempotency_key: guid, session_id: guid.optional() }).strict();
-/** Ardent TeamMission 1.0 (src/team-contract.ts). */
-export const ardentTeamMissionSchema = z.object({
-    id: boundedId,
-    revision: z.number().int().min(1).max(2_147_483_647),
-    parent_task: boundedId.nullable(),
-    constraints: missionTexts(),
-    allowed_actions: z.array(z.enum(['observe', 'analyze', 'create_artifact', 'create_draft', 'reversible_change', 'deploy', 'external_publish', 'destructive_response']))
-        .min(1).max(8).refine(value => new Set(value).size === value.length, 'Duplicate action'),
-    /** Tool and memory grants, such as tool:artifact_write or project:<id>. */
-    resources: missionTexts(1),
-    /** Unix seconds. */
-    deadline: z.number().int().min(1).max(253_402_300_799),
-    acceptance_criteria: missionTexts(1),
-    expected_artifacts: missionTexts(),
-}).strict();
-export const ARDENT_CONTEXT_ITEMS_MAX_BYTES = 64 * 1024;
-export const ardentContextItemSchema = z.object({
-    title: z.string().trim().min(1).max(200), mime: z.string().regex(/^[a-z]+\/[A-Za-z0-9.+-]+$/).max(100).optional(), text: z.string().min(1),
-}).strict();
-/** action mission-submit (the whole action body is at most 200 KB). The session must have context mission. */
-export const ardentMissionSubmitSchema = z.object({
-    session_id: guid.optional(),
-    objective: z.string().trim().min(1).max(16_000),
-    mission: ardentTeamMissionSchema,
-    context_items: z.array(ardentContextItemSchema).max(64).optional()
-        .refine(items => utf8Length((items ?? []).map(item => item.title + item.text).join('')) <= ARDENT_CONTEXT_ITEMS_MAX_BYTES, 'Context items exceed 64 KiB'),
-    labels: z.record(z.string().regex(/^[a-z][a-z0-9._:-]{0,63}$/), z.string().max(256)).refine(value => Object.keys(value).length <= 32, 'At most 32 labels').optional(),
-    idempotency_key: z.string().min(1).max(128),
-}).strict();
-/** action preview-submit (at most 300 KB). Needs x-acting-subject. */
-export const ardentPreviewOverridesSchema = z.object({
-    soul: z.string().min(1).max(131_072).optional(),
-    identity: z.string().min(1).max(131_072).optional(),
-    skills_enabled: z.array(z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/)).max(100).optional(),
-    model: z.string().trim().min(1).max(200).optional(),
-}).strict();
-export const ardentPreviewSubmitSchema = z.object({
-    prompt: z.string().trim().min(1).max(16_000),
-    overrides: ardentPreviewOverridesSchema.optional(),
-    session_id: guid.optional(),
-    idempotency_key: z.string().min(1).max(128).optional(),
-}).strict();
-/** action development-note. Needs x-acting-subject. */
-export const ardentDevelopmentNoteSchema = z.object({
-    kind: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
-    title: z.string().trim().min(1).max(200),
-    body: z.string().trim().min(1).max(8000),
-    sources: z.array(z.object({ kind: z.enum(['task', 'artifact', 'memory', 'url', 'identity', 'skill', 'note']), ref: z.string().trim().min(1).max(512) }).strict()).max(16).optional(),
-    author: z.enum(['operator', 'agent']).optional(),
-}).strict();
-export const ardentDevelopmentRecordSchema = z.object({
-    id: z.string(), agent_ref: z.string(), kind: z.string(), title: z.string(), body: z.string(),
-    author: z.enum(['agent', 'operator', 'runtime']), epistemic: z.enum(['agent_reported', 'operator_reported', 'observed']),
-    before_sha256: digest.nullable(), after_sha256: digest.nullable(),
-    sources: z.array(z.object({ kind: z.string(), ref: z.string() })), created_at: z.string(),
-});
-export const ardentDevelopmentPageSchema = z.object({ records: z.array(ardentDevelopmentRecordSchema), next: z.string().nullable() });
-/** actions task-pause and task-resume. A finished task answers 409. */
-export const ardentTaskPauseStateSchema = z.object({ task_id: z.string(), state: z.string(), admission: z.enum(['open', 'paused']) });
-/** Ardent artifact manifest 1.0 (key fields; Ardent adds others). */
-export const ardentArtifactManifestSchema = z.looseObject({
-    schema_version: z.string(), name: z.string(), mime: z.string(), sha256: digest, size: z.number().int().min(0),
-    revision: z.number().int(), supersedes_sha256: digest.nullable(),
-    acceptance_status: z.enum(['unreviewed', 'approved', 'partial', 'rejected']), created_at: z.number(), expires_at: z.number().optional(),
-});
-export const ardentArtifactRecordSchema = z.object({ task_id: z.string(), superseded_by_sha256: digest.nullable(), manifest: ardentArtifactManifestSchema });
-export const ardentTaskArtifactsSchema = z.object({ artifacts: z.array(ardentArtifactRecordSchema) });
-// Task stream events (GET …/tasks/:taskId/stream).
-/** task.text: the current step's visible reply text (on connect and when a step starts). task.delta appends to it. Never replayed. */
-export const ardentTaskTextEventSchema = z.object({ step: z.number().int(), text: z.string() });
-/** task.event: one journal event; its SSE id is the sequence to resume after. */
-export const ardentTaskJournalEventSchema = ardentTaskEventSchema;
-/** task.done: the final task record. */
-export const ardentTaskDoneEventSchema = z.object({ id: z.string(), state: z.string(), result: z.string().nullable().optional(), error: z.string().nullable().optional() }).loose();
-// New Agent (POST /ardent/agents) and its operations.
-const credentialFreeUrl = (value) => {
-    try {
-        const url = new URL(value);
-        return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
-    }
-    catch {
-        return false;
-    }
-};
-const identityText = z.string().max(131_072).refine(value => value.trim().length > 0 && utf8Length(value) <= 131_072, 'Identity text must be 1 to 128 KiB');
-/** An Emberpath alias or an OpenAI-compatible endpoint and model. Never credentials. */
-export const ardentAgentModelSchema = z.union([
-    z.object({ emberpath_alias: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/) }).strict(),
-    z.object({ base_url: z.string().max(2048).refine(credentialFreeUrl, 'Expected an HTTP(S) URL without credentials, query or fragment'), model: z.string().min(1).max(200) }).strict(),
-]);
-export const ardentAgentDeployRequestSchema = z.object({
-    nodeId: z.string().regex(/^[A-Za-z0-9._-]{1,128}$/),
-    profile: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
-    apiPort: z.number().int().min(1024).max(65535).optional(),
-    soul_md: identityText,
-    identity_md: identityText,
-    model: ardentAgentModelSchema,
-    skills: z.array(z.string().regex(/^[A-Za-z0-9_-]{1,100}$/)).max(100).default([]),
-    hivemem: z.literal(true),
-    artifacts_max_bytes: z.number().int().min(1024).max(67_108_864).optional(),
-}).strict();
-export const ardentAgentStepSchema = z.object({
-    name: z.string(),
-    status: z.enum(['pending', 'running', 'succeeded', 'skipped', 'failed']),
-    startedAt: z.string().nullable(),
-    finishedAt: z.string().nullable(),
-    receipt: z.record(z.string(), z.unknown()).nullable(),
-    error: z.string().nullable(),
-});
-export const agentOperationSchema = z.object({
-    id: z.string(),
-    kind: z.enum(['deploy', 'hivemem']),
-    nodeId: z.string(),
-    profile: z.string(),
-    status: z.enum(['running', 'succeeded', 'failed']),
-    steps: z.array(ardentAgentStepSchema),
-    error: z.string().nullable(),
-    createdBy: z.string(),
-    attempts: z.number().int(),
-    createdAt: z.string(),
-    updatedAt: z.string(),
-    completedAt: z.string().nullable(),
-}).loose();
+/** action task-submit: the prompt is at most 16000 characters and the idempotency key a UUID. */
+const ardentTaskSubmitSchema = ardentServiceTaskSubmitRequestSchema.shape.body;
+/** action skill-set: the skill name is the target. */
+const ardentSkillTargetSchema = ardentServiceSkillSetRequestSchema.shape.target;
+/** The New Agent and resume answers. */
+const operationAcceptedSchema = z.object({ operationId: z.string() });
 const envelope = z.object({ success: z.literal(true), data: z.unknown() });
 const failure = z.object({ success: z.literal(false), error: z.object({ code: z.string(), message: z.string() }) });
 export class MagnusClient {
@@ -300,7 +105,7 @@ export class MagnusClient {
     // ── Released routes ──
     /** Every Magnus-managed Ardent profile across the fleet. */
     async listProfiles(context = {}) {
-        return z.array(magnusArdentProfileSchema).parse(await this.json('GET', '/api/v1/ardent/profiles', context));
+        return z.array(ardentServiceProfileSchema).parse(await this.json('GET', '/api/v1/ardent/profiles', context));
     }
     async listInstallations(context = {}) {
         return z.array(magnusArdentInstallationSchema).parse(await this.json('GET', '/api/v1/ardent/installations', context));
@@ -329,7 +134,7 @@ export class MagnusClient {
         return Array.isArray(list) ? list : list.skills;
     }
     async taskEvents(ref, taskId, after = 0, context = {}) {
-        return z.object({ events: z.array(ardentTaskEventSchema) }).parse(await this.resource(ref, `tasks/${uuid(taskId)}/events`, { ...context, query: { after } })).events;
+        return z.object({ events: z.array(ardentTaskJournalEventSchema) }).parse(await this.resource(ref, `tasks/${uuid(taskId)}/events`, { ...context, query: { after } })).events;
     }
     async identity(ref, kind, context = {}) {
         return ardentIdentityFileSchema.parse(await this.resource(ref, `identity/${kind}`, context));
@@ -369,14 +174,11 @@ export class MagnusClient {
         const parsed = ardentTaskSubmitSchema.safeParse(body);
         if (!parsed.success)
             throw new MagnusError(`Task submission is invalid: ${parsed.error.issues[0]?.message ?? 'invalid'}`, 400, 'VALIDATION_ERROR');
-        return ardentAcceptedTaskSchema.parse(await this.action(ref, 'task-submit', { body: parsed.data }, context));
+        return ardentTaskAdmissionSchema.parse(await this.action(ref, 'task-submit', { body: parsed.data }, context));
     }
     async cancelTask(ref, taskId, context = {}) {
         return this.action(ref, 'task-cancel', { target: uuid(taskId) }, context);
     }
-    async memorySearch(ref, query, context = {}) {
-        return this.action(ref, 'memory-search', { body: { query } }, context);
-    }
     /** Ardent rejects a stale revision with 409, so concurrent edits never overwrite each other. */
     async saveIdentity(ref, kind, body, context = {}) {
         return ardentIdentityFileSchema.parse(await this.action(ref, 'identity-save', { target: kind, body: validated(ardentIdentityEditSchema, body, 'identity-save') }, context));
@@ -398,21 +200,21 @@ export class MagnusClient {
     async saveConfig(ref, body, context = {}) {
         return ardentConfigSavedSchema.parse(await this.action(ref, 'config-save', { body: validated(ardentConfigEditSchema, body, 'config-save') }, context));
     }
-    // ── Studio routes (typed locally; see the header) ──
+    // ── Studio routes ──
     /** The node agent's Studio level for a node: 0 when it reports none. */
     async studioLevel(nodeId, context = {}) {
         return (await this.getInstallation(nodeId, context)).capabilities?.studio ?? 0;
     }
     /** Open (or reopen: the same key answers the same session) an Ardent session. studio >= 1; a context needs studio >= 2. */
     async openSession(ref, body, context = {}) {
-        return ardentSessionSchema.parse(await this.action(ref, 'session-open', { body: ardentSessionOpenSchema.parse(body) }, context));
+        return ardentServiceSessionSchema.parse(await this.action(ref, 'session-open', { body: ardentSessionOpenSchema.parse(body) }, context));
     }
     /** Submit a team mission in a session opened with context mission. studio >= 2. */
     async submitMission(ref, body, context = {}) {
         const parsed = ardentMissionSubmitSchema.safeParse(body);
         if (!parsed.success)
             throw new MagnusError(`Mission is invalid: ${parsed.error.issues[0]?.message ?? 'invalid'}`, 400, 'VALIDATION_ERROR');
-        return ardentAcceptedTaskSchema.parse(await this.action(ref, 'mission-submit', { body: parsed.data }, context));
+        return ardentTaskAdmissionSchema.parse(await this.action(ref, 'mission-submit', { body: parsed.data }, context));
     }
     /** Pause at the next step boundary. studio >= 2; a finished task answers 409. */
     async pauseTask(ref, taskId, context = {}) {
@@ -425,7 +227,7 @@ export class MagnusClient {
     async submitPreview(ref, body, context) {
         if (!context.actingSubject)
             throw new MagnusError('A preview needs the acting person', 400, 'ACTING_SUBJECT_REQUIRED');
-        return ardentAcceptedTaskSchema.parse(await this.action(ref, 'preview-submit', { body: ardentPreviewSubmitSchema.parse(body) }, context));
+        return ardentTaskAdmissionSchema.parse(await this.action(ref, 'preview-submit', { body: ardentPreviewSubmitSchema.parse(body) }, context));
     }
     /** Record a development note. studio >= 2; needs the acting person. */
     async addDevelopmentNote(ref, body, context) {
@@ -466,11 +268,11 @@ export class MagnusClient {
     async createAgent(body, context) {
         if (!context.actingSubject)
             throw new MagnusError('New Agent needs the acting person', 400, 'ACTING_SUBJECT_REQUIRED');
-        return z.object({ operationId: z.string() }).parse(await this.json('POST', '/api/v1/ardent/agents', context, ardentAgentDeployRequestSchema.parse(body)));
+        return operationAcceptedSchema.parse(await this.json('POST', '/api/v1/ardent/agents', context, ardentAgentDeployRequestSchema.parse(body)));
     }
     /** Step receipts of a New Agent or Enable HiveMem operation. */
     async agentOperation(operationId, context = {}) {
-        return agentOperationSchema.parse(await this.json('GET', `/api/v1/ardent/agents/operations/${operationIdOf(operationId)}`, context));
+        return ardentAgentOperationSchema.parse(await this.json('GET', `/api/v1/ardent/agents/operations/${operationIdOf(operationId)}`, context));
     }
     /** Live operation updates: `operation` events, then one `done`. */
     async *streamAgentOperation(operationId, options = {}) {
@@ -483,7 +285,7 @@ export class MagnusClient {
     async resumeAgentOperation(operationId, context) {
         if (!context.actingSubject)
             throw new MagnusError('Resuming an operation needs the acting person', 400, 'ACTING_SUBJECT_REQUIRED');
-        return z.object({ operationId: z.string() }).parse(await this.json('POST', `/api/v1/ardent/agents/operations/${operationIdOf(operationId)}/resume`, context));
+        return operationAcceptedSchema.parse(await this.json('POST', `/api/v1/ardent/agents/operations/${operationIdOf(operationId)}/resume`, context));
     }
     // ── Transport ──
     async json(method, path, context, body) {

package/dist/conductor/follower.js

@@ -3,7 +3,7 @@
 // so a clean end reconnects. When the stream fails, the follower polls the journal and the task
 // every 1 to 5 seconds, then tries the stream again.
 import { setTimeout as delay } from 'node:timers/promises';
-import { ardentTaskDoneEventSchema, ardentTaskEventSchema, ardentTaskTextEventSchema, MagnusError } from '../clients/magnus.js';
+import { ardentTaskDoneEventSchema, ardentTaskJournalEventSchema, ardentTaskTextEventSchema, MagnusError } from '../clients/magnus.js';
 /** Ardent states after which a task's turn is over. Ardent keeps `input_required` out of its stream's done set, so it is listed here. */
 export const ARDENT_FINISHED = ['completed', 'partial', 'failed', 'cancelled', 'unknown', 'input_required'];
 export class TaskFollower {
@@ -83,7 +83,7 @@ export class TaskFollower {
                     this.hooks.text(parsed.data.step, parsed.data.text, message.event === 'task.text' ? 'replace' : 'append');
             }
             else if (message.event === 'task.event') {
-                const parsed = ardentTaskEventSchema.safeParse(parseJson(message.data));
+                const parsed = ardentTaskJournalEventSchema.safeParse(parseJson(message.data));
                 if (!parsed.success)
                     continue;
                 if (await this.hooks.event(parsed.data))

package/dist/server/routes/agent-studio.js

@@ -4,7 +4,7 @@
 import { streamSSE } from 'hono/streaming';
 import { ConfigEditError, configuredSkills, editConfig, modelPath } from '../../agents/config-edit.js';
 import { operationView } from '../../agents/operations.js';
-import { agentOperationSchema, ARDENT_SERVICE_CAN_RESTART, ardentTaskDoneEventSchema, ardentTaskEventSchema, ardentTaskTextEventSchema, MagnusError, parseAgentRef, } from '../../clients/magnus.js';
+import { ardentAgentOperationSchema, ARDENT_SERVICE_CAN_RESTART, ardentTaskDoneEventSchema, ardentTaskJournalEventSchema, ardentTaskTextEventSchema, MagnusError, parseAgentRef, } from '../../clients/magnus.js';
 import { ARDENT_FINISHED } from '../../conductor/follower.js';
 import { agentRefSchema, APPLY_PARTS, IDEMPOTENCY_HEADER, idempotencyKeySchema, } from '../../shared/browser.js';
 import { actorOf, requireProject } from '../deps.js';
@@ -56,7 +56,7 @@ export function agentStudioRoutes(register, deps) {
             return { body: operationView(store.agents.operation(record.id), current) };
         }
         catch {
-            const stored = agentOperationSchema.safeParse(record.operation);
+            const stored = ardentAgentOperationSchema.safeParse(record.operation);
             return { body: operationView(record, stored.success ? stored.data : undefined) };
         }
     });
@@ -207,7 +207,7 @@ export function agentStudioRoutes(register, deps) {
                                 await send(message.event === 'task.text' ? 'preview.text' : 'preview.delta', text.data);
                         }
                         else if (message.event === 'task.event') {
-                            const event = ardentTaskEventSchema.safeParse(JSON.parse(message.data));
+                            const event = ardentTaskJournalEventSchema.safeParse(JSON.parse(message.data));
                             if (!event.success)
                                 continue;
                             cursor = event.data.sequence;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hivemagnus/ardent-studio",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Ardent Project Studio service: projects, team assignment, conversation room and deliverable review for Ardent agents managed by Magnus",
   "keywords": [
     "ardent",
@@ -67,6 +67,7 @@
     "verify": "npm run privacy:test && npm run scan:secrets && npm run check:private && npm run typecheck && npm run lint && npm test && npm run build && npm run check:contracts && npm run pack:check"
   },
   "dependencies": {
+    "@hivemagnus/magnus-contracts": "2.2.0",
     "@hono/node-server": "^2.1.5",
     "better-sqlite3": "^13.0.3",
     "fflate": "^0.8.3",
@@ -89,5 +90,8 @@
   "allowScripts": {
     "better-sqlite3@13.0.3": true,
     "esbuild@0.28.2": true
+  },
+  "overrides": {
+    "minimatch": "11.0.5"
   }
 }