@vm0/cli 9.209.3 → 9.210.0

package/{chunk-O6UJMPWI.js → chunk-6EGWCGWC.js}

@@ -60737,13 +60737,13 @@ function attributeValueToTypedAttributeValue(rawValue, useFallback) {
   if (!useFallback || useFallback === "skip-undefined" && value === void 0) {
     return;
   }
-  let stringValue = "";
+  let stringValue2 = "";
   try {
-    stringValue = JSON.stringify(value) ?? "";
+    stringValue2 = JSON.stringify(value) ?? "";
   } catch {
   }
   return {
-    value: stringValue,
+    value: stringValue2,
     type: "string",
     ...checkedUnit
   };
@@ -80408,7 +80408,7 @@ if (DSN) {
   init2({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.209.3",
+    release: "9.210.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -80427,7 +80427,7 @@ if (DSN) {
     }
   });
   setContext("cli", {
-    version: "9.209.3",
+    version: "9.210.0",
     command: process.argv.slice(2).join(" ")
   });
   setContext("runtime", {
@@ -86687,7 +86687,7 @@ function validateBaseUrlScheme(scheme, base, serviceName2) {
     throw new Error(errMsg(base, serviceName2, "scheme must be http or https"));
   }
 }
-function validateUrlSchemeDelimiter(value, serviceName2, label, displayValue = value) {
+function validateUrlSchemeDelimiter(value, serviceName2, label, displayValue2 = value) {
   if (value.includes("://")) return;
   const colonIndex = value.indexOf(":");
   if (colonIndex !== -1) {
@@ -86696,15 +86696,15 @@ function validateUrlSchemeDelimiter(value, serviceName2, label, displayValue = v
     const allowedScheme = label === "auth.base URL" ? scheme.toLowerCase() === REQUIRED_AUTH_BASE_URL_SCHEME : ALLOWED_BASE_URL_SCHEMES.has(scheme.toLowerCase());
     if (!allowedScheme) {
       throw new Error(
-        `Invalid ${label} "${displayValue}" in firewall "${serviceName2}": ${schemeDetail}`
+        `Invalid ${label} "${displayValue2}" in firewall "${serviceName2}": ${schemeDetail}`
       );
     }
     throw new Error(
-      `Invalid ${label} "${displayValue}" in firewall "${serviceName2}": URL must include "://" after the scheme`
+      `Invalid ${label} "${displayValue2}" in firewall "${serviceName2}": URL must include "://" after the scheme`
     );
   }
   throw new Error(
-    `Invalid ${label} "${displayValue}" in firewall "${serviceName2}": URL must include a scheme (e.g. "https://${displayValue}")`
+    `Invalid ${label} "${displayValue2}" in firewall "${serviceName2}": URL must include a scheme (e.g. "https://${displayValue2}")`
   );
 }
 function isAscii(value) {
@@ -89082,7 +89082,14 @@ var orgMessageResponseSchema = external_exports.object({
 
 // ../../packages/api-contracts/src/contracts/orgs.ts
 var c5 = initContract();
-var orgTierSchema = external_exports.enum(["free", "pro-suspend", "pro", "team"]);
+var orgTierSchema = external_exports.enum([
+  "free",
+  "limited-free-1",
+  "pro-suspend",
+  "pro",
+  "team"
+]);
+var ORG_TIER_SET = new Set(orgTierSchema.options);
 var orgSlugSchema = external_exports.string().min(3, "Org slug must be at least 3 characters").max(64, "Org slug must be at most 64 characters").regex(
   /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]{1,2}$/,
   "Org slug must contain only lowercase letters, numbers, and hyphens, and must start and end with an alphanumeric character"
@@ -90306,6 +90313,7 @@ var zeroModelPoliciesMainContract = c13.router({
       200: orgModelPoliciesResponseSchema,
       400: apiErrorSchema,
       401: apiErrorSchema,
+      402: apiErrorSchema,
       403: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -90530,7 +90538,7 @@ var paginationSchema = external_exports.object({
 });
 var listQuerySchema = external_exports.object({
   cursor: external_exports.string().optional(),
-  limit: external_exports.coerce.number().min(1).max(100).default(20)
+  limit: external_exports.coerce.number().int().min(1).max(100).default(20)
 });
 var c15 = initContract();
 var logStatusSchema = external_exports.enum([
@@ -90971,6 +90979,12 @@ var sequenceQueryNumberSchema = safeIntegerQueryNumberSchema.refine(
   },
   { message: "Sequence cursor is out of range" }
 );
+function boundedIntegerQueryNumberSchema(min, max) {
+  return external_exports.preprocess(
+    rejectBlankQueryNumber2,
+    external_exports.coerce.number().int().min(min).max(max)
+  );
+}
 function logSinceQuerySchema(cursorKind) {
   return cursorKind === "time" ? timestampQueryNumberSchema : sequenceQueryNumberSchema;
 }
@@ -91291,6 +91305,7 @@ var runNetworkLogsContract = c16.router({
 var searchResultSchema = external_exports.object({
   runId: external_exports.string(),
   agentName: external_exports.string(),
+  framework: external_exports.string().nullable().optional(),
   matchedEvent: runEventSchema,
   contextBefore: external_exports.array(runEventSchema),
   contextAfter: external_exports.array(runEventSchema)
@@ -91299,6 +91314,15 @@ var logsSearchResponseSchema = external_exports.object({
   results: external_exports.array(searchResultSchema),
   hasMore: external_exports.boolean()
 });
+var logsSearchQuerySchema = external_exports.object({
+  keyword: external_exports.string().trim().min(1),
+  agentId: external_exports.string().uuid().optional(),
+  runId: external_exports.string().uuid().optional(),
+  since: timestampQueryNumberSchema.optional(),
+  limit: boundedIntegerQueryNumberSchema(1, 50).default(20),
+  before: boundedIntegerQueryNumberSchema(0, 10).default(0),
+  after: boundedIntegerQueryNumberSchema(0, 10).default(0)
+});
 var logsSearchContract = c16.router({
   /**
    * GET /api/logs/search
@@ -91308,15 +91332,7 @@ var logsSearchContract = c16.router({
     method: "GET",
     path: "/api/logs/search",
     headers: authHeadersSchema,
-    query: external_exports.object({
-      keyword: external_exports.string().min(1),
-      agentId: external_exports.string().uuid().optional(),
-      runId: external_exports.string().optional(),
-      since: timestampQueryNumberSchema.optional(),
-      limit: external_exports.coerce.number().min(1).max(50).default(20),
-      before: external_exports.coerce.number().min(0).max(10).default(0),
-      after: external_exports.coerce.number().min(0).max(10).default(0)
-    }),
+    query: logsSearchQuerySchema,
     responses: {
       200: logsSearchResponseSchema,
       400: apiErrorSchema,
@@ -91946,6 +91962,7 @@ var chatThreadByIdContract = c18.router({
       204: c18.noBody(),
       400: apiErrorSchema,
       401: apiErrorSchema,
+      402: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Delete a chat thread",
@@ -92037,6 +92054,7 @@ var chatThreadModelSelectionContract = c18.router({
       204: c18.noBody(),
       400: apiErrorSchema,
       401: apiErrorSchema,
+      402: apiErrorSchema,
       404: apiErrorSchema
     },
     summary: "Update a chat thread model selection"
@@ -92179,7 +92197,7 @@ var chatSearchContract = c18.router({
     path: "/api/zero/chat/search",
     headers: authHeadersSchema,
     query: external_exports.object({
-      keyword: external_exports.string().min(1),
+      keyword: external_exports.string().trim().min(1),
       agentId: external_exports.string().uuid().optional(),
       since: external_exports.coerce.number().optional(),
       limit: external_exports.coerce.number().min(1).max(50).default(20),
@@ -94359,15 +94377,7 @@ var zeroLogsSearchContract = c27.router({
     method: "GET",
     path: "/api/zero/logs/search",
     headers: authHeadersSchema,
-    query: external_exports.object({
-      keyword: external_exports.string().min(1),
-      agentId: external_exports.string().uuid().optional(),
-      runId: external_exports.string().optional(),
-      since: timestampQueryNumberSchema.optional(),
-      limit: external_exports.coerce.number().min(1).max(50).default(20),
-      before: external_exports.coerce.number().min(0).max(10).default(0),
-      after: external_exports.coerce.number().min(0).max(10).default(0)
-    }),
+    query: logsSearchQuerySchema,
     responses: {
       200: logsSearchResponseSchema,
       400: apiErrorSchema,
@@ -95842,6 +95852,9 @@ var zeroWorkflowScheduleSchema = external_exports.discriminatedUnion("type", [
 var unattendedTriggerPermissionActionSchema = firewallPolicyValueSchema.exclude(["ask"]);
 var unattendedTriggerConnectorRefSchema = external_exports.string().min(1).max(64);
 var unattendedTriggerPermissionKeySchema = external_exports.string().min(1).max(128);
+var unattendedTriggerConnectorRefsSchema = external_exports.array(
+  unattendedTriggerConnectorRefSchema
+);
 var unattendedTriggerPermissionPolicySchema = external_exports.record(
   unattendedTriggerConnectorRefSchema,
   external_exports.object({
@@ -95852,6 +95865,7 @@ var unattendedTriggerPermissionPolicySchema = external_exports.record(
   })
 );
 var setUnattendedTriggerPermissionPolicyRequestSchema = external_exports.object({
+  unattendedConnectorRefs: unattendedTriggerConnectorRefsSchema.optional(),
   unattendedPermissionPolicy: unattendedTriggerPermissionPolicySchema.nullable()
 });
 var zeroWorkflowTriggerSummaryBaseSchema = external_exports.object({
@@ -95861,6 +95875,7 @@ var zeroWorkflowTriggerSummaryBaseSchema = external_exports.object({
   chatThreadId: external_exports.string().nullable(),
   nextRunAt: external_exports.string().datetime().nullable(),
   lastRunAt: external_exports.string().datetime().nullable(),
+  unattendedConnectorRefs: unattendedTriggerConnectorRefsSchema,
   unattendedPermissionPolicy: unattendedTriggerPermissionPolicySchema.nullable()
 });
 var zeroWorkflowScheduleTriggerSummarySchema = zeroWorkflowTriggerSummaryBaseSchema.extend({
@@ -96274,21 +96289,6 @@ var zeroWorkflowTriggersContract = c32.router({
     },
     summary: "Disable a workflow trigger"
   },
-  run: {
-    method: "POST",
-    path: "/api/zero/workflow-triggers/:id/run",
-    headers: authHeadersSchema,
-    pathParams: triggerIdParams,
-    body: c32.noBody(),
-    responses: {
-      200: external_exports.object({ runId: external_exports.string() }),
-      401: apiErrorSchema,
-      403: apiErrorSchema,
-      404: apiErrorSchema,
-      409: apiErrorSchema
-    },
-    summary: "Fire a one-off test run of a workflow trigger"
-  },
   setPermissionPolicy: {
     method: "PUT",
     path: "/api/zero/workflow-triggers/:id/permission-policy",
@@ -96408,13 +96408,6 @@ async function disableWorkflowTrigger(id) {
   if (result.status === 200) return result.body;
   handleError(result, `Failed to disable workflow trigger "${id}"`);
 }
-async function runWorkflowTrigger(id) {
-  const config3 = await getClientConfig();
-  const client = initClient(zeroWorkflowTriggersContract, config3);
-  const result = await client.run({ params: { id } });
-  if (result.status === 200) return result.body;
-  handleError(result, `Failed to run workflow trigger "${id}"`);
-}
 
 // src/lib/api/domains/integrations-slack.ts
 init_esm_shims();
@@ -101569,6 +101562,45 @@ async function removeEmptyDirs(dir, excludeDirs = [".vm0"]) {
   return isEmpty;
 }
 
+// ../../packages/core/src/frameworks.ts
+init_esm_shims();
+var SUPPORTED_FRAMEWORKS = ["claude-code", "codex"];
+function isSupportedFramework(framework) {
+  if (!framework) return false;
+  return SUPPORTED_FRAMEWORKS.includes(framework);
+}
+function assertSupportedFramework(framework, context2) {
+  if (!isSupportedFramework(framework)) {
+    const contextMsg = context2 ? ` in ${context2}` : "";
+    throw new Error(
+      `Unsupported framework "${framework}"${contextMsg}. Supported frameworks: ${SUPPORTED_FRAMEWORKS.join(", ")}`
+    );
+  }
+}
+function getValidatedFramework(framework) {
+  if (framework === void 0) {
+    return "claude-code";
+  }
+  assertSupportedFramework(framework);
+  return framework;
+}
+var FRAMEWORK_DISPLAY_NAMES = {
+  "claude-code": "Claude Code",
+  codex: "Codex"
+};
+function getFrameworkDisplayName(framework) {
+  assertSupportedFramework(framework);
+  return FRAMEWORK_DISPLAY_NAMES[framework];
+}
+var FRAMEWORK_INSTRUCTIONS_FILENAMES = {
+  "claude-code": "CLAUDE.md",
+  codex: "AGENTS.md"
+};
+function getInstructionsFilename(framework) {
+  const validated = getValidatedFramework(framework);
+  return FRAMEWORK_INSTRUCTIONS_FILENAMES[validated];
+}
+
 // ../../packages/core/src/resource-registry.ts
 init_esm_shims();
 var PRESENTATION_REQUIRED_RESOURCE_IDS = [
@@ -109811,6 +109843,26 @@ var onboardingSetupContract = c63.router({
     summary: "Complete admin onboarding in a single request"
   }
 });
+var onboardingCompleteLimitedFreeContract = c63.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/onboarding/complete-limited-free",
+    headers: authHeadersSchema,
+    body: external_exports.object({}).strict(),
+    responses: {
+      200: external_exports.object({
+        agentId: external_exports.string(),
+        tier: external_exports.literal("limited-free-1"),
+        needsOnboarding: external_exports.literal(false)
+      }),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      409: apiErrorSchema
+    },
+    summary: "Complete onboarding and enter the limited free tier"
+  }
+});
 
 // ../../packages/api-contracts/src/contracts/skills.ts
 init_esm_shims();
@@ -112142,45 +112194,6 @@ function getInstructionsStorageName(agentName) {
 // ../../packages/core/src/github-url.ts
 init_esm_shims();
 
-// ../../packages/core/src/frameworks.ts
-init_esm_shims();
-var SUPPORTED_FRAMEWORKS = ["claude-code", "codex"];
-function isSupportedFramework(framework) {
-  if (!framework) return false;
-  return SUPPORTED_FRAMEWORKS.includes(framework);
-}
-function assertSupportedFramework(framework, context2) {
-  if (!isSupportedFramework(framework)) {
-    const contextMsg = context2 ? ` in ${context2}` : "";
-    throw new Error(
-      `Unsupported framework "${framework}"${contextMsg}. Supported frameworks: ${SUPPORTED_FRAMEWORKS.join(", ")}`
-    );
-  }
-}
-function getValidatedFramework(framework) {
-  if (framework === void 0) {
-    return "claude-code";
-  }
-  assertSupportedFramework(framework);
-  return framework;
-}
-var FRAMEWORK_DISPLAY_NAMES = {
-  "claude-code": "Claude Code",
-  codex: "Codex"
-};
-function getFrameworkDisplayName(framework) {
-  assertSupportedFramework(framework);
-  return FRAMEWORK_DISPLAY_NAMES[framework];
-}
-var FRAMEWORK_INSTRUCTIONS_FILENAMES = {
-  "claude-code": "CLAUDE.md",
-  codex: "AGENTS.md"
-};
-function getInstructionsFilename(framework) {
-  const validated = getValidatedFramework(framework);
-  return FRAMEWORK_INSTRUCTIONS_FILENAMES[validated];
-}
-
 // ../../packages/core/src/feature-switch-key.ts
 init_esm_shims();
 
@@ -112678,207 +112691,766 @@ var ClaudeEventParser = class {
 
 // src/lib/events/codex-event-parser.ts
 init_esm_shims();
+var MAX_FORMATTED_ARRAY_ITEMS = 6;
+var MAX_FORMATTED_ARRAY_DEPTH = 4;
+var MAX_FORMATTED_OBJECT_FIELDS = 8;
+var MAX_FORMATTED_OBJECT_INSPECTED_FIELDS = 16;
+var MAX_FORMATTED_TEXT_LENGTH = 240;
+var MAX_ERROR_SIGNAL_DEPTH = 8;
+var MAX_FORMATTED_PLAN_STEPS = 20;
+var MAX_FORMATTED_FILE_CHANGES = 20;
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function hasOwnKey(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function nonEmptyStringValue(value) {
+  const valueString = stringValue(value);
+  return valueString && valueString.length > 0 ? valueString : void 0;
+}
+function trimmedStringValue(value) {
+  const valueString = stringValue(value)?.trim();
+  return valueString && valueString.length > 0 ? valueString : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getFirstString(record, keys) {
+  for (const key of keys) {
+    const value = trimmedStringValue(record[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function getFirstNumber(record, keys) {
+  for (const key of keys) {
+    const value = numberValue(record[key]);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function truncate2(text) {
+  if (text.length <= MAX_FORMATTED_TEXT_LENGTH) {
+    return text;
+  }
+  return `${text.slice(0, MAX_FORMATTED_TEXT_LENGTH - 3)}...`;
+}
+function formatScalar(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0 ? truncate2(value) : void 0;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return truncate2(String(value));
+  }
+  return void 0;
+}
+function hasSignalValue(value, depth = 0) {
+  if (value === null || value === void 0 || value === false) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  if (typeof value === "boolean") {
+    return true;
+  }
+  if (depth >= MAX_ERROR_SIGNAL_DEPTH) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    if (depth >= MAX_FORMATTED_ARRAY_DEPTH) {
+      return false;
+    }
+    return value.slice(0, MAX_FORMATTED_ARRAY_ITEMS).some((item) => {
+      return hasSignalValue(item, depth + 1);
+    });
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return false;
+  }
+  let inspectedFields = 0;
+  for (const key in record) {
+    if (!hasOwnKey(record, key)) {
+      continue;
+    }
+    if (inspectedFields >= MAX_FORMATTED_OBJECT_INSPECTED_FIELDS) {
+      return false;
+    }
+    inspectedFields += 1;
+    if (hasSignalValue(record[key], depth + 1)) {
+      return true;
+    }
+  }
+  return false;
+}
+function formatUnknownValue(value, depth = 0) {
+  const scalar = formatScalar(value);
+  if (scalar !== void 0) {
+    return scalar;
+  }
+  if (Array.isArray(value)) {
+    if (depth >= MAX_FORMATTED_ARRAY_DEPTH) {
+      return "...";
+    }
+    const items = value.slice(0, MAX_FORMATTED_ARRAY_ITEMS).map((item) => {
+      return formatUnknownValue(item, depth + 1);
+    }).filter((item) => {
+      return item !== void 0 && item.length > 0;
+    });
+    if (items.length === 0) {
+      return void 0;
+    }
+    const suffix = value.length > MAX_FORMATTED_ARRAY_ITEMS ? ", ..." : "";
+    return `[${items.join(", ")}${suffix}]`;
+  }
+  const record = asRecord(value);
+  if (!record || depth > 0) {
+    return void 0;
+  }
+  const fields = [];
+  let inspectedFields = 0;
+  for (const key in record) {
+    if (!hasOwnKey(record, key)) {
+      continue;
+    }
+    if (fields.length >= MAX_FORMATTED_OBJECT_FIELDS || inspectedFields >= MAX_FORMATTED_OBJECT_INSPECTED_FIELDS) {
+      fields.push("...");
+      break;
+    }
+    inspectedFields += 1;
+    const fieldValue = record[key];
+    const formatted = formatUnknownValue(fieldValue, depth + 1);
+    if (formatted !== void 0) {
+      fields.push(`${key}=${formatted}`);
+    }
+  }
+  return fields.length > 0 ? `{${fields.join(", ")}}` : void 0;
+}
+function formatSignalValue(value, includeBoundedPlaceholder = false) {
+  if (value === null || value === void 0 || value === false) {
+    return void 0;
+  }
+  const formatted = formatUnknownValue(value);
+  if (!formatted) {
+    return void 0;
+  }
+  if (hasSignalValue(value)) {
+    return formatted;
+  }
+  return includeBoundedPlaceholder && formatted.includes("...") ? formatted : void 0;
+}
+function combineDistinctMessages(first, second) {
+  const messages = [];
+  for (const message of [first, second]) {
+    const trimmed = message?.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const containingIndex = messages.findIndex((existing) => {
+      return existing === trimmed || existing.includes(trimmed);
+    });
+    if (containingIndex !== -1) {
+      continue;
+    }
+    const containedIndex = messages.findIndex((existing) => {
+      return trimmed.includes(existing);
+    });
+    if (containedIndex !== -1) {
+      messages[containedIndex] = trimmed;
+      continue;
+    }
+    messages.push(trimmed);
+  }
+  return messages.length > 0 ? messages.join("\n") : void 0;
+}
+function isGenericFailureMessage(message) {
+  const normalized = message.trim().toLowerCase().replace(/[\s.:!?]+$/u, "");
+  return normalized === "error" || normalized === "turn failed" || normalized === "turn interrupted" || normalized === "unknown error" || normalized === "codex error";
+}
+function combineResultWithError(result, errorMessage) {
+  if (result === void 0 || result.length === 0) {
+    return errorMessage;
+  }
+  if (!errorMessage) {
+    return result;
+  }
+  const trimmedResult = result.trim();
+  if (!trimmedResult) {
+    return errorMessage;
+  }
+  if (trimmedResult === errorMessage || trimmedResult.includes(errorMessage)) {
+    return result;
+  }
+  if (errorMessage.includes(trimmedResult)) {
+    return errorMessage;
+  }
+  return `${result}
+${errorMessage}`;
+}
+function formatDetailSuffix(details) {
+  return details.length > 0 ? ` (${details.join("; ")})` : "";
+}
+function extractErrorMessage(value, depth = 0) {
+  if (value === null || value === void 0 || value === false) {
+    return void 0;
+  }
+  const direct = trimmedStringValue(value);
+  if (direct) {
+    return direct;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return hasSignalValue(value, depth) ? formatUnknownValue(value) : void 0;
+  }
+  const message = getFirstString(record, ["message"]) ?? getFirstString(record, ["error", "code", "failureReason"]);
+  const details = [
+    getFirstString(record, ["additional_details", "additionalDetails"]),
+    getFirstString(record, ["codex_error_info", "codexErrorInfo"]),
+    formatSignalValue(record.connectors, message !== void 0)
+  ].filter((detail) => {
+    return detail !== void 0 && detail.length > 0;
+  });
+  if (message) {
+    const uniqueDetails = details.filter((detail) => {
+      return !message.includes(detail);
+    });
+    return `${message}${formatDetailSuffix(uniqueDetails)}`;
+  }
+  if (details.length > 0) {
+    return details.join("; ");
+  }
+  if (depth >= MAX_ERROR_SIGNAL_DEPTH) {
+    return void 0;
+  }
+  const nested = extractErrorMessage(record.error, depth + 1);
+  if (nested) {
+    return nested;
+  }
+  return hasSignalValue(record, depth) ? formatUnknownValue(record) : void 0;
+}
+function extractEventErrorMessage(event) {
+  return combineDistinctMessages(
+    trimmedStringValue(event.message),
+    extractErrorMessage(event.error)
+  );
+}
+function getTurnRecord(event) {
+  return asRecord(event.turn);
+}
+function getTurnId(event) {
+  const topLevelId = getFirstString(event, ["turn_id", "turnId"]);
+  if (topLevelId) {
+    return topLevelId;
+  }
+  const turn = getTurnRecord(event);
+  return turn ? getFirstString(turn, ["id"]) : void 0;
+}
+function getTurnStatus(event) {
+  const turn = getTurnRecord(event);
+  return (turn ? getFirstString(turn, ["status"]) : void 0) ?? getFirstString(event, ["status"]);
+}
+var FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "aborted",
+  "cancelled",
+  "canceled",
+  "declined",
+  "error",
+  "failed",
+  "interrupted",
+  "timed_out",
+  "timeout"
+]);
+var SUCCESSFUL_TURN_COMPLETION_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "success",
+  "succeeded"
+]);
+function isFailedStatus(status) {
+  return status !== void 0 && FAILED_STATUSES.has(status.toLowerCase());
+}
+function isUnsuccessfulTurnCompletionStatus(status) {
+  return status !== void 0 && !SUCCESSFUL_TURN_COMPLETION_STATUSES.has(status.toLowerCase());
+}
+function hasExtractableError(value) {
+  return extractErrorMessage(value) !== void 0;
+}
+function hasTurnCompletionError(event, turn) {
+  return turn !== null && hasExtractableError(turn.error) || hasExtractableError(event.error);
+}
+function getTurnErrorMessage(event, turn) {
+  const turnMessage = turn !== null ? extractErrorMessage(turn.error) : void 0;
+  const eventMessage = extractEventErrorMessage(event);
+  if (turnMessage && eventMessage && isGenericFailureMessage(eventMessage)) {
+    return turnMessage;
+  }
+  return combineDistinctMessages(turnMessage, eventMessage);
+}
+function getUsage(event) {
+  const turn = getTurnRecord(event);
+  return asRecord(event.usage) ?? (turn ? asRecord(turn.usage) : null) ?? {};
+}
+function getTurnDurationMs(event, turn) {
+  return (turn ? getFirstNumber(turn, ["duration_ms", "durationMs"]) : void 0) ?? getFirstNumber(event, ["duration_ms", "durationMs"]) ?? 0;
+}
+function getItem(event) {
+  return asRecord(event.item);
+}
+function getItemId(item) {
+  return getFirstString(item, ["id"]);
+}
+function getItemType(item) {
+  return getFirstString(item, ["type"]);
+}
+function getItemStatus(item) {
+  return getFirstString(item, ["status"]);
+}
+function getItemErrorMessage(item) {
+  return extractErrorMessage(item.error);
+}
+function shouldRenderGenericItemFailure(eventType, item) {
+  return eventType === "item.completed" && (isFailedStatus(getItemStatus(item)) || getItemErrorMessage(item) !== void 0);
+}
+function formatPlanStatus(status) {
+  if (status === "completed") return "completed";
+  if (status === "in_progress") return "in progress";
+  if (status === "pending") return "pending";
+  return status ?? "step";
+}
+function formatPlanLines(plan) {
+  if (!Array.isArray(plan)) {
+    return [];
+  }
+  const lines = plan.slice(0, MAX_FORMATTED_PLAN_STEPS).map((step) => {
+    const stepRecord = asRecord(step);
+    if (!stepRecord) {
+      return void 0;
+    }
+    const text = trimmedStringValue(stepRecord.step);
+    if (!text) {
+      return void 0;
+    }
+    const status = formatPlanStatus(trimmedStringValue(stepRecord.status));
+    return `- ${status}: ${text}`;
+  }).filter((line) => {
+    return line !== void 0;
+  });
+  const remaining = plan.length - MAX_FORMATTED_PLAN_STEPS;
+  if (remaining > 0) {
+    lines.push(`- ... +${remaining} more steps`);
+  }
+  return lines;
+}
+function formatGenericItem(item) {
+  const itemType = getItemType(item);
+  if (!itemType) {
+    return void 0;
+  }
+  const fields = [itemType];
+  const id = getItemId(item);
+  if (id) {
+    fields.push(`id=${id}`);
+  }
+  const status = getItemStatus(item);
+  if (status) {
+    fields.push(`status=${status}`);
+  }
+  let inspectedFields = 0;
+  for (const key in item) {
+    if (!hasOwnKey(item, key)) {
+      continue;
+    }
+    if (key === "id" || key === "type" || key === "status") {
+      continue;
+    }
+    if (fields.length >= MAX_FORMATTED_OBJECT_FIELDS + 3 || inspectedFields >= MAX_FORMATTED_OBJECT_INSPECTED_FIELDS) {
+      fields.push("...");
+      break;
+    }
+    inspectedFields += 1;
+    const value = item[key];
+    const formatted = formatUnknownValue(value);
+    if (formatted !== void 0) {
+      fields.push(`${key}=${formatted}`);
+    }
+  }
+  return `[item] ${fields.join(" ")}`;
+}
+function formatFileChangeAction(kind) {
+  if (kind === "add") return "Created";
+  if (kind === "modify") return "Modified";
+  if (kind === "delete") return "Deleted";
+  return "Changed";
+}
 var CodexEventParser = class {
   /**
-   * Parse a raw Codex CLI JSONL event into a simplified format
-   * Returns null if the event type is unknown or malformed
+   * Parse a raw Codex JSONL event into the shared CLI parsed-event format.
+   * Returns null if the event type is unknown or too malformed to display.
    */
   static parse(rawEvent) {
-    if (!rawEvent || typeof rawEvent !== "object" || !("type" in rawEvent)) {
+    const event = asRecord(rawEvent);
+    if (!event) {
+      return null;
+    }
+    const eventType = stringValue(event.type);
+    if (!eventType) {
       return null;
     }
-    const eventType = rawEvent.type;
     if (eventType === "thread.started") {
-      return this.parseThreadStarted(rawEvent);
+      return this.parseThreadStarted(event);
     }
     if (eventType === "turn.completed") {
-      return this.parseTurnCompleted(rawEvent);
+      return this.parseTurnCompleted(event);
     }
     if (eventType === "turn.failed") {
-      return this.parseTurnFailed(rawEvent);
+      return this.parseTurnFailed(event);
+    }
+    if (eventType === "turn.plan.updated") {
+      return this.parseTurnPlanUpdated(event);
+    }
+    if (eventType === "warning") {
+      return this.parseWarning(event);
     }
     if (eventType.startsWith("item.")) {
-      return this.parseItemEvent(rawEvent);
+      return this.parseItemEvent(event, eventType);
     }
     if (eventType === "error") {
-      return this.parseErrorEvent(rawEvent);
+      return this.parseErrorEvent(event);
     }
     return null;
   }
   static parseThreadStarted(event) {
+    const threadId2 = getFirstString(event, ["thread_id", "threadId"]);
+    if (!threadId2) {
+      return null;
+    }
     return {
       type: "init",
       timestamp: /* @__PURE__ */ new Date(),
       data: {
         framework: "codex",
-        sessionId: event.thread_id,
+        sessionId: threadId2,
         tools: []
       }
     };
   }
   static parseTurnCompleted(event) {
+    const status = getTurnStatus(event);
+    const turn = getTurnRecord(event);
+    const turnId = getTurnId(event);
+    const durationMs = getTurnDurationMs(event, turn);
+    if (isUnsuccessfulTurnCompletionStatus(status) || hasTurnCompletionError(event, turn)) {
+      const result = getTurnErrorMessage(event, turn) ?? (status ? `Turn ${status}` : "Turn failed");
+      return {
+        type: "result",
+        timestamp: /* @__PURE__ */ new Date(),
+        data: {
+          success: false,
+          result,
+          durationMs,
+          numTurns: 1,
+          cost: 0,
+          usage: getUsage(event),
+          ...turnId ? { turnId } : {}
+        }
+      };
+    }
     return {
       type: "result",
       timestamp: /* @__PURE__ */ new Date(),
       data: {
         success: true,
         result: "",
-        durationMs: 0,
+        durationMs,
         numTurns: 1,
         cost: 0,
-        usage: event.usage || {}
+        usage: getUsage(event),
+        ...turnId ? { turnId } : {}
       }
     };
   }
   static parseTurnFailed(event) {
+    const turn = getTurnRecord(event);
+    const turnId = getTurnId(event);
     return {
       type: "result",
       timestamp: /* @__PURE__ */ new Date(),
       data: {
         success: false,
-        result: event.error || "Turn failed",
-        durationMs: 0,
+        result: getTurnErrorMessage(event, turn) ?? "Turn failed",
+        durationMs: getTurnDurationMs(event, turn),
         numTurns: 1,
         cost: 0,
-        usage: {}
+        usage: getUsage(event),
+        ...turnId ? { turnId } : {}
+      }
+    };
+  }
+  static parseTurnPlanUpdated(event) {
+    const lines = formatPlanLines(event.plan);
+    const explanation = trimmedStringValue(event.explanation);
+    if (lines.length === 0 && !explanation) {
+      return null;
+    }
+    return {
+      type: "text",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        text: ["[plan]", explanation, ...lines].filter((line) => {
+          return line !== void 0 && line.length > 0;
+        }).join("\n")
       }
     };
   }
-  static parseItemEvent(event) {
-    const item = event.item;
+  static parseWarning(event) {
+    const message = extractEventErrorMessage(event);
+    if (!message) {
+      return null;
+    }
+    return {
+      type: "text",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: { text: `[warning] ${message}` }
+    };
+  }
+  static parseItemEvent(event, eventType) {
+    const item = getItem(event);
     if (!item) {
       return null;
     }
-    const itemType = item.type;
-    if (itemType === "agent_message" && item.text) {
-      return { type: "text", timestamp: /* @__PURE__ */ new Date(), data: { text: item.text } };
+    const itemType = getItemType(item);
+    if (!itemType) {
+      return null;
+    }
+    if (itemType === "agent_message") {
+      return this.parseTextItem(eventType, item, (text) => {
+        return text;
+      });
     }
     if (itemType === "command_execution") {
-      return this.parseCommandExecution(event);
+      return this.parseCommandExecution(eventType, item);
     }
     if (itemType === "file_edit" || itemType === "file_write") {
-      return this.parseFileEditOrWrite(event);
+      return this.parseFileEditOrWrite(eventType, item);
     }
     if (itemType === "file_read") {
-      return this.parseFileRead(event);
+      return this.parseFileRead(eventType, item);
     }
     if (itemType === "file_change") {
       return this.parseFileChange(item);
     }
-    if (itemType === "reasoning" && item.text) {
+    if (itemType === "reasoning") {
+      return this.parseTextItem(eventType, item, (text) => {
+        return `[thinking] ${text}`;
+      });
+    }
+    if (itemType === "plan") {
+      return this.parseTextItem(eventType, item, (text) => {
+        return `[plan]
+${text}`;
+      });
+    }
+    if (eventType === "item.completed") {
+      return this.parseGenericCompletedItem(item);
+    }
+    return null;
+  }
+  static parseTextItem(eventType, item, formatText) {
+    const text = trimmedStringValue(item.text);
+    if (text) {
       return {
         type: "text",
         timestamp: /* @__PURE__ */ new Date(),
-        data: { text: `[thinking] ${item.text}` }
+        data: { text: formatText(text) }
       };
     }
-    return null;
+    return shouldRenderGenericItemFailure(eventType, item) ? this.parseGenericCompletedItem(item) : null;
   }
-  static parseCommandExecution(event) {
-    const item = event.item;
-    if (event.type === "item.started" && item.command) {
+  static parseGenericCompletedItem(item) {
+    const text = formatGenericItem(item);
+    return text ? { type: "text", timestamp: /* @__PURE__ */ new Date(), data: { text } } : null;
+  }
+  static parseCommandExecution(eventType, item) {
+    const itemId = getItemId(item);
+    const command = trimmedStringValue(item.command);
+    if (!itemId) {
+      return null;
+    }
+    if (eventType === "item.started" && command) {
       return {
         type: "tool_use",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
           tool: "Bash",
-          toolUseId: item.id,
-          input: { command: item.command }
+          toolUseId: itemId,
+          input: { command }
         }
       };
     }
-    if (event.type === "item.completed") {
-      const output = item.aggregated_output ?? item.output ?? "";
+    if (eventType === "item.completed") {
+      const output = nonEmptyStringValue(item.aggregated_output) ?? nonEmptyStringValue(item.output) ?? "";
+      const status = getItemStatus(item);
+      const exitCode = numberValue(item.exit_code);
+      const errorMessage = getItemErrorMessage(item);
+      const isError2 = (exitCode !== void 0 ? exitCode !== 0 : false) || isFailedStatus(status) || errorMessage !== void 0;
       return {
         type: "tool_result",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
-          toolUseId: item.id,
-          result: output,
-          isError: item.exit_code !== 0
+          tool: "Bash",
+          toolUseId: itemId,
+          input: command ? { command } : {},
+          result: combineResultWithError(output, errorMessage) ?? (isFailedStatus(status) ? `Command ${status}` : ""),
+          isError: isError2
         }
       };
     }
     return null;
   }
-  static parseFileEditOrWrite(event) {
-    const item = event.item;
-    if (event.type === "item.started" && item.path) {
+  static parseFileEditOrWrite(eventType, item) {
+    const itemId = getItemId(item);
+    const path4 = trimmedStringValue(item.path);
+    if (!itemId) {
+      return null;
+    }
+    if (eventType === "item.started" && path4) {
       return {
         type: "tool_use",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
-          tool: item.type === "file_edit" ? "Edit" : "Write",
-          toolUseId: item.id,
-          input: { file_path: item.path }
+          tool: getItemType(item) === "file_edit" ? "Edit" : "Write",
+          toolUseId: itemId,
+          input: { file_path: path4 }
         }
       };
     }
-    if (event.type === "item.completed") {
+    if (eventType === "item.completed") {
+      const status = getItemStatus(item);
+      const tool = getItemType(item) === "file_edit" ? "Edit" : "Write";
+      const errorMessage = getItemErrorMessage(item);
       return {
         type: "tool_result",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
-          toolUseId: item.id,
-          result: item.diff || "File operation completed",
-          isError: false
+          tool,
+          toolUseId: itemId,
+          input: path4 ? { file_path: path4 } : {},
+          result: combineResultWithError(
+            nonEmptyStringValue(item.diff),
+            errorMessage
+          ) ?? (isFailedStatus(status) ? `File operation ${status}` : "File operation completed"),
+          isError: isFailedStatus(status) || errorMessage !== void 0
         }
       };
     }
     return null;
   }
-  static parseFileRead(event) {
-    const item = event.item;
-    if (event.type === "item.started" && item.path) {
+  static parseFileRead(eventType, item) {
+    const itemId = getItemId(item);
+    const path4 = trimmedStringValue(item.path);
+    if (!itemId) {
+      return null;
+    }
+    if (eventType === "item.started" && path4) {
       return {
         type: "tool_use",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
           tool: "Read",
-          toolUseId: item.id,
-          input: { file_path: item.path }
+          toolUseId: itemId,
+          input: { file_path: path4 }
         }
       };
     }
-    if (event.type === "item.completed") {
+    if (eventType === "item.completed") {
+      const status = getItemStatus(item);
+      const output = nonEmptyStringValue(item.output);
+      const errorMessage = getItemErrorMessage(item);
       return {
         type: "tool_result",
         timestamp: /* @__PURE__ */ new Date(),
         data: {
-          toolUseId: item.id,
-          result: "File read completed",
-          isError: false
+          tool: "Read",
+          toolUseId: itemId,
+          input: path4 ? { file_path: path4 } : {},
+          result: combineResultWithError(output, errorMessage) ?? (isFailedStatus(status) ? `File read ${status}` : "File read completed"),
+          isError: isFailedStatus(status) || errorMessage !== void 0
         }
       };
     }
     return null;
   }
   static parseFileChange(item) {
-    if (!item.changes || item.changes.length === 0) {
+    const status = getItemStatus(item);
+    const errorMessage = getItemErrorMessage(item);
+    const lines = Array.isArray(item.changes) ? item.changes.slice(0, MAX_FORMATTED_FILE_CHANGES).map((change) => {
+      const changeRecord = asRecord(change);
+      if (!changeRecord) {
+        return void 0;
+      }
+      const path4 = trimmedStringValue(changeRecord.path);
+      if (!path4) {
+        return void 0;
+      }
+      const action = formatFileChangeAction(
+        trimmedStringValue(changeRecord.kind)
+      );
+      return `${action}: ${path4}`;
+    }).filter((line) => {
+      return line !== void 0;
+    }) : [];
+    if (Array.isArray(item.changes) && item.changes.length > MAX_FORMATTED_FILE_CHANGES) {
+      lines.push(
+        `... +${item.changes.length - MAX_FORMATTED_FILE_CHANGES} more changes`
+      );
+    }
+    if (lines.length === 0 && !isFailedStatus(status) && !errorMessage) {
       return null;
     }
-    const changes = item.changes.map((c101) => {
-      const action = c101.kind === "add" ? "Created" : c101.kind === "modify" ? "Modified" : "Deleted";
-      return `${action}: ${c101.path}`;
-    }).join("\n");
+    const statusLine = isFailedStatus(status) ? `Status: ${status}` : void 0;
+    const errorLine = errorMessage ? `Error: ${errorMessage}` : void 0;
     return {
       type: "text",
       timestamp: /* @__PURE__ */ new Date(),
-      data: { text: `[files]
-${changes}` }
+      data: {
+        text: ["[files]", statusLine, errorLine, ...lines].filter((line) => {
+          return line !== void 0 && line.length > 0;
+        }).join("\n")
+      }
     };
   }
   static parseErrorEvent(event) {
+    const turn = getTurnRecord(event);
+    const turnId = getTurnId(event);
+    const hasTurnContext = turn !== null || turnId !== void 0;
     return {
       type: "result",
       timestamp: /* @__PURE__ */ new Date(),
       data: {
         success: false,
-        result: event.message || event.error || "Unknown error",
-        durationMs: 0,
-        numTurns: 0,
+        result: getTurnErrorMessage(event, turn) ?? "Unknown error",
+        durationMs: getTurnDurationMs(event, turn),
+        numTurns: hasTurnContext ? 1 : 0,
         cost: 0,
-        usage: {}
+        usage: getUsage(event),
+        ...turnId ? { turnId } : {}
       }
     };
   }
@@ -112894,7 +113466,7 @@ function parseEvent(rawEvent, framework) {
 }
 
 // src/lib/events/event-stream-normalizer.ts
-function asRecord(rawEvent) {
+function asRecord2(rawEvent) {
   if (!rawEvent || typeof rawEvent !== "object") {
     return null;
   }
@@ -112904,13 +113476,72 @@ function getEventType(rawEvent) {
   const eventType = rawEvent?.type;
   return typeof eventType === "string" ? eventType : void 0;
 }
+function stringData(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isFailureResult(event) {
+  return event?.type === "result" && event.data.success === false;
+}
+function isTopLevelCodexError(eventType, parsed) {
+  return eventType === "error" && isFailureResult(parsed);
+}
+function isTerminalCodexFailure(eventType, parsed) {
+  if (!isFailureResult(parsed)) {
+    return false;
+  }
+  return eventType === "turn.failed" || eventType === "turn.completed";
+}
+function getParsedTurnId(event) {
+  return stringData(event.data.turnId);
+}
+function getResultText(event) {
+  return stringData(event.data.result);
+}
+function combineDistinctMessages2(first, second) {
+  const messages = [];
+  for (const message of [first, second]) {
+    if (!message) {
+      continue;
+    }
+    const containingIndex = messages.findIndex((existing) => {
+      return existing === message || existing.includes(message);
+    });
+    if (containingIndex !== -1) {
+      continue;
+    }
+    const containedIndex = messages.findIndex((existing) => {
+      return message.includes(existing);
+    });
+    if (containedIndex !== -1) {
+      messages[containedIndex] = message;
+      continue;
+    }
+    messages.push(message);
+  }
+  return messages.length > 0 ? messages.join("\n") : void 0;
+}
+function attachFramework(parsed, framework) {
+  if (!parsed || !framework || parsed.data.framework !== void 0) {
+    return parsed;
+  }
+  return {
+    ...parsed,
+    data: {
+      ...parsed.data,
+      framework
+    }
+  };
+}
 var EventStreamNormalizer = class {
   pendingCodexError = null;
   process(rawEvent, framework, timestamp) {
     const isCodex = framework === "codex";
-    const rawRecord = asRecord(rawEvent);
+    const rawRecord = asRecord2(rawEvent);
     const eventType = getEventType(rawRecord);
-    const parsed = rawRecord ? parseEvent(rawRecord, framework) : null;
+    const parsed = attachFramework(
+      rawRecord ? parseEvent(rawRecord, framework) : null,
+      framework
+    );
     if (parsed && timestamp) {
       parsed.timestamp = timestamp;
     }
@@ -112921,19 +113552,44 @@ var EventStreamNormalizer = class {
       }
       return output2;
     }
-    if (eventType === "error" && parsed?.type === "result") {
+    if (isTopLevelCodexError(eventType, parsed)) {
       const output2 = this.flush();
       this.pendingCodexError = parsed;
       return output2;
     }
-    if (eventType === "turn.failed") {
+    if (isTerminalCodexFailure(eventType, parsed)) {
+      if (this.pendingCodexError) {
+        const pendingTurnId = getParsedTurnId(this.pendingCodexError);
+        const terminalTurnId = getParsedTurnId(parsed);
+        const shouldCollapse = !pendingTurnId || terminalTurnId !== void 0 && pendingTurnId === terminalTurnId;
+        if (shouldCollapse) {
+          const mergedResult = combineDistinctMessages2(
+            getResultText(this.pendingCodexError),
+            getResultText(parsed)
+          );
+          this.pendingCodexError = null;
+          return [
+            {
+              ...parsed,
+              data: {
+                ...parsed.data,
+                ...mergedResult ? { result: mergedResult } : {}
+              }
+            }
+          ];
+        }
+        const output2 = this.flush();
+        output2.push(parsed);
+        return output2;
+      }
       this.pendingCodexError = null;
-      return parsed ? [parsed] : [];
+      return [parsed];
     }
-    const output = this.flush();
-    if (parsed) {
-      output.push(parsed);
+    if (!parsed) {
+      return [];
     }
+    const output = this.flush();
+    output.push(parsed);
     return output;
   }
   flush() {
@@ -112946,18 +113602,42 @@ var EventStreamNormalizer = class {
   }
 };
 
+// src/lib/utils/time-format.ts
+init_esm_shims();
+function formatIsoTimestamp(value) {
+  const timestamp = value instanceof Date ? value : new Date(value);
+  if (!Number.isFinite(timestamp.getTime())) {
+    return "invalid-date";
+  }
+  return timestamp.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
 // src/lib/events/event-renderer.ts
 init_esm_shims();
 
 // src/lib/events/tool-formatters.ts
 init_esm_shims();
+var MAX_FORMATTED_TODOS = 20;
 function pluralize(count, singular, plural) {
   return count === 1 ? singular : plural;
 }
-function truncate2(text, maxLength) {
+function truncate3(text, maxLength) {
   if (text.length <= maxLength) return text;
   return text.slice(0, maxLength - 3) + "...";
 }
+function displayValue(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function nonEmptyDisplayValue(value) {
+  const display = displayValue(value);
+  return display.length > 0 ? display : void 0;
+}
+function recordValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
 function formatToolHeader(data) {
   const { tool, input } = data;
   const headline = getToolHeadline(tool, input);
@@ -112965,31 +113645,31 @@ function formatToolHeader(data) {
 }
 var toolHeadlineFormatters = {
   Read: (input) => {
-    return `Read${source_default.dim(`(${String(input.file_path || "")})`)}`;
+    return `Read${source_default.dim(`(${displayValue(input.file_path)})`)}`;
   },
   Edit: (input) => {
-    return `Edit${source_default.dim(`(${String(input.file_path || "")})`)}`;
+    return `Edit${source_default.dim(`(${displayValue(input.file_path)})`)}`;
   },
   Write: (input) => {
-    return `Write${source_default.dim(`(${String(input.file_path || "")})`)}`;
+    return `Write${source_default.dim(`(${displayValue(input.file_path)})`)}`;
   },
   Bash: (input) => {
-    return `Bash${source_default.dim(`(${truncate2(String(input.command || ""), 60)})`)}`;
+    return `Bash${source_default.dim(`(${truncate3(displayValue(input.command), 60)})`)}`;
   },
   Glob: (input) => {
-    return `Glob${source_default.dim(`(${String(input.pattern || "")})`)}`;
+    return `Glob${source_default.dim(`(${displayValue(input.pattern)})`)}`;
   },
   Grep: (input) => {
-    return `Grep${source_default.dim(`(${String(input.pattern || "")})`)}`;
+    return `Grep${source_default.dim(`(${displayValue(input.pattern)})`)}`;
   },
   Task: (input) => {
-    return `Task${source_default.dim(`(${truncate2(String(input.description || ""), 60)})`)}`;
+    return `Task${source_default.dim(`(${truncate3(displayValue(input.description), 60)})`)}`;
   },
   WebFetch: (input) => {
-    return `WebFetch${source_default.dim(`(${truncate2(String(input.url || ""), 60)})`)}`;
+    return `WebFetch${source_default.dim(`(${truncate3(displayValue(input.url), 60)})`)}`;
   },
   WebSearch: (input) => {
-    return `WebSearch${source_default.dim(`(${truncate2(String(input.query || ""), 60)})`)}`;
+    return `WebSearch${source_default.dim(`(${truncate3(displayValue(input.query), 60)})`)}`;
   },
   TodoWrite: () => {
     return "TodoWrite";
@@ -113003,28 +113683,18 @@ function formatToolResult(toolUse, result, verbose) {
   const { tool, input } = toolUse;
   const { result: resultText, isError: isError2 } = result;
   const lines = [];
-  if (tool === "Read" && !isError2 && resultText) {
-    const readLines = formatReadContent(resultText, verbose);
-    lines.push(...readLines);
-    return lines;
-  }
-  if (tool === "TodoWrite" && !isError2) {
-    const todoLines = formatTodoList(input);
-    lines.push(...todoLines);
-    return lines;
-  }
-  if (tool === "Edit" && !isError2) {
-    const editLines = formatEditDiff(input, verbose);
-    lines.push(...editLines);
-    return lines;
-  }
-  if (tool === "Write" && !isError2) {
-    const writeLines = formatWritePreview(input, verbose);
-    lines.push(...writeLines);
-    return lines;
+  const specialLines = formatSpecialToolResult(
+    tool,
+    input,
+    resultText,
+    isError2,
+    verbose
+  );
+  if (specialLines) {
+    return specialLines;
   }
   if (isError2) {
-    const errorMsg = resultText ? truncate2(resultText, 80) : "Error";
+    const errorMsg = resultText ? truncate3(resultText, 80) : "Error";
     lines.push(`\u2514 \u2717 ${source_default.dim(errorMsg)}`);
     return lines;
   }
@@ -113053,6 +113723,30 @@ function formatToolResult(toolUse, result, verbose) {
   }
   return lines;
 }
+function formatSpecialToolResult(tool, input, resultText, isError2, verbose) {
+  if (isError2) {
+    return null;
+  }
+  if (tool === "Read" && resultText) {
+    return formatReadContent(resultText, verbose);
+  }
+  if (tool === "TodoWrite") {
+    return formatTodoList(input);
+  }
+  if (tool === "Edit" && hasClaudeEditInput(input)) {
+    return formatEditDiff(input, verbose);
+  }
+  if (tool === "Write" && hasClaudeWriteInput(input)) {
+    return formatWritePreview(input, verbose);
+  }
+  return null;
+}
+function hasClaudeEditInput(input) {
+  return typeof input.old_string === "string" || typeof input.new_string === "string";
+}
+function hasClaudeWriteInput(input) {
+  return typeof input.content === "string";
+}
 function formatReadContent(resultText, verbose) {
   const lines = [];
   const rawLines = resultText.split("\n");
@@ -113064,9 +113758,7 @@ function formatReadContent(resultText, verbose) {
       contentLines.push(match[1] ?? "");
     }
   }
-  const displayLines = contentLines.length > 0 ? contentLines : rawLines.filter((line) => {
-    return line.trim().length > 0;
-  });
+  const displayLines = contentLines.length > 0 ? contentLines : rawLines;
   const totalLines = displayLines.length;
   if (totalLines === 0) {
     lines.push(`\u2514 \u2713 ${source_default.dim("(empty)")}`);
@@ -113094,7 +113786,7 @@ function formatReadContent(resultText, verbose) {
 }
 function formatWritePreview(input, verbose) {
   const lines = [];
-  const content = String(input.content || "");
+  const content = displayValue(input.content);
   const contentLines = content.split("\n");
   const totalLines = contentLines.length;
   if (verbose) {
@@ -113119,8 +113811,8 @@ function formatWritePreview(input, verbose) {
 }
 function formatEditDiff(input, verbose) {
   const lines = [];
-  const oldString = String(input.old_string || "");
-  const newString = String(input.new_string || "");
+  const oldString = displayValue(input.old_string);
+  const newString = displayValue(input.new_string);
   const oldLines = oldString.split("\n");
   const newLines = newString.split("\n");
   const removed = oldLines.length;
@@ -113139,7 +113831,7 @@ function formatEditDiff(input, verbose) {
     const showOld = Math.min(previewLimit, oldLines.length);
     const showNew = Math.min(previewLimit, newLines.length);
     for (let i = 0; i < showOld; i++) {
-      lines.push(`  - ${source_default.dim(truncate2(oldLines[i] ?? "", 60))}`);
+      lines.push(`  - ${source_default.dim(truncate3(oldLines[i] ?? "", 60))}`);
     }
     const remainingOld = oldLines.length - previewLimit;
     if (remainingOld > 0) {
@@ -113148,7 +113840,7 @@ function formatEditDiff(input, verbose) {
       );
     }
     for (let i = 0; i < showNew; i++) {
-      lines.push(`  + ${source_default.dim(truncate2(newLines[i] ?? "", 60))}`);
+      lines.push(`  + ${source_default.dim(truncate3(newLines[i] ?? "", 60))}`);
     }
     const remainingNew = newLines.length - previewLimit;
     if (remainingNew > 0) {
@@ -113162,19 +113854,30 @@ function formatEditDiff(input, verbose) {
 function formatTodoList(input) {
   const lines = [];
   const todos = input.todos;
-  if (!todos || !Array.isArray(todos)) {
+  if (!Array.isArray(todos)) {
     lines.push("\u2514 \u2713 Done");
     return lines;
   }
-  for (let i = 0; i < todos.length; i++) {
-    const todo = todos[i];
-    const content = todo.content || "Unknown task";
-    const status = todo.status || "pending";
+  if (todos.length === 0) {
+    lines.push("\u2514 \u2713 Done");
+    return lines;
+  }
+  const displayedTodos = todos.slice(0, MAX_FORMATTED_TODOS);
+  for (let i = 0; i < displayedTodos.length; i++) {
+    const todo = recordValue(displayedTodos[i]);
+    const content = nonEmptyDisplayValue(todo?.content) ?? "Unknown task";
+    const status = nonEmptyDisplayValue(todo?.status) ?? "pending";
     const icon = getTodoStatusIcon(status);
     const styledContent = formatTodoContent(content, status);
     const prefix = i === 0 ? "\u2514 " : "  ";
     lines.push(`${prefix}${icon} ${styledContent}`);
   }
+  const remaining = todos.length - MAX_FORMATTED_TODOS;
+  if (remaining > 0) {
+    lines.push(
+      `  ${source_default.dim(`\u2026 +${remaining} ${pluralize(remaining, "task", "tasks")} (vm0 logs <runId> to see all)`)}`
+    );
+  }
   return lines;
 }
 function getTodoStatusIcon(status) {
@@ -113201,8 +113904,23 @@ function formatTodoContent(content, status) {
 }
 
 // src/lib/events/event-renderer.ts
+function recordData(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+function displayString(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function displayNonNegativeNumber(value) {
+  const number = typeof value === "number" ? value : typeof value === "string" && value.trim().length > 0 ? Number(value) : void 0;
+  return number !== void 0 && Number.isFinite(number) && number >= 0 ? number : 0;
+}
 var EventRenderer = class _EventRenderer {
   pendingToolUse = /* @__PURE__ */ new Map();
+  ambiguousToolUseIds = /* @__PURE__ */ new Set();
+  ambiguousRenderedToolUses = /* @__PURE__ */ new Map();
   options;
   lastEventType = null;
   frameworkDisplayName = "Agent";
@@ -113226,7 +113944,7 @@ var EventRenderer = class _EventRenderer {
    * Format timestamp for display (without milliseconds, matching metrics format)
    */
   static formatTimestamp(timestamp) {
-    return timestamp.toISOString().replace(/\.\d{3}Z$/, "Z");
+    return formatIsoTimestamp(timestamp);
   }
   /**
    * Render a parsed event to console
@@ -113235,9 +113953,11 @@ var EventRenderer = class _EventRenderer {
     const timestampPrefix = this.options.showTimestamp ? `[${_EventRenderer.formatTimestamp(event.timestamp)}] ` : "";
     switch (event.type) {
       case "init":
+        this.renderPendingToolUses();
         this.renderInit(event, timestampPrefix);
         break;
       case "text":
+        this.renderPendingToolUses();
         this.renderText(event, timestampPrefix);
         break;
       case "tool_use":
@@ -113247,10 +113967,30 @@ var EventRenderer = class _EventRenderer {
         this.handleToolResult(event, timestampPrefix);
         break;
       case "result":
+        this.renderPendingToolUses();
         this.renderResult(event, timestampPrefix);
         break;
     }
   }
+  /**
+   * Render any buffered display state that cannot wait for a future event.
+   */
+  flush() {
+    this.renderPendingToolUses();
+    this.pendingToolUse.clear();
+    this.ambiguousToolUseIds.clear();
+    this.ambiguousRenderedToolUses.clear();
+  }
+  renderPendingToolUses() {
+    for (const pending of this.pendingToolUse.values()) {
+      if (pending.rendered) {
+        continue;
+      }
+      const { toolUse, prefix } = pending;
+      this.renderToolUseOnly(toolUse, prefix);
+      pending.rendered = true;
+    }
+  }
   /**
    * Render run completed state
    * Note: This is run lifecycle status, not an event
@@ -113305,12 +114045,30 @@ var EventRenderer = class _EventRenderer {
    * or render immediately (when not buffered, e.g., historical log viewing)
    */
   handleToolUse(event, prefix) {
-    const toolUseId = String(event.data.toolUseId || "");
-    const tool = String(event.data.tool || "");
-    const input = event.data.input || {};
+    const toolUseId = displayString(event.data.toolUseId);
+    const tool = displayString(event.data.tool);
+    const input = recordData(event.data.input);
     const toolUseData = { tool, input };
-    if (this.options.buffered !== false) {
-      this.pendingToolUse.set(toolUseId, { toolUse: toolUseData, prefix });
+    if (this.options.buffered !== false && toolUseId.length > 0) {
+      const existing = this.pendingToolUse.get(toolUseId);
+      if (existing || this.ambiguousToolUseIds.has(toolUseId)) {
+        if (existing) {
+          if (!existing.rendered) {
+            this.renderToolUseOnly(existing.toolUse, existing.prefix);
+          }
+          this.rememberAmbiguousRenderedToolUse(toolUseId, existing.toolUse);
+        }
+        this.pendingToolUse.delete(toolUseId);
+        this.ambiguousToolUseIds.add(toolUseId);
+        this.renderToolUseOnly(toolUseData, prefix);
+        this.rememberAmbiguousRenderedToolUse(toolUseId, toolUseData);
+        return;
+      }
+      this.pendingToolUse.set(toolUseId, {
+        toolUse: toolUseData,
+        prefix,
+        rendered: false
+      });
     } else {
       this.renderToolUseOnly(toolUseData, prefix);
     }
@@ -113338,14 +114096,69 @@ var EventRenderer = class _EventRenderer {
    * Handle tool_result event - lookup buffered tool_use and render grouped
    */
   handleToolResult(event, prefix) {
-    const toolUseId = String(event.data.toolUseId || "");
-    const result = String(event.data.result || "");
+    const toolUseId = displayString(event.data.toolUseId);
+    const result = displayString(event.data.result);
     const isError2 = Boolean(event.data.isError);
+    if (toolUseId.length > 0 && this.ambiguousToolUseIds.has(toolUseId)) {
+      const orphanToolUse2 = this.getToolUseFromResultEvent(event);
+      const renderedToolUse = orphanToolUse2 ? this.getMatchingAmbiguousRenderedToolUse(toolUseId, orphanToolUse2) : void 0;
+      if (renderedToolUse) {
+        this.renderToolResultOnly(renderedToolUse, { result, isError: isError2 }, prefix);
+        return;
+      }
+      if (orphanToolUse2) {
+        this.renderGroupedTool(orphanToolUse2, { result, isError: isError2 }, prefix);
+      }
+      return;
+    }
     const pending = this.pendingToolUse.get(toolUseId);
     if (pending) {
-      this.renderGroupedTool(pending.toolUse, { result, isError: isError2 }, prefix);
+      if (pending.rendered) {
+        this.renderToolResultOnly(pending.toolUse, { result, isError: isError2 }, prefix);
+      } else {
+        this.renderGroupedTool(pending.toolUse, { result, isError: isError2 }, prefix);
+      }
       this.pendingToolUse.delete(toolUseId);
+      return;
+    }
+    const orphanToolUse = this.getToolUseFromResultEvent(event);
+    if (orphanToolUse) {
+      this.renderGroupedTool(orphanToolUse, { result, isError: isError2 }, prefix);
+    }
+  }
+  getToolUseFromResultEvent(event) {
+    const tool = event.data.tool;
+    if (typeof tool !== "string" || tool.length === 0) {
+      return null;
+    }
+    return {
+      tool,
+      input: recordData(event.data.input)
+    };
+  }
+  rememberAmbiguousRenderedToolUse(toolUseId, toolUse) {
+    const renderedToolUses = this.ambiguousRenderedToolUses.get(toolUseId);
+    if (renderedToolUses) {
+      renderedToolUses.push(toolUse);
+      return;
+    }
+    this.ambiguousRenderedToolUses.set(toolUseId, [toolUse]);
+  }
+  getMatchingAmbiguousRenderedToolUse(toolUseId, toolUse) {
+    const renderedToolUses = this.ambiguousRenderedToolUses.get(toolUseId);
+    if (!renderedToolUses) {
+      return void 0;
+    }
+    for (let index = renderedToolUses.length - 1; index >= 0; index -= 1) {
+      const renderedToolUse = renderedToolUses[index];
+      if (renderedToolUse !== void 0 && this.hasSameToolHeader(renderedToolUse, toolUse)) {
+        return renderedToolUse;
+      }
     }
+    return void 0;
+  }
+  hasSameToolHeader(first, second) {
+    return formatToolHeader(first).join("\n") === formatToolHeader(second).join("\n");
   }
   /**
    * Get continuation prefix (simple indent, no timestamp alignment)
@@ -113377,12 +114190,30 @@ var EventRenderer = class _EventRenderer {
     console.log();
     this.lastEventType = "tool";
   }
+  renderToolResultOnly(toolUse, result, prefix) {
+    if (this.lastEventType === "text") {
+      console.log();
+    }
+    const verbose = this.options.verbose ?? false;
+    const cont = this.getContinuationPrefix();
+    const resultLines = formatToolResult(toolUse, result, verbose);
+    for (let i = 0; i < resultLines.length; i++) {
+      const line = resultLines[i];
+      if (i === 0) {
+        console.log(prefix + cont + line);
+      } else {
+        console.log(cont + line);
+      }
+    }
+    console.log();
+    this.lastEventType = "tool";
+  }
   renderInit(event, prefix) {
-    const frameworkStr = String(event.data.framework || "claude-code");
+    const frameworkStr = displayString(event.data.framework) || "claude-code";
     const displayName = isSupportedFramework(frameworkStr) ? getFrameworkDisplayName(frameworkStr) : frameworkStr;
     this.frameworkDisplayName = displayName;
     console.log(prefix + source_default.bold(`\u25B7 ${displayName} Started`));
-    console.log(`  Session: ${source_default.dim(String(event.data.sessionId || ""))}`);
+    console.log(`  Session: ${source_default.dim(displayString(event.data.sessionId))}`);
     if (event.data.model) {
       console.log(`  Model: ${source_default.dim(String(event.data.model))}`);
     }
@@ -113395,29 +114226,38 @@ var EventRenderer = class _EventRenderer {
     this.lastEventType = "init";
   }
   renderText(event, prefix) {
-    const text = String(event.data.text || "");
+    const text = displayString(event.data.text);
     console.log(prefix + "\u25CF " + text);
     this.lastEventType = "text";
   }
   renderResult(event, prefix) {
     console.log();
     const success = Boolean(event.data.success);
+    const eventFramework = displayString(event.data.framework);
+    const displayName = eventFramework && isSupportedFramework(eventFramework) ? getFrameworkDisplayName(eventFramework) : eventFramework || this.frameworkDisplayName;
+    this.frameworkDisplayName = displayName;
     if (success) {
-      console.log(
-        prefix + source_default.bold(`\u25C6 ${this.frameworkDisplayName} Completed`)
-      );
+      console.log(prefix + source_default.bold(`\u25C6 ${displayName} Completed`));
     } else {
-      console.log(prefix + source_default.bold(`\u25C6 ${this.frameworkDisplayName} Failed`));
+      console.log(prefix + source_default.bold(`\u25C6 ${displayName} Failed`));
+      const result = displayString(event.data.result).trim();
+      if (result.length > 0) {
+        const [firstLine, ...restLines] = result.split("\n");
+        console.log(`  Error: ${source_default.red(firstLine)}`);
+        for (const line of restLines) {
+          console.log(`         ${source_default.red(line)}`);
+        }
+      }
     }
-    const durationMs = Number(event.data.durationMs || 0);
+    const durationMs = displayNonNegativeNumber(event.data.durationMs);
     const durationSec = (durationMs / 1e3).toFixed(1);
     console.log(`  Duration: ${source_default.dim(durationSec + "s")}`);
-    const numTurns = Number(event.data.numTurns || 0);
+    const numTurns = displayNonNegativeNumber(event.data.numTurns);
     console.log(`  Turns: ${source_default.dim(String(numTurns))}`);
     const usage = event.data.usage;
     if (usage && typeof usage === "object") {
-      const inputTokens = Number(usage.input_tokens || 0);
-      const outputTokens = Number(usage.output_tokens || 0);
+      const inputTokens = displayNonNegativeNumber(usage.input_tokens);
+      const outputTokens = displayNonNegativeNumber(usage.output_tokens);
       const formatTokens = (count) => {
         if (count >= 1e3) {
           return Math.floor(count / 1e3) + "k";
@@ -113522,8 +114362,9 @@ Expected format: '{"ref": {"permissions": {"perm": "allow|deny|ask"}}}'`
   }
   return result.data;
 }
+var UUID_PATTERN2 = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
 function isUUID(str) {
-  return /^[0-9a-f-]{36}$/i.test(str);
+  return UUID_PATTERN2.test(str);
 }
 function extractVarNames(composeContent) {
   const grouped = extractAndGroupVariables(composeContent);
@@ -113606,6 +114447,9 @@ var POLL_INTERVAL_MS = 1e3;
 var TERMINAL_DRAIN_POLL_INTERVAL_MS = 500;
 var TERMINAL_DRAIN_IDLE_MS = 1e3;
 var TERMINAL_DRAIN_MAX_MS = 3e3;
+function supportedEventFramework(framework) {
+  return isSupportedFramework(framework) ? framework : void 0;
+}
 function isTerminalRunState(run) {
   return TERMINAL_RUN_STATUSES.includes(run.status);
 }
@@ -113707,6 +114551,7 @@ async function pollEvents(runId, options) {
     for (const parsed of normalizer.flush()) {
       renderer.render(parsed);
     }
+    renderer.flush();
   };
   for (; ; ) {
     const previousSequence = nextSequence;
@@ -113720,7 +114565,7 @@ async function pollEvents(runId, options) {
       for (const event of response.events) {
         const parsedEvents = normalizer.process(
           event.eventData,
-          response.framework
+          supportedEventFramework(response.framework)
         );
         for (const parsed of parsedEvents) {
           renderer.render(parsed);
@@ -113947,6 +114792,17 @@ function parsePositiveLogCount(value, optionName) {
   }
   return count;
 }
+function parseBoundedLogCount(value, optionName, min, max) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`${optionName} must be between ${min} and ${max}`);
+  }
+  const count = Number(trimmed);
+  if (!Number.isSafeInteger(count) || count < min || count > max) {
+    throw new Error(`${optionName} must be between ${min} and ${max}`);
+  }
+  return count;
+}
 async function collectLogItems(options) {
   const collected = [];
   const seenCursors = /* @__PURE__ */ new Set();
@@ -113960,9 +114816,6 @@ async function collectLogItems(options) {
       order: options.order
     });
     collected.push(...page.items);
-    if (page.items.length === 0) {
-      break;
-    }
     if (options.targetCount !== "all" && collected.length >= options.targetCount) {
       break;
     }
@@ -113977,6 +114830,16 @@ async function collectLogItems(options) {
   return options.order === "desc" ? entries.reverse() : entries;
 }
 
+// src/lib/utils/search-query.ts
+init_esm_shims();
+function parseSearchQuery(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} cannot be empty.`);
+  }
+  return trimmed;
+}
+
 export {
   InvalidArgumentError,
   Command,
@@ -114079,7 +114942,6 @@ export {
   deleteWorkflowTrigger,
   enableWorkflowTrigger,
   disableWorkflowTrigger,
-  runWorkflowTrigger,
   createGoal,
   editGoal,
   getGoal,
@@ -114161,6 +115023,7 @@ export {
   excludeVm0Filter,
   listTarFiles,
   removeExtraFiles,
+  isSupportedFramework,
   getInstructionsFilename,
   PRESENTATION_REQUIRED_RESOURCE_IDS,
   listImageStyles,
@@ -114177,8 +115040,8 @@ export {
   selectResourceCandidates,
   matchFirewallBaseUrl,
   findMatchingPermissions,
-  parseEvent,
   EventStreamNormalizer,
+  formatIsoTimestamp,
   EventRenderer,
   collectKeyValue,
   collectVolumeVersions,
@@ -114200,7 +115063,9 @@ export {
   promptConfirm,
   promptPassword,
   parsePositiveLogCount,
-  collectLogItems
+  parseBoundedLogCount,
+  collectLogItems,
+  parseSearchQuery
 };
 /*! Bundled license information:
 
@@ -114210,4 +115075,4 @@ undici/lib/web/fetch/body.js:
 undici/lib/web/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-O6UJMPWI.js.map
+//# sourceMappingURL=chunk-6EGWCGWC.js.map