@larkup/cli 0.2.21 → 0.2.23

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   runWithServer,
   setActiveServer,
   trackUsageEvent
-} from "./chunk-PDVC2XOG.js";
+} from "./chunk-L34L3RDQ.js";
 import {
   getInstalledTool,
   getInstalledTools,
@@ -19,11 +19,11 @@ import {
   isToolInstalled,
   loadTool,
   uninstallTool
-} from "./chunk-RHTL75EX.js";
+} from "./chunk-I6JJWCUQ.js";
 import {
   getAllTools,
   getToolById
-} from "./chunk-O7OJUFU6.js";
+} from "./chunk-FM6HYXZ5.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -34,7 +34,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@larkup/cli",
-  version: "0.2.21",
+  version: "0.2.23",
   publishConfig: {
     access: "public"
   },
@@ -73,8 +73,8 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    tsup: "^8.0.0",
-    tsx: "^4.22.4",
+    tsup: "^8.5.1",
+    tsx: "^4.23.5",
     typescript: "^6.0.3"
   }
 };
@@ -960,12 +960,12 @@ function addChatProviderDependency(dependencies, provider) {
 }
 
 // ../../packages/core/src/generator/generate-server.ts
-function lang(path14) {
-  if (path14.endsWith(".json")) return "json";
-  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
-  if (path14.endsWith(".md")) return "markdown";
-  if (path14.endsWith("Dockerfile")) return "dockerfile";
-  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
+function lang(path15) {
+  if (path15.endsWith(".json")) return "json";
+  if (path15.endsWith(".mjs") || path15.endsWith(".js")) return "javascript";
+  if (path15.endsWith(".md")) return "markdown";
+  if (path15.endsWith("Dockerfile")) return "dockerfile";
+  if (path15.endsWith(".yml") || path15.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore() {
@@ -2282,22 +2282,22 @@ function generateServer(config) {
     { path: "README.md", contents: readme(config, server) }
   ].map((f) => ({ ...f, language: lang(f.path) }));
   try {
-    const fs13 = __require("fs");
-    const path14 = __require("path");
-    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs13.existsSync(faviconPath)) {
+    const fs14 = __require("fs");
+    const path15 = __require("path");
+    const faviconPath = path15.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs14.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs13.readFileSync(faviconPath).toString("base64"),
+        contents: fs14.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs13.existsSync(webFaviconPath)) {
+      const webFaviconPath = path15.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs14.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs14.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -2311,12 +2311,12 @@ function generateServer(config) {
 }
 
 // ../../packages/core/src/generator/generate-agent-server.ts
-function lang2(path14) {
-  if (path14.endsWith(".json")) return "json";
-  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
-  if (path14.endsWith(".md")) return "markdown";
-  if (path14.endsWith("Dockerfile")) return "dockerfile";
-  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
+function lang2(path15) {
+  if (path15.endsWith(".json")) return "json";
+  if (path15.endsWith(".mjs") || path15.endsWith(".js")) return "javascript";
+  if (path15.endsWith(".md")) return "markdown";
+  if (path15.endsWith("Dockerfile")) return "dockerfile";
+  if (path15.endsWith(".yml") || path15.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore2() {
@@ -3330,22 +3330,22 @@ function generateAgentServer(config) {
     { path: "README.md", contents: readme2(config, server) }
   ].map((f) => ({ ...f, language: lang2(f.path) }));
   try {
-    const fs13 = __require("fs");
-    const path14 = __require("path");
-    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs13.existsSync(faviconPath)) {
+    const fs14 = __require("fs");
+    const path15 = __require("path");
+    const faviconPath = path15.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs14.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs13.readFileSync(faviconPath).toString("base64"),
+        contents: fs14.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs13.existsSync(webFaviconPath)) {
+      const webFaviconPath = path15.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs14.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs14.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -4042,7 +4042,7 @@ async function addDocCommand(options) {
     const doc = await addDocument({
       title: title ?? "Untitled",
       content,
-      source: options.file ? "upload" : "paste",
+      source: options.file ? "files" : "text",
       url: options.url
     });
     log.success(`Added "${doc.title}" (${doc.charCount.toLocaleString()} chars)`);
@@ -4251,7 +4251,7 @@ async function embedTexts(config, texts) {
     values: texts
   });
   const totalTokens = texts.reduce((acc, t) => acc + Math.ceil(t.length / 4), 0);
-  const { trackUsageEvent: trackUsageEvent2, estimateCost: estimateCost2 } = await import("./analytics-store-JGHJTMOB.js");
+  const { trackUsageEvent: trackUsageEvent2, estimateCost: estimateCost2 } = await import("./analytics-store-KI3NXDYV.js");
   void trackUsageEvent2({
     type: "embedding",
     embeddingModelId: config.embeddingModelId,
@@ -4297,7 +4297,7 @@ async function createAdapter(config, onRateLimit) {
   }
   switch (config.vectorStore) {
     case "pinecone": {
-      const { PineconeAdapter } = await import("./pinecone-5SGBRUV3.js");
+      const { PineconeAdapter } = await import("./pinecone-OHOY4YYM.js");
       return new PineconeAdapter({
         apiKey: overrides.apiKey,
         indexName: overrides.indexName,
@@ -4308,7 +4308,7 @@ async function createAdapter(config, onRateLimit) {
       });
     }
     case "chroma": {
-      const { ChromaAdapter } = await import("./chroma-NWWTSRG6.js");
+      const { ChromaAdapter } = await import("./chroma-BCASZNMJ.js");
       return new ChromaAdapter({
         mode: overrides.mode,
         host: overrides.host,
@@ -4322,7 +4322,7 @@ async function createAdapter(config, onRateLimit) {
     }
     case "lancedb":
     default: {
-      const { LanceDBAdapter } = await import("./lancedb-RUTGJYW7.js");
+      const { LanceDBAdapter } = await import("./lancedb-UB2EPDCN.js");
       return new LanceDBAdapter({
         mode: overrides.mode,
         dbPath: overrides.dbPath,
@@ -4708,8 +4708,10 @@ async function readTextFiles(files) {
 }
 
 // src/commands/media.ts
-import { promises as fs9 } from "fs";
-import path10 from "path";
+import { promises as fs10 } from "fs";
+import { createHash, randomUUID as randomUUID9 } from "crypto";
+import { createReadStream } from "fs";
+import path11 from "path";
 
 // ../../packages/core/src/media-store.ts
 import { promises as fs7 } from "fs";
@@ -4943,6 +4945,508 @@ function createStorageProvider(_config) {
   return new LocalStorageProvider();
 }
 
+// ../../packages/core/src/video-knowledge/revision-store.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// ../../packages/core/src/video-knowledge/store.ts
+import { promises as fs9 } from "fs";
+import path10 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+var EMPTY_STATE = {
+  schemaVersion: 1,
+  revisions: [],
+  jobs: [],
+  inspectionReservations: [],
+  backgroundRefinements: [],
+  artifactAnalysisCache: [],
+  artifacts: [],
+  evidence: [],
+  observations: [],
+  states: [],
+  transitions: [],
+  events: [],
+  scenes: [],
+  chapters: [],
+  summaries: [],
+  derived: [],
+  conflicts: [],
+  manifests: [],
+  projections: []
+};
+var writeChain4 = Promise.resolve();
+var LOCK_STALE_MS = 5 * 6e4;
+var LOCK_ATTEMPTS = 500;
+function cloneEmpty() {
+  return structuredClone(EMPTY_STATE);
+}
+async function dataPath(create) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  return dir ? path10.join(dir, "video-knowledge.json") : null;
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+async function readVideoKnowledgeState() {
+  const file = await dataPath(false);
+  if (!file) return cloneEmpty();
+  try {
+    const parsed = JSON.parse(await fs9.readFile(file, "utf8"));
+    if (parsed.schemaVersion !== 1)
+      throw new Error(`Unsupported video knowledge schema at ${file}.`);
+    return { ...cloneEmpty(), ...parsed };
+  } catch (error) {
+    if (isMissing(error)) return cloneEmpty();
+    throw error;
+  }
+}
+async function writeState2(state) {
+  const file = await dataPath(true);
+  if (!file) return;
+  const temp = path10.join(
+    path10.dirname(file),
+    `.${path10.basename(file)}.${process.pid}.${randomUUID4()}.tmp`
+  );
+  try {
+    await fs9.writeFile(temp, JSON.stringify(state, null, 2), "utf8");
+    await fs9.rename(temp, file);
+  } catch (error) {
+    await fs9.unlink(temp).catch(() => {
+    });
+    throw error;
+  }
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function acquireStateLock() {
+  const file = await dataPath(true);
+  if (!file) return async () => {
+  };
+  const lock = `${file}.lock`;
+  for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt++) {
+    try {
+      const handle = await fs9.open(lock, "wx");
+      await handle.writeFile(`${process.pid}:${(/* @__PURE__ */ new Date()).toISOString()}`);
+      return async () => {
+        await handle.close().catch(() => {
+        });
+        await fs9.unlink(lock).catch(() => {
+        });
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const stat = await fs9.stat(lock);
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+          await fs9.unlink(lock).catch(() => {
+          });
+        }
+      } catch (statError) {
+        if (!isMissing(statError)) throw statError;
+      }
+      await delay(Math.min(50, 5 + attempt));
+    }
+  }
+  throw new Error(`Timed out waiting for the video knowledge state lock: ${lock}`);
+}
+function mutateVideoKnowledgeState(mutate) {
+  const run = writeChain4.then(async () => {
+    const release = await acquireStateLock();
+    try {
+      const state = await readVideoKnowledgeState();
+      const result = await mutate(state);
+      await writeState2(state);
+      return result;
+    } finally {
+      await release();
+    }
+  });
+  writeChain4 = run.catch(() => {
+  });
+  return run;
+}
+
+// ../../packages/core/src/video-knowledge/revision-store.ts
+function createVideoKnowledgeRevision(input) {
+  return mutateVideoKnowledgeState((state) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const revision = {
+      id: randomUUID5(),
+      mediaAssetId: input.mediaAssetId,
+      sourceFingerprint: input.sourceFingerprint,
+      pipelineVersion: input.pipelineVersion,
+      parentRevisionId: input.parentRevisionId,
+      guidance: input.guidance,
+      status: "queued",
+      budget: input.budget,
+      coverage: input.coverage,
+      schemaVersion: 1,
+      createdAt: now
+    };
+    state.revisions.push(revision);
+    return revision;
+  });
+}
+
+// ../../packages/core/src/video-knowledge/job-store.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function createVideoKnowledgeJob(input) {
+  return mutateVideoKnowledgeState((state) => {
+    const existing = state.jobs.find(
+      (job2) => job2.idempotencyKey === input.idempotencyKey && !["failed", "cancelled", "completed"].includes(job2.status)
+    );
+    if (existing) return existing;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const job = {
+      id: randomUUID6(),
+      mediaAssetId: input.mediaAssetId,
+      knowledgeRevisionId: input.knowledgeRevisionId,
+      idempotencyKey: input.idempotencyKey,
+      budget: input.budget,
+      status: "queued",
+      attempt: 0,
+      checkpoint: {
+        stage: "queued",
+        completedEvidenceIds: [],
+        completedProjectionIds: [],
+        updatedAt: now
+      },
+      retryHistory: [],
+      createdAt: now,
+      updatedAt: now
+    };
+    state.jobs.push(job);
+    return job;
+  });
+}
+function claimVideoKnowledgeJob(id, owner, leaseMs = 6e4) {
+  return mutateVideoKnowledgeState((state) => {
+    const job = state.jobs.find((candidate) => candidate.id === id);
+    if (!job || job.cancellationRequestedAt || ["completed", "failed", "cancelled"].includes(job.status))
+      return void 0;
+    const now = Date.now();
+    if (job.retryAfter && new Date(job.retryAfter).getTime() > now) return void 0;
+    if (job.leaseExpiresAt && new Date(job.leaseExpiresAt).getTime() > now && job.leaseOwner !== owner)
+      return void 0;
+    job.leaseOwner = owner;
+    job.leaseExpiresAt = new Date(now + leaseMs).toISOString();
+    job.heartbeatAt = new Date(now).toISOString();
+    job.status = job.status === "queued" ? "acquiring" : job.status;
+    job.attempt += 1;
+    job.retryAfter = void 0;
+    job.updatedAt = new Date(now).toISOString();
+    return job;
+  });
+}
+function checkpointVideoKnowledgeJob(id, owner, stage, checkpoint, leaseMs = 6e4) {
+  return mutateVideoKnowledgeState((state) => {
+    const job = state.jobs.find((candidate) => candidate.id === id);
+    if (!job || job.leaseOwner !== owner || job.cancellationRequestedAt) return void 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    job.status = stage;
+    job.checkpoint = { ...job.checkpoint, ...checkpoint, stage, updatedAt: now };
+    job.heartbeatAt = now;
+    job.leaseExpiresAt = new Date(Date.now() + leaseMs).toISOString();
+    job.updatedAt = now;
+    return job;
+  });
+}
+function finishVideoKnowledgeJob(id, owner, status, error) {
+  return mutateVideoKnowledgeState((state) => {
+    const job = state.jobs.find((candidate) => candidate.id === id);
+    if (!job || job.leaseOwner && job.leaseOwner !== owner) return void 0;
+    job.status = status;
+    job.error = error;
+    job.leaseOwner = void 0;
+    job.leaseExpiresAt = void 0;
+    job.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return job;
+  });
+}
+
+// ../../packages/core/src/video-knowledge/knowledge-builder.ts
+import { randomUUID as randomUUID7 } from "crypto";
+var uncalibrated = {
+  score: 1,
+  source: "heuristic",
+  calibrationStatus: "uncalibrated",
+  uncertaintyReasons: [
+    "Legacy timeline evidence has not been calibrated against the video evaluation corpus."
+  ]
+};
+function textFromValue(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && !Array.isArray(value) && typeof value.text === "string") {
+    return value.text;
+  }
+  return JSON.stringify(value);
+}
+function isStateValue(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function buildVideoKnowledgeFromEvidence(input) {
+  return mutateVideoKnowledgeState((state) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const maxSceneDuration = Math.max(30, input.maximumSceneDurationSecs ?? 300);
+    const accepted = [...input.evidence].filter(
+      (item) => Number.isFinite(item.timeRange.startSecs) && Number.isFinite(item.timeRange.endSecs)
+    ).sort(
+      (left, right) => left.timeRange.startSecs - right.timeRange.startSecs || left.timeRange.endSecs - right.timeRange.endSecs
+    );
+    const evidence = accepted.map((item) => {
+      const id = randomUUID7();
+      const lineageId = randomUUID7();
+      state.evidence.push({
+        id,
+        lineageId,
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        modality: item.modality,
+        timeRange: range(
+          item.timeRange.startSecs,
+          item.timeRange.endSecs,
+          item.timeRange.precision
+        ),
+        frameArtifactIds: item.frameArtifactIds,
+        payload: item.payload,
+        source: item.source,
+        confidence: item.confidence,
+        schemaVersion: 1,
+        createdAt: now
+      });
+      return { item, id, lineageId };
+    });
+    const observations = [];
+    for (const record of evidence) {
+      const kind = record.item.observation?.kind ?? (record.item.modality === "transcript" ? "speech" : record.item.modality === "ocr" ? "ocr" : record.item.modality === "audio-event" ? "audio-event" : record.item.modality === "computed" ? "computed" : "state");
+      const id = randomUUID7();
+      const lineageId = randomUUID7();
+      state.observations.push({
+        id,
+        lineageId,
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        kind,
+        timeRange: range(
+          record.item.timeRange.startSecs,
+          record.item.timeRange.endSecs,
+          record.item.timeRange.precision
+        ),
+        value: record.item.observation?.value ?? record.item.payload,
+        evidenceLineageIds: [record.lineageId],
+        confidence: record.item.observation?.confidence ?? record.item.confidence,
+        schemaVersion: 1,
+        createdAt: now
+      });
+      observations.push({ id, lineageId, evidenceLineageId: record.lineageId, item: record.item });
+    }
+    const previousByProperty = /* @__PURE__ */ new Map();
+    for (const observation of observations) {
+      const value = observation.item.observation?.value ?? observation.item.payload;
+      if (!isStateValue(value)) continue;
+      const subject = typeof value.subject === "string" ? value.subject.trim() : "";
+      const property = typeof value.property === "string" ? value.property.trim() : "";
+      if (!subject || !property || value.value === void 0) continue;
+      const key = `${subject}\0${property}`;
+      const previous = previousByProperty.get(key);
+      const stateId = randomUUID7();
+      const stateLineageId = randomUUID7();
+      state.states.push({
+        id: stateId,
+        lineageId: stateLineageId,
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        subject,
+        property,
+        value: value.value,
+        timeRange: range(
+          observation.item.timeRange.startSecs,
+          observation.item.timeRange.endSecs,
+          observation.item.timeRange.precision
+        ),
+        previousStateId: previous?.id,
+        evidenceLineageIds: [observation.evidenceLineageId],
+        confidence: observation.item.observation?.confidence ?? observation.item.confidence,
+        schemaVersion: 1,
+        createdAt: now
+      });
+      const conflictingState = state.states.find(
+        (candidate) => candidate.id !== stateId && candidate.mediaAssetId === input.mediaAssetId && candidate.subject === subject && candidate.property === property && candidate.timeRange.startSecs <= observation.item.timeRange.endSecs && candidate.timeRange.endSecs >= observation.item.timeRange.startSecs && JSON.stringify(candidate.value) !== JSON.stringify(value.value)
+      );
+      if (conflictingState) {
+        const existing = state.conflicts.some(
+          (conflict) => conflict.knowledgeRevisionId === input.knowledgeRevisionId && conflict.evidenceLineageIds.includes(observation.evidenceLineageId) && conflict.evidenceLineageIds.some(
+            (lineageId) => conflictingState.evidenceLineageIds.includes(lineageId)
+          )
+        );
+        if (!existing) {
+          state.conflicts.push({
+            id: randomUUID7(),
+            mediaAssetId: input.mediaAssetId,
+            knowledgeRevisionId: input.knowledgeRevisionId,
+            evidenceLineageIds: [
+              .../* @__PURE__ */ new Set([...conflictingState.evidenceLineageIds, observation.evidenceLineageId])
+            ],
+            affectedObservationLineageIds: [observation.lineageId],
+            status: "conflicted",
+            schemaVersion: 1,
+            createdAt: now
+          });
+        }
+      }
+      if (previous && JSON.stringify(previous.value) !== JSON.stringify(value.value)) {
+        const transitionLineageId = randomUUID7();
+        state.transitions.push({
+          id: randomUUID7(),
+          lineageId: transitionLineageId,
+          mediaAssetId: input.mediaAssetId,
+          knowledgeRevisionId: input.knowledgeRevisionId,
+          beforeStateId: previous.id,
+          afterStateId: stateId,
+          description: `${subject} ${property} changed from ${textFromValue(
+            previous.value
+          )} to ${textFromValue(value.value)}.`,
+          timeRange: range(
+            observation.item.timeRange.startSecs,
+            observation.item.timeRange.endSecs,
+            observation.item.timeRange.precision
+          ),
+          evidenceLineageIds: [observation.evidenceLineageId],
+          confidence: observation.item.observation?.confidence ?? observation.item.confidence,
+          schemaVersion: 1,
+          createdAt: now
+        });
+      }
+      previousByProperty.set(key, { id: stateId, lineageId: stateLineageId, value: value.value });
+    }
+    const events = observations.map((observation) => {
+      const item = observation.item;
+      const transition = state.transitions.find(
+        (candidate) => candidate.knowledgeRevisionId === input.knowledgeRevisionId && candidate.timeRange.startSecs === item.timeRange.startSecs && candidate.evidenceLineageIds.includes(observation.evidenceLineageId)
+      );
+      const event = {
+        id: randomUUID7(),
+        lineageId: randomUUID7(),
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        type: transition ? "state-transition" : item.observation?.kind ?? item.modality,
+        description: transition?.description ?? textFromValue(item.observation?.value ?? item.payload).slice(0, 2e3),
+        timeRange: range(
+          item.timeRange.startSecs,
+          item.timeRange.endSecs,
+          item.timeRange.precision
+        ),
+        evidenceLineageIds: [observation.evidenceLineageId],
+        observationLineageIds: [observation.lineageId],
+        transitionLineageIds: transition ? [transition.lineageId] : [],
+        confidence: item.observation?.confidence ?? item.confidence,
+        schemaVersion: 1,
+        createdAt: now
+      };
+      state.events.push(event);
+      return event;
+    });
+    const sceneGroups = [];
+    for (const event of events) {
+      const group = sceneGroups.at(-1);
+      if (!group || event.timeRange.startSecs - group.at(-1).timeRange.endSecs > 15 || event.timeRange.endSecs - group[0].timeRange.startSecs > maxSceneDuration) {
+        sceneGroups.push([event]);
+      } else {
+        group.push(event);
+      }
+    }
+    const scenes = sceneGroups.map((group, index) => {
+      const scene = {
+        id: randomUUID7(),
+        lineageId: randomUUID7(),
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        title: `Scene ${index + 1}: ${eventsDescription(group).slice(0, 120)}`,
+        timeRange: range(
+          group[0].timeRange.startSecs,
+          group.at(-1).timeRange.endSecs,
+          group.some((event) => event.timeRange.precision === "estimated") ? "estimated" : "segment"
+        ),
+        eventLineageIds: group.map((event) => event.lineageId),
+        evidenceLineageIds: group.flatMap((event) => event.evidenceLineageIds),
+        quality: { ...uncalibrated, coverage: 1 },
+        capabilities: [...new Set(group.map((event) => `larkup:${event.type}`))],
+        schemaVersion: 1,
+        createdAt: now
+      };
+      state.scenes.push(scene);
+      return scene;
+    });
+    const chapterSize = 6;
+    for (let start = 0; start < scenes.length; start += chapterSize) {
+      const group = scenes.slice(start, start + chapterSize);
+      state.chapters.push({
+        id: randomUUID7(),
+        lineageId: randomUUID7(),
+        mediaAssetId: input.mediaAssetId,
+        knowledgeRevisionId: input.knowledgeRevisionId,
+        title: `Chapter ${Math.floor(start / chapterSize) + 1}: ${group[0].title.slice(0, 120)}`,
+        timeRange: range(group[0].timeRange.startSecs, group.at(-1).timeRange.endSecs, "segment"),
+        sceneLineageIds: group.map((scene) => scene.lineageId),
+        eventLineageIds: group.flatMap((scene) => scene.eventLineageIds),
+        evidenceLineageIds: group.flatMap((scene) => scene.evidenceLineageIds),
+        quality: { ...uncalibrated, coverage: 1 },
+        schemaVersion: 1,
+        createdAt: now
+      });
+    }
+    return {
+      evidenceIds: evidence.map((item) => item.id),
+      evidenceLineageIds: evidence.map((item) => item.lineageId),
+      observationIds: observations.map((item) => item.id),
+      observationLineageIds: observations.map((item) => item.lineageId),
+      eventIds: events.map((item) => item.id),
+      sceneIds: scenes.map((item) => item.id)
+    };
+  });
+}
+function range(startSecs, endSecs, precision) {
+  return { startSecs: Math.max(0, startSecs), endSecs: Math.max(startSecs, endSecs), precision };
+}
+function eventsDescription(events) {
+  return events.map((event) => event.description).filter(Boolean).join(" ").replace(/\s+/g, " ").trim() || "Timeline evidence";
+}
+
+// ../../packages/core/src/video-knowledge/manifest-store.ts
+import { randomUUID as randomUUID8 } from "crypto";
+function saveVideoKnowledgeProjection(record) {
+  return mutateVideoKnowledgeState((state) => {
+    const projection = {
+      ...record,
+      id: randomUUID8(),
+      schemaVersion: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.projections.push(projection);
+    return projection;
+  });
+}
+function activateVideoKnowledgeManifest(input) {
+  return mutateVideoKnowledgeState((state) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const projection of state.projections) {
+      if (projection.mediaAssetId === input.mediaAssetId)
+        projection.active = input.activeProjectionIds.includes(projection.id);
+    }
+    const manifest = {
+      ...input,
+      id: randomUUID8(),
+      schemaVersion: 1,
+      createdAt: now,
+      activatedAt: now
+    };
+    state.manifests.push(manifest);
+    const revision = state.revisions.find(
+      (candidate) => candidate.id === input.knowledgeRevisionId
+    );
+    if (revision) revision.activeManifestId = manifest.id;
+    return manifest;
+  });
+}
+
 // src/commands/media.ts
 var MIME_TYPES = {
   ".png": "image/png",
@@ -4985,12 +5489,12 @@ async function processMediaCommand(inputs, options) {
   const assets = await Promise.all(
     mediaFiles.map(async (filePath) => {
       const type = mediaType(filePath);
-      const stat = await fs9.stat(filePath);
-      const extension = path10.extname(filePath).toLowerCase() || ".bin";
+      const stat = await fs10.stat(filePath);
+      const extension = path11.extname(filePath).toLowerCase() || ".bin";
       const key = `${type}s/${Date.now()}_${Math.random().toString(36).slice(2)}${extension}`;
       const mimeType = MIME_TYPES[extension] || "application/octet-stream";
-      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs9.readFile(filePath), mimeType);
-      return { type, fileName: path10.basename(filePath), mimeType, storageUri, fileSize: stat.size };
+      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs10.readFile(filePath), mimeType);
+      return { type, fileName: path11.basename(filePath), mimeType, storageUri, fileSize: stat.size };
     })
   );
   const stored = await addMediaAssets(assets);
@@ -5072,7 +5576,7 @@ async function processMediaAsset(asset) {
       if (!tool2.processVideo)
         throw new Error("The installed Video & Audio tool cannot process videos.");
       await update("Extracting video audio", 20);
-      const outputDir = await fs9.mkdtemp(path10.join(process.cwd(), ".larkup", "tmp-media-"));
+      const outputDir = await fs10.mkdtemp(path11.join(process.cwd(), ".larkup", "tmp-media-"));
       try {
         const video = await tool2.processVideo(localFile, {
           outputDir,
@@ -5093,7 +5597,7 @@ async function processMediaAsset(asset) {
         dimensions = { width: video.meta.width, height: video.meta.height };
         frameCount = video.frames.length;
       } finally {
-        await fs9.rm(outputDir, { recursive: true, force: true }).catch(() => {
+        await fs10.rm(outputDir, { recursive: true, force: true }).catch(() => {
         });
       }
     } else {
@@ -5125,6 +5629,14 @@ async function processMediaAsset(asset) {
         contentKind: claimed.type === "video" ? "video-transcript" : "audio-transcript"
       }
     });
+    const knowledge = await publishCliVideoKnowledge({
+      asset: claimed,
+      localFile,
+      durationSecs,
+      frameCount,
+      documentId: document.id,
+      segments
+    });
     await updateMediaAsset(claimed.id, {
       processingStatus: "completed",
       processingProgress: 100,
@@ -5132,7 +5644,9 @@ async function processMediaAsset(asset) {
       caption: `${claimed.type === "video" ? "Video" : "Audio"}: ${Math.round(durationSecs)}s`,
       durationSecs,
       dimensions,
-      documentIds: [document.id]
+      documentIds: [document.id],
+      activeVideoKnowledgeRevisionId: knowledge.revisionId,
+      activeVideoKnowledgeManifestId: knowledge.manifestId
     });
     void trackUsageEvent({
       type: "media_processing",
@@ -5155,6 +5669,133 @@ async function processMediaAsset(asset) {
     log.warn(message);
   }
 }
+async function publishCliVideoKnowledge(input) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(input.localFile)) hash.update(chunk);
+  const revision = await createVideoKnowledgeRevision({
+    mediaAssetId: input.asset.id,
+    sourceFingerprint: hash.digest("hex"),
+    pipelineVersion: "video-knowledge-v1",
+    budget: {
+      maxDurationSecs: input.durationSecs,
+      maxBytes: input.asset.fileSize,
+      maxFrames: input.frameCount,
+      maxModelCalls: 0,
+      maxCostUsd: 0,
+      usedDurationSecs: input.durationSecs,
+      usedFrames: input.frameCount
+    },
+    coverage: {
+      sourceDurationSecs: input.durationSecs,
+      inspectedRanges: [],
+      transcriptCoverage: 0,
+      visualCoverage: 0,
+      ocrCoverage: 0,
+      partialReasons: []
+    }
+  });
+  const job = await createVideoKnowledgeJob({
+    mediaAssetId: input.asset.id,
+    knowledgeRevisionId: revision.id,
+    idempotencyKey: `${input.asset.id}:${revision.sourceFingerprint}:video-knowledge-v1`,
+    budget: revision.budget
+  });
+  const owner = randomUUID9();
+  if (!await claimVideoKnowledgeJob(job.id, owner))
+    throw new Error("Unable to claim CLI video knowledge job.");
+  try {
+    const confidence = {
+      score: 0.8,
+      source: "provider",
+      calibrationStatus: "uncalibrated",
+      uncertaintyReasons: ["CLI transcription has provider-segment timestamp precision."]
+    };
+    const evidence = [
+      ...input.segments.filter((segment) => segment.text.trim()).map((segment) => ({
+        modality: "transcript",
+        timeRange: {
+          startSecs: segment.startSecs,
+          endSecs: segment.endSecs,
+          precision: "segment"
+        },
+        payload: { text: segment.text },
+        source: { kind: "provider", provider: "stt" },
+        confidence,
+        observation: { kind: "speech", value: { text: segment.text } }
+      })),
+      ...deriveCliAudioSignals(input.segments).map((signal) => ({
+        modality: "audio-event",
+        timeRange: {
+          startSecs: signal.timestampSecs,
+          endSecs: signal.timestampSecs,
+          precision: "segment"
+        },
+        payload: {
+          transcriptChange: signal.transcriptChange,
+          silenceBoundary: signal.silenceBoundary
+        },
+        source: { kind: "heuristic", version: "audio-signals-v1" },
+        confidence: { ...confidence, source: "heuristic" },
+        observation: {
+          kind: "audio-event",
+          value: {
+            transcriptChange: signal.transcriptChange,
+            silenceBoundary: signal.silenceBoundary
+          }
+        }
+      }))
+    ];
+    const built = await buildVideoKnowledgeFromEvidence({
+      mediaAssetId: input.asset.id,
+      knowledgeRevisionId: revision.id,
+      evidence
+    });
+    const projection = await saveVideoKnowledgeProjection({
+      mediaAssetId: input.asset.id,
+      knowledgeRevisionId: revision.id,
+      kind: "transcript",
+      documentId: input.documentId,
+      lineageIds: [],
+      evidenceIds: built.evidenceIds,
+      quality: {
+        score: 0.7,
+        source: "heuristic",
+        calibrationStatus: "uncalibrated",
+        uncertaintyReasons: ["Search projection; source evidence is authoritative."]
+      },
+      active: false
+    });
+    await checkpointVideoKnowledgeJob(job.id, owner, "projecting", {
+      completedEvidenceIds: built.evidenceIds,
+      completedProjectionIds: [projection.id]
+    });
+    const manifest = await activateVideoKnowledgeManifest({
+      mediaAssetId: input.asset.id,
+      knowledgeRevisionId: revision.id,
+      activeEvidenceRevisionIds: Object.fromEntries(
+        built.evidenceLineageIds.map((lineageId, index) => [lineageId, built.evidenceIds[index]])
+      ),
+      activeObservationRevisionIds: Object.fromEntries(
+        built.observationLineageIds.map((lineageId, index) => [
+          lineageId,
+          built.observationIds[index]
+        ])
+      ),
+      activeProjectionIds: [projection.id],
+      activationReason: "initial"
+    });
+    await finishVideoKnowledgeJob(job.id, owner, "completed");
+    return { revisionId: revision.id, manifestId: manifest.id };
+  } catch (error) {
+    await finishVideoKnowledgeJob(
+      job.id,
+      owner,
+      "failed",
+      error instanceof Error ? error.message : "CLI knowledge publication failed."
+    );
+    throw error;
+  }
+}
 async function indexPendingMedia() {
   const config = await readConfig();
   const previousRun = await readRun();
@@ -5171,7 +5812,7 @@ async function indexPendingMedia() {
   spinner2.stop(`Indexed ${finalRun.totalChunks} chunks`);
 }
 function mediaType(filePath) {
-  const extension = path10.extname(filePath).toLowerCase();
+  const extension = path11.extname(filePath).toLowerCase();
   if ([".png", ".jpg", ".jpeg", ".webp", ".gif"].includes(extension)) return "image";
   if ([".mp4", ".webm", ".mov", ".mkv"].includes(extension)) return "video";
   if ([".mp3", ".m4a", ".wav", ".ogg", ".flac"].includes(extension)) return "audio";
@@ -5190,6 +5831,25 @@ function formatTime(seconds) {
   const minutes = Math.floor(seconds / 60);
   return `${minutes}:${String(Math.floor(seconds % 60)).padStart(2, "0")}`;
 }
+function deriveCliAudioSignals(chunks) {
+  let previous;
+  return [...chunks].sort((left, right) => left.startSecs - right.startSecs).map((chunk) => {
+    const earlier = new Set(
+      (previous?.text ?? "").toLocaleLowerCase().match(/[\p{Letter}\p{Number}]+/gu) ?? []
+    );
+    const words = new Set(
+      chunk.text.toLocaleLowerCase().match(/[\p{Letter}\p{Number}]+/gu) ?? []
+    );
+    const transcriptChange = words.size === 0 ? 0 : [...words].filter((word) => !earlier.has(word)).length / words.size;
+    const signal = {
+      timestampSecs: chunk.startSecs,
+      transcriptChange,
+      silenceBoundary: Boolean(previous && chunk.startSecs - previous.endSecs >= 2)
+    };
+    previous = chunk;
+    return signal;
+  });
+}
 
 // src/commands/index-cmd.ts
 async function indexCommand(inputs, options) {
@@ -5200,9 +5860,10 @@ async function indexCommand(inputs, options) {
       const textFiles = await readTextFiles(files);
       const mediaFiles = files.filter(isMediaPath);
       for (const document of textFiles) {
-        await addDocument({ title: document.title, content: document.content, source: "upload" });
+        await addDocument({ title: document.title, content: document.content, source: "files" });
       }
-      if (textFiles.length > 0) log.success(`Loaded ${textFiles.length} document${textFiles.length === 1 ? "" : "s"}.`);
+      if (textFiles.length > 0)
+        log.success(`Loaded ${textFiles.length} document${textFiles.length === 1 ? "" : "s"}.`);
       if (mediaFiles.length > 0) await mediaCommand(mediaFiles, { index: false });
       if (textFiles.length === 0 && mediaFiles.length === 0) {
         log.error("No supported text or media files were found.");
@@ -5218,7 +5879,9 @@ async function indexCommand(inputs, options) {
       log.error("Corpus is empty. Add documents first: larkup add-doc --file <path>");
     }
     if (!getEmbeddingModel(config.embeddingModelId)) {
-      log.error(`Unknown embedding model "${config.embeddingModelId}". Set it in the Configure stage.`);
+      log.error(
+        `Unknown embedding model "${config.embeddingModelId}". Set it in the Configure stage.`
+      );
     }
     await ensureApiKey(config, "embedding");
     log.info(log.fmt.cyan(`Indexing ${docs.length} document(s) into ${config.vectorStore}\u2026`));
@@ -5237,7 +5900,11 @@ async function indexCommand(inputs, options) {
       }
     }, 400);
     try {
-      await runIndexer(run.id, config, options.incremental && previousRun?.status === "completed" ? previousRun : null);
+      await runIndexer(
+        run.id,
+        config,
+        options.incremental && previousRun?.status === "completed" ? previousRun : null
+      );
     } catch (e) {
       done = true;
       clearInterval(timer);
@@ -5248,7 +5915,9 @@ async function indexCommand(inputs, options) {
     clearInterval(timer);
     const final = await readRun();
     if (final?.status === "completed") {
-      s.stop(`Indexed ${final.totalChunks} chunks (${final.dimensions}-dim) in ${((final.durationMs ?? 0) / 1e3).toFixed(1)}s`);
+      s.stop(
+        `Indexed ${final.totalChunks} chunks (${final.dimensions}-dim) in ${((final.durationMs ?? 0) / 1e3).toFixed(1)}s`
+      );
       log.success("Indexing complete!");
     } else {
       s.stop("Indexing failed.");
@@ -5258,20 +5927,20 @@ async function indexCommand(inputs, options) {
 }
 
 // src/commands/generate.ts
-import { promises as fs10 } from "fs";
-import path11 from "path";
+import { promises as fs11 } from "fs";
+import path12 from "path";
 async function generateCommand(options) {
   await inServerScope(options.server, async () => {
     await requireActive();
     const config = await readConfig();
     if (options.out) {
-      const dir = path11.isAbsolute(options.out) ? options.out : path11.join(process.cwd(), options.out);
+      const dir = path12.isAbsolute(options.out) ? options.out : path12.join(process.cwd(), options.out);
       const server2 = generateServer(config);
-      await fs10.mkdir(dir, { recursive: true });
+      await fs11.mkdir(dir, { recursive: true });
       for (const f of server2.files) {
-        const dest = path11.join(dir, f.path);
-        await fs10.mkdir(path11.dirname(dest), { recursive: true });
-        await fs10.writeFile(dest, f.contents, "utf8");
+        const dest = path12.join(dir, f.path);
+        await fs11.mkdir(path12.dirname(dest), { recursive: true });
+        await fs11.writeFile(dest, f.contents, "utf8");
       }
       log.success(`Generated ${server2.files.length} files \u2192 ${dir}`);
     } else {
@@ -5619,8 +6288,8 @@ async function marketplaceCommand(action = "list", toolId) {
 }
 
 // src/commands/deploy.ts
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs12 } from "fs";
+import path13 from "path";
 async function deployCommand(target, options) {
   await inServerScope(options.server, async () => {
     await requireActive();
@@ -5656,13 +6325,13 @@ async function deployCommand(target, options) {
   });
 }
 async function copyGenerated(source, output) {
-  const destination = path12.resolve(output);
-  const relative = path12.relative(source, destination);
-  if (relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative)) {
+  const destination = path13.resolve(output);
+  const relative = path13.relative(source, destination);
+  if (relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative)) {
     throw new Error("Deployment output must be outside the generated server directory.");
   }
-  await fs11.mkdir(destination, { recursive: true });
-  await fs11.cp(source, destination, { recursive: true, force: true });
+  await fs12.mkdir(destination, { recursive: true });
+  await fs12.cp(source, destination, { recursive: true, force: true });
   return destination;
 }
 
@@ -5747,8 +6416,8 @@ function openCommandForPlatform(url) {
 }
 
 // src/commands/documents.ts
-import { promises as fs12 } from "fs";
-import path13 from "path";
+import { promises as fs13 } from "fs";
+import path14 from "path";
 
 // ../../packages/core/src/corpus-retriever.ts
 function applyFilters(docs, filter) {
@@ -5867,10 +6536,10 @@ async function documentsCommand(action = "list", idOrPath, options) {
     }
     if (action === "export") {
       const format = options.format === "jsonl" ? "jsonl" : "csv";
-      const output = path13.resolve(options.out || idOrPath || `corpus.${format}`);
+      const output = path14.resolve(options.out || idOrPath || `corpus.${format}`);
       const content = format === "jsonl" ? await exportCorpusAsJSONL(void 0, Number.MAX_SAFE_INTEGER) : await exportCorpusAsCSV(void 0, Number.MAX_SAFE_INTEGER);
-      await fs12.mkdir(path13.dirname(output), { recursive: true });
-      await fs12.writeFile(output, content, "utf8");
+      await fs13.mkdir(path14.dirname(output), { recursive: true });
+      await fs13.writeFile(output, content, "utf8");
       log.success(`Exported corpus \u2192 ${output}`);
       return;
     }
@@ -5896,7 +6565,7 @@ ${document.content}`);
       return;
     }
     if (action === "update") {
-      const content = options.file ? await fs12.readFile(path13.resolve(options.file), "utf8") : options.text;
+      const content = options.file ? await fs13.readFile(path14.resolve(options.file), "utf8") : options.text;
       const updated = await updateDocument(document.id, {
         title: options.title,
         content,