@paneui/cli 0.0.6 → 0.0.8

package/dist/commands/{artifact.js → template.js}

@@ -1,11 +1,11 @@
-// `pane artifact` — manage reusable, versioned artifacts.
+// `pane template` — manage reusable, versioned templates.
 //
-// Flat command namespace: `artifact` is one top-level command that branches on
+// Flat command namespace: `template` is one top-level command that branches on
 // a positional subcommand (create / version / update / search / list / show /
 // delete).
-// An artifact is a reusable UI template (HTML + event schema + optional input
-// schema); a session is one *use* of one version of it. Authoring an artifact
-// once and instancing it via `pane session create --artifact-id` removes the
+// An template is a reusable UI template (HTML + event schema + optional input
+// schema); a surface is one *use* of one version of it. Authoring an template
+// once and instancing it via `pane surface create --template-id` removes the
 // per-use cost of regenerating the same HTML.
 import { createArtifactSchema, createArtifactVersionSchema, patchArtifactMetadataSchema, } from "@paneui/core";
 import { assertKnownFlags } from "../argv.js";
@@ -17,14 +17,14 @@ const CREATE_FLAGS = [
     "slug",
     "description",
     "tags",
-    "artifact",
-    "artifact-type",
+    "template",
+    "template-type",
     "event-schema",
     "input-schema",
 ];
 const VERSION_FLAGS = [
-    "artifact",
-    "artifact-type",
+    "template",
+    "template-type",
     "event-schema",
     "input-schema",
 ];
@@ -32,70 +32,70 @@ const UPDATE_FLAGS = ["name", "slug", "description", "tags"];
 const NO_FLAGS = [];
 const NO_BOOLS = [];
 const DELETE_BOOLS = ["yes"];
-export const artifactHelp = `pane artifact — manage reusable, versioned artifacts
+export const artifactHelp = `pane template — manage reusable, versioned templates
 
-An artifact is a reusable UI template: HTML + an event schema + an optional
-input schema. A session is one use of one version of it. Author an artifact
-once, then instance it many times with 'pane session create --artifact-id <id|slug>'
-instead of regenerating the HTML on every session.
+An template is a reusable UI template: HTML + an event schema + an optional
+input schema. A surface is one use of one version of it. Author an template
+once, then instance it many times with 'pane surface create --template-id <id|slug>'
+instead of regenerating the HTML on every surface.
 
 Usage:
-  pane artifact <subcommand> [options]
+  pane template <subcommand> [options]
 
 Subcommands:
-  create     Create a named, reusable artifact (its v1).
-  version    Append a new version to an existing artifact.
-  update     Update an artifact's head metadata (name/slug/description/tags).
-  search     Search the agent's named artifacts (lean — no HTML).
-  list       List the agent's named artifacts (search with no query).
-  show       Show a full artifact: head metadata + its version list.
-  delete     Permanently delete an artifact and ALL its versions. Requires
-             --yes. Refused with 409 conflict if any session (open or
-             closed) still references the artifact — delete those first.
+  create     Create a named, reusable template (its v1).
+  version    Append a new version to an existing template.
+  update     Update an template's head metadata (name/slug/description/tags).
+  search     Search the agent's named templates (lean — no HTML).
+  list       List the agent's named templates (search with no query).
+  show       Show a full template: head metadata + its version list.
+  delete     Permanently delete an template and ALL its versions. Requires
+             --yes. Refused with 409 conflict if any surface (open or
+             closed) still references the template — delete those first.
 
-  pane artifact create --name <n> --artifact <path|inline>
+  pane template create --name <n> --template <path|inline>
                        [--event-schema <path|json>] [--slug <s>]
                        [--description <d>] [--tags <t1,t2>]
-                       [--input-schema <path|json>] [--artifact-type <t>]
-      Creates a named artifact. Prints { artifact_id, slug, version }.
+                       [--input-schema <path|json>] [--template-type <t>]
+      Creates a named template. Prints { template_id, slug, version }.
 
-  pane artifact version <id|slug> --artifact <path|inline>
+  pane template version <id|slug> --template <path|inline>
                         [--event-schema <path|json>]
-                        [--input-schema <path|json>] [--artifact-type <t>]
-      Appends a new immutable version. Prints { artifact_id, version }.
+                        [--input-schema <path|json>] [--template-type <t>]
+      Appends a new immutable version. Prints { template_id, version }.
 
-  pane artifact update <id|slug> [--name <n>] [--slug <s>]
+  pane template update <id|slug> [--name <n>] [--slug <s>]
                        [--description <d>] [--tags <t1,t2>]
       Updates head metadata only (never the content). Prints the lean summary.
 
-  pane artifact search [query]
+  pane template search [query]
       Text search over name + description + tags, ranked by last_used_at.
       Prints an array of { id, slug, name, description, tags,
       latest_version, last_used_at }.
 
-  pane artifact list
-      Alias of 'search' with no query — lists all the agent's artifacts.
+  pane template list
+      Alias of 'search' with no query — lists all the agent's templates.
 
-  pane artifact show <id|slug>
-      Prints the full artifact: head metadata + every version's content.
+  pane template show <id|slug>
+      Prints the full template: head metadata + every version's content.
 
-  pane artifact delete <id|slug> --yes
-      Permanently deletes the artifact and all its versions. Refused
-      (409 conflict) if any session in any state still references one
-      of the artifact's versions — run 'pane session delete <session-id>' on
+  pane template delete <id|slug> --yes
+      Permanently deletes the template and all its versions. Refused
+      (409 conflict) if any surface in any state still references one
+      of the template's versions — run 'pane surface delete <surface-id>' on
       each first, or wait for the relay's TTL sweeper to reclaim them.
-      Prints { artifact, deleted: true } on success.
+      Prints { template, deleted: true } on success.
 
 Options:
-  --name <n>          Artifact display name (required for 'create').
+  --name <n>          Template display name (required for 'create').
   --slug <s>          Stable, agent-chosen handle (unique per agent). The
-                      durable way to reference the artifact later.
-  --description <d>   Prose: what the artifact is and does. Read by an agent
+                      durable way to reference the template later.
+  --description <d>   Prose: what the template is and does. Read by an agent
                       deciding whether to reuse it.
   --tags <t1,t2,...>  Comma-separated keywords for search.
-  --artifact <v>      HTML artifact body — a file path, or inline HTML.
+  --template <v>      HTML template body — a file path, or inline HTML.
   --event-schema <v>  Event schema — a .json file path, or inline JSON.
-                      Optional: omit for a view-only artifact (a
+                      Optional: omit for a view-only template (a
                       report/dashboard the human only views — no page/agent
                       events).
 
@@ -117,27 +117,27 @@ Options:
                       emittedBy is any non-empty subset of ["page", "agent"].
                       payload is a JSON Schema; the relay validates every
                       emit against it. See docs/SPEC.md for the full grammar.
-  --input-schema <v>  JSON Schema for this artifact's per-session input_data —
+  --input-schema <v>  JSON Schema for this template's per-surface input_data —
                       a file path, or inline JSON. Optional.
-  --artifact-type <t> "html-inline" (default) or "html-ref".
+  --template-type <t> "html-inline" (default) or "html-ref".
   --url <url>         Relay base URL (overrides PANE_URL).
   --api-key <key>     Agent API key (overrides PANE_API_KEY).
   -h, --help          Show this help.
 
 Output: stdout is machine-readable JSON.`;
-/** Resolve --artifact-type, defaulting to html-inline. */
+/** Resolve --template-type, defaulting to html-inline. */
 function resolveArtifactType(args) {
-    const t = (args.flags.get("artifact-type") ?? "html-inline");
+    const t = (args.flags.get("template-type") ?? "html-inline");
     if (t !== "html-inline" && t !== "html-ref") {
-        fail("--artifact-type must be 'html-inline' or 'html-ref'", "invalid_args");
+        fail("--template-type must be 'html-inline' or 'html-ref'", "invalid_args");
     }
     return t;
 }
-/** Resolve the artifact HTML body (file or inline; verbatim URL for html-ref). */
+/** Resolve the template HTML body (file or inline; verbatim URL for html-ref). */
 function resolveSource(args, type) {
-    const artifactVal = args.flags.get("artifact");
+    const artifactVal = args.flags.get("template");
     if (!artifactVal)
-        fail("missing --artifact", "invalid_args");
+        fail("missing --template", "invalid_args");
     try {
         return type === "html-ref" ? artifactVal : resolveText(artifactVal);
     }
@@ -148,7 +148,7 @@ function resolveSource(args, type) {
 /**
  * Resolve --event-schema — file path or inline JSON. --event-schema is
  * optional: when absent this returns `undefined`, which makes a view-only
- * artifact (no event vocabulary — the human only views it). The caller must
+ * template (no event vocabulary — the human only views it). The caller must
  * omit `event_schema` from the request entirely when this returns `undefined`.
  */
 function resolveEventSchema(args) {
@@ -190,7 +190,7 @@ function resolveTags(args) {
     return tags.length > 0 ? tags : undefined;
 }
 async function runArtifactCreate(args) {
-    assertKnownFlags(args, CREATE_FLAGS, NO_BOOLS, "pane artifact create");
+    assertKnownFlags(args, CREATE_FLAGS, NO_BOOLS, "pane template create");
     const name = args.flags.get("name");
     if (!name)
         fail("missing --name", "invalid_args");
@@ -207,7 +207,7 @@ async function runArtifactCreate(args) {
         type,
     };
     // event_schema is OMITTED entirely when --event-schema is absent — a view-only
-    // artifact. Setting it to `undefined` would still add the key.
+    // template. Setting it to `undefined` would still add the key.
     if (eventSchema !== undefined)
         candidate["event_schema"] = eventSchema;
     if (slug !== undefined)
@@ -222,14 +222,14 @@ async function runArtifactCreate(args) {
     if (!parsed.success) {
         const issue = parsed.error.issues[0];
         const where = issue && issue.path.length > 0 ? issue.path.join(".") : "request";
-        fail(`invalid artifact: ${where}: ${issue ? issue.message : "validation failed"}`, "invalid_args", parsed.error.flatten());
+        fail(`invalid template: ${where}: ${issue ? issue.message : "validation failed"}`, "invalid_args", parsed.error.flatten());
     }
     const req = parsed.data;
     const client = makeClient(args);
     try {
         const res = await client.createArtifact(req);
         printJson({
-            artifact_id: res.artifact_id,
+            template_id: res.template_id,
             slug: slug ?? null,
             version: res.version,
         });
@@ -239,10 +239,10 @@ async function runArtifactCreate(args) {
     }
 }
 async function runArtifactVersion(args) {
-    assertKnownFlags(args, VERSION_FLAGS, NO_BOOLS, "pane artifact version");
+    assertKnownFlags(args, VERSION_FLAGS, NO_BOOLS, "pane template version");
     const idOrSlug = args.positionals[1];
     if (!idOrSlug) {
-        fail("missing artifact <id|slug> — usage: pane artifact version <id|slug>", "invalid_args");
+        fail("missing template <id|slug> — usage: pane template version <id|slug>", "invalid_args");
     }
     const type = resolveArtifactType(args);
     const source = resolveSource(args, type);
@@ -268,17 +268,17 @@ async function runArtifactVersion(args) {
     const client = makeClient(args);
     try {
         const res = await client.createArtifactVersion(idOrSlug, req);
-        printJson({ artifact_id: res.artifact_id, version: res.version });
+        printJson({ template_id: res.template_id, version: res.version });
     }
     catch (e) {
         failFromError(e);
     }
 }
 async function runArtifactUpdate(args) {
-    assertKnownFlags(args, UPDATE_FLAGS, NO_BOOLS, "pane artifact update");
+    assertKnownFlags(args, UPDATE_FLAGS, NO_BOOLS, "pane template update");
     const idOrSlug = args.positionals[1];
     if (!idOrSlug) {
-        fail("missing artifact <id|slug> — usage: pane artifact update <id|slug>", "invalid_args");
+        fail("missing template <id|slug> — usage: pane template update <id|slug>", "invalid_args");
     }
     const candidate = {};
     const name = args.flags.get("name");
@@ -313,7 +313,7 @@ async function runArtifactUpdate(args) {
     }
 }
 async function runArtifactSearch(args, query) {
-    assertKnownFlags(args, NO_FLAGS, NO_BOOLS, query === undefined ? "pane artifact list" : "pane artifact search");
+    assertKnownFlags(args, NO_FLAGS, NO_BOOLS, query === undefined ? "pane template list" : "pane template search");
     const client = makeClient(args);
     try {
         const res = await client.searchArtifacts(query);
@@ -324,10 +324,10 @@ async function runArtifactSearch(args, query) {
     }
 }
 async function runArtifactShow(args) {
-    assertKnownFlags(args, NO_FLAGS, NO_BOOLS, "pane artifact show");
+    assertKnownFlags(args, NO_FLAGS, NO_BOOLS, "pane template show");
     const idOrSlug = args.positionals[1];
     if (!idOrSlug) {
-        fail("missing artifact <id|slug> — usage: pane artifact show <id|slug>", "invalid_args");
+        fail("missing template <id|slug> — usage: pane template show <id|slug>", "invalid_args");
     }
     const client = makeClient(args);
     try {
@@ -338,24 +338,24 @@ async function runArtifactShow(args) {
         failFromError(e);
     }
 }
-// `pane artifact delete <id|slug> --yes` — remove an artifact (and, server-
+// `pane template delete <id|slug> --yes` — remove an template (and, server-
 // side, all its versions). The relay refuses with 409 conflict if any
-// session still references it; the CLI surfaces that as the relay-supplied
+// surface still references it; the CLI surfaces that as the relay-supplied
 // envelope. `--yes` is required because there's no Undo button on a delete
-// and the same `pane artifact create` slug isn't reservable once gone.
+// and the same `pane template create` slug isn't reservable once gone.
 async function runArtifactDelete(args) {
-    assertKnownFlags(args, NO_FLAGS, DELETE_BOOLS, "pane artifact delete");
+    assertKnownFlags(args, NO_FLAGS, DELETE_BOOLS, "pane template delete");
     const idOrSlug = args.positionals[1];
     if (!idOrSlug) {
-        fail("missing artifact <id|slug> — usage: pane artifact delete <id|slug> --yes", "invalid_args");
+        fail("missing template <id|slug> — usage: pane template delete <id|slug> --yes", "invalid_args");
     }
     if (!args.bools.has("yes")) {
-        fail("'pane artifact delete' permanently removes the artifact and all its versions — it is destructive. Pass --yes to confirm.", "invalid_args");
+        fail("'pane template delete' permanently removes the template and all its versions — it is destructive. Pass --yes to confirm.", "invalid_args");
     }
     const client = makeClient(args);
     try {
         await client.deleteArtifact(idOrSlug);
-        printJson({ artifact: idOrSlug, deleted: true });
+        printJson({ template: idOrSlug, deleted: true });
     }
     catch (e) {
         failFromError(e);
@@ -386,9 +386,9 @@ export async function runArtifact(args) {
             await runArtifactDelete(args);
             break;
         case undefined:
-            fail("missing subcommand — usage: pane artifact <create|version|update|search|list|show|delete> (run 'pane artifact --help')", "invalid_args");
+            fail("missing subcommand — usage: pane template <create|version|update|search|list|show|delete> (run 'pane template --help')", "invalid_args");
             break;
         default:
-            fail(`unknown artifact subcommand '${sub}' — expected create|version|update|search|list|show|delete (run 'pane artifact --help')`, "invalid_args");
+            fail(`unknown template subcommand '${sub}' — expected create|version|update|search|list|show|delete (run 'pane template --help')`, "invalid_args");
     }
 }

package/dist/commands/watch.js

@@ -1,4 +1,4 @@
-// `pane session watch <id>` — long-lived: hold a WebSocket and stream events as
+// `pane surface watch <id>` — long-lived: hold a WebSocket and stream events as
 // JSON-lines on stdout. This harness-agnostic stdout is the core contract:
 // one compact JSON object per line, flushed after every event, so any
 // pipe-reader (Claude Code's Monitor tool, `while read line`, jq -c, ...)
@@ -11,14 +11,14 @@ import { printJsonLine, fail } from "../output.js";
 import { VERSION } from "../version.js";
 const KNOWN_FLAGS = ["since", "type", "filter-type", "timeout"];
 const KNOWN_BOOLS = ["once"];
-export const watchHelp = `pane session watch — stream a session's events as JSON-lines
+export const watchHelp = `pane surface watch — stream a surface's events as JSON-lines
 
 Usage:
-  pane session watch <session-id> [options]
+  pane surface watch <surface-id> [options]
 
-Holds a WebSocket to WS /v1/sessions/:id/stream. Prints ONE compact JSON
+Holds a WebSocket to WS /v1/surfaces/:id/stream. Prints ONE compact JSON
 object per line to stdout, flushing after each — designed to be piped into a
-line-reader. On session close, prints a final {"type":"_closed"} line and
+line-reader. On surface close, prints a final {"type":"_closed"} line and
 exits 0.
 
 Modes:
@@ -34,7 +34,7 @@ Options:
   --filter-type <t[,t2,…]>
                       Print only events whose type is in this set.
                       system.* events (lifecycle: participant.joined,
-                      session.expired, …) and the terminal {"type":
+                      surface.expired, …) and the terminal {"type":
                       "_closed"} line always pass through, so the
                       harness still sees them. Combine with --type X
                       --filter-type X for "stream only X events and
@@ -42,7 +42,7 @@ Options:
                       --type alone that agents often expect.
   --since <cursor>    Replay only events after this opaque cursor.
   --timeout <secs>    Wall-clock max wait. Fail with code ws_timeout if
-                      the natural exit condition (--once, --type, session
+                      the natural exit condition (--once, --type, surface
                       close) doesn't happen within this many seconds.
                       Frames arriving DO NOT reset the timer — this is
                       the budget for "give up on the human", not an idle
@@ -52,17 +52,17 @@ Options:
   --api-key <key>     Agent API key (overrides PANE_API_KEY).
   -h, --help          Show this help.
 
-Each line is one event envelope: { id, session_id, author, ts, type, data,
+Each line is one event envelope: { id, surface_id, author, ts, type, data,
 causation_id, idempotency_key }. The terminal line is {"type":"_closed"}.
 
-Pattern — Claude Code Monitor tool: run \`pane session watch <id> --type form.submitted\`
+Pattern — Claude Code Monitor tool: run \`pane surface watch <id> --type form.submitted\`
 as a monitored process; the harness re-invokes the model when the line lands.
 
 Wait for any of several events:
-  pane session watch <id> --type form.submitted,form.cancelled --timeout 60
+  pane surface watch <id> --type form.submitted,form.cancelled --timeout 60
 
 Stream only matching events to stdout, exit on the first:
-  pane session watch <id> --type form.submitted --filter-type form.submitted`;
+  pane surface watch <id> --type form.submitted --filter-type form.submitted`;
 // Parse a comma-separated event-type list (e.g. "form.submitted,form.cancelled")
 // into a Set. Empty/whitespace entries are dropped. Returns null when the flag
 // wasn't given (so callers can distinguish "no filter" from "empty filter").
@@ -91,10 +91,10 @@ export function shouldPrintEvent(eventType, filterTypes) {
     return filterTypes.has(eventType);
 }
 export async function runWatch(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane session watch");
-    const sessionId = args.positionals[0];
-    if (!sessionId)
-        fail("missing <session-id>", "invalid_args");
+    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane surface watch");
+    const surfaceId = args.positionals[0];
+    if (!surfaceId)
+        fail("missing <surface-id>", "invalid_args");
     const cfg = resolveConfig(args);
     const since = args.flags.get("since") ?? null;
     // --type controls the EXIT condition (set of types that trigger exit 0
@@ -135,7 +135,7 @@ export async function runWatch(args) {
         }
         finish(0);
     };
-    // Track whether the relay told us the session expired before the socket
+    // Track whether the relay told us the surface expired before the socket
     // closed — a 1006/1008/1011 close after that is still a clean shutdown.
     let sawSessionExpired = false;
     // Wall-clock timeout. The reporter's mental model (#137) and the skill
@@ -145,7 +145,7 @@ export async function runWatch(args) {
     // useless once any frame arrived, even a system.participant.joined
     // emitted the moment a human connected. Frames now DO NOT reset the
     // timer; the only ways `--timeout` doesn't fire are the natural exit
-    // conditions (--once, --type match, session close) finishing first.
+    // conditions (--once, --type match, surface close) finishing first.
     let timer;
     if (timeoutSec !== null) {
         timer = setTimeout(() => {
@@ -154,7 +154,7 @@ export async function runWatch(args) {
     }
     const handle = openStream({
         wsBaseUrl: client.wsBaseUrl,
-        sessionId: sessionId,
+        surfaceId: surfaceId,
         token: cfg.apiKey,
         since,
     }, {
@@ -167,8 +167,8 @@ export async function runWatch(args) {
             if (shouldPrintEvent(event.type, filterTypes)) {
                 printJsonLine(event);
             }
-            // A system.session.expired event means the session is closing.
-            if (event.type === "system.session.expired") {
+            // A system.surface.expired event means the surface is closing.
+            if (event.type === "system.surface.expired") {
                 sawSessionExpired = true;
                 emitClosed();
                 return;
@@ -184,8 +184,8 @@ export async function runWatch(args) {
         onClose: ({ code, reason }) => {
             // A clean close is 1000 (normal) or 1001 (going away). Any other code
             // — 1006 abnormal, 1008 policy/auth, 1011 server error — is a failure
-            // UNLESS we already saw system.session.expired, which means the relay
-            // closed us on purpose after a clean session end.
+            // UNLESS we already saw system.surface.expired, which means the relay
+            // closed us on purpose after a clean surface end.
             if (code === 1000 || code === 1001 || sawSessionExpired) {
                 emitClosed();
                 return;

package/dist/index.js

@@ -23,14 +23,14 @@ function failArgvError(e) {
     process.stderr.write(JSON.stringify({ error }) + "\n");
     process.exit(1);
 }
-import { runSession, sessionHelp } from "./commands/session.js";
-import { runArtifact, artifactHelp } from "./commands/artifact.js";
+import { runSession, sessionHelp } from "./commands/surface.js";
+import { runArtifact, artifactHelp } from "./commands/template.js";
 import { runAgent, agentHelp } from "./commands/agent.js";
 import { runKey, keyHelp } from "./commands/key.js";
 import { runTaste, tasteHelp } from "./commands/taste.js";
 import { runFeedback, feedbackHelp } from "./commands/feedback.js";
 import { runConfig, configHelp } from "./commands/config.js";
-import { runBlob, blobHelp } from "./commands/blob.js";
+import { runBlob, blobHelp } from "./commands/attachment.js";
 import { runSkill, skillHelp } from "./commands/skill.js";
 import { VERSION } from "./version.js";
 import { PaneApiError } from "@paneui/core";
@@ -41,23 +41,23 @@ Usage:
   pane <noun> <verb> [options]
 
 Nouns:
-  session           Open / observe / send to / close sessions
+  surface           Open / observe / send to / close surfaces
                     (create | list | show | send | watch | delete |
                      participant <list|new|revoke>).
-  artifact          Reusable, versioned UI templates
+  template          Reusable, versioned UI templates
                     (create | version | update | search | list | show | delete).
   key               YOUR agent's API key (list | revoke).
   taste             YOUR agent's freeform UI taste notes
                     (get | set | clear) — presentation preferences the agent
                     has learned from human feedback and reads before
-                    generating a pane artifact.
+                    generating a pane template.
   feedback          One-shot feedback to the relay operator
                     (create | list) — bug reports, feature requests, notes.
-  blob              Binary attachments (upload | download | show | list |
+  attachment              Binary attachments (upload | download | show | list |
                     delete | token <mint|revoke|list>). Blobs are scoped to
-                    an agent, a session, or an artifact, and can be referenced
+                    an agent, a surface, or an template, and can be referenced
                     from event payloads + input_data via
-                    \`format: pane-blob-id\`.
+                    \`format: pane-attachment-id\`.
   agent             Agent identity on this machine (register | logout).
   config            CLI config inspection (show).
   skill             The relay's SKILL.md (show | version) — auto-updating;
@@ -85,8 +85,8 @@ Output: stdout is machine-readable JSON; errors go to stderr as
 //
 // `version` is deliberately NOT here: the top-level `-v` / `--version` is
 // handled from rawArgv[0] before parseArgs runs, so it never needs to be a
-// boolean flag — and keeping it out lets `pane session create --version <n>` /
-// `pane artifact version` consume a value as a normal value-flag.
+// boolean flag — and keeping it out lets `pane surface create --version <n>` /
+// `pane template version` consume a value as a normal value-flag.
 const BOOLEAN_FLAGS = new Set([
     "json",
     "once",
@@ -122,12 +122,12 @@ async function main() {
         throw e;
     }
     const helps = {
-        session: sessionHelp,
-        artifact: artifactHelp,
+        surface: sessionHelp,
+        template: artifactHelp,
         key: keyHelp,
         taste: tasteHelp,
         feedback: feedbackHelp,
-        blob: blobHelp,
+        attachment: blobHelp,
         agent: agentHelp,
         config: configHelp,
         skill: skillHelp,
@@ -150,10 +150,10 @@ async function main() {
         return;
     }
     switch (noun) {
-        case "session":
+        case "surface":
             await runSession(args);
             break;
-        case "artifact":
+        case "template":
             await runArtifact(args);
             break;
         case "key":
@@ -165,7 +165,7 @@ async function main() {
         case "feedback":
             await runFeedback(args);
             break;
-        case "blob":
+        case "attachment":
             await runBlob(args);
             break;
         case "agent":

package/dist/input.js

@@ -1,5 +1,5 @@
 // Helpers for reading CLI inputs that may be either a file path or an inline
-// literal (JSON, or raw text for an HTML artifact body).
+// literal (JSON, or raw text for an HTML template body).
 import { readFileSync, statSync } from "node:fs";
 /**
  * True if `value` names an existing file. Only a missing path (ENOENT) is
@@ -35,7 +35,7 @@ export function resolveJson(value, label) {
 }
 /**
  * Resolve raw text that is either a file path or an inline literal — no JSON
- * parsing. Used for an inline HTML artifact body.
+ * parsing. Used for an inline HTML template body.
  */
 export function resolveText(value) {
     return isFilePath(value) ? readFileSync(value, "utf8") : value;

package/dist/output.js

@@ -8,7 +8,7 @@ export function printJson(value) {
     process.stdout.write(JSON.stringify(value, null, 2) + "\n");
 }
 /**
- * Print a single compact JSON line to stdout and flush. Used by `pane session watch`
+ * Print a single compact JSON line to stdout and flush. Used by `pane surface watch`
  * so a pipe-reader (e.g. Claude Code's Monitor tool) sees each event
  * immediately, one event per line.
  */

package/dist/version.js

@@ -8,4 +8,4 @@
 // Keep this in lockstep with packages/cli/package.json's `version` field;
 // they're consulted in different places (here for the runtime header,
 // package.json for npm publish + dependency resolution).
-export const VERSION = "0.0.6";
+export const VERSION = "0.0.8";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@paneui/cli",
-  "version": "0.0.6",
-  "description": "Command-line client for the Pane relay: create sessions, inspect state, send and watch events.",
+  "version": "0.0.8",
+  "description": "Command-line client for the Pane relay: create surfaces, inspect state, send and watch events.",
   "license": "MIT",
   "type": "module",
   "keywords": [
@@ -41,7 +41,7 @@
     "test:unit": "vitest run"
   },
   "dependencies": {
-    "@paneui/core": "^0.0.6"
+    "@paneui/core": "^0.0.8"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/dist/commands/blob-delete.js

@@ -1,37 +0,0 @@
-// `pane blob delete <blob-id>` — soft-delete a blob.
-import { assertKnownFlags } from "../argv.js";
-import { makeClient } from "../config.js";
-import { fail, failFromError, printJson } from "../output.js";
-const KNOWN_FLAGS = [];
-const KNOWN_BOOLS = [];
-export const blobDeleteHelp = `pane blob delete — soft-delete a blob
-
-Usage:
-  pane blob delete <blob-id> [options]
-
-Marks the blob as deleted (DELETE /v1/blobs/:id). Idempotent: deleting an
-already-deleted blob still returns success. Tokens minted against this blob
-become unusable.
-
-Options:
-  --url <url>            Relay base URL (overrides PANE_URL).
-  --api-key <key>        Agent API key (overrides PANE_API_KEY).
-  -h, --help             Show this help.
-
-Output (stdout, JSON):
-  { blob_id, deleted: true }`;
-export async function runBlobDelete(args) {
-    assertKnownFlags(args, KNOWN_FLAGS, KNOWN_BOOLS, "pane blob delete");
-    const blobId = args.positionals[0];
-    if (!blobId) {
-        fail("missing <blob-id> — 'pane blob delete <blob-id>'", "invalid_args");
-    }
-    const client = makeClient(args);
-    try {
-        const r = await client.deleteBlob(blobId);
-        printJson({ blob_id: blobId, ...r });
-    }
-    catch (e) {
-        failFromError(e);
-    }
-}