@telepath-computer/television 0.1.98 → 0.1.99

package/dist/cli.cjs

@@ -33973,11 +33973,20 @@ var ArtifactClient = class {
    */
   create(input) {
     const body = {
-      type: input.type,
+      kind: input.kind,
       title: input.title
     };
-    if (input.externalFilePath !== void 0) body.externalFilePath = input.externalFilePath;
-    if (input.externalURL !== void 0) body.externalURL = input.externalURL;
+    switch (input.kind) {
+      case "markdown":
+        body.externalFilePath = input.externalFilePath;
+        break;
+      case "url":
+        body.externalURL = input.externalURL;
+        break;
+      case "web-bundle":
+        if (input.skipPending !== void 0) body.skipPending = input.skipPending;
+        break;
+    }
     if (input.screenID !== void 0) body.screenID = input.screenID;
     return this.#http.requestJSON("POST", "/artifacts", body);
   }
@@ -34116,10 +34125,6 @@ var TelevisionClient = class {
   }
 };
 
-// ../shared/src/constants.ts
-var MS_PER_SECOND = 1e3;
-var SECONDS_PER_MINUTE = 60;
-
 // ../server/src/server.ts
 var import_express2 = __toESM(require_express2(), 1);
 var import_node_http = __toESM(require("node:http"), 1);
@@ -47946,16 +47951,17 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../server/src/artifact-paths.ts
+var import_node_path3 = __toESM(require("node:path"), 1);
+
 // ../artifact/src/model.ts
-var ARTIFACT_TYPES = ["text/markdown", "text/html"];
+var ARTIFACT_KINDS = ["markdown", "web-bundle", "url"];
 var ARTIFACT_STATUSES = ["committed", "pending"];
-var ARTIFACT_TYPE_TO_EXTENSION = {
-  "text/markdown": "md",
-  "text/html": "html"
+var ARTIFACT_KIND_TO_EXTENSION = {
+  markdown: "md",
+  "web-bundle": "html",
+  url: "html"
 };
-function isArtifactType(value) {
-  return ARTIFACT_TYPES.includes(value);
-}
 function isExternalArtifactURL(value) {
   let parsed;
   try {
@@ -47967,7 +47973,7 @@ function isExternalArtifactURL(value) {
 }
 var ArtifactSchema = external_exports.object({
   id: external_exports.string().min(1),
-  type: external_exports.enum(ARTIFACT_TYPES),
+  kind: external_exports.enum(ARTIFACT_KINDS),
   title: external_exports.string(),
   status: external_exports.enum(ARTIFACT_STATUSES),
   externalFilePath: external_exports.string().optional(),
@@ -47980,41 +47986,92 @@ var ArtifactSchema = external_exports.object({
       path: ["externalURL"]
     });
   }
-  if (value.externalURL !== void 0) {
-    if (!isExternalArtifactURL(value.externalURL)) {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        message: "externalURL must be an http(s) URL",
-        path: ["externalURL"]
-      });
-    }
-    if (value.status !== "committed") {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        message: "URL-backed artifacts must have status committed",
-        path: ["status"]
-      });
-    }
+  if (value.kind !== "web-bundle" && value.status !== "committed") {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "only web-bundle artifacts can be pending",
+      path: ["status"]
+    });
+  }
+  switch (value.kind) {
+    case "markdown":
+      if (value.externalFilePath === void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "markdown artifacts require externalFilePath",
+          path: ["externalFilePath"]
+        });
+      }
+      if (value.externalURL !== void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "markdown artifacts cannot set externalURL",
+          path: ["externalURL"]
+        });
+      }
+      break;
+    case "web-bundle":
+      if (value.externalFilePath !== void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "web-bundle artifacts cannot set externalFilePath",
+          path: ["externalFilePath"]
+        });
+      }
+      if (value.externalURL !== void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "web-bundle artifacts cannot set externalURL",
+          path: ["externalURL"]
+        });
+      }
+      break;
+    case "url":
+      if (value.externalURL === void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "url artifacts require externalURL",
+          path: ["externalURL"]
+        });
+        break;
+      }
+      if (value.externalFilePath !== void 0) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "url artifacts cannot set externalFilePath",
+          path: ["externalFilePath"]
+        });
+      }
+      if (!isExternalArtifactURL(value.externalURL)) {
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: "externalURL must be an http(s) URL",
+          path: ["externalURL"]
+        });
+      }
+      break;
   }
 });
 function createArtifact(input) {
-  return {
+  const artifact = ArtifactSchema.parse({
     id: input.id ?? ulid(),
-    type: input.type,
+    kind: input.kind,
     title: input.title,
     status: input.status ?? "committed",
     externalFilePath: input.externalFilePath,
     externalURL: input.externalURL
-  };
+  });
+  return Object.fromEntries(
+    Object.entries(artifact).filter(([, value]) => value !== void 0)
+  );
 }
 var ViewManifestSchema = external_exports.object({
   name: external_exports.string().min(1),
   description: external_exports.string(),
-  accepts: external_exports.array(external_exports.string().min(1)).min(1)
+  accepts: external_exports.array(external_exports.enum(ARTIFACT_KINDS)).min(1)
 });
 
 // ../server/src/artifact-paths.ts
-var import_node_path3 = __toESM(require("node:path"), 1);
 function getArtifactLiveMetadataPath(storagePath, artifactID) {
   return import_node_path3.default.join(storagePath, "artifacts", `${artifactID}.json`);
 }
@@ -48046,8 +48103,8 @@ function getArtifactBundlePath(storagePath, artifactID, state) {
 function getArtifactPublicDirPath(storagePath, artifactID, state) {
   return import_node_path3.default.join(getArtifactBundlePath(storagePath, artifactID, state), "public");
 }
-function getArtifactEntryFilePath(storagePath, artifactID, type, state) {
-  const extension2 = ARTIFACT_TYPE_TO_EXTENSION[type];
+function getArtifactEntryFilePath(storagePath, artifactID, kind, state) {
+  const extension2 = ARTIFACT_KIND_TO_EXTENSION[kind];
   return import_node_path3.default.join(getArtifactPublicDirPath(storagePath, artifactID, state), `index.${extension2}`);
 }
 
@@ -48148,22 +48205,31 @@ var createScreenSchema = external_exports.object({
   name: external_exports.string(),
   id: external_exports.string().optional()
 });
-var createArtifactBaseFields = {
-  type: external_exports.enum(ARTIFACT_TYPES),
+var createWebBundleArtifactSchema = external_exports.object({
+  kind: external_exports.literal("web-bundle"),
   title: external_exports.string(),
-  externalFilePath: external_exports.string().optional(),
-  externalURL: external_exports.string().optional()
-};
-var externalSourceMutexRefine = (value) => !(value.externalFilePath !== void 0 && value.externalURL !== void 0);
-var externalSourceMutexMessage = {
-  message: "externalFilePath and externalURL are mutually exclusive",
-  path: ["externalURL"]
-};
-var createArtifactSchema = external_exports.object(createArtifactBaseFields).strict().refine(externalSourceMutexRefine, externalSourceMutexMessage);
-var createArtifactBodySchema = external_exports.object({
-  ...createArtifactBaseFields,
-  screenID: external_exports.string().optional()
-}).strict().refine(externalSourceMutexRefine, externalSourceMutexMessage);
+  skipPending: external_exports.boolean().optional()
+}).strict();
+var createMarkdownArtifactSchema = external_exports.object({
+  kind: external_exports.literal("markdown"),
+  title: external_exports.string(),
+  externalFilePath: external_exports.string()
+}).strict();
+var createURLArtifactSchema = external_exports.object({
+  kind: external_exports.literal("url"),
+  title: external_exports.string(),
+  externalURL: external_exports.string()
+}).strict();
+var createArtifactSchema = external_exports.discriminatedUnion("kind", [
+  createWebBundleArtifactSchema,
+  createMarkdownArtifactSchema,
+  createURLArtifactSchema
+]);
+var createArtifactBodySchema = external_exports.discriminatedUnion("kind", [
+  createWebBundleArtifactSchema.extend({ screenID: external_exports.string().optional() }).strict(),
+  createMarkdownArtifactSchema.extend({ screenID: external_exports.string().optional() }).strict(),
+  createURLArtifactSchema.extend({ screenID: external_exports.string().optional() }).strict()
+]);
 var patchArtifactSchema = external_exports.object({
   title: external_exports.string().optional()
 }).refine((value) => value.title !== void 0, { message: "title is required" });
@@ -48314,16 +48380,12 @@ function registerRoutes(app, store, options) {
     }
     try {
       const artifact = store.createArtifact({
-        type: parsed.data.type,
-        title: parsed.data.title,
         screenID: req.params.id,
-        externalFilePath: parsed.data.externalFilePath,
-        externalURL: parsed.data.externalURL
+        ...parsed.data
       });
-      const externallyBacked = artifact.externalFilePath !== void 0 || artifact.externalURL !== void 0;
       res.status(HTTP_CREATED).json({
         artifact,
-        ...externallyBacked ? {} : { pendingPath: getArtifactPendingBundlePath(store.storagePath, artifact.id) }
+        ...artifact.status === "pending" ? { pendingPath: getArtifactPendingBundlePath(store.storagePath, artifact.id) } : {}
       });
     } catch (error48) {
       handleStoreError(res, error48, "Failed to create artifact");
@@ -48372,14 +48434,10 @@ function registerRoutes(app, store, options) {
       return;
     }
     try {
-      const artifact = store.createArtifact({
-        type: parsed.data.type,
-        title: parsed.data.title,
-        externalFilePath: parsed.data.externalFilePath,
-        externalURL: parsed.data.externalURL
-      });
+      const { screenID: _screenID, ...createInput } = parsed.data;
+      const artifact = store.createArtifact(createInput);
       const body = { artifact };
-      if (artifact.externalFilePath === void 0 && artifact.externalURL === void 0) {
+      if (artifact.status === "pending") {
         body.pendingPath = getArtifactPendingBundlePath(store.storagePath, artifact.id);
       }
       if (parsed.data.screenID !== void 0) {
@@ -48473,12 +48531,16 @@ function registerRoutes(app, store, options) {
         sendError(res, HTTP_NOT_FOUND, `Artifact not found: ${req.params.id}`);
         return;
       }
-      if (artifact.externalURL) {
-        res.redirect(HTTP_FOUND, artifact.externalURL);
+      if (artifact.kind === "url") {
+        const externalURL = artifact.externalURL;
+        if (!externalURL) {
+          throw new Error(`URL artifact ${artifact.id} is missing externalURL`);
+        }
+        res.redirect(HTTP_FOUND, externalURL);
         return;
       }
       const content = store.readArtifactContent(req.params.id);
-      res.setHeader("Content-Type", contentTypeForArtifactType(artifact.type));
+      res.setHeader("Content-Type", contentTypeForArtifactKind(artifact.kind));
       res.send(content);
     } catch (error48) {
       handleStoreError(res, error48, "Failed to read artifact content");
@@ -48519,7 +48581,7 @@ function registerRoutes(app, store, options) {
   });
   app.put("/artifacts/:id/content", ...auth, import_express.default.text({ type: "*/*", limit: "10mb" }), (req, res) => {
     const artifact = store.getArtifact(req.params.id);
-    if (artifact?.externalURL) {
+    if (artifact?.kind === "url") {
       sendError(res, HTTP_METHOD_NOT_ALLOWED, "URL-backed artifacts have no server-writable content");
       return;
     }
@@ -48603,13 +48665,8 @@ function registerRoutes(app, store, options) {
     }
   );
 }
-function contentTypeForArtifactType(type) {
-  switch (type) {
-    case "text/markdown":
-      return "text/markdown; charset=utf-8";
-    case "text/html":
-      return "text/html; charset=utf-8";
-  }
+function contentTypeForArtifactKind(kind) {
+  return kind === "markdown" ? "text/markdown; charset=utf-8" : "text/html; charset=utf-8";
 }
 
 // ../../node_modules/ws/wrapper.mjs
@@ -49255,19 +49312,6 @@ var defaultWatchContentFile = (filePath, onChange) => {
 var JSON_INDENT_SPACES = 2;
 var CONTENT_WATCH_DEBOUNCE_MS = 100;
 var JSON_FILE_SUFFIX = ".json";
-var ACTIVITY_LOG_HEADING = "## Activity Log";
-var ACTIVITY_LOG_MAX_AGE_MINUTES = 30;
-var ACTIVITY_LOG_MAX_AGE_MS = ACTIVITY_LOG_MAX_AGE_MINUTES * SECONDS_PER_MINUTE * MS_PER_SECOND;
-var REQUIRED_ARTIFACT_HEADINGS = [
-  "## User intent",
-  "## Purpose",
-  "## Data shape",
-  "## Data sources",
-  "## Rendering",
-  "## Update workflow",
-  "## Non-goals"
-];
-var TIMESTAMP_PATTERN = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\b/g;
 var ServerStore = class extends EventTarget {
   storagePath;
   authToken;
@@ -49353,21 +49397,19 @@ var ServerStore = class extends EventTarget {
     if (!artifact) {
       return void 0;
     }
-    if (artifact.externalURL) {
-      return void 0;
-    }
-    if (artifact.externalFilePath) {
-      return artifact.externalFilePath;
-    }
-    const publicDir = this.getArtifactPublicDir(id);
-    if (!publicDir) {
-      return void 0;
+    switch (artifact.kind) {
+      case "url":
+        return void 0;
+      case "markdown":
+        return artifact.externalFilePath;
+      case "web-bundle":
+        return getArtifactEntryFilePath(this.storagePath, id, artifact.kind, "committed");
     }
-    return getArtifactEntryFilePath(this.storagePath, id, artifact.type, "committed");
+    return assertNever2(artifact.kind, "artifact kind");
   }
   getArtifactPublicDir(id) {
     const artifact = this._artifacts.get(id);
-    if (!artifact || artifact.externalFilePath || artifact.externalURL) {
+    if (!artifact || artifact.kind !== "web-bundle") {
       return void 0;
     }
     return getArtifactPublicDirPath(this.storagePath, id, "committed");
@@ -49399,7 +49441,7 @@ var ServerStore = class extends EventTarget {
    */
   writeArtifactContent(id, content) {
     const artifact = this._artifacts.get(id);
-    if (artifact?.externalURL) {
+    if (artifact?.kind === "url") {
       throw new InvalidRequestError(
         `Artifact ${id} is URL-backed; its content is not server-writable`
       );
@@ -49408,7 +49450,7 @@ var ServerStore = class extends EventTarget {
     if (!contentPath) {
       throw new NotFoundError(`Artifact not found: ${id}`, { entityType: "artifact", entityID: id });
     }
-    if (artifact && !artifact.externalFilePath && artifact.status === "pending" && !this.hasCommittedBundle(id)) {
+    if (artifact?.kind === "web-bundle" && artifact.status === "pending" && !this.hasCommittedBundle(id)) {
       throw new InvalidRequestError(
         `Artifact ${id} has no committed content yet. Use commit or abandon after writing the pending bundle`
       );
@@ -49438,20 +49480,10 @@ var ServerStore = class extends EventTarget {
       );
     }
     const screen = input.screenID !== void 0 ? this.requireScreen(input.screenID) : null;
-    const externallyBacked = input.externalFilePath !== void 0 || input.externalURL !== void 0;
-    const artifact = createArtifact({
-      type: input.type,
-      title: input.title,
-      status: externallyBacked ? "committed" : "pending",
-      externalFilePath: input.externalFilePath ? this.normalizeExternalArtifactPath(input.externalFilePath, input.type) : void 0,
-      externalURL: input.externalURL ? this.normalizeExternalArtifactURL(input.externalURL) : void 0
-    });
-    if (!externallyBacked) {
-      this.scaffoldPendingBundle(artifact.id, artifact.type);
-    }
+    const artifact = this.createKindArtifact(input);
     this.writeArtifact(artifact);
     this._artifacts.set(artifact.id, artifact);
-    if (artifact.status === "committed" && artifact.externalURL === void 0) {
+    if (artifact.status === "committed" && artifact.kind !== "url") {
       this.startWatchingArtifactContent(artifact.id);
     }
     this.dispatchEvent(new ArtifactCreatedEvent("artifact-created", { artifact }));
@@ -49486,15 +49518,17 @@ var ServerStore = class extends EventTarget {
     if (!artifact) {
       throw new NotFoundError(`Artifact not found: ${artifactID}`, { entityType: "artifact", entityID: artifactID });
     }
-    if (artifact.externalFilePath || artifact.externalURL) {
-      throw new InvalidRequestError(`Only internal artifacts can enter pending edit: ${artifactID}`);
+    if (artifact.kind !== "web-bundle") {
+      throw new InvalidRequestError(`Only web-bundle artifacts can enter pending edit: ${artifactID}`);
     }
     if (artifact.status === "pending") {
       throw new InvalidRequestError(`Artifact ${artifactID} already has pending work. Use commit or abandon before editing again`);
     }
+    const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
+    (0, import_node_fs5.rmSync)(pendingPath, { recursive: true, force: true });
     (0, import_node_fs5.cpSync)(
       getArtifactCommittedBundlePath(this.storagePath, artifactID),
-      getArtifactPendingBundlePath(this.storagePath, artifactID),
+      pendingPath,
       { recursive: true }
     );
     artifact.status = "pending";
@@ -49507,21 +49541,17 @@ var ServerStore = class extends EventTarget {
     if (!artifact) {
       throw new NotFoundError(`Artifact not found: ${artifactID}`, { entityType: "artifact", entityID: artifactID });
     }
-    const issues = this.validatePendingArtifact(artifact);
-    if (issues.length > 0) {
-      throw new InvalidRequestError(
-        [
-          `Commit failed for artifact ${artifactID}:`,
-          ...issues.map((issue2) => `- ${issue2}`)
-        ].join("\n")
-      );
+    if (artifact.kind !== "web-bundle") {
+      throw new InvalidRequestError(`Only web-bundle artifacts can commit pending work: ${artifactID}`);
+    }
+    if (artifact.status !== "pending") {
+      throw new InvalidRequestError(`Artifact ${artifactID} has no pending work to commit`);
     }
     const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
     const committedPath = getArtifactCommittedBundlePath(this.storagePath, artifactID);
     this.stopWatchingArtifactContent(artifactID);
     (0, import_node_fs5.rmSync)(committedPath, { recursive: true, force: true });
-    (0, import_node_fs5.cpSync)(pendingPath, committedPath, { recursive: true });
-    (0, import_node_fs5.rmSync)(pendingPath, { recursive: true, force: true });
+    (0, import_node_fs5.renameSync)(pendingPath, committedPath);
     artifact.status = "committed";
     this.writeArtifact(artifact);
     this._artifacts.set(artifactID, artifact);
@@ -49535,8 +49565,8 @@ var ServerStore = class extends EventTarget {
     if (!artifact) {
       throw new NotFoundError(`Artifact not found: ${artifactID}`, { entityType: "artifact", entityID: artifactID });
     }
-    if (artifact.externalFilePath || artifact.externalURL) {
-      throw new InvalidRequestError(`Only internal artifacts can abandon pending work: ${artifactID}`);
+    if (artifact.kind !== "web-bundle") {
+      throw new InvalidRequestError(`Only web-bundle artifacts can abandon pending work: ${artifactID}`);
     }
     if (artifact.status !== "pending") {
       throw new InvalidRequestError(`Artifact ${artifactID} has no pending work to abandon`);
@@ -49854,11 +49884,17 @@ var ServerStore = class extends EventTarget {
   }
   startContentWatchersForLoadedArtifacts() {
     for (const [artifactID, artifact] of this._artifacts.entries()) {
-      if (artifact.externalURL) {
-        continue;
-      }
-      if (artifact.status === "committed" || !artifact.externalFilePath && this.hasCommittedBundle(artifactID)) {
-        this.startWatchingArtifactContent(artifactID);
+      switch (artifact.kind) {
+        case "url":
+          continue;
+        case "markdown":
+          this.startWatchingArtifactContent(artifactID);
+          continue;
+        case "web-bundle":
+          if (artifact.status === "committed" || this.hasCommittedBundle(artifactID)) {
+            this.startWatchingArtifactContent(artifactID);
+          }
+          continue;
       }
     }
   }
@@ -49990,6 +50026,65 @@ var ServerStore = class extends EventTarget {
   hasCommittedBundle(artifactID) {
     return (0, import_node_fs5.existsSync)(getArtifactCommittedBundlePath(this.storagePath, artifactID));
   }
+  createKindArtifact(input) {
+    const kind = input.kind;
+    switch (kind) {
+      case "markdown": {
+        if (input.externalFilePath === void 0) {
+          throw new InvalidRequestError("markdown artifacts require externalFilePath");
+        }
+        if (input.externalURL !== void 0) {
+          throw new InvalidRequestError("markdown artifacts cannot set externalURL");
+        }
+        if (input.skipPending !== void 0) {
+          throw new InvalidRequestError("skipPending is only valid for web-bundle artifacts");
+        }
+        return createArtifact({
+          kind,
+          title: input.title,
+          status: "committed",
+          externalFilePath: this.normalizeExternalArtifactPath(input.externalFilePath, kind)
+        });
+      }
+      case "url": {
+        if (input.externalURL === void 0) {
+          throw new InvalidRequestError("url artifacts require externalURL");
+        }
+        if (input.externalFilePath !== void 0) {
+          throw new InvalidRequestError("url artifacts cannot set externalFilePath");
+        }
+        if (input.skipPending !== void 0) {
+          throw new InvalidRequestError("skipPending is only valid for web-bundle artifacts");
+        }
+        return createArtifact({
+          kind,
+          title: input.title,
+          status: "committed",
+          externalURL: this.normalizeExternalArtifactURL(input.externalURL)
+        });
+      }
+      case "web-bundle": {
+        if (input.externalFilePath !== void 0) {
+          throw new InvalidRequestError("web-bundle artifacts cannot set externalFilePath");
+        }
+        if (input.externalURL !== void 0) {
+          throw new InvalidRequestError("web-bundle artifacts cannot set externalURL");
+        }
+        const artifact = createArtifact({
+          kind,
+          title: input.title,
+          status: input.skipPending ? "committed" : "pending"
+        });
+        if (artifact.status === "pending") {
+          this.scaffoldPendingBundle(artifact.id);
+        } else {
+          this.scaffoldCommittedBundle(artifact.id);
+        }
+        return artifact;
+      }
+    }
+    return assertNever2(kind, "artifact kind");
+  }
   createDefaultScreen() {
     this.createScreen({ name: "Default" });
   }
@@ -50017,17 +50112,18 @@ var ServerStore = class extends EventTarget {
       throw new NotFoundError(`Artifact not found: ${artifactID}`, { entityType: "artifact", entityID: artifactID });
     }
     const affectedScreenIDs = this.collectReferencingScreenIDs(artifactID);
-    if (!artifact.externalFilePath && !artifact.externalURL) {
+    if (artifact.kind === "web-bundle") {
       (0, import_node_fs5.rmSync)(getArtifactPendingBundlePath(this.storagePath, artifactID), { recursive: true, force: true });
     }
     this.stopWatchingArtifactContent(artifactID);
-    if (!artifact.externalFilePath && !artifact.externalURL && artifact.status === "pending" && !this.hasCommittedBundle(artifactID)) {
+    if (artifact.kind === "web-bundle" && artifact.status === "pending" && !this.hasCommittedBundle(artifactID)) {
       this._artifacts.delete(artifactID);
       (0, import_node_fs5.rmSync)(getArtifactLiveMetadataPath(this.storagePath, artifactID), { force: true });
       this.stripArtifactFromScreens(artifactID, affectedScreenIDs);
       this.emitArtifactRemovedEvents(artifactID, affectedScreenIDs);
       return {
         outcome: "discarded",
+        kind: "web-bundle",
         artifactID
       };
     }
@@ -50063,34 +50159,49 @@ var ServerStore = class extends EventTarget {
     const metadataPath = getArtifactTrashMetadataPath(this.storagePath, artifact.id);
     (0, import_node_fs5.mkdirSync)(import_node_path9.default.dirname(metadataPath), { recursive: true });
     (0, import_node_fs5.writeFileSync)(metadataPath, JSON.stringify(artifact, null, JSON_INDENT_SPACES));
-    if (artifact.externalURL) {
-      return {
-        outcome: "trashed",
-        artifactID: artifact.id,
-        metadataPath,
-        externalURL: artifact.externalURL
-      };
-    }
-    if (artifact.externalFilePath) {
-      return {
-        outcome: "trashed",
-        artifactID: artifact.id,
-        metadataPath,
-        externalFilePath: artifact.externalFilePath
-      };
-    }
-    const committedBundlePath = getArtifactCommittedBundlePath(this.storagePath, artifact.id);
-    const bundlePath = getArtifactTrashBundlePath(this.storagePath, artifact.id);
-    (0, import_node_fs5.rmSync)(bundlePath, { recursive: true, force: true });
-    if ((0, import_node_fs5.existsSync)(committedBundlePath)) {
-      (0, import_node_fs5.renameSync)(committedBundlePath, bundlePath);
+    switch (artifact.kind) {
+      case "url": {
+        const externalURL = artifact.externalURL;
+        if (!externalURL) {
+          throw new Error(`URL artifact ${artifact.id} is missing externalURL`);
+        }
+        return {
+          outcome: "trashed",
+          kind: "url",
+          artifactID: artifact.id,
+          metadataPath,
+          externalURL
+        };
+      }
+      case "markdown": {
+        const externalFilePath = artifact.externalFilePath;
+        if (!externalFilePath) {
+          throw new Error(`Markdown artifact ${artifact.id} is missing externalFilePath`);
+        }
+        return {
+          outcome: "trashed",
+          kind: "markdown",
+          artifactID: artifact.id,
+          metadataPath,
+          externalFilePath
+        };
+      }
+      case "web-bundle": {
+        const committedBundlePath = getArtifactCommittedBundlePath(this.storagePath, artifact.id);
+        const bundlePath = getArtifactTrashBundlePath(this.storagePath, artifact.id);
+        (0, import_node_fs5.rmSync)(bundlePath, { recursive: true, force: true });
+        if ((0, import_node_fs5.existsSync)(committedBundlePath)) {
+          (0, import_node_fs5.renameSync)(committedBundlePath, bundlePath);
+        }
+        return {
+          outcome: "trashed",
+          kind: "web-bundle",
+          artifactID: artifact.id,
+          metadataPath,
+          bundlePath
+        };
+      }
     }
-    return {
-      outcome: "trashed",
-      artifactID: artifact.id,
-      metadataPath,
-      bundlePath
-    };
   }
   trashScreen(screen) {
     const metadataPath = getTrashedScreenMetadataPath(this.storagePath, screen.id);
@@ -50258,82 +50369,14 @@ Review docs/storage.md for the current schema, and either update the file to mat
   writeArtifact(artifact) {
     (0, import_node_fs5.writeFileSync)(getArtifactLiveMetadataPath(this.storagePath, artifact.id), JSON.stringify(artifact, null, JSON_INDENT_SPACES));
   }
-  scaffoldPendingBundle(artifactID, type) {
-    const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
+  scaffoldPendingBundle(artifactID) {
     const publicDir = getArtifactPublicDirPath(this.storagePath, artifactID, "pending");
     (0, import_node_fs5.mkdirSync)(publicDir, { recursive: true });
-    (0, import_node_fs5.writeFileSync)(import_node_path9.default.join(pendingPath, "artifact.md"), "");
-    (0, import_node_fs5.writeFileSync)(import_node_path9.default.join(pendingPath, "memory.md"), "");
-    (0, import_node_fs5.writeFileSync)(import_node_path9.default.join(pendingPath, "data.json"), "{}");
-    (0, import_node_fs5.writeFileSync)(getArtifactEntryFilePath(this.storagePath, artifactID, type, "pending"), "");
   }
-  validatePendingArtifact(artifact) {
-    const issues = [];
-    const artifactID = artifact.id;
-    if (artifact.externalFilePath) {
-      issues.push(`artifacts/${artifactID}.json is external; only internal artifacts can have pending content to commit`);
-    }
-    if (artifact.status !== "pending") {
-      issues.push(`artifacts/${artifactID}.json must have status "pending" to commit pending content`);
-    }
-    const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
-    this.validateArtifactDoc(import_node_path9.default.join(pendingPath, "artifact.md"), issues);
-    this.validateDataJson(import_node_path9.default.join(pendingPath, "data.json"), issues);
-    this.validateMemory(import_node_path9.default.join(pendingPath, "memory.md"), issues);
-    this.validateEntryFile(getArtifactEntryFilePath(this.storagePath, artifactID, artifact.type, "pending"), issues);
-    return issues;
-  }
-  validateArtifactDoc(filePath, issues) {
-    const text = this.readTextFileForValidation(filePath, issues);
-    if (text === null) return;
-    if (text.length === 0) {
-      issues.push(`${filePath} must be non-empty`);
-    }
-    for (const heading of REQUIRED_ARTIFACT_HEADINGS) {
-      if (!text.includes(heading)) {
-        issues.push(`${filePath} must contain heading ${heading}`);
-      }
-    }
-  }
-  validateDataJson(filePath, issues) {
-    const text = this.readTextFileForValidation(filePath, issues);
-    if (text === null) return;
-    try {
-      JSON.parse(text);
-    } catch (error48) {
-      issues.push(`${filePath} must contain valid JSON (${error48 instanceof Error ? error48.message : "parse failed"})`);
-    }
-  }
-  validateMemory(filePath, issues) {
-    const text = this.readTextFileForValidation(filePath, issues);
-    if (text === null) return;
-    if (!text.includes(ACTIVITY_LOG_HEADING)) {
-      issues.push(`${filePath} must contain ${ACTIVITY_LOG_HEADING}`);
-    }
-    const now = Date.now();
-    const timestamps = text.match(TIMESTAMP_PATTERN) ?? [];
-    const hasFreshTimestamp = timestamps.some((timestamp) => {
-      const parsed = Date.parse(timestamp);
-      return Number.isFinite(parsed) && parsed <= now && now - parsed <= ACTIVITY_LOG_MAX_AGE_MS;
-    });
-    if (!hasFreshTimestamp) {
-      issues.push(`${filePath} must contain a UTC activity timestamp from the last 30 minutes`);
-    }
-  }
-  validateEntryFile(filePath, issues) {
-    const text = this.readTextFileForValidation(filePath, issues);
-    if (text === null) return;
-    if (text.length === 0) {
-      issues.push(`${filePath} must be non-empty`);
-    }
-  }
-  readTextFileForValidation(filePath, issues) {
-    try {
-      return (0, import_node_fs5.readFileSync)(filePath, "utf8");
-    } catch {
-      issues.push(`${filePath} must exist`);
-      return null;
-    }
+  scaffoldCommittedBundle(artifactID) {
+    const publicDir = getArtifactPublicDirPath(this.storagePath, artifactID, "committed");
+    (0, import_node_fs5.mkdirSync)(publicDir, { recursive: true });
+    (0, import_node_fs5.writeFileSync)(getArtifactEntryFilePath(this.storagePath, artifactID, "web-bundle", "committed"), "");
   }
   get screensDir() {
     return import_node_path9.default.join(this.storagePath, "screens");
@@ -50346,7 +50389,7 @@ Review docs/storage.md for the current schema, and either update the file to mat
     }
     return rawURL;
   }
-  normalizeExternalArtifactPath(sourcePath, type) {
+  normalizeExternalArtifactPath(sourcePath, kind) {
     if (!import_node_path9.default.isAbsolute(sourcePath)) {
       throw new InvalidRequestError("externalFilePath must be absolute");
     }
@@ -50358,9 +50401,9 @@ Review docs/storage.md for the current schema, and either update the file to mat
     } catch {
       throw new InvalidRequestError(`externalFilePath does not exist or is not readable: ${sourcePath}`);
     }
-    const expectedExtension = type === "text/html" ? ".html" : ".md";
+    const expectedExtension = `.${ARTIFACT_KIND_TO_EXTENSION[kind]}`;
     if (import_node_path9.default.extname(sourcePath).toLowerCase() !== expectedExtension) {
-      throw new InvalidRequestError(`externalFilePath extension does not match artifact type ${type}: ${sourcePath}`);
+      throw new InvalidRequestError(`externalFilePath extension does not match artifact kind ${kind}: ${sourcePath}`);
     }
     return sourcePath;
   }
@@ -50371,6 +50414,9 @@ Review docs/storage.md for the current schema, and either update the file to mat
     return import_node_path9.default.join(this.storagePath, "token");
   }
 };
+function assertNever2(value, context) {
+  throw new Error(`Unexpected ${context}: ${JSON.stringify(value)}`);
+}
 function findCardIDForArtifact(layout, artifactID) {
   for (const node of layout) {
     const id = findCardIDInNode(node, artifactID);
@@ -50400,7 +50446,7 @@ function findCardIDInNode(node, artifactID) {
 var import_meta = {};
 var DAEMON_NAME = "com.television.server";
 var MAX_PORT = 65535;
-var HELP_POINTER = "Television guidance is split across bundled skills. For screens, lifecycle work, and the `tv` CLI, read the `television` skill. For artifact authoring, use `tv skills install` or `tv skills show`, then let the matching `artifact-*` skill guide the output.";
+var HELP_POINTER = "Television ships bundled skills. The main skill is `television` \u2014 read it for screens, lifecycle, the `tv` CLI, and artifact workflow. Additional `television-*` skills cover specialized artifact types and theming. Install all bundled skills with `tv skills install <path>` (e.g. ~/.openclaw/skills) or `tv skills install -i`.";
 var CLIDirectiveError = class extends Error {
   name = "CLIDirectiveError";
 };
@@ -50430,8 +50476,8 @@ function resolveVercelSkillsInstallerBin() {
   return localRequire.resolve("skills/bin/cli.mjs");
 }
 function readCLIVersion() {
-  if ("0.1.98".length > 0) {
-    return "0.1.98";
+  if ("0.1.99".length > 0) {
+    return "0.1.99";
   }
   const devPackageJsonPath = import_node_path10.default.join(getDevPackageDir(), "package.json");
   if (!(0, import_node_fs6.existsSync)(devPackageJsonPath)) {
@@ -50441,81 +50487,30 @@ function readCLIVersion() {
 }
 var FRONTMATTER_DELIMITER = "---\n";
 var FRONTMATTER_DELIMITER_LENGTH = FRONTMATTER_DELIMITER.length;
-function splitFrontmatter(text) {
-  if (!text.startsWith(FRONTMATTER_DELIMITER)) {
-    return { frontmatter: {}, body: text };
-  }
-  const closing = text.indexOf("\n---", FRONTMATTER_DELIMITER_LENGTH);
-  if (closing === -1) {
-    return { frontmatter: {}, body: text };
-  }
-  const block = text.slice(FRONTMATTER_DELIMITER_LENGTH, closing);
-  const after = text.slice(closing + FRONTMATTER_DELIMITER_LENGTH);
-  const body = after.startsWith("\n") ? after.slice(1) : after;
-  const frontmatter = {};
-  for (const rawLine of block.split("\n")) {
-    const line = rawLine.trim();
-    if (line === "" || line.startsWith("#")) continue;
-    const colon = line.indexOf(":");
-    if (colon === -1) continue;
-    const key = line.slice(0, colon).trim();
-    let value = line.slice(colon + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    frontmatter[key] = value;
-  }
-  return { frontmatter, body };
-}
-function readBundledSkill(skillRoot) {
-  const skillMarkdownPath = import_node_path10.default.join(skillRoot, "SKILL.md");
-  if (!(0, import_node_fs6.existsSync)(skillMarkdownPath)) {
-    throw new Error(`Bundled skill is missing SKILL.md at ${skillMarkdownPath}.`);
-  }
-  const markdown = (0, import_node_fs6.readFileSync)(skillMarkdownPath, "utf8");
-  const { frontmatter } = splitFrontmatter(markdown);
-  const name = frontmatter.name?.trim();
-  const description = frontmatter.description?.trim();
-  if (!name || !description) {
-    throw new Error(`Bundled skill has invalid frontmatter at ${skillMarkdownPath}.`);
-  }
-  return { name, description, markdown, root: skillRoot };
-}
-function listBundledSkills(collectionRoot) {
-  return (0, import_node_fs6.readdirSync)(collectionRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readBundledSkill(import_node_path10.default.join(collectionRoot, entry.name))).sort((a, b) => a.name.localeCompare(b.name));
-}
-function resolveBundledSkill(collectionRoot, skillName) {
-  const skillRoot = import_node_path10.default.join(collectionRoot, skillName);
-  if (!(0, import_node_fs6.existsSync)(skillRoot)) {
-    throw createDirectiveError(`tv skills show could not find bundled skill \`${skillName}\`.`);
-  }
-  return readBundledSkill(skillRoot);
-}
 function buildAgentHelpNote() {
   return [
     "",
     "Agent workflow note:",
-    "  Television guidance is split across bundled skills.",
-    "  For screens, lifecycle work, and the `tv` CLI, read `television`.",
-    "  For artifact authoring, install or inspect the bundled skills with `tv skills install` or `tv skills show`.",
-    "  Then use the matching `artifact-*` skill, such as `artifact-calendar` or `artifact-table`."
+    "  The main skill is `television` \u2014 read it for screens, lifecycle, the `tv` CLI, and artifact workflow.",
+    "  Additional `television-*` skills cover specialized artifact types and theming.",
+    "  Install all bundled skills: `tv skills install <path>` (e.g. ~/.openclaw/skills) or `tv skills install -i`."
   ].join("\n");
 }
 function buildArtifactWorkflowHelpNote(includeHTMLNote) {
   const lines = [
     "",
     "Agent note:",
-    "  For Television lifecycle work, read `television`."
+    "  The main skill is `television` \u2014 read it for screens, lifecycle, and artifact workflow."
   ];
   if (includeHTMLNote) {
-    lines.push("  For artifact authoring, install or inspect the bundled skills with `tv skills install` or `tv skills show`.");
-    lines.push("  Then use the matching `artifact-*` skill, such as `artifact-calendar` or `artifact-table`.");
+    lines.push("  Additional `television-*` skills cover specialized artifact types and theming.");
+    lines.push("  Install all bundled skills: `tv skills install <path>` (e.g. ~/.openclaw/skills) or `tv skills install -i`.");
   }
   return lines.join("\n");
 }
 function commandNameFromArgv(argv) {
-  const commandName = argv.find((value) => !value.startsWith("-"));
-  return commandName ?? "tv";
+  const parts = argv.filter((value) => !value.startsWith("-"));
+  return parts.length > 0 ? parts.join(" ") : "tv";
 }
 function formatCLIError(error48) {
   if (error48 instanceof CLIDirectiveError) {
@@ -50576,6 +50571,22 @@ function resolveBundledSkillsRoot() {
   const devPath = import_node_path10.default.resolve(getDevPackageDir(), "../skills/dist");
   return (0, import_node_fs6.existsSync)(devPath) ? devPath : void 0;
 }
+function copyBundledSkillsToDestination(bundledSkillsRoot, destinationRoot) {
+  if ((0, import_node_fs6.existsSync)(destinationRoot) && !(0, import_node_fs6.statSync)(destinationRoot).isDirectory()) {
+    throw new Error(`Skills destination is not a directory: ${destinationRoot}`);
+  }
+  (0, import_node_fs6.mkdirSync)(destinationRoot, { recursive: true });
+  const copied = [];
+  const entries = (0, import_node_fs6.readdirSync)(bundledSkillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const sourcePath = import_node_path10.default.join(bundledSkillsRoot, entry.name);
+    const destinationPath = import_node_path10.default.join(destinationRoot, entry.name);
+    (0, import_node_fs6.rmSync)(destinationPath, { recursive: true, force: true });
+    (0, import_node_fs6.cpSync)(sourcePath, destinationPath, { recursive: true });
+    copied.push({ name: entry.name, sourcePath, destinationPath });
+  }
+  return copied;
+}
 function isInTempDirectory(inputPath) {
   try {
     const realTmp = (0, import_node_fs6.realpathSync)(import_node_os4.default.tmpdir());
@@ -50586,14 +50597,14 @@ function isInTempDirectory(inputPath) {
     return false;
   }
 }
-function validateExternalArtifactPath(inputPath) {
+function validateExternalArtifactPath(commandName, inputPath) {
   if (!import_node_path10.default.isAbsolute(inputPath)) {
-    throw createDirectiveError("tv create-external-artifact requires --path to be an absolute path.");
+    throw createDirectiveError(`tv ${commandName} requires --path to be an absolute path.`);
   }
   try {
     (0, import_node_fs6.accessSync)(inputPath, import_node_fs6.constants.R_OK);
   } catch {
-    throw createDirectiveError(`tv create-external-artifact could not read --path ${inputPath}.`);
+    throw createDirectiveError(`tv ${commandName} could not read --path ${inputPath}.`);
   }
   return inputPath;
 }
@@ -50608,58 +50619,73 @@ function resolveFocusDirective(argv, commandName, focusFlag) {
   return shouldFocus;
 }
 function formatArtifactRemovalResult(result) {
-  if (result.outcome === "unlinked") {
-    return [`  ${result.artifactID}: unlinked (still referenced elsewhere)`];
-  }
-  if (result.outcome === "discarded") {
-    return [`  ${result.artifactID}: discarded (pending-create, no committed content)`];
-  }
-  if ("bundlePath" in result) {
-    return [
-      `  ${result.artifactID}: trashed`,
-      `    metadata: ${result.metadataPath}`,
-      `    bundle:   ${result.bundlePath}`
-    ];
-  }
-  if ("externalURL" in result) {
-    return [
-      `  ${result.artifactID}: trashed`,
-      `    metadata: ${result.metadataPath}`,
-      `    external URL ${result.externalURL} not touched.`
-    ];
+  switch (result.outcome) {
+    case "unlinked":
+      return [`  ${result.artifactID}: unlinked (still referenced elsewhere)`];
+    case "discarded":
+      return [`  ${result.artifactID}: discarded (pending-create web-bundle, no committed content)`];
+    case "trashed": {
+      const kind = result.kind;
+      switch (kind) {
+        case "web-bundle":
+          return [
+            `  ${result.artifactID}: trashed`,
+            `    metadata: ${result.metadataPath}`,
+            `    bundle:   ${result.bundlePath}`
+          ];
+        case "url":
+          return [
+            `  ${result.artifactID}: trashed`,
+            `    metadata: ${result.metadataPath}`,
+            `    external URL ${result.externalURL} not touched.`
+          ];
+        case "markdown":
+          return [
+            `  ${result.artifactID}: trashed`,
+            `    metadata: ${result.metadataPath}`,
+            `    external file ${result.externalFilePath} not touched.`
+          ];
+        default:
+          return assertNever3(kind, "artifact removal result kind");
+      }
+    }
   }
-  return [
-    `  ${result.artifactID}: trashed`,
-    `    metadata: ${result.metadataPath}`,
-    `    external file ${result.externalFilePath} not touched.`
-  ];
+  return assertNever3(result, "artifact removal result");
 }
 function formatDeleteArtifactResult(result) {
-  if (result.outcome === "discarded") {
-    return [
-      `Pending-create artifact ${result.artifactID} discarded.`,
-      "No trash paths were written because no committed artifact existed yet."
-    ];
-  }
-  if ("bundlePath" in result) {
-    return [
-      `Internal artifact ${result.artifactID} moved to trash:`,
-      `  metadata: ${result.metadataPath}`,
-      `  bundle:   ${result.bundlePath}`
-    ];
-  }
-  if ("externalURL" in result) {
-    return [
-      `URL artifact ${result.artifactID} moved to trash:`,
-      `  metadata: ${result.metadataPath}`,
-      `  external URL ${result.externalURL} not touched.`
-    ];
+  switch (result.outcome) {
+    case "discarded":
+      return [
+        `Pending-create web-bundle artifact ${result.artifactID} discarded.`,
+        "No trash paths were written because no committed artifact existed yet."
+      ];
+    case "trashed": {
+      const kind = result.kind;
+      switch (kind) {
+        case "web-bundle":
+          return [
+            `Web-bundle artifact ${result.artifactID} moved to trash:`,
+            `  metadata: ${result.metadataPath}`,
+            `  bundle:   ${result.bundlePath}`
+          ];
+        case "url":
+          return [
+            `URL artifact ${result.artifactID} moved to trash:`,
+            `  metadata: ${result.metadataPath}`,
+            `  external URL ${result.externalURL} not touched.`
+          ];
+        case "markdown":
+          return [
+            `Markdown artifact ${result.artifactID} moved to trash:`,
+            `  metadata: ${result.metadataPath}`,
+            `  external file ${result.externalFilePath} not touched.`
+          ];
+        default:
+          return assertNever3(kind, "delete artifact result kind");
+      }
+    }
   }
-  return [
-    `External artifact ${result.artifactID} moved to trash:`,
-    `  metadata: ${result.metadataPath}`,
-    `  external file ${result.externalFilePath} not touched.`
-  ];
+  return assertNever3(result, "delete artifact result");
 }
 function formatScreenRemovalResult(result) {
   const header = [
@@ -50676,6 +50702,9 @@ function formatScreenRemovalResult(result) {
   }
   return header;
 }
+function assertNever3(value, context) {
+  throw new Error(`Unexpected ${context}: ${JSON.stringify(value)}`);
+}
 function formatCommanderError(argv, error48) {
   const commandName = commandNameFromArgv(argv);
   const optionMatch = /option '([^']+)'/.exec(error48.message);
@@ -50728,7 +50757,8 @@ function createEnvironment(environment) {
       port: options.port,
       staticDir: options.staticDir,
       canonicalDir: options.canonicalDir,
-      public: options.public
+      public: options.public,
+      acpProfile: resolveACPAgentProfile(process.env)
     })),
     createDaemon: environment.createDaemon ?? ((options = {}) => {
       const args = [process.argv[1], "serve"];
@@ -50819,93 +50849,86 @@ function createProgram(env, argv = []) {
       });
     });
   });
-  program2.command("create-internal-artifact").description(
-    "Stage a pending internal artifact bundle that Television owns and renders. Internal artifacts use a staged lifecycle: this command creates the pending bundle on disk, you edit its files (artifact.md, data.json, memory.md, public/index.{md,html}), and you finish with `tv commit-pending-artifact` or discard with `tv abandon-pending-artifact`. The artifact has immediate membership on --screen so the user can see in-progress state. Pick --focus-artifact when the user should be taken to it now, or --no-focus to work in the background."
-  ).requiredOption("--screen <id>", "Target screen ID").requiredOption("--type <type>", `Artifact type (${ARTIFACT_TYPES.join(" or ")})`).requiredOption("--title <title>", "Artifact title").option("--focus-artifact", "Focus the new artifact after creation").option("--no-focus", "Create the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
-    const shouldFocus = resolveFocusDirective(argv, "create-internal-artifact", "--focus-artifact");
-    if (!isArtifactType(opts.type)) {
-      throw createDirectiveError(
-        `tv create-internal-artifact requires --type to be one of: ${ARTIFACT_TYPES.join(", ")}.`
-      );
-    }
+  program2.command("create-web-bundle-artifact").description(
+    "Create a Television-managed web bundle artifact. Pending is the default: Television creates a staging bundle on disk, you edit files under it, and you finish with `tv commit-artifact` or `tv abandon-artifact`. Pass --skip-pending to create the committed bundle immediately instead."
+  ).requiredOption("--screen <id>", "Target screen ID").requiredOption("--title <title>", "Artifact title").option("--skip-pending", "Create the committed bundle immediately instead of staging pending work").option("--focus-artifact", "Focus the new artifact after creation").option("--no-focus", "Create the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
+    const shouldFocus = resolveFocusDirective(argv, "create-web-bundle-artifact", "--focus-artifact");
     const client = createAuthenticatedClient(opts.server);
     const result = await client.artifacts.create({
+      kind: "web-bundle",
       title: opts.title,
-      type: opts.type,
+      skipPending: opts.skipPending,
       screenID: opts.screen
     });
     if (shouldFocus) {
       await client.display.focus({ artifactID: result.artifact.id, screenID: opts.screen });
     }
-    if (!("pendingPath" in result)) {
-      throw new Error("Server did not return pendingPath for internal artifact creation");
+    if ("pendingPath" in result) {
+      writeLine(env.stdout, `Pending web bundle artifact ${result.artifact.id} created.`);
+      writeLine(env.stdout, `Edit files in ${result.pendingPath}, then commit with:`);
+      writeLine(env.stdout, `  tv commit-artifact --id ${result.artifact.id}`);
+      return;
     }
-    writeLine(env.stdout, `Pending internal artifact ${result.artifact.id} created.`);
-    writeLine(env.stdout, `Edit files in ${result.pendingPath}, then commit with:`);
-    writeLine(env.stdout, `  tv commit-pending-artifact --id ${result.artifact.id}`);
+    writeLine(env.stdout, `Web bundle artifact ${result.artifact.id} created.`);
+    writeLine(env.stdout, "The committed bundle is ready for direct editing on disk.");
   });
-  program2.command("edit-internal-artifact").description(
-    "Stage a pending edit against an existing internal artifact. The bundle becomes editable on disk; the live committed version stays in place until you finish. Read artifact.md, data.json, and memory.md before changing anything so you preserve user intent and prior decisions. Finish with `tv commit-pending-artifact`, or discard with `tv abandon-pending-artifact`."
+  program2.command("edit-artifact").description(
+    "Stage a pending edit against an existing committed web bundle artifact. The committed version stays live until you finish. Finish with `tv commit-artifact`, or discard with `tv abandon-artifact`."
   ).requiredOption("--id <id>", "Artifact ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
     const result = await client.artifacts.edit({ artifactID: opts.id });
     writeLine(env.stdout, `Pending edit for artifact ${result.artifact.id} staged.`);
     writeLine(env.stdout, `Edit files in ${result.pendingPath}, then commit with:`);
-    writeLine(env.stdout, `  tv commit-pending-artifact --id ${result.artifact.id}`);
+    writeLine(env.stdout, `  tv commit-artifact --id ${result.artifact.id}`);
   });
-  program2.command("commit-pending-artifact").description(
-    "Validate the pending bundle and, if valid, commit it as the live artifact. Validation enforces required structure: artifact.md must contain all required headings (## User intent, ## Purpose, ## Data shape, ## Data sources, ## Rendering, ## Update workflow, ## Non-goals); data.json must be valid JSON; memory.md must contain ## Activity Log and a fresh UTC timestamp (YYYY-MM-DDTHH:MM:SSZ); public/index.{md,html} must be non-empty and match the artifact type. The CLI prints a directive when validation fails \u2014 fix the bundle and retry."
+  program2.command("commit-artifact").description(
+    "Commit a pending web bundle artifact, promoting the pending bundle to the live committed artifact."
   ).requiredOption("--id <id>", "Artifact ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
     const { artifact } = await client.artifacts.commitPending({ artifactID: opts.id });
     writeLine(env.stdout, `Artifact ${artifact.id} committed.`);
   });
-  program2.command("abandon-pending-artifact").description(
-    "Discard pending work without committing. For a pending create, the artifact never becomes live and the bundle is removed. For a pending edit, the live committed version is kept unchanged. Use this when the staged work should not ship."
+  program2.command("abandon-artifact").description(
+    "Discard pending web bundle work without committing. For a pending create, the artifact never becomes live. For a pending edit, the committed version stays unchanged."
   ).requiredOption("--id <id>", "Artifact ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(false)).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
     await client.artifacts.abandonPending({ artifactID: opts.id });
     writeLine(env.stdout, `Pending operation on artifact ${opts.id} abandoned.`);
   });
-  program2.command("create-external-artifact").description(
-    "Create an artifact that points at an existing file on disk. Television displays the file and watches it for changes, but does not own it: there is no bundle, no pending lifecycle, and `tv delete-artifact` only forgets the pointer \u2014 it never deletes the underlying file. --path must be absolute, the file must already exist and be readable, and its extension must match --type. Use this when the file already exists outside Television; use create-internal-artifact when Television should own a maintainable bundle."
-  ).requiredOption("--screen <id>", "Target screen ID").requiredOption("--type <type>", `Artifact type (${ARTIFACT_TYPES.join(" or ")})`).requiredOption("--title <title>", "Artifact title").requiredOption("--path <path>", "Absolute path to an existing content file").option("--focus-artifact", "Focus the new artifact after creation").option("--no-focus", "Create the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
-    const shouldFocus = resolveFocusDirective(argv, "create-external-artifact", "--focus-artifact");
-    if (!isArtifactType(opts.type)) {
-      throw createDirectiveError(
-        `tv create-external-artifact requires --type to be one of: ${ARTIFACT_TYPES.join(", ")}.`
-      );
-    }
-    const externalPath = validateExternalArtifactPath(opts.path);
+  program2.command("create-markdown-artifact").description(
+    "Create a committed markdown artifact that points at an existing markdown file on disk. Television displays the file and watches it for changes, but does not own it."
+  ).requiredOption("--screen <id>", "Target screen ID").requiredOption("--title <title>", "Artifact title").requiredOption("--path <path>", "Absolute path to an existing markdown file").option("--focus-artifact", "Focus the new artifact after creation").option("--no-focus", "Create the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
+    const shouldFocus = resolveFocusDirective(argv, "create-markdown-artifact", "--focus-artifact");
+    const externalPath = validateExternalArtifactPath("create-markdown-artifact", opts.path);
     if (isInTempDirectory(externalPath)) {
       writeLine(
         env.stderr,
         `Warning: artifact path is in a temp directory (${externalPath}).
-If you wish to display temporary content to the user, use an internal artifact instead.`
+If you wish to display temporary content to the user, use a web bundle artifact instead.`
       );
     }
     const client = createAuthenticatedClient(opts.server);
     const { artifact } = await client.artifacts.create({
+      kind: "markdown",
       externalFilePath: externalPath,
       title: opts.title,
-      type: opts.type,
       screenID: opts.screen
     });
     if (shouldFocus) {
       await client.display.focus({ artifactID: artifact.id, screenID: opts.screen });
     }
-    writeLine(env.stdout, `External artifact ${artifact.id} created.`);
+    writeLine(env.stdout, `Markdown artifact ${artifact.id} created.`);
     writeLine(env.stdout, `Television will display content from ${externalPath} and watch it for changes.`);
   });
   program2.command("create-url-artifact").description(
-    "Create an artifact that embeds a live http(s) page. Type is always text/html \u2014 do not pass --type. URL artifacts commit immediately and have no pending lifecycle. The page renders in a sandboxed <webview> in the desktop app and an <iframe> in the browser; some sites block embedding via X-Frame-Options or CSP, in which case the page may show as blank. Use this for live dashboards, docs, or third-party pages; use create-internal-artifact when the content should be Television-owned and durable."
+    "Create an artifact that embeds a live http(s) page. URL artifacts commit immediately and have no pending lifecycle. The page renders in a sandboxed <webview> in the desktop app and an <iframe> in the browser; some sites block embedding via X-Frame-Options or CSP, in which case the page may show as blank."
   ).requiredOption("--screen <id>", "Target screen ID").requiredOption("--title <title>", "Artifact title").requiredOption("--url <url>", "http(s) URL of the page to embed").option("--focus-artifact", "Focus the new artifact after creation").option("--no-focus", "Create the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).addHelpText("after", buildArtifactWorkflowHelpNote(true)).action(async (opts) => {
     const shouldFocus = resolveFocusDirective(argv, "create-url-artifact", "--focus-artifact");
     const client = createAuthenticatedClient(opts.server);
     const { artifact } = await client.artifacts.create({
+      kind: "url",
       externalURL: opts.url,
       title: opts.title,
-      type: "text/html",
       screenID: opts.screen
     });
     if (shouldFocus) {
@@ -50918,7 +50941,7 @@ If you wish to display temporary content to the user, use an internal artifact i
     writeJSON(env.stdout, { storagePath: getTelevisionStoragePath() });
   });
   program2.command("update-artifact").description(
-    "Update artifact metadata in place. Currently only --title is changeable; ID and type are immutable. This does not modify bundle content \u2014 for content changes on internal artifacts, use `tv edit-internal-artifact` and the pending-edit lifecycle."
+    "Update artifact metadata in place. Currently only --title is changeable; ID and kind/type are immutable. This does not modify bundle content \u2014 for content changes on committed web bundle artifacts, use `tv edit-artifact` and the pending-edit lifecycle."
   ).requiredOption("--id <id>", "Artifact ID").requiredOption("--title <title>", "New title").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
     await client.artifacts.update({ artifactID: opts.id, title: opts.title });
@@ -50933,14 +50956,8 @@ If you wish to display temporary content to the user, use an internal artifact i
     writeLine(env.stdout, `Artifact ${result.artifactID} detached from screen ${result.screenID}.`);
   };
   program2.command("detach-artifact").description(
-    "Remove the artifact's card from one screen's layout. The artifact itself is never touched: its metadata, its bundle (if internal), and its pointer (if external/url) all stay intact. Detaching the last screen reference does NOT delete the artifact \u2014 it just leaves it unplaced. Use `tv delete-artifact` when the user wants global removal, and `tv list-artifacts --unplaced` to find unplaced artifacts."
+    "Remove the artifact's card from one screen's layout. The artifact itself is never touched: its metadata, its web-bundle bytes, or its markdown/URL pointer all stay intact. Detaching the last screen reference does NOT delete the artifact \u2014 it just leaves it unplaced. Use `tv delete-artifact` when the user wants global removal, and `tv list-artifacts --unplaced` to find unplaced artifacts."
   ).requiredOption("--id <id>", "Artifact ID").requiredOption("--screen <id>", "Screen ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(detachAction);
-  program2.command("remove-artifact", { hidden: true }).description("Deprecated alias for detach-artifact").requiredOption("--id <id>", "Artifact ID").requiredOption("--screen <id>", "Screen ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
-    env.stderr.write(
-      "Deprecated: 'tv remove-artifact' has been renamed to 'tv detach-artifact'. Note: detach no longer trashes the artifact even on the last reference; use 'tv delete-artifact' to remove an artifact globally.\n"
-    );
-    await detachAction(opts);
-  });
   program2.command("attach-artifact").description(
     "Attach an existing artifact to a screen by appending a default-sized card to the right end of the screen's strip. Idempotent: attaching an artifact that is already on this screen is a no-op (existing card position is preserved). An artifact may belong to multiple screens simultaneously; attach does not move it, it adds another reference. Pick --focus-artifact when the user should be taken to the new card now, or --no-focus to attach in the background."
   ).requiredOption("--id <id>", "Artifact ID").requiredOption("--screen <id>", "Screen ID").option("--focus-artifact", "Focus the artifact after attaching it").option("--no-focus", "Attach the artifact in the background without changing focus").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
@@ -50959,7 +50976,7 @@ If you wish to display temporary content to the user, use an internal artifact i
     );
   });
   program2.command("delete-artifact").description(
-    "Globally remove an artifact. Detaches it from every screen it appears on, then: trashes the bundle (internal), forgets the pointer (external \u2014 the underlying file is untouched), drops the URL reference (URL), or discards pending-create work. This is the only path to global removal \u2014 `tv detach-artifact` only removes one screen-level card and leaves the artifact otherwise intact. There is no restore-from-trash workflow; treat delete as terminal."
+    "Globally remove an artifact. Detaches it from every screen it appears on, then: trashes the bundle (web-bundle), forgets the markdown file pointer without touching the file, forgets the URL pointer without touching the remote page, or discards pending-create work. This is the only path to global removal \u2014 `tv detach-artifact` only removes one screen-level card and leaves the artifact otherwise intact. There is no restore-from-trash workflow; treat delete as terminal."
   ).requiredOption("--id <id>", "Artifact ID").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
     const result = await client.artifacts.delete({ artifactID: opts.id });
@@ -51005,10 +51022,10 @@ If you wish to display temporary content to the user, use an internal artifact i
     writeJSON(env.stdout, await client.screens.list());
   });
   program2.command("get-screen").description(
-    "Get a screen and its artifacts as JSON. Includes each artifact's kind (internal/external/url) and status (pending/committed) so you can plan follow-up actions without a second call. With no --id, auto-selects when exactly one screen exists; otherwise --id is required."
-  ).option("--id <id>", "Screen ID (auto-selects if only one exists)").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
+    "Get a screen and its artifacts as JSON. Includes each artifact's kind (markdown/web-bundle/url) and status (pending/committed) so you can plan follow-up actions without a second call. With no --screen, auto-selects when exactly one screen exists; otherwise --screen is required."
+  ).option("--screen <id>", "Screen ID (auto-selects if only one exists)").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
     const client = createAuthenticatedClient(opts.server);
-    writeJSON(env.stdout, await client.screens.get({ screenID: opts.id }));
+    writeJSON(env.stdout, await client.screens.get({ screenID: opts.screen }));
   });
   program2.command("focus-status").description(
     "Print display state as JSON: the active (persistently focused) screen ID and the active theme name."
@@ -51050,45 +51067,38 @@ If you wish to display temporary content to the user, use an internal artifact i
   const skillsCommand = program2.command("skills").description("Manage the bundled Television skills").addHelpText("after", [
     "",
     "This command group manages the bundled Television skill collection.",
-    "`tv skills install` installs or reinstalls every bundled Television skill globally through the `skills` package.",
-    "`tv skills show` lists each bundled skill or prints one SKILL.md directly, which is useful for agents that need the content without running the interactive installer."
+    "`tv skills install <path>` copies the bundled Television skills into the destination agent skills folder.",
+    "Examples: ~/.openclaw/skills, ~/.hermes/skills, ~/.agents/skills.",
+    "`tv skills install -i` runs the external skills installer against Television's bundled skills root."
   ].join("\n"));
-  skillsCommand.command("path").description("Print the bundled Television skills collection root").action(() => {
+  skillsCommand.command("install").description("Copy bundled Television skills into an agent harness skills folder, or run the external installer against the bundled skills root").argument("[path]", "Destination agent skills folder (for example: ~/.openclaw/skills, ~/.hermes/skills, ~/.agents/skills)").option("-i, --interactive", "Run the external skills installer against the bundled Television skills root").allowUnknownOption(true).action(async function(inputPath, opts) {
     const bundledTelevisionSkillsCollectionRoot = env.resolveBundledSkillsRoot();
-    if (!bundledTelevisionSkillsCollectionRoot) {
-      throw new Error("Could not resolve the bundled Television skills root.");
+    if (opts.interactive) {
+      if (inputPath) {
+        throw createDirectiveError("tv skills install -i does not take a destination path.");
+      }
+      if (!bundledTelevisionSkillsCollectionRoot) {
+        throw new Error("Could not resolve the bundled Television skills root.");
+      }
+      const args = ["add", bundledTelevisionSkillsCollectionRoot];
+      await env.runSkillsInstaller(args);
+      return;
     }
-    writeLine(env.stdout, bundledTelevisionSkillsCollectionRoot);
-  });
-  skillsCommand.command("install").description("Install or reinstall all bundled Television skills globally").allowUnknownOption(true).action(async function() {
-    const bundledTelevisionSkillsCollectionRoot = env.resolveBundledSkillsRoot();
-    if (!bundledTelevisionSkillsCollectionRoot) {
-      throw new Error("Could not resolve the bundled Television skills root.");
+    if (!inputPath) {
+      throw createDirectiveError(
+        "tv skills install requires a destination agent skills folder, or -i for interactive."
+      );
     }
-    await env.runSkillsInstaller(["add", bundledTelevisionSkillsCollectionRoot, "--global"]);
-  });
-  skillsCommand.command("show").description("List bundled Television skills or print one SKILL.md by name").argument("[skill]", "Bundled skill name").action((skillName) => {
-    const bundledTelevisionSkillsCollectionRoot = env.resolveBundledSkillsRoot();
     if (!bundledTelevisionSkillsCollectionRoot) {
       throw new Error("Could not resolve the bundled Television skills root.");
     }
-    if (skillName === void 0) {
-      const bundledSkills = listBundledSkills(bundledTelevisionSkillsCollectionRoot);
-      bundledSkills.forEach((skill2, index) => {
-        writeLine(env.stdout, `${skill2.name} \u2014 ${skill2.description}`);
-        writeLine(env.stdout, `  ${skill2.root}`);
-        if (index < bundledSkills.length - 1) {
-          writeLine(env.stdout, "");
-        }
-      });
-      return;
-    }
-    const skill = resolveBundledSkill(bundledTelevisionSkillsCollectionRoot, skillName);
-    writeLine(env.stdout, `Path: ${skill.root}`);
-    writeLine(env.stdout, "---");
-    env.stdout.write(skill.markdown);
-    if (!skill.markdown.endsWith("\n")) {
-      writeLine(env.stdout, "");
+    const destinationRoot = import_node_path10.default.resolve(inputPath);
+    const copied = copyBundledSkillsToDestination(bundledTelevisionSkillsCollectionRoot, destinationRoot);
+    writeLine(env.stdout, `Copied ${copied.length} bundled Television skill(s):`);
+    for (const skill of copied) {
+      writeLine(env.stdout, `- ${skill.name}`);
+      writeLine(env.stdout, `  from: ${skill.sourcePath}`);
+      writeLine(env.stdout, `  to:   ${skill.destinationPath}`);
     }
   });
   program2.command("stop").description("Stop the Television system service").action(async () => {