@ornncompute/cli 0.2.24 → 1.0.34

package/vendor/capabilities/capabilities/compute.js

@@ -0,0 +1,522 @@
+import { z } from "zod";
+import { defineCapability, } from "../capability.js";
+const positionals = z.array(z.string()).default([]);
+export const launchInput = z
+    .object({
+    $positionals: positionals,
+    guided: z.boolean().optional(),
+    idempotencyKey: z.string().optional(),
+    key: z.string().optional(),
+    keyId: z.string().optional(),
+    label: z.string().optional(),
+    machine: z.string().optional(),
+    machines: z.string().optional(),
+    mode: z.string().optional(),
+    mountAccess: z.string().optional(),
+    network: z.string().optional(),
+    noWait: z.boolean().optional(),
+    nodes: z.union([z.string(), z.number()]).optional(),
+    organization: z.string().optional(),
+    publicKey: z.string().optional(),
+    publicKeyFile: z.string().optional(),
+    reservation: z.string().optional(),
+    resume: z.union([z.string().min(1), z.literal(true)]).optional(),
+    timeout: z.string().optional(),
+    username: z.string().optional(),
+    wait: z.boolean().optional(),
+    yes: z.boolean().optional(),
+    volume: z.string().optional(),
+})
+    .strict();
+const keyListInput = z
+    .object({
+    $positionals: positionals,
+    cursor: z.string().optional(),
+    limit: z.coerce.number().int().min(1).max(500).optional(),
+})
+    .strict();
+const keyMutationInput = z
+    .object({
+    $positionals: positionals,
+    idempotencyKey: z.string().optional(),
+    key: z.string().optional(),
+    keyId: z.string().optional(),
+    label: z.string().optional(),
+    publicKey: z.string().optional(),
+    publicKeyFile: z.string().optional(),
+    yes: z.boolean().optional(),
+})
+    .strict();
+const machineListInput = z
+    .object({
+    $positionals: positionals,
+    cursor: z.string().optional(),
+    limit: z.coerce.number().int().min(1).max(500).optional(),
+})
+    .strict();
+const machineShowInput = z
+    .object({
+    $positionals: positionals,
+    guided: z.boolean().optional(),
+})
+    .strict();
+const machineWaitInput = z
+    .object({
+    $positionals: positionals,
+    guided: z.boolean().optional(),
+    timeout: z.string().optional(),
+})
+    .strict();
+const machineSwitchInput = z
+    .object({
+    $positionals: positionals,
+    guided: z.boolean().optional(),
+    eraseLocalData: z.boolean().optional(),
+    idempotencyKey: z.string().optional(),
+    mode: z.string().optional(),
+    network: z.string().optional(),
+    noWait: z.boolean().optional(),
+    timeout: z.string().optional(),
+    wait: z.boolean().optional(),
+    yes: z.boolean().optional(),
+})
+    .strict();
+const machineMaintenanceInput = z
+    .object({
+    $positionals: positionals,
+    eraseLocalData: z.boolean().optional(),
+    guided: z.boolean().optional(),
+    idempotencyKey: z.string().optional(),
+    noWait: z.boolean().optional(),
+    timeout: z.string().optional(),
+    wait: z.boolean().optional(),
+    yes: z.boolean().optional(),
+})
+    .strict();
+function runtime(context) {
+    const interaction = context.cli?.interaction;
+    if (!interaction)
+        throw new Error("This capability must execute through the Ornn CLI runtime.");
+    return interaction;
+}
+async function executeLaunch(context, input) {
+    const interaction = runtime(context);
+    if (!interaction.launch)
+        throw new Error("No launch mode handlers are registered.");
+    return interaction.launch({ context, input, interaction });
+}
+function executeSshKeys(command) {
+    return async (context, input) => {
+        const interaction = runtime(context);
+        if (!interaction.sshKeys)
+            throw new Error("SSH-key commands are unavailable.");
+        return interaction.sshKeys(command, input, context);
+    };
+}
+function executeMachines(command) {
+    return async (context, input) => {
+        const interaction = runtime(context);
+        if (!interaction.machines)
+            throw new Error("Machine commands are unavailable.");
+        return interaction.machines(command, input, context);
+    };
+}
+function cliOnly(specification) {
+    return defineCapability({ ...specification, mcp: false, slack: false });
+}
+export const launchCapability = cliOnly({
+    id: "access.launch",
+    domain: "access",
+    roles: ["user"],
+    description: "Launch one explicitly selected access mode from active reserved capacity.",
+    mutation: "preview-confirm",
+    input: launchInput,
+    cli: {
+        command: ["launch"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "journey",
+            order: 2,
+            outcome: "Launch one reviewed VM, Bare Metal machine, Kubernetes cluster, or Slurm cluster from active reserved capacity, including a declared durable Bare Metal workspace.",
+            human: "ornn launch [<capacity-reservation>] --mode vm|bare-metal|kubernetes|slurm [--key <ssh-key>]; Bare Metal may add --network shared --volume <managed-volume> --mount-access read-only|read-write; Kubernetes/Slurm prompt for missing --network public|private and --nodes <membership-count>",
+            automation: "ornn launch <canonical-reservation-id> --mode vm|bare-metal|kubernetes|slurm --organization <id> --yes --idempotency-key <key> --format json; VM/Bare Metal/Slurm require --key <canonical-key-id>; Bare Metal may add --network shared --volume <canonical-volume-id> --mount-access read-only|read-write; Kubernetes/Slurm require --network public|private --nodes <membership-count> --machines <canonical-machine-ids>",
+            acceptedReferences: [
+                "canonical capacity-reservation ID",
+                "canonical eligible machine IDs",
+                "invocation-local eligible reservation and machine choices",
+                "exact SSH-key and managed-volume references; organization network shared",
+            ],
+            review: "organization, active capacity reservation, explicit access mode, native access, exact machine or cluster membership goal, declared SSH key, network and volume-mount relationships, allocation window and quantity, and wait behavior",
+            resumableStates: [
+                "partial durable workspace",
+                "accepted machine or cluster",
+                "native access ready",
+                "partial membership",
+            ],
+            related: [
+                "connect",
+                "machines list",
+                "clusters show",
+                "volume-mounts show",
+                "filesystems show",
+                "ssh-keys list",
+                "ssh-keys assignments status",
+            ],
+        },
+    },
+    execute: executeLaunch,
+});
+export const machineListCapability = cliOnly({
+    id: "access.machines.list",
+    domain: "access",
+    roles: ["user"],
+    description: "List direct VM and Bare Metal machines in one bounded page.",
+    mutation: "read",
+    input: machineListInput,
+    cli: {
+        command: ["machines", "list"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 460,
+            outcome: "List owned direct machines with lifecycle and SSH reachability kept separate.",
+            human: "ornn machines list [--limit <1-500>] [--cursor <opaque-cursor>]",
+            automation: "ornn machines list --limit 50 --format json",
+            acceptedReferences: ["opaque page cursor"],
+            related: ["machines show", "machines wait"],
+        },
+    },
+    execute: executeMachines("list"),
+});
+export const machineShowCapability = cliOnly({
+    id: "access.machines.show",
+    domain: "access",
+    roles: ["user"],
+    description: "Inspect one exact direct machine without changing it.",
+    mutation: "read",
+    input: machineShowInput,
+    cli: {
+        command: ["machines", "show"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 461,
+            outcome: "Show one exact VM or Bare Metal machine, its lifecycle, and independent SSH reachability.",
+            human: "ornn machines show <canonical-machine-id|exact-hostname>",
+            automation: "ornn machines show <canonical-machine-id> --format json",
+            acceptedReferences: [
+                "canonical machine ID",
+                "exact unique hostname",
+                "invocation-local guided choice",
+            ],
+            related: ["connect", "machines wait"],
+        },
+    },
+    execute: executeMachines("show"),
+});
+export const machineWaitCapability = cliOnly({
+    id: "access.machines.wait",
+    domain: "access",
+    roles: ["user"],
+    description: "Wait locally for one exact direct machine to become SSH-ready.",
+    mutation: "read",
+    input: machineWaitInput,
+    cli: {
+        command: ["machines", "wait"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 462,
+            outcome: "Wait for usable SSH without canceling remote work on timeout or interruption.",
+            human: "ornn machines wait <canonical-machine-id|exact-hostname> [--timeout <duration>]",
+            automation: "ornn machines wait <canonical-machine-id> --timeout <duration> --format json",
+            acceptedReferences: [
+                "canonical machine ID",
+                "exact unique hostname",
+                "invocation-local guided choice",
+            ],
+            resumableStates: ["provisioning", "SSH-key delivery pending", "SSH ready"],
+            related: ["machines show", "connect"],
+        },
+    },
+    execute: executeMachines("wait"),
+});
+export const machineSwitchCapability = cliOnly({
+    id: "access.machines.switch",
+    domain: "access",
+    roles: ["user"],
+    description: "Switch one direct-machine reservation's mode or network intent.",
+    mutation: "preview-confirm",
+    input: machineSwitchInput,
+    cli: {
+        command: ["machines", "switch"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 463,
+            outcome: "Change only the explicitly requested VM, Bare Metal, or network goal while retaining SSH-key intent.",
+            human: "ornn machines switch <canonical-reservation-id> [--mode vm|bare-metal] [--network public|private] [--erase-local-data]",
+            automation: "ornn machines switch <canonical-reservation-id> [--mode vm|bare-metal] [--network public|private] [--erase-local-data] --yes --idempotency-key <key> --format json",
+            acceptedReferences: ["canonical capacity-reservation ID"],
+            review: "exact reservation, current and requested access mode, network intent, retained SSH keys, access interruption, and permanent local-data erasure for cross-mode changes",
+            resumableStates: ["switch accepted", "SSH ready"],
+            related: ["machines wait", "connect"],
+        },
+    },
+    execute: executeMachines("switch"),
+});
+export const machineRebootCapability = cliOnly({
+    id: "access.machines.reboot",
+    domain: "access",
+    roles: ["user"],
+    description: "Reboot one exact direct machine after reviewing the access interruption.",
+    mutation: "preview-confirm",
+    input: machineMaintenanceInput,
+    cli: {
+        command: ["machines", "reboot"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 464,
+            outcome: "Reboot one exact machine and normally wait for restored SSH readiness.",
+            human: "ornn machines reboot <canonical-machine-id|exact-hostname> [--no-wait]",
+            automation: "ornn machines reboot <canonical-machine-id> --yes --idempotency-key <key> --format json",
+            acceptedReferences: [
+                "canonical machine ID",
+                "exact unique hostname",
+                "invocation-local guided choice",
+            ],
+            review: "temporary SSH interruption with SSH keys, network, mounted volume, and local data preserved",
+            resumableStates: ["reboot accepted", "SSH ready"],
+            related: ["machines wait", "connect"],
+        },
+    },
+    execute: executeMachines("reboot"),
+});
+export const machineResetCapability = cliOnly({
+    id: "access.machines.reset",
+    domain: "access",
+    roles: ["user"],
+    description: "Erase local machine data and hard reset one exact direct machine.",
+    mutation: "preview-confirm",
+    input: machineMaintenanceInput,
+    cli: {
+        command: ["machines", "reset"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 465,
+            outcome: "Hard reset one exact machine only with explicit local-data erasure scope and final consent.",
+            human: "ornn machines reset <canonical-machine-id|exact-hostname> --erase-local-data [--no-wait]",
+            automation: "ornn machines reset <canonical-machine-id> --erase-local-data --yes --idempotency-key <key> --format json",
+            acceptedReferences: [
+                "canonical machine ID",
+                "exact unique hostname",
+                "invocation-local guided choice",
+            ],
+            review: "permanent local-data erasure, temporary access interruption, restored SSH keys, and preserved external volume relationship",
+            resumableStates: ["reset accepted", "SSH ready"],
+            related: ["machines wait", "connect"],
+        },
+    },
+    execute: executeMachines("reset"),
+});
+export const sshKeyListCapability = cliOnly({
+    id: "access.ssh_keys.list",
+    domain: "access",
+    roles: ["user"],
+    mutation: "read",
+    input: keyListInput,
+    description: "List organization SSH keys in a bounded page.",
+    cli: {
+        command: ["ssh-keys", "list"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 450,
+            outcome: "List organization SSH keys without exposing key material.",
+            human: "ornn ssh-keys list [--limit <1-500>] [--cursor <cursor>]",
+            automation: "ornn ssh-keys list --format json [--limit <1-500>] [--cursor <cursor>]",
+            acceptedReferences: [],
+            related: ["ssh-keys add", "ssh-keys assignments list"],
+        },
+    },
+    execute: executeSshKeys("list"),
+});
+export const sshKeyAddCapability = cliOnly({
+    id: "access.ssh_keys.add",
+    domain: "access",
+    roles: ["user"],
+    mutation: "preview-confirm",
+    input: keyMutationInput,
+    description: "Add or replay one organization SSH public key.",
+    cli: {
+        command: ["ssh-keys", "add"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 451,
+            outcome: "Add one organization SSH public key by durable public-key identity.",
+            human: "ornn ssh-keys add --public-key-file <path> --label <label>",
+            automation: "ornn ssh-keys add --public-key <public-key> --label <label> --idempotency-key <key> --format json",
+            acceptedReferences: ["public key value", "public key file"],
+            resumableStates: ["ready"],
+            related: ["ssh-keys list", "ssh-keys assignments assign"],
+        },
+    },
+    execute: executeSshKeys("add"),
+});
+export const sshKeyDeleteCapability = cliOnly({
+    id: "access.ssh_keys.delete",
+    domain: "access",
+    roles: ["user"],
+    mutation: "preview-confirm",
+    input: keyMutationInput,
+    description: "Delete one exact organization SSH key after review.",
+    cli: {
+        command: ["ssh-keys", "delete"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 452,
+            outcome: "Delete one exact organization SSH key without implying machine delivery.",
+            human: "ornn ssh-keys delete <exact-key-id-or-label>",
+            automation: "ornn ssh-keys delete <canonical-key-id> --yes --idempotency-key <key> --format json",
+            acceptedReferences: [
+                "canonical SSH-key ID",
+                "exact unique key label in an eligible terminal",
+            ],
+            review: "key identity and loss of future access",
+            resumableStates: ["ended"],
+            related: ["ssh-keys list"],
+        },
+    },
+    execute: executeSshKeys("delete"),
+});
+export const sshKeyAssignmentListCapability = cliOnly({
+    id: "access.ssh_key_assignments.list",
+    domain: "access",
+    roles: ["user"],
+    mutation: "read",
+    input: keyListInput,
+    description: "List SSH keys assigned to one capacity reservation.",
+    cli: {
+        command: ["ssh-keys", "assignments", "list"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 453,
+            outcome: "List the SSH keys assigned to one exact capacity reservation.",
+            human: "ornn ssh-keys assignments list <canonical-reservation-id>",
+            automation: "ornn ssh-keys assignments list <canonical-reservation-id> --format json",
+            acceptedReferences: ["canonical capacity-reservation ID"],
+            related: ["ssh-keys assignments status"],
+        },
+    },
+    execute: executeSshKeys("assignments.list"),
+});
+export const sshKeyAssignmentAssignCapability = cliOnly({
+    id: "access.ssh_key_assignments.assign",
+    domain: "access",
+    roles: ["user"],
+    mutation: "preview-confirm",
+    input: keyMutationInput,
+    description: "Assign one existing organization SSH key to one capacity reservation.",
+    cli: {
+        command: ["ssh-keys", "assignments", "assign"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 454,
+            outcome: "Assign or replay one exact SSH-key relationship.",
+            human: "ornn ssh-keys assignments assign <canonical-reservation-id> --key <exact-key-id-or-label>",
+            automation: "ornn ssh-keys assignments assign <canonical-reservation-id> --key <canonical-key-id> --yes --idempotency-key <key> --format json",
+            acceptedReferences: [
+                "canonical capacity-reservation ID",
+                "canonical SSH-key ID",
+                "exact unique key label in an eligible terminal",
+            ],
+            review: "reservation and SSH-key relationship",
+            resumableStates: ["associated", "queued", "installed"],
+            related: ["ssh-keys assignments status"],
+        },
+    },
+    execute: executeSshKeys("assignments.assign"),
+});
+export const sshKeyAssignmentSyncCapability = cliOnly({
+    id: "access.ssh_key_assignments.sync",
+    domain: "access",
+    roles: ["user"],
+    mutation: "preview-confirm",
+    input: keyMutationInput,
+    description: "Synchronize assigned SSH keys to every active reservation machine.",
+    cli: {
+        command: ["ssh-keys", "assignments", "sync"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 455,
+            outcome: "Queue idempotent SSH-key synchronization and report delayed delivery honestly.",
+            human: "ornn ssh-keys assignments sync <canonical-reservation-id>",
+            automation: "ornn ssh-keys assignments sync <canonical-reservation-id> --yes --idempotency-key <key> --format json",
+            acceptedReferences: ["canonical capacity-reservation ID"],
+            review: "reservation, assigned keys, and target machines",
+            resumableStates: ["queued", "installed", "failed"],
+            related: ["ssh-keys assignments status"],
+        },
+    },
+    execute: executeSshKeys("assignments.sync"),
+});
+export const sshKeyAssignmentStatusCapability = cliOnly({
+    id: "access.ssh_key_assignments.status",
+    domain: "access",
+    roles: ["user"],
+    mutation: "read",
+    input: keyListInput,
+    description: "Show assigned, queued, installed, and failed SSH-key delivery per machine.",
+    cli: {
+        command: ["ssh-keys", "assignments", "status"],
+        vnext: {
+            arguments: "semantic",
+            audience: "customer",
+            category: "resource",
+            order: 456,
+            outcome: "Distinguish SSH-key assignment from delayed machine delivery.",
+            human: "ornn ssh-keys assignments status <canonical-reservation-id>",
+            automation: "ornn ssh-keys assignments status <canonical-reservation-id> --format json",
+            acceptedReferences: ["canonical capacity-reservation ID"],
+            resumableStates: ["associated", "queued", "installed", "failed"],
+            related: ["ssh-keys assignments sync", "connect"],
+        },
+    },
+    execute: executeSshKeys("assignments.status"),
+});
+export const computeCapabilities = [
+    launchCapability,
+    machineListCapability,
+    machineShowCapability,
+    machineWaitCapability,
+    machineSwitchCapability,
+    machineRebootCapability,
+    machineResetCapability,
+    sshKeyListCapability,
+    sshKeyAddCapability,
+    sshKeyDeleteCapability,
+    sshKeyAssignmentListCapability,
+    sshKeyAssignmentAssignCapability,
+    sshKeyAssignmentSyncCapability,
+    sshKeyAssignmentStatusCapability,
+];

package/vendor/capabilities/capabilities/evidence.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { defineCapability, } from "../capability.js";
+const positionals = z.array(z.string()).default([]);
+export const evidenceInput = z
+    .object({
+    $positionals: positionals,
+    before: z.string().optional(),
+    count: z.string().optional(),
+    cursor: z.string().optional(),
+    end: z.string().optional(),
+    follow: z.boolean().optional(),
+    guided: z.boolean().optional(),
+    interval: z.string().optional(),
+    limit: z.string().optional(),
+    maxPoints: z.string().optional(),
+    start: z.string().optional(),
+    stream: z.enum(["kernel", "serial"]).optional(),
+    timeout: z.string().optional(),
+})
+    .strict();
+function runtime(context) {
+    const interaction = context.cli?.interaction;
+    if (!interaction?.evidence)
+        throw new Error("The CLI evidence runtime is unavailable.");
+    return interaction;
+}
+function execute(command) {
+    return (context, input) => runtime(context).evidence(command, input, context);
+}
+function cliOnly({ automation, category, command, description, human, id, order, outcome, references, related, }) {
+    const executor = command.length === 1 ? "check" : `${command[0]}.${command[1]}`;
+    return defineCapability({
+        id,
+        domain: "observability",
+        roles: ["user"],
+        description,
+        mutation: "read",
+        input: evidenceInput,
+        cli: {
+            command,
+            vnext: {
+                arguments: "semantic",
+                audience: "customer",
+                category,
+                order,
+                outcome,
+                human,
+                automation,
+                acceptedReferences: references,
+                resumableStates: ["no data", "unavailable", "streaming", "ended", "interrupted"],
+                related,
+            },
+        },
+        mcp: false,
+        slack: false,
+        execute: execute(executor),
+    });
+}
+export const checkCapability = cliOnly({
+    id: "evidence.check",
+    command: ["check"],
+    category: "journey",
+    order: 4,
+    description: "Compose lifecycle, reachability, authoritative health, metrics, and logs for one machine or cluster.",
+    outcome: "Check one exact machine or cluster without turning missing evidence into health.",
+    human: "ornn check [<canonical-resource-id-or-exact-hostname>] [--follow] [--start <time> --end <time>]",
+    automation: "ornn check <canonical-machine-or-cluster-id> --start <time> --end <time> --max-points 240 --limit 200 --format json",
+    references: [
+        "canonical machine ID",
+        "exact unique machine hostname",
+        "canonical cluster ID",
+        "invocation-local guided choice",
+    ],
+    related: [
+        "connect",
+        "machines metrics",
+        "machines logs",
+        "clusters metrics",
+        "clusters logs",
+        "cost",
+    ],
+});
+export const machineMetricsCapability = cliOnly({
+    id: "evidence.machine_metrics",
+    command: ["machines", "metrics"],
+    category: "resource",
+    order: 560,
+    description: "Read or follow bounded customer-safe metrics for one exact machine.",
+    outcome: "Return normalized machine metrics with explicit evidence state and window.",
+    human: "ornn machines metrics [<machine-id-or-exact-hostname>] [--guided] [--start <time> --end <time>] [--max-points <1-500>] [--follow]",
+    automation: "ornn machines metrics <canonical-machine-id> --start <time> --end <time> --max-points 240 --format json",
+    references: [
+        "canonical machine ID",
+        "exact unique machine hostname",
+        "invocation-local guided choice",
+    ],
+    related: ["check", "machines logs"],
+});
+export const machineLogsCapability = cliOnly({
+    id: "evidence.machine_logs",
+    command: ["machines", "logs"],
+    category: "resource",
+    order: 561,
+    description: "Read or follow bounded customer-safe kernel or serial logs for one exact machine.",
+    outcome: "Return normalized machine logs with opaque pagination and unsafe lines omitted.",
+    human: "ornn machines logs [<machine-id-or-exact-hostname>] [--guided] [--stream kernel|serial] [--limit <1-500>] [--cursor <cursor>] [--follow]",
+    automation: "ornn machines logs <canonical-machine-id> --stream kernel --limit 200 --format json",
+    references: [
+        "canonical machine ID",
+        "exact unique machine hostname",
+        "invocation-local guided choice",
+    ],
+    related: ["check", "machines metrics"],
+});
+export const clusterMetricsCapability = cliOnly({
+    id: "evidence.cluster_metrics",
+    command: ["clusters", "metrics"],
+    category: "resource",
+    order: 562,
+    description: "Read or follow bounded customer-safe metrics for every member of one exact cluster.",
+    outcome: "Return normalized per-machine cluster metrics without changing cluster health.",
+    human: "ornn clusters metrics [<cluster-id>] [--guided] [--start <time> --end <time>] [--max-points <1-500>] [--follow]",
+    automation: "ornn clusters metrics <canonical-cluster-id> --start <time> --end <time> --max-points 240 --format json",
+    references: ["canonical cluster ID", "invocation-local guided choice"],
+    related: ["check", "clusters logs"],
+});
+export const clusterLogsCapability = cliOnly({
+    id: "evidence.cluster_logs",
+    command: ["clusters", "logs"],
+    category: "resource",
+    order: 563,
+    description: "Read or follow bounded customer-safe logs for every member of one exact cluster.",
+    outcome: "Return normalized per-machine cluster logs without exposing staff or supplier details.",
+    human: "ornn clusters logs [<cluster-id>] [--guided] [--stream kernel|serial] [--limit <1-500>] [--follow]",
+    automation: "ornn clusters logs <canonical-cluster-id> --stream kernel --limit 200 --format json",
+    references: ["canonical cluster ID", "invocation-local guided choice"],
+    related: ["check", "clusters metrics"],
+});
+export const evidenceCapabilities = [
+    checkCapability,
+    machineMetricsCapability,
+    machineLogsCapability,
+    clusterMetricsCapability,
+    clusterLogsCapability,
+];