@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-6VHUGVNP.js → chunk-ODEIDKGW.js}

@@ -1,58 +1,19 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="85084307-fe97-5ecd-bfa8-3c803663a33c")}catch(e){}}();
-import {
-  runDocs
-} from "./chunk-X2MGQMZO.js";
-import {
-  scanHistoryDrift
-} from "./chunk-NVZ6NVHJ.js";
-import {
-  runFiles
-} from "./chunk-AFGKSHAM.js";
-import {
-  isRemoteLinkedArtifactReference
-} from "./chunk-H5IOT54C.js";
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b111adf0-7ac6-5083-9fb7-c9a093abf43b")}catch(e){}}();
 import {
   runUpdate
-} from "./chunk-YIIIAKCE.js";
-import {
-  wrapOwnershipConflict
-} from "./chunk-ILVOOAT4.js";
-import {
-  PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
-  TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
-  TELEMETRY_SCHEMA_VERSION,
-  flushTelemetryQueueNow
-} from "./chunk-EY7ZE3TG.js";
+} from "./chunk-MRXAHR4B.js";
 import {
   buildCapabilityContractMetadata,
   buildRegistrationCollisionRemediation,
   collectUnknownCapabilityGuidance,
   readManagedExtensionState,
   runInit
-} from "./chunk-QRZNCRNA.js";
+} from "./chunk-MI3346YW.js";
 import {
   collectStaleVectorizationIds,
   runNext
-} from "./chunk-XPUTSGJU.js";
-import {
-  collectDanglingDependencyReferences,
-  createRelationshipKindRegistry
-} from "./chunk-L5BTTDU5.js";
-import {
-  computeContentFieldUtilization
-} from "./chunk-NCVT6XEL.js";
-import {
-  computeMetadataCoverage,
-  groupItemsByDimension,
-  lifecycleClassifierFromStatusRegistry
-} from "./chunk-CKX4WOPC.js";
-import {
-  parseLimit
-} from "./chunk-PT7MCCGD.js";
-import {
-  resolveAuthor
-} from "./chunk-CUFW7ITY.js";
+} from "./chunk-CZA2DXCV.js";
 import {
   buildVectorizationEmbeddingIdentity,
   hasVectorizationEmbeddingIdentityChanged,
@@ -62,7 +23,10 @@ import {
   resolveProviderConfigSource,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-E4FXM2XB.js";
+} from "./chunk-UE7LK3RE.js";
+import {
+  scanHistoryDrift
+} from "./chunk-XXWDEQ6O.js";
 import {
   ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
   ACTIVITY_FLAG_CONTRACTS,
@@ -154,7 +118,10 @@ import {
   UPGRADE_FLAG_CONTRACTS,
   VALIDATE_FLAG_CONTRACTS,
   compactFlagAliasContracts
-} from "./chunk-7UCY6DR5.js";
+} from "./chunk-JPWUZOMR.js";
+import {
+  wrapOwnershipConflict
+} from "./chunk-Y2VSGFT4.js";
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -171,12 +138,41 @@ import {
   parseLinkedTestRegexList,
   parseLinkedTestStringList,
   runCreate
-} from "./chunk-HTXXXF45.js";
+} from "./chunk-BDC4TW4B.js";
+import {
+  collectDanglingDependencyReferences
+} from "./chunk-77XFQRTD.js";
+import {
+  runDocs
+} from "./chunk-LT5UWU7H.js";
+import {
+  runFiles
+} from "./chunk-YGEA4CLH.js";
+import {
+  isRemoteLinkedArtifactReference
+} from "./chunk-VSQE43NO.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-FHOBCGQO.js";
+} from "./chunk-SVAWG7EE.js";
+import {
+  computeContentFieldUtilization
+} from "./chunk-YG56M3NE.js";
+import {
+  computeMetadataCoverage,
+  groupItemsByDimension,
+  lifecycleClassifierFromStatusRegistry
+} from "./chunk-XKVHL3MB.js";
+import {
+  parseLimit
+} from "./chunk-FIUTBFC6.js";
+import {
+  readHistoryEntries
+} from "./chunk-M4B4RK4J.js";
+import {
+  resolveAuthor
+} from "./chunk-CUFW7ITY.js";
 import {
   CURRENT_ITEM_FORMAT_VERSION,
   compareTimestampStrings,
@@ -203,7 +199,7 @@ import {
   stableValueEquals,
   toItemRecord,
   writeSettings
-} from "./chunk-P22HGFFI.js";
+} from "./chunk-QFG4MB7P.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -218,9 +214,12 @@ import {
   SCOPE_VALUES,
   SETTINGS_DEFAULTS,
   activateExtensions,
+  appendLineAtomic,
   collectRegisteredItemFieldNames,
   commandOptionFlagLabel,
+  createRelationshipKindRegistry,
   ensureDir,
+  getHistoryPath,
   getItemFormatFromPath,
   getSettingsPath,
   getTestRunRecordPath,
@@ -239,17 +238,1821 @@ import {
   resolveCommandOptionPolicyState,
   resolveGlobalPmRoot,
   resolveItemTypeRegistry,
+  resolvePmPackageRootFromModule,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
+  resolveTelemetryErrorCategory,
   statusIsTerminal,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-KX62NMZC.js";
+} from "./chunk-D35WYXWC.js";
+
+// dist/core/telemetry/observability.js
+var SETUP_ROOT_COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "config",
+  "completion",
+  "completion-statuses",
+  "completion-tags",
+  "completion-types"
+]);
+var QUERY_ROOT_COMMANDS = /* @__PURE__ */ new Set([
+  "list",
+  "list-all",
+  "list-open",
+  "list-in-progress",
+  "list-blocked",
+  "list-closed",
+  "list-canceled",
+  "list-draft",
+  "search",
+  "get",
+  "context",
+  "calendar",
+  "history",
+  "activity",
+  "aggregate",
+  "deps",
+  "contracts",
+  "stats"
+]);
+var MUTATION_ROOT_COMMANDS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "update-many",
+  "close-many",
+  "append",
+  "close",
+  "delete",
+  "restore",
+  "claim",
+  "release",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "docs",
+  "start-task",
+  "pause-task",
+  "close-task"
+]);
+var TESTING_ROOT_COMMANDS = /* @__PURE__ */ new Set([
+  "test",
+  "test-all",
+  "test-runs",
+  "test-verify",
+  "trace-test",
+  "test-ping"
+]);
+var DIAGNOSTICS_ROOT_COMMANDS = /* @__PURE__ */ new Set([
+  "health",
+  "validate",
+  "normalize",
+  "reindex",
+  "gc",
+  "telemetry",
+  "extension-doctor"
+]);
+function normalizeCommandPath(commandPath) {
+  return commandPath.trim().replaceAll(/\s+/g, " ").toLowerCase();
+}
+function normalizeErrorCode(errorCode2) {
+  const normalized = errorCode2?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+var TELEMETRY_ERROR_MESSAGE_CLASSIFIERS = [
+  {
+    code: "unknown_command",
+    matches: (message) => message.includes("unknown command")
+  },
+  {
+    code: "unknown_option",
+    matches: (message) => message.includes("unknown option")
+  },
+  {
+    code: "missing_required_option",
+    matches: (message) => message.includes("missing required options") || message.includes("missing required option")
+  },
+  {
+    code: "missing_required_argument",
+    matches: (message) => message.includes("missing required argument")
+  },
+  {
+    code: "no_update_fields",
+    matches: (message) => message.includes("no update flags provided")
+  },
+  {
+    code: "ownership_conflict",
+    matches: (message) => message.includes("is assigned to") && message.includes("use --force")
+  },
+  {
+    code: "lock_conflict",
+    matches: (message) => message.includes("is locked")
+  },
+  {
+    code: "terminal_state_conflict",
+    matches: (message) => message.includes("already terminal") && message.includes("use --force")
+  },
+  {
+    code: "tracker_not_initialized",
+    matches: (message) => message.includes("tracker is not initialized")
+  },
+  {
+    code: "item_not_found",
+    matches: (message) => message.includes(" not found")
+  },
+  {
+    code: "close_through_update",
+    matches: (message) => message.includes('use "pm close <id> <text>" to close an item') || message.includes("invalid --status value") && message.includes('"closed"')
+  },
+  {
+    code: "invalid_argument_value",
+    matches: (message) => message.startsWith("invalid ") || message.includes(" must be ") || message.includes(" requires ")
+  },
+  {
+    code: "invalid_command_usage",
+    matches: (message) => message.includes("either as positional") && message.includes("not both")
+  }
+];
+var TELEMETRY_EXIT_CODE_FALLBACKS = /* @__PURE__ */ new Map([
+  [EXIT_CODE.USAGE, "invalid_command_usage"],
+  [EXIT_CODE.NOT_FOUND, "item_not_found"],
+  [EXIT_CODE.CONFLICT, "lock_conflict"],
+  [EXIT_CODE.DEPENDENCY_FAILED, "dependency_failed"]
+]);
+function deriveTelemetryCommandTaxonomy(commandPath) {
+  const normalizedPath = normalizeCommandPath(commandPath);
+  const tokens = normalizedPath.length > 0 ? normalizedPath.split(" ") : ["<unknown>"];
+  const root = tokens[0];
+  const leaf = tokens[tokens.length - 1];
+  let family = "other";
+  if (SETUP_ROOT_COMMANDS.has(root)) {
+    family = "setup";
+  } else if (QUERY_ROOT_COMMANDS.has(root)) {
+    family = "query";
+  } else if (MUTATION_ROOT_COMMANDS.has(root)) {
+    family = "mutation";
+  } else if (TESTING_ROOT_COMMANDS.has(root)) {
+    family = "testing";
+  } else if (root === "extension") {
+    family = "extension";
+  } else if (DIAGNOSTICS_ROOT_COMMANDS.has(root)) {
+    family = "diagnostics";
+  }
+  return {
+    command_path: normalizedPath.length > 0 ? normalizedPath : "<unknown>",
+    command_root: root,
+    command_leaf: leaf,
+    command_depth: tokens.length,
+    command_family: family
+  };
+}
+function inferTelemetryErrorCode(params) {
+  if (params.ok) {
+    return void 0;
+  }
+  const explicit = normalizeErrorCode(params.errorCode);
+  if (explicit) {
+    return explicit;
+  }
+  const message = (params.errorMessage ?? "").trim().toLowerCase();
+  for (const classifier of TELEMETRY_ERROR_MESSAGE_CLASSIFIERS) {
+    if (classifier.matches(message)) {
+      return classifier.code;
+    }
+  }
+  const exitCode = Number.isFinite(params.exitCode) ? Math.max(0, Math.trunc(params.exitCode)) : void 0;
+  if (exitCode !== void 0) {
+    return TELEMETRY_EXIT_CODE_FALLBACKS.get(exitCode) ?? "command_failed";
+  }
+  return "command_failed";
+}
+function deriveTelemetryCommandResolution(params) {
+  if (params.ok) {
+    return "success";
+  }
+  const normalizedCode = normalizeErrorCode(params.errorCode);
+  if (normalizedCode === "unknown_command") {
+    return "nonexistent_command";
+  }
+  if (normalizedCode === "unknown_option") {
+    return "invalid_option";
+  }
+  if (normalizedCode === "missing_required_option") {
+    return "missing_required_option";
+  }
+  if (normalizedCode === "missing_required_argument") {
+    return "missing_required_argument";
+  }
+  if (normalizedCode === "health_findings") {
+    return "health_findings";
+  }
+  if (normalizedCode === "validation_findings") {
+    return "validation_findings";
+  }
+  if (params.errorCategory === "usage") {
+    return "invalid_usage";
+  }
+  if (params.errorCategory === "validation") {
+    return "validation_failed";
+  }
+  if (params.errorCategory === "conflict") {
+    return "conflict";
+  }
+  if (params.errorCategory === "runtime") {
+    return "runtime_failed";
+  }
+  return "unknown_failed";
+}
+
+// dist/core/telemetry/runtime.js
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdirSync, rmSync, statSync } from "node:fs";
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var TELEMETRY_QUEUE_RELATIVE_PATH = path.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH = path.join("runtime", "telemetry", "state.json");
+var TELEMETRY_OTEL_SPANS_RELATIVE_PATH = path.join("runtime", "telemetry", "otel-spans.jsonl");
+var TELEMETRY_OTEL_SPANS_FLUSH_BATCH_SIZE = 8;
+var TELEMETRY_OTEL_SPANS_MAX_PENDING = 500;
+var TELEMETRY_SCHEMA_VERSION = 1;
+var TELEMETRY_CLIENT_SCHEMA_VERSION = 1;
+var TELEMETRY_FLUSH_BATCH_SIZE = 100;
+var TELEMETRY_MAX_RETRY_DELAY_MS = 36e5;
+var TELEMETRY_RETRY_BASE_DELAY_MS = 3e4;
+var TELEMETRY_HTTP_TIMEOUT_MS = 5e3;
+var MILLISECONDS_PER_DAY = 864e5;
+var TELEMETRY_MAX_EVENT_BYTES = 65536;
+var TELEMETRY_SANITIZE_MAX_DEPTH = 6;
+var TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS = 20;
+var TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS = 15;
+var TELEMETRY_RESULT_PREVIEW_MAX_BYTES = 8192;
+var TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS = [25, 50, 100, 200];
+var TELEMETRY_QUEUE_TMP_ORPHAN_MAX_AGE_MS = 60 * 60 * 1e3;
+var TELEMETRY_FLUSH_LOCK_STALE_MS = 6e4;
+var TELEMETRY_FLUSH_SPAWN_LOCK_STALE_MS = 6e4;
+var OTEL_TRACES_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
+var OTEL_BASE_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_ENDPOINT";
+var OTEL_SERVICE_NAME_ENV = "OTEL_SERVICE_NAME";
+var PM_TELEMETRY_DISABLED_ENV = "PM_TELEMETRY_DISABLED";
+var PM_NO_TELEMETRY_ENV = "PM_NO_TELEMETRY";
+var PM_TELEMETRY_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var PM_TELEMETRY_OTEL_DISABLED_ENV = "PM_TELEMETRY_OTEL_DISABLED";
+var PM_TELEMETRY_OTEL_DISABLED_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var PM_TELEMETRY_INLINE_FLUSH_ENV = "PM_TELEMETRY_INLINE_FLUSH";
+var PM_TELEMETRY_FLUSH_CHILD_ENV = "PM_TELEMETRY_FLUSH_CHILD";
+var PM_TELEMETRY_SOURCE_CONTEXT_ENV = "PM_TELEMETRY_SOURCE_CONTEXT";
+var PM_AUTHOR_ENV = "PM_AUTHOR";
+var PM_TELEMETRY_SOURCE_CONTEXT_VALUES = [
+  "user",
+  "automation",
+  "test",
+  "dogfood"
+];
+var _lastFlushPromise = Promise.resolve();
+var _queueMutationPromise = Promise.resolve();
+var PM_TELEMETRY_SOURCE_CONTEXT_SET = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
+var BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var PROCESS_SESSION_ID = crypto.randomUUID();
+var SENSITIVE_KEYWORDS = [
+  "token",
+  "secret",
+  "password",
+  "passwd",
+  "api_key",
+  "apikey",
+  "authorization",
+  "cookie",
+  "session",
+  "credentials",
+  "bearer"
+];
+var SENSITIVE_INLINE_KEY_PATTERN = "(?:token|secret|password|passwd|api[_-]?key|apikey|authorization|cookie|session|credentials|bearer)";
+var INLINE_SENSITIVE_ASSIGNMENT_PATTERN = new RegExp(`\\b(${SENSITIVE_INLINE_KEY_PATTERN})\\s*([:=])\\s*([^\\s,;]+)`, "giu");
+var INLINE_SENSITIVE_FLAG_PATTERN = new RegExp(`(--${SENSITIVE_INLINE_KEY_PATTERN})(=|\\s+)([^\\s,;]+)`, "giu");
+var ABSOLUTE_PATH_TOKEN_PATTERN = /(^|[\s"'`(=])\/(?:[^\s"'`),;]+)/g;
+var BEARER_TOKEN_PATTERN = /bearer\s+[a-z0-9._=-]+/giu;
+var PRIVATE_IP_PATTERN = /\b(?:10\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)|172\.(?:1[6-9]|2\d|3[01])\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)|192\.168\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d))\b/g;
+function queuePath(globalPmRoot) {
+  return path.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
+}
+function otelSpansQueuePath(globalPmRoot) {
+  return path.join(globalPmRoot, TELEMETRY_OTEL_SPANS_RELATIVE_PATH);
+}
+function telemetryRuntimeDirectory(globalPmRoot) {
+  return path.dirname(queuePath(globalPmRoot));
+}
+function runtimeStatePath(globalPmRoot) {
+  return path.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
+}
+function flushLockPath(globalPmRoot) {
+  return path.join(globalPmRoot, "runtime", "telemetry", "flush.lock");
+}
+function flushSpawnLockPath(globalPmRoot) {
+  return path.join(globalPmRoot, "runtime", "telemetry", "flush.spawn.lock");
+}
+function telemetryFlushRunnerPath() {
+  return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "telemetry-flush.js");
+}
+function shouldFlushInline() {
+  if (parseBooleanTrueLike(process.env[PM_TELEMETRY_INLINE_FLUSH_ENV])) {
+    return true;
+  }
+  if (parseBooleanTrueLike(process.env[PM_TELEMETRY_FLUSH_CHILD_ENV])) {
+    return true;
+  }
+  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+  return typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test";
+}
+async function readRuntimeState(globalPmRoot) {
+  const raw = await readFileIfExists(runtimeStatePath(globalPmRoot));
+  if (!raw || raw.trim().length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function writeRuntimeState(globalPmRoot, patch) {
+  try {
+    const current = await readRuntimeState(globalPmRoot);
+    const next = {
+      ...current,
+      ...patch
+    };
+    const normalized = Object.fromEntries(Object.entries(next).filter(([, value]) => value !== void 0).sort((left, right) => left[0].localeCompare(right[0])));
+    await writeFileAtomic(runtimeStatePath(globalPmRoot), `${JSON.stringify(normalized, null, 2)}
+`);
+  } catch {
+  }
+}
+function isSensitiveKey(key) {
+  const normalized = key.trim().toLowerCase().replaceAll("-", "_").replaceAll(/[^a-z0-9_]+/g, "_");
+  const tokens = normalized.split("_").filter((token) => token.length > 0);
+  return SENSITIVE_KEYWORDS.some((keyword) => normalized === keyword || normalized.endsWith(`_${keyword}`) || tokens.includes(keyword));
+}
+function redactInlineSensitiveAssignments(input) {
+  const withoutAssignments = input.replaceAll(INLINE_SENSITIVE_ASSIGNMENT_PATTERN, (_match, key, delimiter) => `${key}${delimiter}[redacted]`);
+  return withoutAssignments.replaceAll(INLINE_SENSITIVE_FLAG_PATTERN, (_match, flag, delimiter) => `${flag}${delimiter}[redacted]`);
+}
+function redactAbsolutePathTokens(input) {
+  return input.replaceAll(ABSOLUTE_PATH_TOKEN_PATTERN, (_match, prefix) => `${prefix}[redacted_path]`);
+}
+function isAsciiLetterOrDigitCode(code) {
+  const isUpper = code >= 65 && code <= 90;
+  const isLower = code >= 97 && code <= 122;
+  const isDigit = code >= 48 && code <= 57;
+  return isUpper || isLower || isDigit;
+}
+function isEmailLocalCharacter(character) {
+  if (!character) {
+    return false;
+  }
+  const code = character.charCodeAt(0);
+  if (isAsciiLetterOrDigitCode(code)) {
+    return true;
+  }
+  return character === "." || character === "_" || character === "%" || character === "+" || character === "-";
+}
+function isEmailDomainCharacter(character) {
+  if (!character) {
+    return false;
+  }
+  const code = character.charCodeAt(0);
+  if (isAsciiLetterOrDigitCode(code)) {
+    return true;
+  }
+  return character === "." || character === "-";
+}
+function looksLikeEmailToken(token) {
+  const atIndex = token.indexOf("@");
+  if (atIndex <= 0 || atIndex !== token.lastIndexOf("@") || atIndex === token.length - 1) {
+    return false;
+  }
+  const localPart = token.slice(0, atIndex);
+  const domainPart = token.slice(atIndex + 1);
+  const lastDot = domainPart.lastIndexOf(".");
+  if (lastDot <= 0 || lastDot === domainPart.length - 1) {
+    return false;
+  }
+  if (domainPart.length - (lastDot + 1) < 2) {
+    return false;
+  }
+  for (const character of localPart) {
+    if (!isEmailLocalCharacter(character)) {
+      return false;
+    }
+  }
+  for (const character of domainPart) {
+    if (!isEmailDomainCharacter(character)) {
+      return false;
+    }
+  }
+  return true;
+}
+function redactEmailTokens(input) {
+  let redacted = "";
+  let cursor = 0;
+  while (cursor < input.length) {
+    const atIndex = input.indexOf("@", cursor);
+    if (atIndex < 0) {
+      redacted += input.slice(cursor);
+      break;
+    }
+    let start = atIndex - 1;
+    while (start >= cursor && isEmailLocalCharacter(input[start])) {
+      start -= 1;
+    }
+    start += 1;
+    let end = atIndex + 1;
+    while (end < input.length && isEmailDomainCharacter(input[end])) {
+      end += 1;
+    }
+    const candidate = input.slice(start, end);
+    if (looksLikeEmailToken(candidate)) {
+      redacted += input.slice(cursor, start);
+      redacted += "[redacted_email]";
+      cursor = end;
+      continue;
+    }
+    redacted += input.slice(cursor, atIndex + 1);
+    cursor = atIndex + 1;
+  }
+  return redacted;
+}
+function sanitizeCommonSensitiveTokens(input) {
+  const withoutEmails = redactEmailTokens(input);
+  const withoutBearer = withoutEmails.replaceAll(BEARER_TOKEN_PATTERN, "bearer [redacted_token]");
+  return withoutBearer.replaceAll(PRIVATE_IP_PATTERN, "[redacted_ip]");
+}
+function sanitizeStringRedacted(input) {
+  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input);
+  const withoutInlineSecrets = redactInlineSensitiveAssignments(withoutCommonSensitiveTokens);
+  const withoutAbsolutePaths = redactAbsolutePathTokens(withoutInlineSecrets);
+  const trimmed = withoutAbsolutePaths.trim();
+  if (trimmed.startsWith("/") && trimmed.length > 1) {
+    return "[redacted_path]";
+  }
+  if (withoutAbsolutePaths.length > 512) {
+    return `${withoutAbsolutePaths.slice(0, 509)}...`;
+  }
+  return withoutAbsolutePaths;
+}
+function sanitizeStringMax(input) {
+  const withoutCommonSensitiveTokens = sanitizeCommonSensitiveTokens(input);
+  const withoutInlineSecrets = redactInlineSensitiveAssignments(withoutCommonSensitiveTokens);
+  const withoutAbsolutePaths = redactAbsolutePathTokens(withoutInlineSecrets);
+  const trimmed = withoutAbsolutePaths.trim();
+  if (trimmed.startsWith("/") && trimmed.length > 1) {
+    return "[redacted_path]";
+  }
+  if (withoutAbsolutePaths.length > 2048) {
+    return `${withoutAbsolutePaths.slice(0, 2045)}...`;
+  }
+  return withoutAbsolutePaths;
+}
+function sanitizeString(input, captureLevel = "redacted") {
+  if (captureLevel === "max") {
+    return sanitizeStringMax(input);
+  }
+  return sanitizeStringRedacted(input);
+}
+function sanitizeValue(value, keyHint, captureLevel = "redacted", depth = 0) {
+  if (keyHint && isSensitiveKey(keyHint)) {
+    return "[redacted]";
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return sanitizeString(value, captureLevel);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (depth >= TELEMETRY_SANITIZE_MAX_DEPTH) {
+    return "[depth_truncated]";
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS).map((entry) => sanitizeValue(entry, void 0, captureLevel, depth + 1));
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const sanitized = {};
+    for (const [key, nested] of Object.entries(record)) {
+      sanitized[key] = sanitizeValue(nested, key, captureLevel, depth + 1);
+    }
+    return sanitized;
+  }
+  return String(value);
+}
+function sanitizeCommandArgs(args, captureLevel = "redacted") {
+  const sanitized = [];
+  let nextIsSensitiveValue = false;
+  for (const rawArg of args) {
+    const arg = sanitizeString(rawArg, captureLevel);
+    if (nextIsSensitiveValue) {
+      sanitized.push("[redacted]");
+      nextIsSensitiveValue = false;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const withoutPrefix = arg.slice(2);
+      const delimiterIndex = withoutPrefix.indexOf("=");
+      if (delimiterIndex >= 0) {
+        const key = withoutPrefix.slice(0, delimiterIndex);
+        const value = withoutPrefix.slice(delimiterIndex + 1);
+        if (isSensitiveKey(key)) {
+          sanitized.push(`--${key}=[redacted]`);
+        } else {
+          sanitized.push(`--${key}=${sanitizeString(value, captureLevel)}`);
+        }
+        continue;
+      }
+      if (isSensitiveKey(withoutPrefix)) {
+        sanitized.push(`--${withoutPrefix}`);
+        nextIsSensitiveValue = true;
+        continue;
+      }
+    }
+    sanitized.push(arg);
+  }
+  return sanitized;
+}
+function normalizeCaptureLevel(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "minimal" || normalized === "redacted" || normalized === "max") {
+    return normalized;
+  }
+  return "redacted";
+}
+function parseBooleanTrueLike(value) {
+  return BOOLEAN_TRUE_VALUES.has((value ?? "").trim().toLowerCase());
+}
+function normalizePmVersion(value) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed.length > 0 ? trimmed : "0.0.0";
+}
+function normalizeTelemetryErrorCode(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeTelemetryExitCode(exitCode, ok) {
+  if (Number.isFinite(exitCode)) {
+    return Math.max(0, Math.trunc(exitCode));
+  }
+  return ok ? 0 : 1;
+}
+function normalizeTelemetryErrorCategory(params) {
+  if (params.ok) {
+    return void 0;
+  }
+  if (typeof params.errorCategory === "string" && params.errorCategory.trim().length > 0) {
+    return params.errorCategory;
+  }
+  if (typeof params.errorCode === "string" && params.errorCode.trim().length > 0) {
+    return resolveTelemetryErrorCategory(params.errorCode);
+  }
+  return "unknown";
+}
+function resolveTelemetrySourceContext(globalOptions) {
+  const override = (process.env[PM_TELEMETRY_SOURCE_CONTEXT_ENV] ?? "").trim().toLowerCase();
+  if (PM_TELEMETRY_SOURCE_CONTEXT_SET.has(override)) {
+    return {
+      source_context: override,
+      source_context_source: "env_override"
+    };
+  }
+  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+  if (typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test") {
+    return {
+      source_context: "test",
+      source_context_source: "inferred"
+    };
+  }
+  const nonTty = process.stdin.isTTY !== true || process.stdout.isTTY !== true;
+  const ci = parseBooleanTrueLike(process.env.CI);
+  const scriptLikeMode = globalOptions.json === true || globalOptions.quiet === true;
+  if (nonTty || ci || scriptLikeMode) {
+    return {
+      source_context: "automation",
+      source_context_source: "inferred"
+    };
+  }
+  return {
+    source_context: "user",
+    source_context_source: "inferred"
+  };
+}
+function hashWithInstallationId(installationId, value) {
+  return crypto.createHash("sha256").update(`${installationId}:${value}`).digest("hex");
+}
+function buildAuthorContextPayloadFields(captureLevel, installationId) {
+  const author = (process.env[PM_AUTHOR_ENV] ?? "").trim();
+  if (captureLevel === "minimal") {
+    return { has_author_context: author.length > 0 };
+  }
+  return author.length > 0 ? { author_context_hash: hashWithInstallationId(installationId, author) } : {};
+}
+function normalizeForHash(value, depth = 0) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (depth >= TELEMETRY_SANITIZE_MAX_DEPTH) {
+    return "[depth_truncated]";
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, TELEMETRY_SANITIZE_MAX_ARRAY_ITEMS).map((entry) => normalizeForHash(entry, depth + 1));
+  }
+  if (typeof value === "object") {
+    const record = value;
+    const normalized = {};
+    const sortedKeys = Object.keys(record).sort((left, right) => left.localeCompare(right));
+    for (const key of sortedKeys) {
+      normalized[key] = normalizeForHash(record[key], depth + 1);
+    }
+    return normalized;
+  }
+  return String(value);
+}
+function hashTelemetryValue(installationId, value) {
+  return hashWithInstallationId(installationId, JSON.stringify(normalizeForHash(value)));
+}
+function hashCommandArgs(installationId, args) {
+  return {
+    hashes: args.map((arg) => hashWithInstallationId(installationId, arg)),
+    digest: hashWithInstallationId(installationId, args.join("\0"))
+  };
+}
+function hashTelemetryErrorFingerprint(installationId, command, errorCode2, errorMessage) {
+  const normalizedMessage = sanitizeString(typeof errorMessage === "string" ? errorMessage : "", "redacted");
+  const normalizedCode = typeof errorCode2 === "string" && errorCode2.length > 0 ? errorCode2 : "unknown_error";
+  const fingerprintSource = `${command}\0${normalizedCode}\0${normalizedMessage}`;
+  return hashWithInstallationId(installationId, fingerprintSource);
+}
+function telemetryDisabledByEnvironment() {
+  return PM_TELEMETRY_DISABLED_VALUES.has((process.env[PM_TELEMETRY_DISABLED_ENV] ?? "").trim().toLowerCase()) || PM_TELEMETRY_DISABLED_VALUES.has((process.env[PM_NO_TELEMETRY_ENV] ?? "").trim().toLowerCase());
+}
+function resolveOtelTracesEndpoint() {
+  if (PM_TELEMETRY_OTEL_DISABLED_VALUES.has((process.env[PM_TELEMETRY_OTEL_DISABLED_ENV] ?? "").trim().toLowerCase())) {
+    return null;
+  }
+  const directEndpoint = (process.env[OTEL_TRACES_ENDPOINT_ENV] ?? "").trim();
+  if (directEndpoint.length > 0) {
+    try {
+      return new URL(directEndpoint).toString();
+    } catch {
+      return null;
+    }
+  }
+  const baseEndpoint = (process.env[OTEL_BASE_ENDPOINT_ENV] ?? "").trim();
+  if (baseEndpoint.length === 0) {
+    return null;
+  }
+  try {
+    const url = new URL(baseEndpoint);
+    const normalizedPath = url.pathname.replace(/\/+$/, "");
+    if (!normalizedPath.endsWith("/v1/traces")) {
+      url.pathname = `${normalizedPath.length === 0 ? "" : normalizedPath}/v1/traces`;
+    }
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function isoToUnixNano(iso) {
+  const parsedMs = Date.parse(iso);
+  const epochMs = Number.isNaN(parsedMs) ? Date.now() : parsedMs;
+  return `${BigInt(epochMs) * 1000000n}`;
+}
+function otlpStringAttribute(key, value) {
+  return {
+    key,
+    value: { stringValue: value }
+  };
+}
+function otlpBoolAttribute(key, value) {
+  return {
+    key,
+    value: { boolValue: value }
+  };
+}
+function otlpIntAttribute(key, value) {
+  return {
+    key,
+    value: { intValue: String(Math.max(0, Math.trunc(value))) }
+  };
+}
+function buildOtelSpanRequest(activeCommand, outcome, finishedAtIso, durationMs) {
+  if (typeof activeCommand.otel_traces_endpoint !== "string" || activeCommand.otel_traces_endpoint.trim().length === 0 || typeof activeCommand.otel_trace_id !== "string" || activeCommand.otel_trace_id.length === 0 || typeof activeCommand.otel_span_id !== "string" || activeCommand.otel_span_id.length === 0) {
+    return null;
+  }
+  const serviceNameCandidate = sanitizeString((process.env[OTEL_SERVICE_NAME_ENV] ?? "").trim());
+  const serviceName = serviceNameCandidate.length > 0 ? serviceNameCandidate : "pm-cli";
+  const normalizedExitCode = normalizeTelemetryExitCode(outcome.exit_code, outcome.ok);
+  const normalizedErrorCode = normalizeTelemetryErrorCode(outcome.error_code);
+  const normalizedErrorCategory = normalizeTelemetryErrorCategory({
+    ok: outcome.ok,
+    errorCode: normalizedErrorCode,
+    errorCategory: outcome.error_category
+  });
+  const attributes = [
+    otlpStringAttribute("pm.command", sanitizeString(activeCommand.command)),
+    otlpStringAttribute("pm.version", activeCommand.pm_version),
+    otlpStringAttribute("pm.source_context", activeCommand.source_context),
+    otlpStringAttribute("pm.source_context_source", activeCommand.source_context_source),
+    otlpStringAttribute("pm.installation_id", activeCommand.installation_id),
+    otlpStringAttribute("pm.session_id", PROCESS_SESSION_ID),
+    otlpStringAttribute("pm.pm_root_hash", activeCommand.pm_root_hash),
+    otlpStringAttribute("pm.cwd_hash", activeCommand.cwd_hash),
+    otlpBoolAttribute("pm.ok", outcome.ok),
+    otlpIntAttribute("pm.exit_code", normalizedExitCode),
+    otlpIntAttribute("pm.duration_ms", durationMs)
+  ];
+  if (typeof normalizedErrorCode === "string") {
+    attributes.push(otlpStringAttribute("pm.error_code", normalizedErrorCode));
+  }
+  if (typeof normalizedErrorCategory === "string") {
+    attributes.push(otlpStringAttribute("pm.error_category", normalizedErrorCategory));
+  }
+  if (typeof outcome.error === "string" && outcome.error.trim().length > 0) {
+    attributes.push(otlpStringAttribute("pm.error", sanitizeString(outcome.error)));
+  }
+  const payload = {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [otlpStringAttribute("service.name", serviceName)]
+        },
+        scopeSpans: [
+          {
+            scope: {
+              name: "pm-cli.telemetry",
+              version: "1"
+            },
+            spans: [
+              {
+                traceId: activeCommand.otel_trace_id,
+                spanId: activeCommand.otel_span_id,
+                name: `pm.command.${sanitizeString(activeCommand.command)}`,
+                kind: 1,
+                startTimeUnixNano: isoToUnixNano(activeCommand.started_at),
+                endTimeUnixNano: isoToUnixNano(finishedAtIso),
+                attributes,
+                status: {
+                  code: outcome.ok ? 1 : 2,
+                  message: outcome.ok ? "" : sanitizeString(typeof outcome.error === "string" ? outcome.error : "command_failed")
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+  return { endpoint: activeCommand.otel_traces_endpoint, payload };
+}
+function summarizeResult(result, captureLevel = "redacted") {
+  if (result === null || result === void 0) {
+    return { type: "nullish" };
+  }
+  if (typeof result === "string") {
+    return { type: "string", value: sanitizeString(result, captureLevel) };
+  }
+  if (typeof result === "number" || typeof result === "boolean") {
+    return { type: typeof result, value: result };
+  }
+  if (Array.isArray(result)) {
+    return {
+      type: "array",
+      length: result.length,
+      sample: result.slice(0, 5).map((entry) => sanitizeValue(entry, void 0, captureLevel))
+    };
+  }
+  if (typeof result === "object") {
+    const record = result;
+    const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
+    const sanitized = {};
+    let previewBytes = 0;
+    for (const key of keys.slice(0, 25)) {
+      const sanitizedValue = sanitizeValue(record[key], key, captureLevel);
+      const entrySize = JSON.stringify(sanitizedValue).length;
+      if (previewBytes + entrySize > TELEMETRY_RESULT_PREVIEW_MAX_BYTES) {
+        sanitized[key] = "[preview_truncated]";
+        break;
+      }
+      previewBytes += entrySize;
+      sanitized[key] = sanitizedValue;
+    }
+    return {
+      type: "object",
+      key_count: keys.length,
+      keys_preview: keys.slice(0, 50),
+      preview: sanitized
+    };
+  }
+  return { type: typeof result, value: String(result) };
+}
+function buildCommandStartPayload(params) {
+  const { captureLevel, context, pmVersion, sourceContext, pmRootHash, cwdHash, installationId } = params;
+  const commandTaxonomy = deriveTelemetryCommandTaxonomy(context.command);
+  const hashedArgs = hashCommandArgs(installationId, context.args);
+  const commandInvocationDigest = hashWithInstallationId(installationId, `${context.command}\0${context.args.join("\0")}`);
+  const commandOptionsDigest = hashTelemetryValue(installationId, context.options);
+  const globalOptionsDigest = hashTelemetryValue(installationId, context.global);
+  const authorContextFields = buildAuthorContextPayloadFields(captureLevel, installationId);
+  if (captureLevel === "minimal") {
+    return {
+      capture_level: captureLevel,
+      pm_version: pmVersion,
+      source_context: sourceContext.source_context,
+      source_context_source: sourceContext.source_context_source,
+      command_taxonomy: commandTaxonomy,
+      command_args_digest: hashedArgs.digest,
+      command_invocation_digest: commandInvocationDigest,
+      command_options_digest: commandOptionsDigest,
+      global_options_digest: globalOptionsDigest,
+      ...authorContextFields
+    };
+  }
+  return {
+    pm_version: pmVersion,
+    source_context: sourceContext.source_context,
+    source_context_source: sourceContext.source_context_source,
+    command_taxonomy: commandTaxonomy,
+    ...authorContextFields,
+    command_args: sanitizeCommandArgs(context.args, captureLevel),
+    command_args_hashes: hashedArgs.hashes,
+    command_args_digest: hashedArgs.digest,
+    command_invocation_digest: commandInvocationDigest,
+    command_options: sanitizeValue(context.options, void 0, captureLevel),
+    command_options_digest: commandOptionsDigest,
+    global_options: sanitizeValue(context.global, void 0, captureLevel),
+    global_options_digest: globalOptionsDigest,
+    pm_root_hash: pmRootHash,
+    cwd_hash: cwdHash,
+    capture_level: captureLevel,
+    runtime: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      hostname_hash: hashWithInstallationId(installationId, os.hostname()),
+      stdin_tty: process.stdin.isTTY === true,
+      stdout_tty: process.stdout.isTTY === true
+    }
+  };
+}
+function buildCommandFinishPayload(params) {
+  const { captureLevel, pmVersion, sourceContext, outcome, durationMs, startedAt, command, installationId, commandTaxonomy, exitCode, errorCode: errorCode2, errorCategory, commandResolution, resolutionStage } = params;
+  const errorFingerprint = outcome.ok === false ? hashTelemetryErrorFingerprint(installationId, command, errorCode2, outcome.error) : void 0;
+  const authorContextFields = buildAuthorContextPayloadFields(captureLevel, installationId);
+  if (captureLevel === "minimal") {
+    return {
+      capture_level: captureLevel,
+      pm_version: pmVersion,
+      source_context: sourceContext.source_context,
+      source_context_source: sourceContext.source_context_source,
+      command_taxonomy: commandTaxonomy,
+      command_resolution: commandResolution,
+      resolution_stage: resolutionStage,
+      ok: outcome.ok,
+      exit_code: exitCode,
+      error_code: errorCode2,
+      error_category: errorCategory,
+      error: outcome.error ? sanitizeString(outcome.error, "redacted") : void 0,
+      error_fingerprint: errorFingerprint,
+      duration_ms: durationMs,
+      ...authorContextFields
+    };
+  }
+  return {
+    capture_level: captureLevel,
+    pm_version: pmVersion,
+    source_context: sourceContext.source_context,
+    source_context_source: sourceContext.source_context_source,
+    command_taxonomy: commandTaxonomy,
+    command_resolution: commandResolution,
+    resolution_stage: resolutionStage,
+    ...authorContextFields,
+    ok: outcome.ok,
+    exit_code: exitCode,
+    error_code: errorCode2,
+    error_category: errorCategory,
+    error: outcome.error ? sanitizeString(outcome.error, captureLevel) : void 0,
+    error_fingerprint: errorFingerprint,
+    duration_ms: durationMs,
+    started_at: startedAt,
+    result_summary: summarizeResult(outcome.result, captureLevel)
+  };
+}
+function buildCommandErrorPayload(params) {
+  const { captureLevel, pmVersion, sourceContext, command, commandTaxonomy, commandResolution, resolutionStage, args, options, pmRootHash, cwdHash, installationId, errorCode: errorCode2, errorMessage, errorCategory, exitCode } = params;
+  const attemptedArgHashes = hashCommandArgs(installationId, args);
+  const attemptedCommandDigest = hashWithInstallationId(installationId, command);
+  const attemptedOptionsDigest = hashTelemetryValue(installationId, options);
+  const errorFingerprint = hashTelemetryErrorFingerprint(installationId, command, errorCode2, errorMessage);
+  if (captureLevel === "minimal") {
+    return {
+      capture_level: captureLevel,
+      pm_version: pmVersion,
+      source_context: sourceContext.source_context,
+      source_context_source: sourceContext.source_context_source,
+      command_taxonomy: commandTaxonomy,
+      command_resolution: commandResolution,
+      resolution_stage: resolutionStage,
+      attempted_command_digest: attemptedCommandDigest,
+      attempted_args_digest: attemptedArgHashes.digest,
+      attempted_options_digest: attemptedOptionsDigest,
+      error_code: errorCode2,
+      error_category: errorCategory,
+      exit_code: exitCode,
+      error: sanitizeString(errorMessage, "redacted"),
+      error_fingerprint: errorFingerprint
+    };
+  }
+  return {
+    capture_level: captureLevel,
+    pm_version: pmVersion,
+    source_context: sourceContext.source_context,
+    source_context_source: sourceContext.source_context_source,
+    command_taxonomy: commandTaxonomy,
+    command_resolution: commandResolution,
+    resolution_stage: resolutionStage,
+    attempted_command: sanitizeString(command, captureLevel),
+    attempted_command_digest: attemptedCommandDigest,
+    attempted_args: sanitizeCommandArgs(args, captureLevel),
+    attempted_args_hashes: attemptedArgHashes.hashes,
+    attempted_args_digest: attemptedArgHashes.digest,
+    attempted_options: sanitizeValue(options, void 0, captureLevel),
+    attempted_options_digest: attemptedOptionsDigest,
+    error_code: errorCode2,
+    error_category: errorCategory,
+    exit_code: exitCode,
+    error: sanitizeString(errorMessage, captureLevel),
+    error_fingerprint: errorFingerprint,
+    pm_root_hash: pmRootHash,
+    cwd_hash: cwdHash,
+    runtime: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      hostname_hash: hashWithInstallationId(installationId, os.hostname()),
+      stdin_tty: process.stdin.isTTY === true,
+      stdout_tty: process.stdout.isTTY === true
+    }
+  };
+}
+async function ensureInstallationId(globalPmRoot) {
+  const settings = await readSettings(globalPmRoot);
+  let changed = false;
+  if (settings.telemetry.installation_id.trim().length === 0) {
+    settings.telemetry.installation_id = crypto.randomUUID();
+    changed = true;
+  }
+  if (changed) {
+    await writeSettings(globalPmRoot, settings, "telemetry:install_id");
+  }
+  return {
+    installationId: settings.telemetry.installation_id,
+    endpoint: settings.telemetry.endpoint,
+    retentionDays: Math.max(1, Math.trunc(settings.telemetry.retention_days))
+  };
+}
+async function enqueueTelemetryEvent(globalPmRoot, event) {
+  const queued = {
+    client_schema_version: TELEMETRY_CLIENT_SCHEMA_VERSION,
+    event,
+    attempts: 0
+  };
+  let serialized = JSON.stringify(queued);
+  if (serialized.length > TELEMETRY_MAX_EVENT_BYTES) {
+    const trimmed = {
+      ...event,
+      payload: {
+        ...event.payload,
+        result_summary: {
+          truncated: true,
+          reason: "payload_size_exceeded",
+          original_bytes: serialized.length
+        }
+      }
+    };
+    const trimmedQueued = {
+      client_schema_version: TELEMETRY_CLIENT_SCHEMA_VERSION,
+      event: trimmed,
+      attempts: 0
+    };
+    serialized = JSON.stringify(trimmedQueued);
+  }
+  await withQueueMutation(async () => {
+    await appendLineAtomic(queuePath(globalPmRoot), serialized);
+  });
+}
+function parseQueueLines(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && parsed.event && typeof parsed.event === "object" && typeof parsed.attempts === "number" && (parsed.client_schema_version === void 0 || typeof parsed.client_schema_version === "number" && Number.isFinite(parsed.client_schema_version))) {
+        entries.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function nextRetryIso(attempts) {
+  const delay = Math.min(TELEMETRY_RETRY_BASE_DELAY_MS * 2 ** Math.max(attempts - 1, 0), TELEMETRY_MAX_RETRY_DELAY_MS);
+  return new Date(Date.now() + delay).toISOString();
+}
+function isDueForRetryAt(nextAttemptAfter) {
+  if (typeof nextAttemptAfter !== "string" || nextAttemptAfter.trim().length === 0) {
+    return true;
+  }
+  const dueAtMs = Date.parse(nextAttemptAfter);
+  if (Number.isNaN(dueAtMs)) {
+    return true;
+  }
+  return dueAtMs <= Date.now();
+}
+function isDueForRetry(entry) {
+  return isDueForRetryAt(entry.next_attempt_after);
+}
+function retentionCutoffMs(retentionDays) {
+  const normalizedDays = Number.isFinite(retentionDays) ? Math.max(1, Math.trunc(retentionDays)) : 1;
+  return Date.now() - normalizedDays * MILLISECONDS_PER_DAY;
+}
+function isExpiredQueueEntry(entry, cutoffMs) {
+  const occurredAt = entry.event?.occurred_at;
+  if (typeof occurredAt !== "string" || occurredAt.trim().length === 0) {
+    return false;
+  }
+  const occurredAtMs = Date.parse(occurredAt);
+  if (Number.isNaN(occurredAtMs)) {
+    return false;
+  }
+  return occurredAtMs < cutoffMs;
+}
+function pruneExpiredQueueEntries(entries, retentionDays) {
+  const cutoffMs = retentionCutoffMs(retentionDays);
+  const retained = [];
+  let prunedCount = 0;
+  for (const entry of entries) {
+    const serializedSize = JSON.stringify(entry).length;
+    const oversized = serializedSize > TELEMETRY_MAX_EVENT_BYTES;
+    if (oversized || isExpiredQueueEntry(entry, cutoffMs) || entry.attempts >= TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS) {
+      prunedCount += 1;
+      continue;
+    }
+    retained.push(entry);
+  }
+  return { entries: retained, prunedCount };
+}
+async function rewriteQueue(globalPmRoot, entries) {
+  const serialized = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  const contents = serialized.length > 0 ? `${serialized}
+` : "";
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await writeFileAtomic(queuePath(globalPmRoot), contents);
+      return;
+    } catch (error) {
+      const retryDelay = TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS[attempt];
+      if (retryDelay === void 0 || !isRetryableQueueRewriteError(error)) {
+        throw error;
+      }
+      await sleep(retryDelay);
+    }
+  }
+}
+function isRetryableQueueRewriteError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "EACCES" || code === "EBUSY" || code === "EPERM";
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+async function enqueuePendingOtelSpan(globalPmRoot, request) {
+  const pending = {
+    id: crypto.randomUUID(),
+    endpoint: request.endpoint,
+    payload: request.payload,
+    enqueued_at: nowIso(),
+    attempts: 0
+  };
+  const serialized = JSON.stringify(pending);
+  if (serialized.length > TELEMETRY_MAX_EVENT_BYTES) {
+    return;
+  }
+  await withQueueMutation(async () => {
+    await appendLineAtomic(otelSpansQueuePath(globalPmRoot), serialized);
+  });
+}
+function backfillPendingOtelSpanId(entry) {
+  const material = JSON.stringify([
+    entry.endpoint,
+    entry.enqueued_at,
+    entry.payload
+  ]);
+  return crypto.createHash("sha256").update(material).digest("hex").slice(0, 32);
+}
+function parsePendingOtelSpanLines(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && typeof parsed.endpoint === "string" && parsed.endpoint.trim().length > 0 && "payload" in parsed && typeof parsed.attempts === "number" && Number.isFinite(parsed.attempts)) {
+        if (typeof parsed.id !== "string" || parsed.id.length === 0) {
+          parsed.id = backfillPendingOtelSpanId(parsed);
+        }
+        entries.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+function isExpiredPendingOtelSpan(entry, cutoffMs) {
+  if (typeof entry.enqueued_at !== "string" || entry.enqueued_at.trim().length === 0) {
+    return false;
+  }
+  const enqueuedAtMs = Date.parse(entry.enqueued_at);
+  if (Number.isNaN(enqueuedAtMs)) {
+    return false;
+  }
+  return enqueuedAtMs < cutoffMs;
+}
+function prunePendingOtelSpans(entries, retentionDays) {
+  const cutoffMs = retentionCutoffMs(retentionDays);
+  const retained = [];
+  let prunedCount = 0;
+  for (const entry of entries) {
+    const oversized = JSON.stringify(entry).length > TELEMETRY_MAX_EVENT_BYTES;
+    if (oversized || isExpiredPendingOtelSpan(entry, cutoffMs) || entry.attempts >= TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS) {
+      prunedCount += 1;
+      continue;
+    }
+    retained.push(entry);
+  }
+  if (retained.length > TELEMETRY_OTEL_SPANS_MAX_PENDING) {
+    const overflow = retained.length - TELEMETRY_OTEL_SPANS_MAX_PENDING;
+    prunedCount += overflow;
+    return { entries: retained.slice(overflow), prunedCount };
+  }
+  return { entries: retained, prunedCount };
+}
+async function rewritePendingOtelSpans(globalPmRoot, entries) {
+  const serialized = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  const contents = serialized.length > 0 ? `${serialized}
+` : "";
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await writeFileAtomic(otelSpansQueuePath(globalPmRoot), contents);
+      return;
+    } catch (error) {
+      const retryDelay = TELEMETRY_QUEUE_REWRITE_RETRY_DELAYS_MS[attempt];
+      if (retryDelay === void 0 || !isRetryableQueueRewriteError(error)) {
+        throw error;
+      }
+      await sleep(retryDelay);
+    }
+  }
+}
+async function reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, succeededIds, failedUpdates) {
+  return withQueueMutation(async () => {
+    const raw = await readFileIfExists(otelSpansQueuePath(globalPmRoot));
+    const current = raw === null ? [] : parsePendingOtelSpanLines(raw);
+    const reconciled = [];
+    for (const entry of current) {
+      if (succeededIds.has(entry.id)) {
+        continue;
+      }
+      const failure = failedUpdates.get(entry.id);
+      reconciled.push(failure ? {
+        ...entry,
+        attempts: failure.attempts,
+        next_attempt_after: failure.next_attempt_after
+      } : entry);
+    }
+    const { entries: retained } = prunePendingOtelSpans(reconciled, retentionDays);
+    await rewritePendingOtelSpans(globalPmRoot, retained);
+    return retained.length;
+  });
+}
+async function flushPendingOtelSpans(globalPmRoot, retentionDays) {
+  const raw = await readFileIfExists(otelSpansQueuePath(globalPmRoot));
+  if (raw === null || raw.trim().length === 0) {
+    await writeRuntimeState(globalPmRoot, { pending_otel_spans: 0 });
+    return;
+  }
+  const entries = parsePendingOtelSpanLines(raw);
+  const { entries: retained, prunedCount } = prunePendingOtelSpans(entries, retentionDays);
+  const due = retained.filter((entry) => isDueForRetryAt(entry.next_attempt_after)).slice(0, TELEMETRY_OTEL_SPANS_FLUSH_BATCH_SIZE);
+  if (due.length === 0) {
+    const remaining2 = prunedCount > 0 ? await reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map()) : retained.length;
+    await writeRuntimeState(globalPmRoot, { pending_otel_spans: remaining2 });
+    return;
+  }
+  const attemptTime = nowIso();
+  const succeededIds = /* @__PURE__ */ new Set();
+  const failedUpdates = /* @__PURE__ */ new Map();
+  let succeededCount = 0;
+  let lastError;
+  await Promise.all(due.map(async (span) => {
+    try {
+      const response = await fetch(span.endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(span.payload),
+        signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        throw new Error(`local_otel_export_http_${response.status}`);
+      }
+      succeededIds.add(span.id);
+      succeededCount += 1;
+    } catch (error) {
+      lastError = error instanceof Error ? sanitizeString(error.message, "redacted") : "local_otel_export_failed";
+      const nextAttempts = span.attempts + 1;
+      failedUpdates.set(span.id, {
+        attempts: nextAttempts,
+        next_attempt_after: nextRetryIso(nextAttempts)
+      });
+    }
+  }));
+  const remaining = await reconcilePendingOtelSpansAfterFlush(globalPmRoot, retentionDays, succeededIds, failedUpdates);
+  const statePatch = {
+    pending_otel_spans: remaining,
+    last_otel_attempt_at: attemptTime
+  };
+  if (succeededCount > 0) {
+    statePatch.last_otel_success_at = attemptTime;
+  }
+  if (lastError !== void 0) {
+    statePatch.last_otel_failure_at = attemptTime;
+    statePatch.last_otel_failure_error = lastError;
+  } else if (remaining === 0) {
+    statePatch.last_otel_failure_at = void 0;
+    statePatch.last_otel_failure_error = void 0;
+  }
+  await writeRuntimeState(globalPmRoot, statePatch);
+}
+async function flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays) {
+  try {
+    await flushQueue(globalPmRoot, endpoint, retentionDays);
+  } catch {
+  }
+  try {
+    await flushPendingOtelSpans(globalPmRoot, retentionDays);
+  } catch {
+  }
+}
+async function cleanupTelemetryQueueTempOrphans(globalPmRoot, maxAgeMs = TELEMETRY_QUEUE_TMP_ORPHAN_MAX_AGE_MS) {
+  try {
+    const dirPath = telemetryRuntimeDirectory(globalPmRoot);
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const cutoffMs = Date.now() - Math.max(0, maxAgeMs);
+    await Promise.all(entries.filter((entry) => entry.isFile() && /^\.events\.jsonl\.\d+\.\d+\.[a-f0-9]+\.tmp$/.test(entry.name)).map(async (entry) => {
+      const candidate = path.join(dirPath, entry.name);
+      const candidateStats = await stat(candidate);
+      if (candidateStats.mtimeMs < cutoffMs) {
+        await rm(candidate, { force: true });
+      }
+    }));
+  } catch {
+  }
+}
+async function withQueueMutation(operation) {
+  const run = _queueMutationPromise.catch(
+    /* c8 ignore next */
+    () => {
+    }
+  ).then(operation);
+  _queueMutationPromise = run.catch(
+    /* c8 ignore next */
+    () => {
+    }
+  );
+  return run;
+}
+async function readCurrentQueueEntries(globalPmRoot) {
+  const raw = await readFileIfExists(queuePath(globalPmRoot));
+  if (raw === null || raw.trim().length === 0) {
+    return [];
+  }
+  return parseQueueLines(raw);
+}
+async function removeFlushedEntriesFromCurrentQueue(globalPmRoot, flushedIds, retentionDays) {
+  return withQueueMutation(async () => {
+    const currentEntries = await readCurrentQueueEntries(globalPmRoot);
+    const { entries: retainedEntries } = pruneExpiredQueueEntries(currentEntries, retentionDays);
+    const remaining = retainedEntries.filter((entry) => !flushedIds.has(entry.event.event_id));
+    await rewriteQueue(globalPmRoot, remaining);
+    return remaining;
+  });
+}
+async function markFailedEntriesInCurrentQueue(globalPmRoot, failedIds, attemptTime, retentionDays) {
+  return withQueueMutation(async () => {
+    const currentEntries = await readCurrentQueueEntries(globalPmRoot);
+    const { entries: retainedEntries } = pruneExpiredQueueEntries(currentEntries, retentionDays);
+    const retried = retainedEntries.map((entry) => {
+      if (!failedIds.has(entry.event.event_id)) {
+        return entry;
+      }
+      const attempts = entry.attempts + 1;
+      return {
+        ...entry,
+        attempts,
+        last_attempt_at: attemptTime,
+        next_attempt_after: nextRetryIso(attempts)
+      };
+    });
+    await rewriteQueue(globalPmRoot, retried);
+    return retried;
+  });
+}
+async function flushQueue(globalPmRoot, endpoint, retentionDays) {
+  await cleanupTelemetryQueueTempOrphans(globalPmRoot);
+  const normalizedEndpoint = endpoint.trim();
+  if (normalizedEndpoint.length === 0) {
+    return;
+  }
+  const raw = await readFileIfExists(queuePath(globalPmRoot));
+  if (raw === null || raw.trim().length === 0) {
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: 0
+    });
+    return;
+  }
+  const queueEntries = parseQueueLines(raw);
+  if (queueEntries.length === 0) {
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: 0
+    });
+    return;
+  }
+  const { entries: retainedEntries, prunedCount } = pruneExpiredQueueEntries(queueEntries, retentionDays);
+  if (retainedEntries.length === 0) {
+    await rewriteQueue(globalPmRoot, []);
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: 0
+    });
+    return;
+  }
+  const dueEntries = retainedEntries.filter((entry) => isDueForRetry(entry)).slice(0, TELEMETRY_FLUSH_BATCH_SIZE);
+  if (dueEntries.length === 0) {
+    if (prunedCount > 0) {
+      await rewriteQueue(globalPmRoot, retainedEntries);
+    }
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: retainedEntries.length
+    });
+    return;
+  }
+  const dueIds = new Set(dueEntries.map((entry) => entry.event.event_id));
+  const attemptTime = nowIso();
+  const requestHeaders = {
+    "content-type": "application/json"
+  };
+  const ingestKey = process.env.PM_TELEMETRY_INGEST_KEY?.trim();
+  if (ingestKey) {
+    requestHeaders["x-pm-telemetry-key"] = ingestKey;
+  }
+  try {
+    const response = await fetch(normalizedEndpoint, {
+      method: "POST",
+      headers: requestHeaders,
+      body: JSON.stringify({
+        schema_version: TELEMETRY_SCHEMA_VERSION,
+        events: dueEntries.map((entry) => entry.event)
+      }),
+      signal: AbortSignal.timeout(TELEMETRY_HTTP_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(`telemetry_flush_http_${response.status}`);
+    }
+  } catch (error) {
+    const retried = await markFailedEntriesInCurrentQueue(globalPmRoot, dueIds, attemptTime, retentionDays);
+    const errorMessage = (() => {
+      if (error instanceof Error) {
+        return sanitizeString(error.message, "redacted");
+      }
+      return "telemetry_flush_failed";
+    })();
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: retried.length,
+      last_attempted_flush_at: attemptTime,
+      last_failed_flush_at: attemptTime,
+      last_failed_flush_error: errorMessage
+    });
+    return;
+  }
+  try {
+    const remaining = await removeFlushedEntriesFromCurrentQueue(globalPmRoot, dueIds, retentionDays);
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: remaining.length,
+      last_attempted_flush_at: attemptTime,
+      last_successful_flush_at: attemptTime,
+      last_failed_flush_at: void 0,
+      last_failed_flush_error: void 0
+    });
+  } catch (error) {
+    const errorMessage = (() => {
+      if (error instanceof Error) {
+        return sanitizeString(error.message, "redacted");
+      }
+      return "telemetry_flush_failed";
+    })();
+    const currentEntries = await readCurrentQueueEntries(globalPmRoot).catch(() => retainedEntries);
+    await writeRuntimeState(globalPmRoot, {
+      endpoint: normalizedEndpoint,
+      queue_entries: currentEntries.length,
+      last_attempted_flush_at: attemptTime,
+      last_failed_flush_at: attemptTime,
+      last_failed_flush_error: errorMessage
+    });
+  }
+}
+async function acquireTelemetryFlushLock(globalPmRoot) {
+  const lockPath = flushLockPath(globalPmRoot);
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  try {
+    await mkdir(lockPath);
+    return true;
+  } catch (error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  try {
+    const lockStats = await stat(lockPath);
+    if (Date.now() - lockStats.mtimeMs < TELEMETRY_FLUSH_LOCK_STALE_MS) {
+      return false;
+    }
+    await rm(lockPath, { recursive: true, force: true });
+    await mkdir(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isFreshDirectoryLock(lockPath, staleMs) {
+  try {
+    return Date.now() - statSync(lockPath).mtimeMs < staleMs;
+  } catch {
+    return false;
+  }
+}
+function removeDirectoryLockBestEffort(lockPath) {
+  try {
+    rmSync(lockPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return void 0;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : void 0;
+}
+function createDirectoryLock(lockPath) {
+  try {
+    mkdirSync(lockPath);
+    return true;
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "EEXIST") {
+      return false;
+    }
+    if (code !== "ENOENT") {
+      return false;
+    }
+  }
+  try {
+    mkdirSync(path.dirname(lockPath), { recursive: true });
+    mkdirSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireTelemetryFlushSpawnGate(globalPmRoot) {
+  if (isFreshDirectoryLock(flushLockPath(globalPmRoot), TELEMETRY_FLUSH_LOCK_STALE_MS)) {
+    return false;
+  }
+  const lockPath = flushSpawnLockPath(globalPmRoot);
+  try {
+    if (Date.now() - statSync(lockPath).mtimeMs < TELEMETRY_FLUSH_SPAWN_LOCK_STALE_MS) {
+      return false;
+    }
+    removeDirectoryLockBestEffort(lockPath);
+  } catch (error) {
+    if (errorCode(error) !== "ENOENT") {
+      return false;
+    }
+  }
+  return createDirectoryLock(lockPath);
+}
+function releaseTelemetryFlushSpawnGate(globalPmRoot) {
+  removeDirectoryLockBestEffort(flushSpawnLockPath(globalPmRoot));
+}
+async function flushQueueWithProcessLock(globalPmRoot, endpoint, retentionDays) {
+  const acquired = await acquireTelemetryFlushLock(globalPmRoot);
+  releaseTelemetryFlushSpawnGate(globalPmRoot);
+  if (!acquired) {
+    return;
+  }
+  try {
+    await flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays);
+  } finally {
+    try {
+      await rm(flushLockPath(globalPmRoot), { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays) {
+  if (shouldFlushInline()) {
+    const previousFlush = _lastFlushPromise;
+    const nextFlush = flushTelemetryArtifacts(globalPmRoot, endpoint, retentionDays);
+    _lastFlushPromise = Promise.allSettled([previousFlush, nextFlush]).then(() => {
+    });
+    return;
+  }
+  try {
+    const acquiredSpawnGate = acquireTelemetryFlushSpawnGate(globalPmRoot);
+    if (!acquiredSpawnGate) {
+      return;
+    }
+    const child = spawn(process.execPath, [telemetryFlushRunnerPath()], {
+      detached: true,
+      stdio: "ignore",
+      // Detached workers inherit cwd by default. On Windows that can keep a
+      // disposable project directory locked after the foreground command exits.
+      cwd: os.tmpdir(),
+      env: {
+        ...process.env,
+        PM_GLOBAL_PATH: globalPmRoot,
+        [PM_TELEMETRY_FLUSH_CHILD_ENV]: "1"
+      }
+    });
+    child.on("error", () => {
+      releaseTelemetryFlushSpawnGate(globalPmRoot);
+    });
+    child.unref();
+  } catch {
+    releaseTelemetryFlushSpawnGate(globalPmRoot);
+  }
+}
+async function flushTelemetryQueueNow(globalPmRoot = resolveGlobalPmRoot(process.cwd())) {
+  if (telemetryDisabledByEnvironment()) {
+    return;
+  }
+  try {
+    const settings = await readSettings(globalPmRoot);
+    if (!settings.telemetry.enabled) {
+      return;
+    }
+    const { endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
+    await flushQueueWithProcessLock(globalPmRoot, endpoint, retentionDays);
+  } catch {
+  }
+}
+async function startTelemetryCommand(context) {
+  if (telemetryDisabledByEnvironment()) {
+    return null;
+  }
+  if (context.command === "telemetry" && context.args.some((token) => token.trim().toLowerCase() === "clear")) {
+    return null;
+  }
+  try {
+    const globalPmRoot = resolveGlobalPmRoot(process.cwd());
+    const settings = await readSettings(globalPmRoot);
+    if (!settings.telemetry.enabled) {
+      return null;
+    }
+    const captureLevel = normalizeCaptureLevel(settings.telemetry.capture_level);
+    const { installationId, endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
+    const pmVersion = normalizePmVersion(context.pm_version);
+    const sourceContext = resolveTelemetrySourceContext(context.global);
+    const pmRootHash = hashWithInstallationId(installationId, context.pm_root);
+    const cwdHash = hashWithInstallationId(installationId, process.cwd());
+    const otelTracesEndpoint = resolveOtelTracesEndpoint();
+    const occurredAt = nowIso();
+    const event = {
+      schema_version: TELEMETRY_SCHEMA_VERSION,
+      event_id: crypto.randomUUID(),
+      event_type: "command_start",
+      occurred_at: occurredAt,
+      installation_id: installationId,
+      session_id: PROCESS_SESSION_ID,
+      command: context.command,
+      payload: buildCommandStartPayload({
+        captureLevel,
+        context,
+        pmVersion,
+        sourceContext,
+        pmRootHash,
+        cwdHash,
+        installationId
+      })
+    };
+    await enqueueTelemetryEvent(globalPmRoot, event);
+    scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays);
+    const commandTaxonomy = deriveTelemetryCommandTaxonomy(context.command);
+    return {
+      started_at: occurredAt,
+      started_at_ms: Date.now(),
+      command: context.command,
+      command_taxonomy: commandTaxonomy,
+      pm_version: pmVersion,
+      source_context: sourceContext.source_context,
+      source_context_source: sourceContext.source_context_source,
+      installation_id: installationId,
+      pm_root_hash: pmRootHash,
+      cwd_hash: cwdHash,
+      endpoint,
+      retention_days: retentionDays,
+      global_pm_root: globalPmRoot,
+      capture_level: captureLevel,
+      otel_traces_endpoint: otelTracesEndpoint ?? void 0,
+      otel_trace_id: otelTracesEndpoint ? crypto.randomBytes(16).toString("hex") : void 0,
+      otel_span_id: otelTracesEndpoint ? crypto.randomBytes(8).toString("hex") : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function finishTelemetryCommand(activeCommand, outcome) {
+  if (!activeCommand) {
+    return;
+  }
+  try {
+    const finishedAt = nowIso();
+    const durationMs = Math.max(0, Date.now() - activeCommand.started_at_ms);
+    const normalizedErrorCode = normalizeTelemetryErrorCode(inferTelemetryErrorCode({
+      ok: outcome.ok,
+      errorCode: outcome.error_code,
+      errorMessage: outcome.error,
+      exitCode: outcome.exit_code
+    }));
+    const normalizedErrorCategory = normalizeTelemetryErrorCategory({
+      ok: outcome.ok,
+      errorCode: normalizedErrorCode,
+      errorCategory: outcome.error_category
+    });
+    const normalizedExitCode = normalizeTelemetryExitCode(outcome.exit_code, outcome.ok);
+    const commandResolution = outcome.command_resolution ?? deriveTelemetryCommandResolution({
+      ok: outcome.ok,
+      errorCode: normalizedErrorCode,
+      errorCategory: normalizedErrorCategory
+    });
+    const resolutionStage = outcome.resolution_stage ?? "execute";
+    const event = {
+      schema_version: TELEMETRY_SCHEMA_VERSION,
+      event_id: crypto.randomUUID(),
+      event_type: "command_finish",
+      occurred_at: finishedAt,
+      installation_id: activeCommand.installation_id,
+      session_id: PROCESS_SESSION_ID,
+      command: activeCommand.command,
+      payload: buildCommandFinishPayload({
+        captureLevel: activeCommand.capture_level,
+        pmVersion: activeCommand.pm_version,
+        sourceContext: {
+          source_context: activeCommand.source_context,
+          source_context_source: activeCommand.source_context_source
+        },
+        outcome,
+        durationMs,
+        startedAt: activeCommand.started_at,
+        command: activeCommand.command,
+        installationId: activeCommand.installation_id,
+        commandTaxonomy: activeCommand.command_taxonomy,
+        exitCode: normalizedExitCode,
+        errorCode: normalizedErrorCode,
+        errorCategory: normalizedErrorCategory,
+        commandResolution,
+        resolutionStage
+      })
+    };
+    await enqueueTelemetryEvent(activeCommand.global_pm_root, event);
+    const otelRequest = buildOtelSpanRequest(activeCommand, {
+      ...outcome,
+      exit_code: normalizedExitCode,
+      error_code: normalizedErrorCode,
+      error_category: normalizedErrorCategory
+    }, finishedAt, durationMs);
+    if (otelRequest) {
+      await enqueuePendingOtelSpan(activeCommand.global_pm_root, otelRequest);
+    }
+    scheduleTelemetryFlush(activeCommand.global_pm_root, activeCommand.endpoint, activeCommand.retention_days);
+  } catch {
+  }
+}
+async function emitTelemetryErrorEvent(context) {
+  if (telemetryDisabledByEnvironment()) {
+    return;
+  }
+  try {
+    const globalPmRoot = resolveGlobalPmRoot(process.cwd());
+    const settings = await readSettings(globalPmRoot);
+    if (!settings.telemetry.enabled) {
+      return;
+    }
+    const captureLevel = normalizeCaptureLevel(settings.telemetry.capture_level);
+    const { installationId, endpoint, retentionDays } = await ensureInstallationId(globalPmRoot);
+    const pmVersion = normalizePmVersion(context.pm_version);
+    const sourceContext = resolveTelemetrySourceContext(context.global);
+    const pmRootHash = hashWithInstallationId(installationId, context.pm_root);
+    const cwdHash = hashWithInstallationId(installationId, process.cwd());
+    const occurredAt = nowIso();
+    const normalizedErrorCode = normalizeTelemetryErrorCode(inferTelemetryErrorCode({
+      ok: false,
+      errorCode: context.error_code,
+      errorMessage: context.error_message,
+      exitCode: context.exit_code
+    }));
+    const normalizedErrorCategory = context.error_category ?? resolveTelemetryErrorCategory(normalizedErrorCode);
+    const normalizedExitCode = normalizeTelemetryExitCode(context.exit_code, false);
+    const normalizedCommand = context.command.trim().length > 0 ? context.command : "<unknown>";
+    const commandTaxonomy = deriveTelemetryCommandTaxonomy(normalizedCommand);
+    const commandResolution = context.command_resolution ?? deriveTelemetryCommandResolution({
+      ok: false,
+      errorCode: normalizedErrorCode,
+      errorCategory: normalizedErrorCategory
+    });
+    const resolutionStage = context.resolution_stage ?? "unknown";
+    const event = {
+      schema_version: TELEMETRY_SCHEMA_VERSION,
+      event_id: crypto.randomUUID(),
+      event_type: "command_error",
+      occurred_at: occurredAt,
+      installation_id: installationId,
+      session_id: PROCESS_SESSION_ID,
+      command: sanitizeString(normalizedCommand, "redacted"),
+      payload: buildCommandErrorPayload({
+        captureLevel,
+        pmVersion,
+        sourceContext,
+        command: normalizedCommand,
+        commandTaxonomy,
+        commandResolution,
+        resolutionStage,
+        args: context.args,
+        options: context.options,
+        pmRootHash,
+        cwdHash,
+        installationId,
+        errorCode: normalizedErrorCode,
+        errorCategory: normalizedErrorCategory,
+        exitCode: normalizedExitCode,
+        errorMessage: context.error_message
+      })
+    };
+    await enqueueTelemetryEvent(globalPmRoot, event);
+    scheduleTelemetryFlush(globalPmRoot, endpoint, retentionDays);
+  } catch {
+  }
+}
 
-// dist/sdk/start-task-status.js
-function resolveStartTaskInProgressStatus(statusRegistry) {
-  return normalizeStatusInputWithRegistry("in_progress", statusRegistry) ?? statusRegistry.open_status;
+// dist/sdk/ownership-source.js
+async function describeItemOwnershipConflict(pmRoot, itemId, assignee) {
+  const history = await readHistoryEntries(getHistoryPath(pmRoot, itemId), itemId).catch(() => []);
+  const latestOwnershipOperation = [...history].reverse().find((entry) => entry.patch.some((operation) => operation.path === "/metadata/assignee"))?.op;
+  return latestOwnershipOperation === "claim" ? `claimed by ${assignee}` : `assigned to ${assignee}`;
 }
 
 // dist/cli/commands/claim.js
@@ -277,7 +2080,7 @@ async function runClaim(id, force, global, options = {}) {
     message: options.message,
     force,
     skipNoop: true,
-    mutate(document) {
+    async mutate(document) {
       const currentAssignee = document.metadata.assignee;
       const currentAssigneeText = typeof currentAssignee === "string" ? currentAssignee : "";
       previousAssignee = currentAssigneeText.trim().length > 0 ? currentAssigneeText : null;
@@ -291,7 +2094,8 @@ async function runClaim(id, force, global, options = {}) {
         return { changedFields: [] };
       }
       if (heldByOther && !force) {
-        throw new PmCliError(`Item ${document.metadata.id} is already claimed by ${previousAssignee}. Use --force to take over, or --if-available to skip without failing.`, EXIT_CODE.CONFLICT, {
+        const ownershipPhrase = await describeItemOwnershipConflict(pmRoot, document.metadata.id, currentAssigneeText);
+        throw new PmCliError(`Item ${document.metadata.id} is already ${ownershipPhrase}. Use --force to take over, or --if-available to skip without failing.`, EXIT_CODE.CONFLICT, {
           code: "already_claimed_by",
           why: "Claim is an atomic test-and-set so parallel agents never proceed believing they own the same item.",
           nextSteps: [
@@ -1195,22 +2999,22 @@ function packageOwnedActionForCommand(command) {
 }
 function resolveActionCommandPath(action) {
   if (PM_CORE_COMMAND_NAMES.includes(action)) {
-    return normalizeCommandPath(action);
+    return normalizeCommandPath2(action);
   }
   if (action.startsWith("extension-")) {
-    return normalizeCommandPath(`extension ${action.slice("extension-".length)}`);
+    return normalizeCommandPath2(`extension ${action.slice("extension-".length)}`);
   }
   if (action.startsWith("package-")) {
-    return normalizeCommandPath(`package ${action.slice("package-".length)}`);
+    return normalizeCommandPath2(`package ${action.slice("package-".length)}`);
   }
   if (action.startsWith("test-runs-")) {
-    return normalizeCommandPath(`test-runs ${action.slice("test-runs-".length)}`);
+    return normalizeCommandPath2(`test-runs ${action.slice("test-runs-".length)}`);
   }
   if (action.startsWith("templates-")) {
-    return normalizeCommandPath(`templates ${action.slice("templates-".length)}`);
+    return normalizeCommandPath2(`templates ${action.slice("templates-".length)}`);
   }
   if (PACKAGE_OWNED_ACTIONS.has(action)) {
-    return PACKAGE_OWNED_ACTION_COMMAND_PATHS.get(action) ?? normalizeCommandPath(action);
+    return PACKAGE_OWNED_ACTION_COMMAND_PATHS.get(action) ?? normalizeCommandPath2(action);
   }
   return null;
 }
@@ -1226,7 +3030,7 @@ function actionDescriptorMatchesSelectedCommand(descriptor, selectedCommand) {
   });
 }
 function splitCommandPathAliases(commandPath) {
-  return commandPath.split("|").map((entry) => normalizeCommandPath(entry)).filter((entry) => entry.length > 0);
+  return commandPath.split("|").map((entry) => normalizeCommandPath2(entry)).filter((entry) => entry.length > 0);
 }
 function resolveScopedCommandsFromActionDescriptors(descriptors, commandCatalog) {
   const commandSet = new Set(commandCatalog);
@@ -1306,7 +3110,7 @@ function filterSchemaByActions(schema, actions) {
     oneOf: filtered
   };
 }
-function normalizeCommandPath(value) {
+function normalizeCommandPath2(value) {
   return value.trim().toLowerCase().split(/\s+/).filter((entry) => entry.length > 0).join(" ");
 }
 function normalizeActionNameFromCommand(commandPath) {
@@ -1391,7 +3195,7 @@ function toExtensionFlagContract(definition) {
 function collectExtensionFlagContractsByCommand(registrations) {
   const grouped = /* @__PURE__ */ new Map();
   for (const registration of registrations) {
-    const commandPath = normalizeCommandPath(registration.target_command);
+    const commandPath = normalizeCommandPath2(registration.target_command);
     if (commandPath.length === 0) {
       continue;
     }
@@ -1442,7 +3246,7 @@ function collectExtensionCommandContracts(runtimeProbe) {
   const flagsByCommand = collectExtensionFlagContractsByCommand(runtimeProbe.flagRegistrations);
   const definitionsByCommand = /* @__PURE__ */ new Map();
   for (const definition of runtimeProbe.commandDefinitions) {
-    const command = normalizeCommandPath(definition.command);
+    const command = normalizeCommandPath2(definition.command);
     if (command.length === 0) {
       continue;
     }
@@ -1476,7 +3280,7 @@ function collectExtensionCommandContracts(runtimeProbe) {
   }
   const extensionCommands = /* @__PURE__ */ new Set();
   for (const command of runtimeProbe.handlers) {
-    extensionCommands.add(normalizeCommandPath(command));
+    extensionCommands.add(normalizeCommandPath2(command));
   }
   for (const command of definitionsByCommand.keys()) {
     extensionCommands.add(command);
@@ -1663,7 +3467,7 @@ async function resolveRuntimeExtensionActionProbe(global) {
       ...loadResult,
       loaded: loadResult.loaded
     });
-    const handlers = new Set(activationResult.commands.handlers.map((entry) => normalizeCommandPath(entry.command)));
+    const handlers = new Set(activationResult.commands.handlers.map((entry) => normalizeCommandPath2(entry.command)));
     return {
       handlers,
       disabledReason: null,
@@ -1723,7 +3527,7 @@ function collectActionContractDescriptors(extensionContracts, options = {}) {
       action: contract.action,
       provider: "extension",
       requires_extension: true,
-      command_path: normalizeCommandPath(contract.command)
+      command_path: normalizeCommandPath2(contract.command)
     });
   }
   return [...descriptors.values()].sort((left, right) => (left.action ?? "").localeCompare(right.action ?? ""));
@@ -2080,7 +3884,7 @@ function buildContractsCommandCatalog(actionDescriptors, mergedExtensionContract
       ...actionDescriptors.flatMap((entry) => entry.command_path ? splitCommandPathAliases(entry.command_path) : []),
       ...mergedExtensionContracts.flatMap((entry) => entry.command.split("|"))
     ])
-  ].map((entry) => normalizeCommandPath(entry)).filter((entry) => entry.length > 0).sort((left, right) => left.localeCompare(right));
+  ].map((entry) => normalizeCommandPath2(entry)).filter((entry) => entry.length > 0).sort((left, right) => left.localeCompare(right));
 }
 function buildCommandNamespaceError(command, namespaceChildren) {
   const displayedNamespaceChildren = namespaceChildren.slice(0, COMMAND_NAMESPACE_DISPLAY_LIMIT);
@@ -2390,14 +4194,76 @@ async function runContracts(options, global) {
   return result;
 }
 
+// dist/cli/commands/scheduling-shortcuts.js
+var DEFAULT_DURATION = "1h";
+var DEFAULT_START = "now";
+var DEFAULT_REMINDER_AT = "+1d";
+function quoteCsvValue(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function appendPair(pairs, key, value) {
+  if (value !== void 0) {
+    pairs.push(`${key}=${quoteCsvValue(value)}`);
+  }
+}
+function buildCommonOptions(type, title, options) {
+  return {
+    type,
+    title,
+    schedulePreset: "lightweight",
+    parent: options.parent,
+    allowMissingParent: options.allowMissingParent,
+    tags: options.tags,
+    priority: options.priority,
+    body: options.body,
+    description: options.description,
+    author: options.author,
+    message: options.message
+  };
+}
+function buildEventEntry(options) {
+  const pairs = [];
+  appendPair(pairs, "start", options.start ?? DEFAULT_START);
+  if (options.end !== void 0) {
+    appendPair(pairs, "end", options.end);
+  } else {
+    appendPair(pairs, "duration", options.duration ?? DEFAULT_DURATION);
+  }
+  appendPair(pairs, "location", options.location);
+  appendPair(pairs, "timezone", options.timezone);
+  if (options.allDay === true) {
+    appendPair(pairs, "all_day", "true");
+  }
+  return pairs.join(",");
+}
+async function createScheduled(type, title, options, global) {
+  const createOptions = buildCommonOptions(type, title, options);
+  createOptions.event = [buildEventEntry(options)];
+  return runCreate(createOptions, global);
+}
+function runMeet(title, options, global) {
+  return createScheduled("Meeting", title, options, global);
+}
+function runEvent(title, options, global) {
+  return createScheduled("Event", title, options, global);
+}
+function runRemind(title, options, global) {
+  const createOptions = buildCommonOptions("Reminder", title, options);
+  const pairs = [];
+  appendPair(pairs, "at", options.at ?? DEFAULT_REMINDER_AT);
+  appendPair(pairs, "text", options.text ?? title);
+  createOptions.reminder = [pairs.join(",")];
+  return runCreate(createOptions, global);
+}
+
 // dist/sdk/governance/gc.js
 import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // dist/core/checkpoint/checkpoint-gc.js
 import fs from "node:fs/promises";
-import path from "node:path";
-var MILLISECONDS_PER_DAY = 864e5;
+import path2 from "node:path";
+var MILLISECONDS_PER_DAY2 = 864e5;
 function isErrno(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -2427,7 +4293,7 @@ async function collectCheckpointFiles(checkpointsDir, warnings) {
   const files = [];
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
-      const subdir = path.join(checkpointsDir, entry.name);
+      const subdir = path2.join(checkpointsDir, entry.name);
       let nested;
       try {
         nested = await fs.readdir(subdir);
@@ -2451,8 +4317,8 @@ async function collectCheckpointFiles(checkpointsDir, warnings) {
 async function runCheckpointGc(pmRoot, options) {
   const { dryRun, hooks } = options;
   const nowMs2 = options.now ?? Date.now();
-  const retentionMs = Math.max(0, options.retentionDays) * MILLISECONDS_PER_DAY;
-  const checkpointsDir = path.join(pmRoot, "checkpoints");
+  const retentionMs = Math.max(0, options.retentionDays) * MILLISECONDS_PER_DAY2;
+  const checkpointsDir = path2.join(pmRoot, "checkpoints");
   const result = {
     scanned: 0,
     removed: [],
@@ -2462,7 +4328,7 @@ async function runCheckpointGc(pmRoot, options) {
   };
   const files = await collectCheckpointFiles(checkpointsDir, result.warnings);
   for (const relName of files) {
-    const absPath = path.join(checkpointsDir, relName);
+    const absPath = path2.join(checkpointsDir, relName);
     const relPath = `checkpoints/${relName}`;
     result.scanned += 1;
     if (hooks?.onRead) {
@@ -2537,7 +4403,7 @@ async function runCheckpointGc(pmRoot, options) {
 
 // dist/core/lock/lock-gc.js
 import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 function parseLock(raw) {
   let parsed;
   try {
@@ -2610,7 +4476,7 @@ function classifyLockContent(file, raw, nowMs2) {
 }
 async function scanLockHealth(pmRoot, now) {
   const nowMs2 = now ?? Date.now();
-  const locksDir = path2.join(pmRoot, "locks");
+  const locksDir = path3.join(pmRoot, "locks");
   const scan = {
     scanned: 0,
     active_lock_count: 0,
@@ -2631,7 +4497,7 @@ async function scanLockHealth(pmRoot, now) {
   for (const file of dirEntries) {
     let raw;
     try {
-      raw = await fs2.readFile(path2.join(locksDir, file), "utf8");
+      raw = await fs2.readFile(path3.join(locksDir, file), "utf8");
     } catch (readError) {
       if (isErrno2(readError, "ENOENT")) {
         continue;
@@ -2655,7 +4521,7 @@ async function scanLockHealth(pmRoot, now) {
 async function runLockGc(pmRoot, options) {
   const { dryRun, hooks } = options;
   const nowMs2 = options.now ?? Date.now();
-  const locksDir = path2.join(pmRoot, "locks");
+  const locksDir = path3.join(pmRoot, "locks");
   const result = {
     scanned: 0,
     removed: [],
@@ -2675,7 +4541,7 @@ async function runLockGc(pmRoot, options) {
   }
   for (const file of dirEntries) {
     result.scanned += 1;
-    const absPath = path2.join(locksDir, file);
+    const absPath = path3.join(locksDir, file);
     const relPath = `locks/${file}`;
     if (hooks?.onRead) {
       const hookWarnings = await hooks.onRead(absPath);
@@ -2803,7 +4669,7 @@ function isErrno3(error, code) {
 }
 async function removeCacheFile(pmRoot, target, dryRun) {
   const relativePath = target.relativePath;
-  const absolutePath = path3.join(pmRoot, relativePath);
+  const absolutePath = path4.join(pmRoot, relativePath);
   const warnings = await runActiveOnReadHooks({
     path: absolutePath,
     scope: "project"
@@ -2980,7 +4846,7 @@ async function runGc(global, options = {}) {
 
 // dist/sdk/author-attribution.js
 import fs4 from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 var HISTORY_AUTHOR_ATTRIBUTION_BASELINE = "2026-07-15T06:22:12.276Z";
 var HISTORY_AUTHOR_ATTRIBUTION_BASELINE_MS = Date.parse(HISTORY_AUTHOR_ATTRIBUTION_BASELINE);
 var HISTORY_AUTHOR_EVENT_CLASSIFICATIONS = [
@@ -3029,7 +4895,7 @@ var inspectHistoryAuthorStream = (itemId, raw, sampleLimit = 20) => {
   };
 };
 var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
-  const historyDirectory = path4.join(pmRoot, "history");
+  const historyDirectory = path5.join(pmRoot, "history");
   let fileNames;
   try {
     fileNames = (await fs4.readdir(historyDirectory)).filter((fileName) => fileName.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
@@ -3046,7 +4912,7 @@ var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
   for (const fileName of fileNames) {
     let raw;
     try {
-      raw = await fs4.readFile(path4.join(historyDirectory, fileName), "utf8");
+      raw = await fs4.readFile(path5.join(historyDirectory, fileName), "utf8");
     } catch {
       continue;
     }
@@ -3075,7 +4941,7 @@ var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
 
 // dist/sdk/governance/health.js
 import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // dist/core/diagnostics/remediation.js
 var REMEDIATION_REGISTRY = Object.freeze([
@@ -3447,11 +5313,11 @@ function buildRemediationCommands(warnings) {
 }
 
 // dist/sdk/governance/health.js
-var PM_TELEMETRY_SOURCE_CONTEXT_SET = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
+var PM_TELEMETRY_SOURCE_CONTEXT_SET2 = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
 var STALE_VECTORIZATION_SUMMARY_LIMIT = 25;
 var BRIEF_HEALTH_DETAIL_LIMIT = 8;
-var TELEMETRY_QUEUE_RELATIVE_PATH = path5.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH = path5.join("runtime", "telemetry", "state.json");
+var TELEMETRY_QUEUE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "state.json");
 var TELEMETRY_ENDPOINT_PROBE_TIMEOUT_MS = 2500;
 var TELEMETRY_QUEUE_HIGH_WATER_MARK = 500;
 var TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD = TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS - 3;
@@ -3490,7 +5356,7 @@ async function isDirectory(targetPath) {
   }
 }
 async function countHistoryStreams(pmRoot, compactPolicy) {
-  const historyDir = path5.join(pmRoot, "history");
+  const historyDir = path6.join(pmRoot, "history");
   if (!await isDirectory(historyDir)) {
     return { count: 0, warnings: [], over_threshold: [], max_entries: null };
   }
@@ -3500,7 +5366,7 @@ async function countHistoryStreams(pmRoot, compactPolicy) {
   const warnings = [];
   const overThreshold = [];
   for (const fileName of historyFiles) {
-    const streamPath = path5.join(historyDir, fileName);
+    const streamPath = path6.join(historyDir, fileName);
     warnings.push(...await runActiveOnReadHooks({ path: streamPath, scope: "project" }));
     if (!policyActive) {
       continue;
@@ -3527,13 +5393,13 @@ async function countHistoryStreams(pmRoot, compactPolicy) {
   };
 }
 function normalizeRelativePath(pmRoot, targetPath) {
-  return path5.relative(pmRoot, targetPath).replaceAll("\\", "/");
+  return path6.relative(pmRoot, targetPath).replaceAll("\\", "/");
 }
 async function listItemDocumentPaths(pmRoot, typeToFolder) {
   const folders = [...new Set(Object.values(typeToFolder))].sort((left, right) => left.localeCompare(right));
   const itemPaths = [];
   for (const folder of folders) {
-    const directoryPath = path5.join(pmRoot, folder);
+    const directoryPath = path6.join(pmRoot, folder);
     let entries = [];
     try {
       entries = await fs5.readdir(directoryPath);
@@ -3547,7 +5413,7 @@ async function listItemDocumentPaths(pmRoot, typeToFolder) {
       if (!ITEM_FILE_EXTENSIONS.some((extension) => entry.toLowerCase().endsWith(extension))) {
         continue;
       }
-      itemPaths.push(path5.join(directoryPath, entry));
+      itemPaths.push(path6.join(directoryPath, entry));
     }
   }
   itemPaths.sort((left, right) => normalizeRelativePath(pmRoot, left).localeCompare(normalizeRelativePath(pmRoot, right)));
@@ -3596,7 +5462,7 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
     }
   }
   const formatVersionScan = scanItemFormatVersions(formatVersionEntries);
-  const historyDir = path5.join(pmRoot, "history");
+  const historyDir = path6.join(pmRoot, "history");
   const historyUnreadable = [];
   const historyConflictMarkers = [];
   const historyInvalidJson = [];
@@ -3610,7 +5476,7 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
   }
   for (const fileName of historyFiles) {
     const itemId = fileName.slice(0, -".jsonl".length);
-    const historyPath = path5.join(historyDir, fileName);
+    const historyPath = path6.join(historyDir, fileName);
     let raw = "";
     try {
       raw = await fs5.readFile(historyPath, "utf8");
@@ -4221,7 +6087,7 @@ function telemetryEnvFlagEnabled(envKey) {
 }
 function telemetrySourceContextOverride() {
   const value = (process.env.PM_TELEMETRY_SOURCE_CONTEXT ?? "").trim().toLowerCase();
-  return PM_TELEMETRY_SOURCE_CONTEXT_SET.has(value) ? value : null;
+  return PM_TELEMETRY_SOURCE_CONTEXT_SET2.has(value) ? value : null;
 }
 function normalizeEndpointForDisplay(rawEndpoint) {
   const trimmed = rawEndpoint.trim();
@@ -4407,9 +6273,9 @@ async function probeTelemetryEndpointHealth(endpoint) {
 }
 async function buildTelemetryCheck(settings, options) {
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  const queuePath = path5.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
-  const statePath = path5.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
-  const queueRaw = await readFileIfExists(queuePath);
+  const queuePath2 = path6.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
+  const statePath = path6.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
+  const queueRaw = await readFileIfExists(queuePath2);
   const queueExists = queueRaw !== null;
   const queueSizeBytes = queueRaw ? Buffer.byteLength(queueRaw, "utf8") : 0;
   const queueSummary = queueRaw ? parseTelemetryQueue(queueRaw) : emptyTelemetryQueueSummary();
@@ -4434,7 +6300,7 @@ async function buildTelemetryCheck(settings, options) {
         capture_level: settings.telemetry.capture_level,
         endpoint: endpointDisplay,
         global_pm_root: globalPmRoot,
-        queue_path: queuePath,
+        queue_path: queuePath2,
         queue_exists: queueExists,
         queue_entries: queueSummary.validEntries,
         queue_draining: isTelemetryQueueDraining(queueHasEntries, warnings),
@@ -4739,7 +6605,7 @@ async function scanHealthDirectories(pmRoot, typeRegistry, strictDirectories) {
   const missingOptionalDirs = [];
   const hookWarnings = [];
   for (const relativeDir of [...requiredDirs, ...optionalDirs]) {
-    const directoryPath = path5.join(pmRoot, relativeDir);
+    const directoryPath = path6.join(pmRoot, relativeDir);
     hookWarnings.push(...await runActiveOnReadHooks({
       path: directoryPath,
       scope: "project"
@@ -5037,71 +6903,9 @@ var _testOnlyHealthCommand = {
   warningCode
 };
 
-// dist/cli/commands/scheduling-shortcuts.js
-var DEFAULT_DURATION = "1h";
-var DEFAULT_START = "now";
-var DEFAULT_REMINDER_AT = "+1d";
-function quoteCsvValue(value) {
-  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-function appendPair(pairs, key, value) {
-  if (value !== void 0) {
-    pairs.push(`${key}=${quoteCsvValue(value)}`);
-  }
-}
-function buildCommonOptions(type, title, options) {
-  return {
-    type,
-    title,
-    schedulePreset: "lightweight",
-    parent: options.parent,
-    allowMissingParent: options.allowMissingParent,
-    tags: options.tags,
-    priority: options.priority,
-    body: options.body,
-    description: options.description,
-    author: options.author,
-    message: options.message
-  };
-}
-function buildEventEntry(options) {
-  const pairs = [];
-  appendPair(pairs, "start", options.start ?? DEFAULT_START);
-  if (options.end !== void 0) {
-    appendPair(pairs, "end", options.end);
-  } else {
-    appendPair(pairs, "duration", options.duration ?? DEFAULT_DURATION);
-  }
-  appendPair(pairs, "location", options.location);
-  appendPair(pairs, "timezone", options.timezone);
-  if (options.allDay === true) {
-    appendPair(pairs, "all_day", "true");
-  }
-  return pairs.join(",");
-}
-async function createScheduled(type, title, options, global) {
-  const createOptions = buildCommonOptions(type, title, options);
-  createOptions.event = [buildEventEntry(options)];
-  return runCreate(createOptions, global);
-}
-function runMeet(title, options, global) {
-  return createScheduled("Meeting", title, options, global);
-}
-function runEvent(title, options, global) {
-  return createScheduled("Event", title, options, global);
-}
-function runRemind(title, options, global) {
-  const createOptions = buildCommonOptions("Reminder", title, options);
-  const pairs = [];
-  appendPair(pairs, "at", options.at ?? DEFAULT_REMINDER_AT);
-  appendPair(pairs, "text", options.text ?? title);
-  createOptions.reminder = [pairs.join(",")];
-  return runCreate(createOptions, global);
-}
-
 // dist/sdk/stats.js
 import fs6 from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // dist/core/history/history-storage-stats.js
 function shouldReplaceExtreme(candidate, current, candidateTieBreaker, currentTieBreaker, direction, tieDirection = "min") {
@@ -5157,21 +6961,21 @@ function computeHistoryStorageStats(streams, options) {
   let newestEntry = null;
   let globalOldestMs = Number.POSITIVE_INFINITY;
   let globalNewestMs = Number.NEGATIVE_INFINITY;
-  for (const stat of stats) {
-    totalLines += stat.lines;
-    totalBytes += stat.bytes;
-    if (stat.oldest_ts !== null) {
-      const ms = Date.parse(stat.oldest_ts);
-      if (shouldReplaceExtreme(ms, globalOldestMs, stat.id, oldestEntry?.id ?? null, "min")) {
+  for (const stat2 of stats) {
+    totalLines += stat2.lines;
+    totalBytes += stat2.bytes;
+    if (stat2.oldest_ts !== null) {
+      const ms = Date.parse(stat2.oldest_ts);
+      if (shouldReplaceExtreme(ms, globalOldestMs, stat2.id, oldestEntry?.id ?? null, "min")) {
         globalOldestMs = ms;
-        oldestEntry = { id: stat.id, ts: stat.oldest_ts };
+        oldestEntry = { id: stat2.id, ts: stat2.oldest_ts };
       }
     }
-    if (stat.newest_ts !== null) {
-      const ms = Date.parse(stat.newest_ts);
-      if (shouldReplaceExtreme(ms, globalNewestMs, stat.id, newestEntry?.id ?? null, "max")) {
+    if (stat2.newest_ts !== null) {
+      const ms = Date.parse(stat2.newest_ts);
+      if (shouldReplaceExtreme(ms, globalNewestMs, stat2.id, newestEntry?.id ?? null, "max")) {
         globalNewestMs = ms;
-        newestEntry = { id: stat.id, ts: stat.newest_ts };
+        newestEntry = { id: stat2.id, ts: stat2.newest_ts };
       }
     }
   }
@@ -5208,7 +7012,7 @@ function countNonEmptyLines(raw) {
   return raw.split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
 }
 async function readHistoryStreamContents(pmRoot) {
-  const historyDir = path6.join(pmRoot, "history");
+  const historyDir = path7.join(pmRoot, "history");
   if (!await pathExists(historyDir)) {
     return [];
   }
@@ -5219,7 +7023,7 @@ async function readHistoryStreamContents(pmRoot) {
   const historyFiles = (await fs6.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((a, b) => a.localeCompare(b));
   const streams = [];
   for (const file of historyFiles) {
-    const historyPath = path6.join(historyDir, file);
+    const historyPath = path7.join(historyDir, file);
     const raw = await readFileIfExists(historyPath);
     if (raw === null) {
       continue;
@@ -5293,10 +7097,10 @@ async function runStats(global, options = {}) {
 
 // dist/sdk/telemetry.js
 import fs7 from "node:fs/promises";
-import path7 from "node:path";
-var TELEMETRY_QUEUE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "state.json");
-var TELEMETRY_RUNTIME_RELATIVE_PATH = path7.join("runtime", "telemetry");
+import path8 from "node:path";
+var TELEMETRY_QUEUE_RELATIVE_PATH3 = path8.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH3 = path8.join("runtime", "telemetry", "state.json");
+var TELEMETRY_RUNTIME_RELATIVE_PATH = path8.join("runtime", "telemetry");
 var DEFAULT_STATS_LIMIT = 20;
 var TELEMETRY_SUBCOMMANDS = [
   "status",
@@ -5513,15 +7317,15 @@ var readTelemetryRuntimeState = async (statePath) => {
 var nullableTelemetryStateValue = (value) => value ?? null;
 var buildTelemetryStatusSummary = async (globalPmRoot) => {
   const settings = await readSettings(globalPmRoot);
-  const queuePath = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
-  const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
-  const queueRaw = await readFileIfExists(queuePath);
+  const queuePath2 = path8.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3);
+  const statePath = path8.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3);
+  const queueRaw = await readFileIfExists(queuePath2);
   const queue = parseTelemetryQueue2(queueRaw);
   const runtimeState = await readTelemetryRuntimeState(statePath);
   return {
     enabled: settings.telemetry.enabled,
     endpoint: settings.telemetry.endpoint,
-    queue_path: queuePath,
+    queue_path: queuePath2,
     state_path: statePath,
     queue_rows_total: queue.rows_total,
     queue_entries: queue.valid_entries,
@@ -5592,7 +7396,7 @@ var runTelemetryClear = async (_options, context) => {
   if (settingsChanged) {
     await writeSettings(context.globalPmRoot, settings, "telemetry:clear");
   }
-  const telemetryRuntimePath = path7.join(context.globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
+  const telemetryRuntimePath = path8.join(context.globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
   const existed = await pathExists(telemetryRuntimePath);
   await fs7.rm(telemetryRuntimePath, { recursive: true, force: true });
   return {
@@ -5618,8 +7422,8 @@ var runTelemetry = async (options, _global) => {
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
   return TELEMETRY_COMMAND_HANDLERS[subcommand](options, {
     globalPmRoot,
-    queuePath: path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2),
-    statePath: path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2)
+    queuePath: path8.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3),
+    statePath: path8.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3)
   });
 };
 
@@ -6080,10 +7884,10 @@ function firstPositionalToken(tokens, flagsWithValue = /* @__PURE__ */ new Set()
 }
 
 // dist/sdk/test/execution.js
-import { spawn } from "node:child_process";
-import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { spawn as spawn2 } from "node:child_process";
+import { cp, mkdir as mkdir2, mkdtemp, readdir as readdir2, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 
 // dist/core/test/item-test-run-tracking.js
 var DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT = 20;
@@ -6762,7 +8566,7 @@ async function killProcessTree(pid) {
   }
   if (process.platform === "win32") {
     await new Promise((resolve) => {
-      const killer = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      const killer = spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], {
         stdio: "ignore",
         windowsHide: true
       });
@@ -6899,7 +8703,7 @@ function waitForLinkedTestChildClose(child) {
   });
 }
 function createLinkedTestChild(command, env) {
-  return spawn(command, {
+  return spawn2(command, {
     cwd: process.cwd(),
     env,
     shell: true,
@@ -7071,7 +8875,7 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
   if (!await pathExists(sourcePath)) {
     return;
   }
-  await mkdir(path8.dirname(targetPath), { recursive: true });
+  await mkdir2(path9.dirname(targetPath), { recursive: true });
   try {
     if (recursive) {
       await cp(sourcePath, targetPath, { recursive: true, force: true });
@@ -7087,21 +8891,21 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
 }
 async function seedLinkedTestSandbox(sandboxPmPath, sandboxGlobalPath, sourceRoots) {
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.projectPmRoot), getSettingsPath(sandboxPmPath));
-  await copyIntoSandboxIfPresent(path8.join(sourceRoots.projectPmRoot, "extensions"), path8.join(sandboxPmPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path9.join(sourceRoots.projectPmRoot, "extensions"), path9.join(sandboxPmPath, "extensions"), true);
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.globalPmRoot), getSettingsPath(sandboxGlobalPath));
-  await copyIntoSandboxIfPresent(path8.join(sourceRoots.globalPmRoot, "extensions"), path8.join(sandboxGlobalPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path9.join(sourceRoots.globalPmRoot, "extensions"), path9.join(sandboxGlobalPath, "extensions"), true);
 }
 async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
   if (!await pathExists(sourceRoot)) {
     return;
   }
-  const entries = await readdir(sourceRoot, { withFileTypes: true });
+  const entries = await readdir2(sourceRoot, { withFileTypes: true });
   for (const entry of entries) {
     if (LINKED_TEST_TRACKER_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const sourcePath = path8.join(sourceRoot, entry.name);
-    const targetPath = path8.join(sandboxRoot, entry.name);
+    const sourcePath = path9.join(sourceRoot, entry.name);
+    const targetPath = path9.join(sandboxRoot, entry.name);
     if (entry.isDirectory()) {
       await copyIntoSandboxIfPresent(sourcePath, targetPath, true);
       continue;
@@ -7116,15 +8920,15 @@ async function countLinkedTestItemFiles(pmRoot) {
     return 0;
   }
   let total = 0;
-  const entries = await readdir(pmRoot, { withFileTypes: true });
+  const entries = await readdir2(pmRoot, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory() || LINKED_TEST_ITEM_COUNT_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const folderPath = path8.join(pmRoot, entry.name);
+    const folderPath = path9.join(pmRoot, entry.name);
     let files;
     try {
-      files = await readdir(folderPath, { withFileTypes: true });
+      files = await readdir2(folderPath, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -7316,10 +9120,10 @@ ${stderr}`;
 function createLinkedTestSandboxLayout(sandboxRoot) {
   return {
     root: sandboxRoot,
-    schemaProjectPmPath: path8.join(sandboxRoot, "schema", "project", ".agents", "pm"),
-    schemaGlobalPmPath: path8.join(sandboxRoot, "schema", "global"),
-    trackerProjectPmPath: path8.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
-    trackerGlobalPmPath: path8.join(sandboxRoot, "tracker", "global")
+    schemaProjectPmPath: path9.join(sandboxRoot, "schema", "project", ".agents", "pm"),
+    schemaGlobalPmPath: path9.join(sandboxRoot, "schema", "global"),
+    trackerProjectPmPath: path9.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
+    trackerGlobalPmPath: path9.join(sandboxRoot, "tracker", "global")
   };
 }
 async function initializeLinkedTestSandboxes(layout) {
@@ -7519,7 +9323,7 @@ async function runSingleLinkedTest(params) {
 }
 async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
   const results = [];
-  const sandboxRoot = await mkdtemp(path8.join(tmpdir(), "pm-linked-test-"));
+  const sandboxRoot = await mkdtemp(path9.join(tmpdir(), "pm-linked-test-"));
   const layout = createLinkedTestSandboxLayout(sandboxRoot);
   const runLevelPmContextMode = parsePmContextMode(options?.pmContext);
   const progressMode = options?.progress === true ? "always" : "auto";
@@ -7562,7 +9366,7 @@ async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
       }));
     }
   } finally {
-    await rm(layout.root, {
+    await rm2(layout.root, {
       recursive: true,
       force: true,
       maxRetries: 3,
@@ -8230,13 +10034,13 @@ var runTestAll = async (options, global) => {
 };
 
 // dist/sdk/test/runs.js
-import os from "node:os";
+import os2 from "node:os";
 
 // dist/core/test/background-runs.js
 import fs8 from "node:fs/promises";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import path9 from "node:path";
+import path10 from "node:path";
 var BACKGROUND_RUN_ACTIVE_STATUSES = /* @__PURE__ */ new Set([
   "queued",
   "running"
@@ -8274,7 +10078,7 @@ function buildBackgroundTestRunFingerprint(kind, commandArgs, pmRoot) {
   const payload = {
     kind,
     command: normalizeCommandArgs(commandArgs),
-    pm_root: path9.resolve(pmRoot)
+    pm_root: path10.resolve(pmRoot)
   };
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -8330,7 +10134,7 @@ async function listBackgroundRunRecordPaths(pmRoot) {
     return [];
   }
   const entries = await fs8.readdir(recordsRoot, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path9.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path10.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
 }
 function parseLinuxRssStatus(raw) {
   const match = raw.match(/^VmRSS:\s+(\d+)\s+kB$/m);
@@ -8508,18 +10312,18 @@ function tailLines(value, limit) {
 async function resolveBackgroundCliEntry(cwd) {
   const configured = process.env.PM_BACKGROUND_CLI_ENTRY?.trim();
   if (configured && configured.length > 0) {
-    const resolvedConfigured = path9.resolve(cwd, configured);
+    const resolvedConfigured = path10.resolve(cwd, configured);
     if (await pathExists(resolvedConfigured)) {
       return resolvedConfigured;
     }
   }
-  const distEntry = path9.resolve(cwd, "dist", "cli.js");
+  const distEntry = path10.resolve(cwd, "dist", "cli.js");
   if (await pathExists(distEntry)) {
     return distEntry;
   }
   const argvEntry = process.argv[1]?.trim();
   if (argvEntry && argvEntry.length > 0) {
-    const resolvedArgvEntry = path9.resolve(cwd, argvEntry);
+    const resolvedArgvEntry = path10.resolve(cwd, argvEntry);
     if (await pathExists(resolvedArgvEntry)) {
       return resolvedArgvEntry;
     }
@@ -8633,7 +10437,7 @@ async function spawnBackgroundTestRunWorker(options) {
     PM_BACKGROUND_TEST_RUN_RESUMED_FROM: record.resumed_from ?? "",
     FORCE_COLOR: "0"
   };
-  const child = spawn2(process.execPath, [cliEntry, ...args], {
+  const child = spawn3(process.execPath, [cliEntry, ...args], {
     cwd: process.cwd(),
     env,
     detached: true,
@@ -8815,7 +10619,7 @@ async function runBackgroundTestRunWorker(pmRoot, runId, noExtensions = false) {
   const env = buildBackgroundWorkerEnv(record);
   await writeBackgroundRunRecord(pmRoot, record);
   const childArgs = buildBackgroundWorkerChildArgs(record, noExtensions);
-  const child = spawn2(process.execPath, [cliEntry, ...childArgs], {
+  const child = spawn3(process.execPath, [cliEntry, ...childArgs], {
     cwd: process.cwd(),
     env,
     detached: false,
@@ -9100,7 +10904,7 @@ function normalizeStream(value) {
 }
 function resolveWhoamiFallback() {
   try {
-    const username = os.userInfo().username.trim();
+    const username = os2.userInfo().username.trim();
     if (username.length > 0) {
       return username;
     }
@@ -9239,7 +11043,7 @@ async function runTestRunsWorker(runId, global) {
 import fs9 from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
-import path10 from "node:path";
+import path11 from "node:path";
 import { promisify } from "node:util";
 
 // dist/core/validate/fix-planning.js
@@ -9545,8 +11349,8 @@ function buildMissingLinkedPathRows(rows, lookup) {
       });
     }
   }
-  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path11, bucket]) => ({
-    path: path11,
+  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path12, bucket]) => ({
+    path: path12,
     classification: bucket.classification,
     items: [...bucket.owners.values()].map((owner) => {
       const metadata = lookup(owner.item_id);
@@ -9883,16 +11687,16 @@ function resolveFileScanMode(scanMode) {
   throw new PmCliError(`Unknown --scan-mode value "${scanMode}". Supported values: ${VALIDATE_FILE_SCAN_MODES.join(", ")}.`, EXIT_CODE.USAGE);
 }
 function resolveWorkspaceRoot(pmRoot) {
-  const resolvedPmRoot = path10.resolve(pmRoot);
+  const resolvedPmRoot = path11.resolve(pmRoot);
   const normalizedPmRoot = resolvedPmRoot.replaceAll("\\", "/");
   if (normalizedPmRoot.endsWith("/.agents/pm")) {
-    return path10.dirname(path10.dirname(resolvedPmRoot));
+    return path11.dirname(path11.dirname(resolvedPmRoot));
   }
-  const resolvedCwd = path10.resolve(process.cwd());
+  const resolvedCwd = path11.resolve(process.cwd());
   const canonicalPmRoot = realpathForWorkspaceRoot(resolvedPmRoot);
   const canonicalCwd = realpathForWorkspaceRoot(resolvedCwd);
-  const relativeFromPmRoot = path10.relative(canonicalPmRoot, canonicalCwd);
-  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path10.isAbsolute(relativeFromPmRoot);
+  const relativeFromPmRoot = path11.relative(canonicalPmRoot, canonicalCwd);
+  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path11.isAbsolute(relativeFromPmRoot);
   if (cwdInsidePmRoot) {
     return resolvedPmRoot;
   }
@@ -9902,11 +11706,11 @@ function realpathForWorkspaceRoot(inputPath) {
   try {
     return realpathSync.native(inputPath);
   } catch {
-    return path10.resolve(inputPath);
+    return path11.resolve(inputPath);
   }
 }
 async function listFilesRecursive(basePath, relativePath, output) {
-  const targetDirectory = relativePath.length > 0 ? path10.join(basePath, relativePath) : basePath;
+  const targetDirectory = relativePath.length > 0 ? path11.join(basePath, relativePath) : basePath;
   let entries;
   try {
     entries = await fs9.readdir(targetDirectory, { withFileTypes: true });
@@ -9920,7 +11724,7 @@ async function listFilesRecursive(basePath, relativePath, output) {
     if (entry.name.startsWith(".")) {
       continue;
     }
-    const childRelative = relativePath.length > 0 ? path10.join(relativePath, entry.name) : entry.name;
+    const childRelative = relativePath.length > 0 ? path11.join(relativePath, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (DIRECTORY_IGNORE_SET.has(entry.name)) {
         continue;
@@ -9940,7 +11744,7 @@ async function collectDefaultProjectFileCandidates(workspaceRoot) {
     await listFilesRecursive(workspaceRoot, directory, discovered);
   }
   for (const candidate of FILE_SCAN_ROOT_FILES) {
-    const absolute = path10.join(workspaceRoot, candidate);
+    const absolute = path11.join(workspaceRoot, candidate);
     try {
       const stats = await fs9.stat(absolute);
       if (stats.isFile()) {
@@ -9972,7 +11776,7 @@ function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
   if (configuredDefault.length > 0) {
     prefixes.add(configuredDefault);
   }
-  const relativePmRoot = normalizeRelativeDirectoryPath(path10.relative(workspaceRoot, pmRoot));
+  const relativePmRoot = normalizeRelativeDirectoryPath(path11.relative(workspaceRoot, pmRoot));
   if (relativePmRoot.length > 0 && !relativePmRoot.startsWith("..")) {
     prefixes.add(relativePmRoot);
   }
@@ -10452,30 +12256,30 @@ function resolveLifecycleDependencyCycleSamplePath(component, graph) {
     return [start, start];
   }
   const componentSet = new Set(component);
-  const path11 = [start];
+  const path12 = [start];
   const visited = /* @__PURE__ */ new Set([start]);
   const search = (current) => {
     const neighbors = (graph.get(current) ?? []).filter((candidate) => componentSet.has(candidate));
     for (const next of neighbors) {
-      if (next === start && path11.length > 1) {
-        path11.push(start);
+      if (next === start && path12.length > 1) {
+        path12.push(start);
         return true;
       }
       if (visited.has(next)) {
         continue;
       }
       visited.add(next);
-      path11.push(next);
+      path12.push(next);
       if (search(next)) {
         return true;
       }
-      path11.pop();
+      path12.pop();
       visited.delete(next);
     }
     return false;
   };
   if (search(start)) {
-    return [...path11];
+    return [...path12];
   }
   return [...component, start];
 }
@@ -10733,7 +12537,7 @@ function linkedArtifactPathExceedsFilesystemLimits(artifactPath) {
   return normalized.length > LINKED_ARTIFACT_MAX_PATH_LENGTH || normalized.split(/[\\/]/).some((segment) => segment.length > LINKED_ARTIFACT_MAX_SEGMENT_LENGTH);
 }
 async function linkedArtifactIsMissing(workspaceRoot, artifactPath) {
-  const absolutePath = path10.isAbsolute(artifactPath) ? artifactPath : path10.resolve(workspaceRoot, artifactPath);
+  const absolutePath = path11.isAbsolute(artifactPath) ? artifactPath : path11.resolve(workspaceRoot, artifactPath);
   if (linkedArtifactPathExceedsFilesystemLimits(absolutePath)) {
     return false;
   }
@@ -11399,20 +13203,31 @@ var runValidate2 = (options, global) => runValidate(options, global, {
   runUpdate: (id, updateOptions, updateGlobal) => runUpdate(id, updateOptions, updateGlobal)
 });
 
+// dist/sdk/start-task-status.js
+function resolveStartTaskInProgressStatus(statusRegistry) {
+  return normalizeStatusInputWithRegistry("in_progress", statusRegistry) ?? statusRegistry.open_status;
+}
+
 export {
-  resolveStartTaskInProgressStatus,
+  deriveTelemetryCommandTaxonomy,
+  deriveTelemetryCommandResolution,
+  flushTelemetryQueueNow,
+  startTelemetryCommand,
+  finishTelemetryCommand,
+  emitTelemetryErrorEvent,
+  describeItemOwnershipConflict,
   runClaim,
   runClaimNext,
   runRelease,
   runContracts,
+  runMeet,
+  runEvent,
+  runRemind,
   runGc,
   inspectHistoryAuthorStream,
   scanHistoryAuthorAttribution,
   runHealth,
   _testOnlyHealthCommand,
-  runMeet,
-  runEvent,
-  runRemind,
   runStats,
   TELEMETRY_SUBCOMMANDS,
   runTelemetry,
@@ -11433,8 +13248,9 @@ export {
   runTestRunsWorker,
   _testOnlyValidateCommand,
   runValidate,
-  runValidate2
+  runValidate2,
+  resolveStartTaskInProgressStatus
 };
-//# sourceMappingURL=chunk-6VHUGVNP.js.map
+//# sourceMappingURL=chunk-ODEIDKGW.js.map
 
-//# debugId=85084307-fe97-5ecd-bfa8-3c803663a33c
+//# debugId=b111adf0-7ac6-5083-9fb7-c9a093abf43b