npm - @treeseed/sdk - Versions diffs - 0.13.0-rc.6 → 0.13.0-rc.8 - Mend

@treeseed/sdk 0.13.0-rc.6 → 0.13.0-rc.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (826) hide show

package/dist/scenes/agent-lab/report-adapters.js DELETED Viewed

@@ -1,33 +0,0 @@
-import { sanitizeAgentLabSnapshot } from "./report-model.js";
-import { simulationViewerRuntime } from "./viewer/runtime.js";
-import { simulationViewerStyles } from "./viewer/styles.js";
-const skins = {
-  "race-control": { label: "Race Control", description: "Live Lab / Race Control", accent: "#d8ff45", accent2: "#45d7ff" },
-  "strategy-command": { label: "Strategy Command", description: "AI Lab / Strategic Field", accent: "#70f5b0", accent2: "#ffc857" },
-  "esports-tournament": { label: "Esports Tournament", description: "TreeSeed Lab / Match Live", accent: "#45d7ff", accent2: "#ff79c6" }
-};
-function escape(value) {
-  return String(value ?? "").replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;");
-}
-function render(snapshotInput, presentation) {
-  const snapshot = sanitizeAgentLabSnapshot(snapshotInput);
-  const skin = skins[presentation];
-  const fallbackName = snapshot.sceneId.replace(/^guide-/, "").replace(/-agent-lab$/, "").replace(/-/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
-  const labName = snapshot.agents.length === 1 ? snapshot.agents[0].title : fallbackName;
-  const json = JSON.stringify(snapshot).replace(/</gu, "\\u003c");
-  const runtime = simulationViewerRuntime().replace(/<\/script/giu, "<\\/script");
-  return `<!doctype html><html lang="en" data-revision="0"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="dark"><meta name="description" content="Standalone production agent simulation evidence viewer"><title>Agent Lab: ${escape(labName)}</title>${simulationViewerStyles(skin.accent, skin.accent2)}</head><body><div id="simulation-root"><div class="shell"><div class="empty">Initializing Agent Lab\u2026</div></div></div><script type="application/json" id="agent-lab-data">${json}</script><script>${runtime}</script></body></html>`;
-}
-const BUILT_IN_AGENT_LAB_PRESENTATIONS = Object.keys(skins).map((id) => ({
-  id,
-  label: skins[id].label,
-  description: skins[id].description,
-  render: (snapshot) => render(snapshot, id)
-}));
-function resolveAgentLabPresentation(id, adapters = []) {
-  return [...BUILT_IN_AGENT_LAB_PRESENTATIONS, ...adapters].find((adapter) => adapter.id === id) ?? null;
-}
-export {
-  BUILT_IN_AGENT_LAB_PRESENTATIONS,
-  resolveAgentLabPresentation
-};

package/dist/scenes/agent-lab/report-model.d.ts DELETED Viewed

@@ -1,122 +0,0 @@
-import type { AgentLabSnapshot } from '../types.js';
-export declare function sanitizeAgentLabValue(value: unknown, key?: string): unknown;
-export declare function sanitizeAgentLabSnapshot(snapshot: AgentLabSnapshot): {
-    workdays: {
-        activity: import("../../index.js").AgentActivityEvent[];
-        assignments: Record<string, unknown>[];
-        providerExecutions: Record<string, unknown>[];
-        governance: Record<string, unknown>[];
-        accounting: Record<string, unknown>;
-        executions: {
-            transcript: {
-                text: string | null;
-                payload: Record<string, unknown>;
-                id: string;
-                timestamp: string | null;
-                type: string;
-                status: string | null;
-            }[];
-            evidence: {
-                detail: unknown;
-                id: string;
-                timestamp: string | null;
-                kind: "context-pack" | "work-package" | "provider-invocation" | "agent-message" | "reasoning" | "tool-call" | "treedx-call" | "provider-output" | "diagnostic";
-                label: string;
-                status: string | null;
-                summary: string | null;
-            }[];
-            signals: Record<string, unknown>[];
-            artifacts: Record<string, unknown>[];
-            usage: Record<string, unknown>;
-            error: Record<string, unknown> | null;
-            assignment: Record<string, unknown>;
-            capacity: import("../types.js").AgentLabCapacitySummary;
-            id: string;
-            assignmentId: string | null;
-            modeRunId: string | null;
-            agentId: string | null;
-            agentClassId: string | null;
-            activityType: string | null;
-            handlerId: string | null;
-            projectId: string | null;
-            status: string;
-            startedAt: string | null;
-            finishedAt: string | null;
-            providerId: string | null;
-            providerManagerId: string | null;
-            runnerId: string | null;
-            executionProviderId: string | null;
-        }[];
-        id: string;
-        title: string;
-        workdayRunId: string | null;
-        status: "pending" | "running" | "completed" | "failed" | "degraded" | "cancelled";
-        startedAt: string | null;
-        finishedAt: string | null;
-        agentTests: string[];
-        assertions: import("../types.js").AgentLabAssertion[];
-        diagnostics: string[];
-    }[];
-    schemaVersion: "treeseed.agent-simulation/v2";
-    sceneId: string;
-    runId: string;
-    status: "starting" | "running" | "completed" | "failed" | "cleaning";
-    presentation: import("../types.js").AgentLabPresentation;
-    timeZone: string;
-    generatedAt: string;
-    team: {
-        id: string | null;
-        name: string | null;
-        isolation: "ephemeral" | "team";
-    };
-    provider: {
-        id: string | null;
-        membershipId: string | null;
-        executionProviderId: "codex";
-        status: string;
-    };
-    repositories: Array<{
-        slug: string;
-        projectId: string | null;
-        repositoryId: string | null;
-        ref: string | null;
-    }>;
-    agents: import("../types.js").AgentLabAgent[];
-    cleanup: {
-        status: "pending" | "running" | "completed" | "failed";
-        diagnostics: string[];
-    };
-    diagnostics: string[];
-};
-export declare function agentClassPalette(classIds: string[]): {
-    [k: string]: string;
-};
-export declare function agentLabTotals(snapshot: AgentLabSnapshot): {
-    workdays: number;
-    workdaysCompleted: number;
-    executions: number;
-    completed: number;
-    failed: number;
-    running: number;
-    agents: number;
-    agentsActive: number;
-    classes: number;
-    activities: number;
-    assignments: number;
-    artifacts: number;
-    assertionsPassed: number;
-    assertionsFailed: number;
-};
-export declare function hasFailedAgentLabContentTool(day: AgentLabSnapshot['workdays'][number]): boolean;
-export declare function initialAgentLabSnapshot(input: {
-    sceneId: string;
-    runId: string;
-    presentation: AgentLabSnapshot['presentation'];
-    timeZone: string;
-    repositories: string[];
-    workdays: Array<{
-        id: string;
-        title?: string;
-        agentTests: string[];
-    }>;
-}): AgentLabSnapshot;

package/dist/scenes/agent-lab/report-model.js DELETED Viewed

@@ -1,194 +0,0 @@
-import { createHash } from "node:crypto";
-const SENSITIVE = /(?:api.?key|authorization|credential|membershipcredential|password|private.?key|secret|token)/iu;
-const MAX_COLLECTION_ITEMS = 40;
-const MAX_OBJECT_FIELDS = 40;
-const MAX_TEXT_BYTES = 1024;
-const MAX_VALUE_BYTES = 8192;
-const MAX_TRANSCRIPT_ITEMS = 120;
-const MAX_EVIDENCE_ITEMS = 80;
-function digest(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function boundedText(value) {
-  const bytes = Buffer.byteLength(value, "utf8");
-  if (bytes <= MAX_TEXT_BYTES) return value;
-  const preview = value.slice(0, MAX_TEXT_BYTES / 2);
-  return `${preview}
-[Agent Lab presentation truncated ${bytes - Buffer.byteLength(preview, "utf8")} bytes; sha256:${digest(value)}. Query durable forensic evidence for the complete value.]`;
-}
-function boundedContainer(original, projected, kind) {
-  const serialized = JSON.stringify(projected);
-  if (Buffer.byteLength(serialized, "utf8") <= MAX_VALUE_BYTES) return projected;
-  return {
-    presentationTruncated: true,
-    byteLength: Buffer.byteLength(JSON.stringify(original), "utf8"),
-    sha256: digest(JSON.stringify(original)),
-    reason: "maximum-value-bytes",
-    kind,
-    ...Array.isArray(original) ? { itemCount: original.length } : { fields: Object.keys(original).slice(0, MAX_OBJECT_FIELDS) },
-    preview: boundedText(serialized)
-  };
-}
-function boundedValue(value, depth = 0) {
-  if (typeof value === "string") return boundedText(value);
-  if (!value || typeof value !== "object") return value;
-  if (depth >= 8) {
-    const serialized = JSON.stringify(value);
-    return { presentationTruncated: true, byteLength: Buffer.byteLength(serialized, "utf8"), sha256: digest(serialized), reason: "maximum-depth" };
-  }
-  if (Array.isArray(value)) {
-    const selected2 = value.length > MAX_COLLECTION_ITEMS ? [...value.slice(0, MAX_COLLECTION_ITEMS / 2), ...value.slice(-MAX_COLLECTION_ITEMS / 2)] : value;
-    const result2 = selected2.map((entry) => boundedValue(entry, depth + 1));
-    if (selected2.length !== value.length) result2.splice(MAX_COLLECTION_ITEMS / 2, 0, {
-      presentationTruncated: true,
-      omittedItems: value.length - selected2.length,
-      sha256: digest(JSON.stringify(value)),
-      reason: "maximum-items"
-    });
-    return boundedContainer(value, result2, "array");
-  }
-  const entries = Object.entries(value);
-  const selected = entries.slice(0, MAX_OBJECT_FIELDS);
-  const result = Object.fromEntries(selected.map(([key, entry]) => [key, boundedValue(entry, depth + 1)]));
-  if (selected.length !== entries.length) result.presentationTruncation = {
-    omittedFields: entries.length - selected.length,
-    sha256: digest(JSON.stringify(value)),
-    reason: "maximum-fields"
-  };
-  return boundedContainer(value, result, "object");
-}
-function boundedTimeline(items, limit) {
-  if (items.length <= limit) return items;
-  return [...items.slice(0, Math.floor(limit / 4)), ...items.slice(-(limit - Math.floor(limit / 4)))];
-}
-function sanitizeAgentLabValue(value, key = "") {
-  const normalizedKey = key.replaceAll("_", "").toLowerCase();
-  const usageMetric = /^(?:(?:input|output|cachedinput|reasoningoutput|prompt|completion|cachereadinput)tokens|(?:total)?tokenestimate(?:source)?|tokencounts|tokenusage|usage)$/u.test(normalizedKey);
-  if (SENSITIVE.test(key) && !usageMetric) return "[REDACTED]";
-  if (Array.isArray(value)) return value.map((entry) => sanitizeAgentLabValue(entry));
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [entryKey, sanitizeAgentLabValue(entry, entryKey)]));
-}
-function sanitizeAgentLabSnapshot(snapshot) {
-  const sanitized = sanitizeAgentLabValue(snapshot);
-  return {
-    ...sanitized,
-    workdays: sanitized.workdays.map((day) => ({
-      ...day,
-      activity: boundedTimeline(day.activity, 1e3).map((entry) => boundedValue(entry)),
-      assignments: day.assignments.map((entry) => boundedValue(entry)),
-      providerExecutions: day.providerExecutions.map((entry) => boundedValue(entry)),
-      governance: day.governance.map((entry) => boundedValue(entry)),
-      accounting: boundedValue(day.accounting),
-      executions: day.executions.map((execution) => ({
-        ...execution,
-        transcript: boundedTimeline(execution.transcript, MAX_TRANSCRIPT_ITEMS).map((entry) => ({
-          ...entry,
-          text: entry.text === null ? null : boundedText(entry.text),
-          payload: boundedValue(entry.payload)
-        })),
-        evidence: boundedTimeline(execution.evidence, MAX_EVIDENCE_ITEMS).map((entry) => ({ ...entry, detail: boundedValue(entry.detail) })),
-        signals: execution.signals.map((entry) => boundedValue(entry)),
-        artifacts: execution.artifacts.map((entry) => boundedValue(entry)),
-        usage: boundedValue(execution.usage),
-        error: execution.error ? boundedValue(execution.error) : null,
-        assignment: boundedValue(execution.assignment),
-        capacity: boundedValue(execution.capacity)
-      }))
-    }))
-  };
-}
-function hash(value) {
-  let result = 2166136261;
-  for (const character of value) {
-    result ^= character.charCodeAt(0);
-    result = Math.imul(result, 16777619);
-  }
-  return result >>> 0;
-}
-function agentClassPalette(classIds) {
-  const unique = [...new Set(classIds.filter(Boolean))].sort();
-  const used = /* @__PURE__ */ new Set();
-  return Object.fromEntries(unique.map((id, index) => {
-    let hue = (hash(id) + index * 137.508) % 360;
-    while ([...used].some((candidate) => Math.abs(candidate - hue) < 18 || Math.abs(candidate - hue) > 342)) hue = (hue + 29) % 360;
-    used.add(hue);
-    return [id, `hsl(${hue.toFixed(1)} 82% 72%)`];
-  }));
-}
-function agentLabTotals(snapshot) {
-  const assignmentExecutions = snapshot.workdays.flatMap((workday) => workday.executions);
-  const executions = snapshot.workdays.flatMap((workday) => workday.providerExecutions.length ? workday.providerExecutions : workday.executions);
-  const activity = snapshot.workdays.flatMap((workday) => workday.activity);
-  const assertions = snapshot.workdays.flatMap((workday) => workday.assertions);
-  return {
-    workdays: snapshot.workdays.length,
-    workdaysCompleted: snapshot.workdays.filter((entry) => entry.status === "completed").length,
-    executions: executions.length,
-    completed: executions.filter((entry) => ["completed", "succeeded"].includes(entry.status)).length,
-    failed: executions.filter((entry) => ["failed", "error"].includes(entry.status)).length,
-    running: executions.filter((entry) => entry.status === "running").length,
-    agents: snapshot.agents.length,
-    agentsActive: new Set(assignmentExecutions.map((entry) => entry.agentId).filter(Boolean)).size,
-    classes: new Set(assignmentExecutions.map((entry) => entry.agentClassId).filter(Boolean)).size,
-    activities: new Set(activity.map((entry) => entry.id)).size,
-    assignments: new Set(snapshot.workdays.flatMap((entry) => entry.assignments).map((entry) => String(entry.id ?? ""))).size,
-    artifacts: assignmentExecutions.reduce((total, entry) => total + entry.artifacts.length, 0),
-    assertionsPassed: assertions.filter((entry) => entry.status === "passed").length,
-    assertionsFailed: assertions.filter((entry) => entry.status === "failed").length
-  };
-}
-function hasFailedContentToolRecord(value) {
-  if (!value || typeof value !== "object") return false;
-  if (!Array.isArray(value)) {
-    const item = value;
-    if (item.type === "mcp_tool_call" && item.status === "failed" && /^(?:treedx_|treeseed_content_)/u.test(String(item.tool ?? ""))) return true;
-  }
-  return Object.values(value).some(hasFailedContentToolRecord);
-}
-function hasFailedAgentLabContentTool(day) {
-  return day.executions.some((execution) => execution.transcript.some((item) => hasFailedContentToolRecord(item.payload)) || execution.evidence.some((item) => item.kind === "work-package" && /"id":"treedx-evidence-warnings"/u.test(JSON.stringify(item.detail)) && /TreeDX[^"\\]* failed/iu.test(JSON.stringify(item.detail))));
-}
-function initialAgentLabSnapshot(input) {
-  return {
-    schemaVersion: "treeseed.agent-simulation/v2",
-    sceneId: input.sceneId,
-    runId: input.runId,
-    status: "starting",
-    presentation: input.presentation,
-    timeZone: input.timeZone,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    team: { id: null, name: null, isolation: "ephemeral" },
-    provider: { id: null, membershipId: null, executionProviderId: "codex", status: "pending" },
-    repositories: input.repositories.map((slug) => ({ slug, projectId: null, repositoryId: null, ref: null })),
-    agents: [],
-    workdays: input.workdays.map((workday) => ({
-      id: workday.id,
-      title: workday.title ?? workday.id,
-      workdayRunId: null,
-      status: "pending",
-      startedAt: null,
-      finishedAt: null,
-      agentTests: workday.agentTests,
-      activity: [],
-      executions: [],
-      providerExecutions: [],
-      assignments: [],
-      governance: [],
-      accounting: {},
-      assertions: [],
-      diagnostics: []
-    })),
-    cleanup: { status: "pending", diagnostics: [] },
-    diagnostics: []
-  };
-}
-export {
-  agentClassPalette,
-  agentLabTotals,
-  hasFailedAgentLabContentTool,
-  initialAgentLabSnapshot,
-  sanitizeAgentLabSnapshot,
-  sanitizeAgentLabValue
-};

package/dist/scenes/agent-lab/report-writer.d.ts DELETED Viewed

@@ -1,14 +0,0 @@
-import type { AgentLabPresentationAdapter, AgentLabSnapshot } from '../types.js';
-export declare const AGENT_SIMULATOR_PORT = 4760;
-export declare function writeAgentLabHtml(path: string, adapter: AgentLabPresentationAdapter, snapshot: AgentLabSnapshot): Promise<void>;
-export type AgentLabLiveReport = {
-    url: string;
-    publish(snapshot: AgentLabSnapshot): Promise<void>;
-    close(): Promise<void>;
-};
-export declare function startAgentLabReportViewer(path: string): Promise<AgentLabLiveReport>;
-export declare function startAgentLabLiveReport(input: {
-    path: string;
-    adapter: AgentLabPresentationAdapter;
-    initial: AgentLabSnapshot;
-}): Promise<AgentLabLiveReport>;

package/dist/scenes/agent-lab/report-writer.js DELETED Viewed

@@ -1,143 +0,0 @@
-import { createServer } from "node:http";
-import { watchFile, unwatchFile } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-const AGENT_SIMULATOR_PORT = 4760;
-function simulatorPort() {
-  const configured = Number(process.env.TREESEED_AGENT_SIMULATOR_PORT ?? AGENT_SIMULATOR_PORT);
-  if (!Number.isInteger(configured) || configured < 1 || configured > 65535) throw new Error("TREESEED_AGENT_SIMULATOR_PORT must be a valid TCP port.");
-  return configured;
-}
-function listen(server) {
-  const port = simulatorPort();
-  return new Promise((resolve, reject) => {
-    server.once("error", (error) => reject(error.code === "EADDRINUSE" ? new Error(`Agent Lab is already active at http://127.0.0.1:${port}/. End or inspect that simulation before starting another.`) : error));
-    server.listen(port, "127.0.0.1", () => resolve(port));
-  });
-}
-async function writeAgentLabHtml(path, adapter, snapshot) {
-  await mkdir(dirname(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(temporary, adapter.render(snapshot), "utf8");
-  await rename(temporary, path);
-}
-function embeddedSnapshot(html) {
-  const marker = '<script type="application/json" id="agent-lab-data">';
-  const start = html.indexOf(marker);
-  const end = start < 0 ? -1 : html.indexOf("</script>", start + marker.length);
-  if (start < 0 || end < 0) throw new Error("The report does not contain embedded agent simulation evidence.");
-  return JSON.parse(html.slice(start + marker.length, end));
-}
-async function startAgentLabReportViewer(path) {
-  let html = await readFile(path, "utf8");
-  let snapshot = embeddedSnapshot(html);
-  let revision = 0;
-  const clients = /* @__PURE__ */ new Set();
-  const server = createServer((request, response) => {
-    if (request.url === "/status") {
-      response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
-      response.end(JSON.stringify({ ok: true, active: snapshot.status === "running" || snapshot.status === "starting", status: snapshot.status, sceneId: snapshot.sceneId, runId: snapshot.runId, generatedAt: snapshot.generatedAt }));
-      return;
-    }
-    if (request.url === "/snapshot") {
-      response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
-      response.end(JSON.stringify({ schemaVersion: "treeseed.agent-simulation-stream/v1", kind: "bootstrap", revision, snapshot }));
-      return;
-    }
-    if (request.url === "/events") {
-      response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
-      clients.add(response);
-      request.on("close", () => clients.delete(response));
-      return;
-    }
-    if (request.url !== "/" && request.url !== "/report.html") {
-      response.writeHead(404).end("Not found");
-      return;
-    }
-    response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
-    response.end(html);
-  });
-  const port = await listen(server);
-  const refresh = async () => {
-    try {
-      html = await readFile(path, "utf8");
-      snapshot = embeddedSnapshot(html);
-      revision += 1;
-      const message = `id: ${revision}
-event: delta
-data: ${JSON.stringify({ schemaVersion: "treeseed.agent-simulation-stream/v1", kind: "upsert", revision, entity: "simulation", id: snapshot.runId, value: snapshot })}
-`;
-      for (const client of clients) client.write(message);
-    } catch {
-    }
-  };
-  watchFile(path, { interval: 750 }, (current, previous) => {
-    if (current.mtimeMs !== previous.mtimeMs) void refresh();
-  });
-  return {
-    url: `http://127.0.0.1:${port}/`,
-    publish: async () => {
-    },
-    close: () => new Promise((resolve) => {
-      unwatchFile(path);
-      for (const client of clients) client.end();
-      server.close(() => resolve());
-    })
-  };
-}
-async function startAgentLabLiveReport(input) {
-  let snapshot = input.initial;
-  let revision = 0;
-  const clients = /* @__PURE__ */ new Set();
-  await writeAgentLabHtml(input.path, input.adapter, snapshot);
-  const server = createServer(async (request, response) => {
-    if (request.url === "/status") {
-      response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
-      response.end(JSON.stringify({ ok: true, active: snapshot.status === "running" || snapshot.status === "starting", status: snapshot.status, sceneId: snapshot.sceneId, runId: snapshot.runId, generatedAt: snapshot.generatedAt }));
-      return;
-    }
-    if (request.url === "/snapshot") {
-      response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
-      response.end(JSON.stringify({ schemaVersion: "treeseed.agent-simulation-stream/v1", kind: "bootstrap", revision, snapshot }));
-      return;
-    }
-    if (request.url === "/events") {
-      response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
-      clients.add(response);
-      request.on("close", () => clients.delete(response));
-      return;
-    }
-    if (request.url !== "/" && request.url !== "/report.html") {
-      response.writeHead(404).end("Not found");
-      return;
-    }
-    response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
-    response.end(input.adapter.render(snapshot));
-  });
-  const port = await listen(server);
-  return {
-    url: `http://127.0.0.1:${port}/`,
-    async publish(next) {
-      snapshot = next;
-      revision += 1;
-      await writeAgentLabHtml(input.path, input.adapter, snapshot);
-      const message = `id: ${revision}
-event: delta
-data: ${JSON.stringify({ schemaVersion: "treeseed.agent-simulation-stream/v1", kind: "upsert", revision, entity: "simulation", id: snapshot.runId, value: snapshot })}
-`;
-      for (const client of clients) client.write(message);
-    },
-    close: () => new Promise((resolve) => {
-      for (const client of clients) client.end();
-      server.close(() => resolve());
-    })
-  };
-}
-export {
-  AGENT_SIMULATOR_PORT,
-  startAgentLabLiveReport,
-  startAgentLabReportViewer,
-  writeAgentLabHtml
-};

package/dist/scenes/agent-lab/run-agent-lab-scene.d.ts DELETED Viewed

@@ -1,6 +0,0 @@
-import type { ScenePlanReport, SceneRunOptions, SceneRunReport, SceneValidationReport } from '../types.js';
-export declare function runAgentLabScene(input: {
-    options: SceneRunOptions;
-    validation: SceneValidationReport;
-    plan: ScenePlanReport;
-}): Promise<SceneRunReport>;

package/dist/scenes/agent-lab/run-agent-lab-scene.js DELETED Viewed

@@ -1,122 +0,0 @@
-import { join } from "node:path";
-import { renameSync, writeFileSync } from "node:fs";
-import { createSceneRunArtifacts, ensureSceneRunDirectories, writeSceneRunArtifacts } from "../support/evidence/artifacts.js";
-import { createSceneTimeline } from "../support/evidence/timeline.js";
-import { createSceneProgress } from "../support/reporting/progress.js";
-import { sceneErrorDiagnostic } from "../support/reporting/diagnostics.js";
-import { writeSceneMarkdownReport } from "../support/reporting/reporter.js";
-import { prepareSceneEnvironment } from "../configuration/environment.js";
-import { resolveSceneAuth } from "../accounts/auth.js";
-import { planOrApplySceneSeed } from "../seeds/seed.js";
-import { initialAgentLabSnapshot } from "./report-model.js";
-import { resolveAgentLabPresentation } from "./report-adapters.js";
-import { startAgentLabLiveReport } from "./report-writer.js";
-function terminalReport(input) {
-  const failed = input.snapshot.status === "failed" || input.diagnostics.some((entry) => entry.severity === "error");
-  const finishedAt = /* @__PURE__ */ new Date();
-  return {
-    ok: !failed,
-    phase: 5,
-    sceneId: input.snapshot.sceneId,
-    runId: input.snapshot.runId,
-    scenePath: input.validation.scenePath,
-    startedAt: input.startedAt.toISOString(),
-    finishedAt: finishedAt.toISOString(),
-    durationMs: Math.max(0, finishedAt.getTime() - input.startedAt.getTime()),
-    environment: input.plan.environment,
-    baseUrl: null,
-    browser: null,
-    device: null,
-    capture: null,
-    workflowStatus: failed ? "failed" : "passed",
-    steps: [],
-    failedStep: failed ? input.snapshot.workdays.find((entry) => entry.status === "failed")?.id ?? null : null,
-    assertions: [],
-    artifacts: input.artifacts,
-    timelinePath: input.artifacts.timelinePath,
-    playwrightTracePath: null,
-    videoPaths: [],
-    renderedVideoPaths: [],
-    logs: {},
-    setup: input.setup ?? null,
-    operations: [],
-    chapters: [],
-    segments: [],
-    checkpoints: [],
-    resumedFrom: null,
-    progressPath: input.artifacts.progressPath ?? null,
-    warnings: input.diagnostics.filter((entry) => entry.severity === "warning"),
-    blockers: input.diagnostics.filter((entry) => entry.severity === "error"),
-    diagnostics: input.diagnostics
-  };
-}
-async function runAgentLabScene(input) {
-  const scene = input.validation.scene, config = scene.agentLab, paths = input.plan.artifactPaths, startedAt = /* @__PURE__ */ new Date();
-  ensureSceneRunDirectories(paths);
-  const artifacts = createSceneRunArtifacts({ paths, playwrightTracePath: null });
-  writeFileSync(artifacts.progressPath, "", "utf8");
-  const timeline = createSceneTimeline({ sceneId: scene.id, runId: paths.runId, startedAtMs: startedAt.getTime() });
-  const progress = createSceneProgress({ sceneId: scene.id, runId: paths.runId, startedAtMs: startedAt.getTime(), progressPath: artifacts.progressPath, onProgress: input.options.onProgress });
-  const environmentReport = await (input.options.environmentAdapter ?? prepareSceneEnvironment)({ projectRoot: input.options.projectRoot, scene, environment: input.plan.environment, env: process.env });
-  const authReport = (input.options.authResolver ?? resolveSceneAuth)({ projectRoot: input.options.projectRoot, scene, environment: input.plan.environment });
-  const seedReport = await (input.options.seedRunner ?? planOrApplySceneSeed)({ projectRoot: input.options.projectRoot, scene, environment: input.plan.environment, auth: authReport, env: process.env });
-  const setup = { environment: environmentReport, auth: authReport, seed: seedReport };
-  const setupDiagnostics = [...environmentReport.diagnostics, ...authReport.diagnostics, ...seedReport.diagnostics];
-  let snapshot = initialAgentLabSnapshot({ sceneId: scene.id, runId: paths.runId, presentation: config.presentation, timeZone: config.timeZone, repositories: config.repositories, workdays: config.workdays });
-  const snapshotPath = join(paths.runRoot, "agent-lab-snapshot.json");
-  const writeSnapshot = () => {
-    const temporary = `${snapshotPath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(snapshot, null, 2)}
-`, "utf8");
-    renameSync(temporary, snapshotPath);
-  };
-  writeSnapshot();
-  const adapter = resolveAgentLabPresentation(config.presentation, input.options.agentLabPresentations);
-  const diagnostics = [...setupDiagnostics];
-  if (!adapter) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_presentation_unavailable", `Agent Lab presentation ${config.presentation} is unavailable.`, "agentLab.presentation"));
-  if (!input.options.agentLabExecutor) diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_executor_unavailable", "Agent Lab requires the CLI production capacity executor.", "agentLab"));
-  if (!adapter || !input.options.agentLabExecutor || setupDiagnostics.some((entry) => entry.severity === "error")) {
-    const report2 = terminalReport({ validation: input.validation, plan: input.plan, startedAt, snapshot: { ...snapshot, status: "failed" }, diagnostics, artifacts, setup });
-    writeSceneMarkdownReport(report2);
-    writeSceneRunArtifacts({ scene, plan: input.plan, report: report2, timeline: timeline.events });
-    return report2;
-  }
-  const live = await startAgentLabLiveReport({ path: paths.htmlReportPath, adapter, initial: snapshot });
-  await input.options.onAgentLabReportReady?.({ url: live.url, path: paths.htmlReportPath });
-  progress.push("scene.run.started", { title: scene.title, environment: input.plan.environment, reportUrl: live.url });
-  timeline.push("scene.start", { title: scene.title, environment: input.plan.environment, journey: "agent-lab", reportUrl: live.url });
-  try {
-    snapshot = await input.options.agentLabExecutor({
-      projectRoot: input.options.projectRoot,
-      contentRef: input.options.agentLabContentRef,
-      config,
-      sceneId: scene.id,
-      runId: paths.runId,
-      reportPath: paths.htmlReportPath,
-      onUpdate: async (update) => {
-        snapshot = update.snapshot;
-        writeSnapshot();
-        await live.publish(snapshot);
-        timeline.push("heartbeat", { status: snapshot.status, workdays: snapshot.workdays.map((entry) => ({ id: entry.id, status: entry.status, executions: entry.executions.length })) });
-        progress.push("scene.run.heartbeat", { status: snapshot.status, reportUrl: live.url });
-      }
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    diagnostics.push(sceneErrorDiagnostic("scene.agent_lab_execution_failed", message, "agentLab"));
-    snapshot = { ...snapshot, status: "failed", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), diagnostics: [...snapshot.diagnostics, message] };
-    writeSnapshot();
-    await live.publish(snapshot);
-  } finally {
-    await live.close();
-  }
-  timeline.push("scene.end", { status: snapshot.status, reportPath: paths.htmlReportPath });
-  progress.push("scene.run.finished", { ok: snapshot.status === "completed", reportPath: paths.htmlReportPath }, { status: snapshot.status });
-  const report = terminalReport({ validation: input.validation, plan: input.plan, startedAt, snapshot, diagnostics, artifacts, setup });
-  writeSceneMarkdownReport(report);
-  writeSceneRunArtifacts({ scene, plan: input.plan, report, timeline: timeline.events });
-  return report;
-}
-export {
-  runAgentLabScene
-};

package/dist/scenes/agent-lab/runtime/diagnostics.d.ts DELETED Viewed

@@ -1,7 +0,0 @@
-import type { AgentLabWorkdaySnapshot } from '../../types.js';
-export declare function agentLabDiagnostic(value: unknown, prefix?: string): string;
-export declare function withAgentLabDiagnostic(day: AgentLabWorkdaySnapshot, value: unknown, prefix?: string): AgentLabWorkdaySnapshot;
-export declare function localAgentLabApiConfig(env: Record<string, string | undefined>): {
-    apiUrl: string;
-    adminToken: string;
-};