@unbrained/pm-cli 2026.7.14 → 2026.7.15

package/dist/cli-bundle/sdk.js

@@ -1,3 +1,7 @@
+import {
+  applyInvocationAuthorOverride,
+  createPmCliProgram
+} from "./chunks/chunk-ZKRZY773.js";
 import {
   PM_CLI_EXPECTED_ERROR_NAME,
   PmClient,
@@ -32,6 +36,11 @@ import {
   getContracts,
   getWorkspaceContracts,
   health,
+  historyCompact,
+  historyCompactBulk,
+  historyRedact,
+  historyRepair,
+  historyRepairAll,
   init,
   isPmCliExpectedError,
   learnings,
@@ -104,25 +113,73 @@ import {
   update,
   upgrade,
   validate
-} from "./chunks/chunk-5URI7TPJ.js";
-import "./chunks/chunk-ZHBI2AP7.js";
+} from "./chunks/chunk-4XQ3BDV4.js";
 import "./chunks/chunk-6X5MZ5R2.js";
 import "./chunks/chunk-3HKUXVKV.js";
-import "./chunks/chunk-RGXD5JJR.js";
+import "./chunks/chunk-PNTULOGU.js";
 import {
+  assertHistoryRepairTarget,
+  runHistoryRepair,
+  runHistoryRepairAll
+} from "./chunks/chunk-LSG2U345.js";
+import {
+  _testOnlyHealthCommand,
+  _testOnlyValidateCommand,
+  inspectHistoryAuthorStream,
+  runGc,
+  runHealth,
   runTestRunsList,
   runTestRunsLogs,
   runTestRunsResume,
   runTestRunsStatus,
-  runTestRunsStop
-} from "./chunks/chunk-IGED7NH2.js";
+  runTestRunsStop,
+  runValidate,
+  scanHistoryAuthorAttribution
+} from "./chunks/chunk-ILX33QXL.js";
+import {
+  runDocs
+} from "./chunks/chunk-ODALILG3.js";
+import {
+  RelationshipGraph,
+  RelationshipKindRegistry,
+  buildRelationshipContext,
+  collectDanglingDependencyReferences,
+  createRelationshipKindRegistry,
+  dependencyToRelationship,
+  isOrderingRelationshipKind,
+  runDeps
+} from "./chunks/chunk-BKVG6XOA.js";
+import "./chunks/chunk-KG44YSKD.js";
+import "./chunks/chunk-6S3YSUYG.js";
+import "./chunks/chunk-H2Z3FYXQ.js";
+import "./chunks/chunk-3AUGG2DP.js";
+import "./chunks/chunk-AHVTB5I5.js";
+import {
+  PROFILE_SUBCOMMANDS,
+  _testOnly as _testOnly4,
+  describeProfileComposition,
+  describeProjectProfile,
+  formatProfileApplyHuman,
+  formatProfileLintHuman,
+  formatProfileListHuman,
+  formatProfileShowHuman,
+  loadCreateTemplateOptions,
+  planProfileApplication,
+  runProfileApply,
+  runProfileLint,
+  runProfileList,
+  runProfileShow,
+  runTemplatesList,
+  runTemplatesSave,
+  runTemplatesShow
+} from "./chunks/chunk-UWQHLMEB.js";
+import "./chunks/chunk-FMBNM2EN.js";
+import "./chunks/chunk-34L5OT3Y.js";
+import "./chunks/chunk-ZHBI2AP7.js";
 import {
   runFiles,
   runFilesDiscover
-} from "./chunks/chunk-FS6UM5WH.js";
-import {
-  runDocs
-} from "./chunks/chunk-JAF4TUQ7.js";
+} from "./chunks/chunk-ZI6VQWQ7.js";
 import {
   applyPathMigrations,
   applyStandaloneNote,
@@ -139,28 +196,25 @@ import {
   runLinkedArtifacts,
   sortLinkedArtifacts,
   validateLinkedPaths
-} from "./chunks/chunk-FIGXOCEQ.js";
+} from "./chunks/chunk-WUJQK4YV.js";
+import "./chunks/chunk-FNSPG7MU.js";
+import "./chunks/chunk-YBLZ2VE7.js";
+import "./chunks/chunk-UOHFKBUV.js";
+import "./chunks/chunk-6CFNAVTF.js";
+import "./chunks/chunk-CRVF2JDM.js";
 import {
-  collectDanglingDependencyReferences,
-  runDeps
-} from "./chunks/chunk-B5DZYTT3.js";
-import "./chunks/chunk-M6ASXYCU.js";
-import "./chunks/chunk-KADLSPIU.js";
-import "./chunks/chunk-ERL2YFJ2.js";
-import "./chunks/chunk-KB726FMH.js";
-import "./chunks/chunk-TH7U4KLY.js";
-import "./chunks/chunk-IFZA4VB5.js";
+  PLAN_SHOW_DEPTH_VALUES,
+  PLAN_SUBCOMMANDS,
+  PLAN_TEMPLATE_NAMES
+} from "./chunks/chunk-K2X6U4UA.js";
 import {
-  describeProfileComposition,
-  describeProjectProfile,
-  loadCreateTemplateOptions,
-  planProfileApplication,
-  runTemplatesList,
-  runTemplatesSave,
-  runTemplatesShow
-} from "./chunks/chunk-PHKP3AGR.js";
-import "./chunks/chunk-655STMGA.js";
-import "./chunks/chunk-FDSBDNYE.js";
+  HISTORY_COMPACT_BULK_DEFAULT_MIN_ENTRIES,
+  assertHistoryCompactTarget,
+  runHistoryCompact,
+  runHistoryCompactBulk
+} from "./chunks/chunk-K3WII2ME.js";
+import "./chunks/chunk-YUSOJDWM.js";
+import "./chunks/chunk-BEP7WJA2.js";
 import {
   isErrnoError,
   limitAnnotationEntries,
@@ -170,22 +224,8 @@ import {
   resolveAnnotationInput,
   runAnnotationCommand,
   wrapOwnershipConflict
-} from "./chunks/chunk-VJTAEIPC.js";
-import "./chunks/chunk-RMF3IOYQ.js";
-import "./chunks/chunk-E2WC6S4P.js";
-import "./chunks/chunk-RA5AIAMP.js";
-import "./chunks/chunk-Q37E63AM.js";
-import "./chunks/chunk-OBDLEQG5.js";
-import "./chunks/chunk-DRNJPEPQ.js";
-import {
-  PLAN_SHOW_DEPTH_VALUES,
-  PLAN_SUBCOMMANDS,
-  PLAN_TEMPLATE_NAMES
-} from "./chunks/chunk-HLHSQ5CA.js";
-import "./chunks/chunk-6OTZMORS.js";
-import "./chunks/chunk-DYEX6NFH.js";
-import "./chunks/chunk-YRYYFGV3.js";
-import "./chunks/chunk-WRKB56FC.js";
+} from "./chunks/chunk-QIPLHNP7.js";
+import "./chunks/chunk-NP22ERDF.js";
 import {
   activateExtensionForTest,
   assertExtensionBlueprint,
@@ -237,7 +277,7 @@ import {
   runRegisteredServiceOverrideForTest,
   runRegisteredVectorStoreAdapterForTest,
   synthesizeExtensionManifest
-} from "./chunks/chunk-YVKE5ZDM.js";
+} from "./chunks/chunk-KPMKHGEA.js";
 import {
   BUILTIN_PROFILES,
   PROFILE_LINT_CODES,
@@ -247,32 +287,52 @@ import {
   listProfiles,
   normalizeProfileName,
   resolveProfile
-} from "./chunks/chunk-UKUIIBDW.js";
+} from "./chunks/chunk-YAQEBNY7.js";
 import "./chunks/chunk-KAE727L2.js";
-import "./chunks/chunk-7TQMR6LK.js";
 import {
+  _testOnlyConfigCommand,
+  runConfig
+} from "./chunks/chunk-WT3ZEOGH.js";
+import {
+  INIT_AGENT_GUIDANCE_MODE_VALUES,
   PM_PACKAGE_CONVENTIONAL_RESOURCE_ROOTS,
   PM_PACKAGE_RESOURCE_KINDS,
+  _testOnly,
+  _testOnly2,
   collectPackageExtensionDirectories,
-  readPmPackageManifest
-} from "./chunks/chunk-4DY4KPQI.js";
-import "./chunks/chunk-MD6ULIPJ.js";
-import "./chunks/chunk-FO7GMJKG.js";
+  readPmPackageManifest,
+  runExtension,
+  runInit,
+  runInitAgentGuidance,
+  summarizeInitResult
+} from "./chunks/chunk-J6364LFM.js";
+import "./chunks/chunk-GM5QHQU6.js";
+import "./chunks/chunk-BCOFWYW4.js";
+import {
+  quoteCommandArg,
+  quoteWindowsCommandArg,
+  renderPmCommand
+} from "./chunks/chunk-PENXZX3U.js";
 import {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
-} from "./chunks/chunk-WQUEHPZB.js";
+} from "./chunks/chunk-EYLCSJAI.js";
 import "./chunks/chunk-Q3K5XPAQ.js";
-import "./chunks/chunk-5CT5BW6E.js";
-import "./chunks/chunk-DO5RGJXT.js";
+import "./chunks/chunk-APRVSW2O.js";
 import {
+  DEFAULT_CHILD_SAMPLE_LIMIT,
+  MAX_CHILD_PROJECTION_ITEMS,
+  buildItemChildrenRollup,
+  buildItemSchedule,
+  itemHasSchedule,
   runSearch
-} from "./chunks/chunk-ILLUE5DI.js";
+} from "./chunks/chunk-HYB5AZ63.js";
 import {
   CONTEXT_EVALUATION_METRIC_NAMES,
   CONTEXT_PACKING_PROFILES,
   CONTEXT_RELEVANCE_SERVICE,
   CONTEXT_RELEVANCE_SIGNAL_NAMES,
+  buildItemContextRelevanceCandidates,
   defaultScoreContextCandidates,
   evaluateContextRanking,
   packContextCandidates,
@@ -285,8 +345,9 @@ import {
   scoreContextCandidates,
   scoreContextCandidatesWithActiveExtensions,
   summarizeContextEvaluationReports
-} from "./chunks/chunk-LWTIRS3Y.js";
+} from "./chunks/chunk-E2OJMKML.js";
 import "./chunks/chunk-KWYX6ZIR.js";
+import "./chunks/chunk-XXXF6PAQ.js";
 import {
   QUERY_CURSOR_CONTRACT,
   createQueryFingerprint,
@@ -295,19 +356,32 @@ import {
   encodeQueryCursor,
   paginateQueryRows,
   resolveQueryCursorStart
-} from "./chunks/chunk-6MHSBDGD.js";
-import "./chunks/chunk-UJ4HJYWL.js";
-import "./chunks/chunk-W6HZ55JO.js";
-import "./chunks/chunk-4WREH7RT.js";
-import "./chunks/chunk-YQYG2V23.js";
+} from "./chunks/chunk-4223PVZT.js";
+import {
+  getItemAt
+} from "./chunks/chunk-3U7ZR6M4.js";
+import "./chunks/chunk-IJIICKVW.js";
+import {
+  _testOnly as _testOnly3,
+  applyHistoryPatch,
+  ensureMaterializedHistoryTarget,
+  extractPatchFailureContext,
+  readHistoryEntries,
+  replayHistoryToTarget,
+  resolveHistorySubject,
+  resolveHistoryTarget,
+  runHistoryRedact
+} from "./chunks/chunk-TD3LVC7D.js";
+import "./chunks/chunk-NU3IMIEA.js";
+import "./chunks/chunk-YRYYFGV3.js";
 import {
   readContextUsageAffinity,
   recordContextUsageServing,
   recordContextUsageTouch,
   recordContextUsageTouches
-} from "./chunks/chunk-Y72FV7RM.js";
+} from "./chunks/chunk-YCQET3OT.js";
 import "./chunks/chunk-CYCJBU3I.js";
-import "./chunks/chunk-ZUKSZVBW.js";
+import "./chunks/chunk-7B67ZL4N.js";
 import {
   ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
   APPEND_FLAG_CONTRACTS,
@@ -430,16 +504,22 @@ import {
   resolveSubcommandFlagContractsForCommand,
   toCompletionFlagString,
   withFlagAliasMetadata
-} from "./chunks/chunk-2QIQGYPW.js";
-import "./chunks/chunk-OI4S4KCI.js";
-import "./chunks/chunk-IAPHYPRL.js";
+} from "./chunks/chunk-H5APFTHZ.js";
+import "./chunks/chunk-UMOPHQSU.js";
+import "./chunks/chunk-RMLWNPH2.js";
 import {
   parseTags
-} from "./chunks/chunk-WD6MSYMP.js";
-import "./chunks/chunk-TWLDBKQU.js";
-import "./chunks/chunk-ANSJHDOZ.js";
+} from "./chunks/chunk-TKOVBP6C.js";
+import "./chunks/chunk-ULTHRDBP.js";
+import "./chunks/chunk-SELVXEZK.js";
 import "./chunks/chunk-D6HZN36B.js";
-import "./chunks/chunk-JL7WZ4O2.js";
+import {
+  SUPPRESS_HOST_OUTPUT_MARKER,
+  isHostOutputSuppressed,
+  suppressHostOutput
+} from "./chunks/chunk-IG3SWA4A.js";
+import "./chunks/chunk-2WSE6PO2.js";
+import "./chunks/chunk-NLDFBC6J.js";
 import {
   BASELINE_ITEM_FORMAT_VERSION,
   CURRENT_ITEM_FORMAT_VERSION,
@@ -467,7 +547,7 @@ import {
   scanItemFormatVersions,
   serializeItemDocument,
   splitFrontMatter
-} from "./chunks/chunk-T4BRCB6Z.js";
+} from "./chunks/chunk-XSJUSQAE.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   CONFIDENCE_TEXT_VALUES,
@@ -501,7 +581,655 @@ import {
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
   writeFileAtomic
-} from "./chunks/chunk-AFWZRL7M.js";
+} from "./chunks/chunk-BSEQUTQP.js";
+
+// dist/sdk/output.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] = "fee22fbe-b4a1-5524-9df1-7be06fb07427");
+  } catch (e2) {
+  }
+})();
+
+// dist/sdk/relationship-analytics.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] = "0a54b889-6d5c-565c-85ff-47e5cce68a32");
+  } catch (e2) {
+  }
+})();
+function appendNeighbor(adjacency, source, target) {
+  adjacency.get(source).add(target);
+}
+function createAdjacency(nodes) {
+  return new Map(nodes.map((node) => [node, /* @__PURE__ */ new Set()]));
+}
+function sortComponents(components) {
+  for (const component of components)
+    component.sort();
+  return components.sort((left, right) => right.length - left.length || left[0].localeCompare(right[0]));
+}
+function stableJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => stableJsonValue(entry));
+  if (value === null || typeof value !== "object")
+    return value;
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function")
+    return stableJsonValue(toJSON.call(value));
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableJsonValue(entry)]));
+}
+function relationshipEdgeKey(edge) {
+  return JSON.stringify(stableJsonValue(edge));
+}
+function appendFinishingOrder(start, adjacency, visited, order) {
+  const stack = [{ id: start, expanded: false }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current.expanded) {
+      order.push(current.id);
+      continue;
+    }
+    if (visited.has(current.id))
+      continue;
+    visited.add(current.id);
+    stack.push({ id: current.id, expanded: true });
+    const neighbors = [...adjacency.get(current.id)].sort().reverse();
+    for (const neighbor of neighbors)
+      if (!visited.has(neighbor))
+        stack.push({ id: neighbor, expanded: false });
+  }
+}
+function computeFinishingOrder(nodes, adjacency) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of nodes)
+    if (!visited.has(start))
+      appendFinishingOrder(start, adjacency, visited, order);
+  return order;
+}
+function collectReverseComponents(order, reverse) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const start of [...order].reverse()) {
+    if (visited.has(start))
+      continue;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of reverse.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
+      }
+    }
+    components.push(component);
+  }
+  return sortComponents(components);
+}
+function stronglyConnectedComponents(nodes, adjacency) {
+  const reverse = createAdjacency(nodes);
+  for (const [source, targets] of adjacency)
+    for (const target of targets)
+      appendNeighbor(reverse, target, source);
+  return collectReverseComponents(computeFinishingOrder(nodes, adjacency), reverse);
+}
+function buildExecutionAdjacency(graph, registry) {
+  const adjacency = createAdjacency(graph.nodes());
+  for (const edge of graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!definition.ordering)
+      continue;
+    const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
+    appendNeighbor(adjacency, sourceFirst ? edge.source : edge.target, sourceFirst ? edge.target : edge.source);
+  }
+  return adjacency;
+}
+function topologicalLayers(nodes, adjacency) {
+  const indegree = new Map(nodes.map((node) => [node, 0]));
+  for (const targets of adjacency.values())
+    for (const target of targets)
+      indegree.set(target, indegree.get(target) + 1);
+  let frontier = nodes.filter((node) => indegree.get(node) === 0).sort();
+  const layers = [];
+  while (frontier.length > 0) {
+    layers.push(frontier);
+    const next2 = [];
+    for (const source of frontier) {
+      for (const target of adjacency.get(source)) {
+        const remaining = indegree.get(target) - 1;
+        indegree.set(target, remaining);
+        if (remaining === 0)
+          next2.push(target);
+      }
+    }
+    frontier = next2.sort();
+  }
+  return layers;
+}
+function longestPath(order, adjacency) {
+  const depth = new Map(order.map((node) => [node, 0]));
+  const parent = /* @__PURE__ */ new Map();
+  for (const source of order) {
+    for (const target of adjacency.get(source)) {
+      if (!depth.has(target))
+        continue;
+      const candidate = depth.get(source) + 1;
+      const currentParent = parent.get(target);
+      if (candidate > depth.get(target) || candidate === depth.get(target) && (currentParent === void 0 || source.localeCompare(currentParent) < 0)) {
+        depth.set(target, candidate);
+        parent.set(target, source);
+      }
+    }
+  }
+  const end = [...order].sort((left, right) => depth.get(right) - depth.get(left) || left.localeCompare(right))[0];
+  const path2 = end === void 0 ? [] : [end];
+  while (path2[0] !== void 0 && parent.has(path2[0]))
+    path2.unshift(parent.get(path2[0]));
+  return { depth: Object.fromEntries(depth), path: path2 };
+}
+function reconstructImpactPath(root, target, parents) {
+  const path2 = [target];
+  let cursor = target;
+  while (cursor !== root) {
+    cursor = parents.get(cursor);
+    path2.push(cursor);
+  }
+  return path2.reverse();
+}
+function analyzeRelationshipExecution(graph, options = {}) {
+  const registry = options.registry ?? createRelationshipKindRegistry();
+  const nodes = [...graph.nodes()];
+  const adjacency = buildExecutionAdjacency(graph, registry);
+  const layers = topologicalLayers(nodes, adjacency);
+  const order = layers.flat();
+  const acyclic = order.length === nodes.length;
+  const cycles = acyclic ? [] : stronglyConnectedComponents(nodes, adjacency).filter((component) => component.length > 1 || adjacency.get(component[0]).has(component[0]));
+  const longest = longestPath(order, adjacency);
+  return {
+    exact: true,
+    acyclic,
+    order,
+    layers,
+    frontier: layers[0] ?? [],
+    depth: longest.depth,
+    criticalPath: longest.path,
+    criticalPathLength: Math.max(0, longest.path.length - 1),
+    cycles,
+    provenance: { algorithm: "kahn-longest-path", edgeFamily: "ordering" }
+  };
+}
+function analyzeGraphImpact(graph, root, options = {}) {
+  const direction = options.direction ?? "outgoing";
+  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const queue = [{ id: root, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set([root]);
+  const parents = /* @__PURE__ */ new Map();
+  const affected = [];
+  let visitedNodes = 0;
+  let inspectedEdges = 0;
+  let truncated = false;
+  traversal: for (let index = 0; index < queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const current = queue[index];
+    visitedNodes += 1;
+    const adjacent = graph.adjacency(current.id, {
+      direction,
+      kinds: options.kinds,
+      signal: options.signal
+    });
+    inspectedEdges += adjacent.meta.inspectedEdges;
+    if (current.depth >= maxDepth) {
+      if (adjacent.value.some((id) => !seen.has(id)))
+        truncated = true;
+      continue;
+    }
+    for (const id of adjacent.value) {
+      if (seen.has(id))
+        continue;
+      if (affected.length >= limit) {
+        truncated = true;
+        break traversal;
+      }
+      seen.add(id);
+      parents.set(id, current.id);
+      const depth = current.depth + 1;
+      affected.push({
+        id,
+        distance: depth,
+        path: reconstructImpactPath(root, id, parents)
+      });
+      queue.push({ id, depth });
+    }
+  }
+  return {
+    root,
+    affected,
+    exact: true,
+    truncated,
+    cost: { visitedNodes, inspectedEdges }
+  };
+}
+function analyzeKnowledgeGraph(graph) {
+  const nodes = [...graph.nodes()];
+  const weak = createAdjacency(nodes);
+  const directed = createAdjacency(nodes);
+  for (const edge of graph.edges()) {
+    appendNeighbor(weak, edge.source, edge.target);
+    appendNeighbor(weak, edge.target, edge.source);
+    appendNeighbor(directed, edge.source, edge.target);
+  }
+  const components = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const start of nodes) {
+    if (visited.has(start))
+      continue;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of weak.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
+      }
+    }
+    components.push(component);
+  }
+  const degrees = nodes.map((id) => ({ id, degree: weak.get(id).size }));
+  const maximum = Math.max(0, ...degrees.map(({ degree }) => degree));
+  return {
+    components: sortComponents(components),
+    stronglyConnected: stronglyConnectedComponents(nodes, directed),
+    orphans: degrees.filter(({ degree }) => degree === 0).map(({ id }) => id),
+    hubs: degrees.filter(({ degree }) => degree > 0 && degree === maximum),
+    exact: true,
+    provenance: { algorithm: "component-degree", edgeFamily: "all" }
+  };
+}
+function compareRelationshipSnapshots(before, after) {
+  const earlier = new Map(before.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  const later = new Map(after.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  return {
+    fromVersion: before.version,
+    toVersion: after.version,
+    added: [...later].filter(([key]) => !earlier.has(key)).map(([, edge]) => edge),
+    removed: [...earlier].filter(([key]) => !later.has(key)).map(([, edge]) => edge),
+    unchangedCount: [...earlier.keys()].filter((key) => later.has(key)).length,
+    exact: true
+  };
+}
+
+// dist/sdk/relationship-history.js
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import path from "node:path";
+!(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] = "787e8f44-80d5-554f-9232-9675cf6a8637");
+  } catch (e2) {
+  }
+})();
+function requiredText(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new TypeError(`Relationship event ${field} must be non-empty`);
+  return value.trim();
+}
+function edgeIdentity(edge, registry) {
+  const definition = registry.require(edge.kind);
+  const endpoints = definition.direction === "undirected" ? [edge.source, edge.target].sort().join("\0") : `${edge.source}\0${edge.target}`;
+  return `${definition.kind}\0${endpoints}`;
+}
+function freezeEdge(edge) {
+  return Object.freeze({
+    ...edge,
+    ...edge.payload === void 0 ? {} : { payload: Object.freeze(structuredClone(edge.payload)) }
+  });
+}
+function assertCardinality(candidate, excludeRelationshipId, registry, indexes) {
+  const definition = registry.require(candidate.kind);
+  const outgoingOwner = indexes.outgoingOne.get(`${definition.kind}\0${candidate.source}`);
+  if (outgoingOwner !== void 0 && outgoingOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship outgoing cardinality exceeded for ${definition.kind}`);
+  const incomingOwner = indexes.incomingOne.get(`${definition.kind}\0${candidate.target}`);
+  if (incomingOwner !== void 0 && incomingOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship incoming cardinality exceeded for ${definition.kind}`);
+  const identity = edgeIdentity(candidate, registry);
+  const identityOwner = indexes.identities.get(identity);
+  if (identityOwner !== void 0 && identityOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship edge already active: ${identity}`);
+}
+function replayEvents(events) {
+  const active = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.action === "remove")
+      active.delete(event.relationshipId);
+    else
+      active.set(event.relationshipId, event.edge);
+  }
+  return active;
+}
+function normalizeEventHeader(input, currentVersion, eventIds) {
+  if (input.expectedVersion !== void 0 && input.expectedVersion !== currentVersion)
+    throw new TypeError(`Relationship event version conflict: expected ${input.expectedVersion}, current ${currentVersion}`);
+  const eventId = requiredText(input.eventId, "eventId");
+  if (eventIds.has(eventId))
+    throw new TypeError(`Relationship event already exists: ${eventId}`);
+  if (input.action !== "add" && input.action !== "remove" && input.action !== "supersede")
+    throw new TypeError(`Unknown relationship event action: ${input.action}`);
+  if (!Number.isFinite(Date.parse(input.timestamp)))
+    throw new TypeError("Relationship event timestamp must be valid");
+  return {
+    eventId,
+    relationshipId: requiredText(input.relationshipId, "relationshipId"),
+    author: requiredText(input.author, "author"),
+    timestamp: new Date(input.timestamp).toISOString()
+  };
+}
+function resolveMutationEdge(input, relationshipId, active, nodes, registry, indexes) {
+  const isActive = active.has(relationshipId);
+  if (input.action === "add" && isActive)
+    throw new TypeError(`Relationship is already active: ${relationshipId}`);
+  if (input.action !== "add" && !isActive)
+    throw new TypeError(`Relationship is not active: ${relationshipId}`);
+  if (input.action === "remove")
+    return void 0;
+  if (!input.edge)
+    throw new TypeError(`Relationship ${input.action} event requires an edge`);
+  const source = typeof input.edge.source === "string" ? input.edge.source.trim() : "";
+  const target = typeof input.edge.target === "string" ? input.edge.target.trim() : "";
+  if (!nodes.has(source) || !nodes.has(target))
+    throw new TypeError(`Relationship endpoint not found: ${source} -> ${target}`);
+  const canonical = new RelationshipGraph([source, target], [input.edge], registry).edges()[0];
+  assertCardinality(canonical, relationshipId, registry, indexes);
+  return freezeEdge(canonical);
+}
+var RelationshipEventLog = class {
+  #nodes;
+  #registry;
+  #events = [];
+  #eventIds = /* @__PURE__ */ new Set();
+  #active = /* @__PURE__ */ new Map();
+  #cardinalityIndexes = {
+    identities: /* @__PURE__ */ new Map(),
+    outgoingOne: /* @__PURE__ */ new Map(),
+    incomingOne: /* @__PURE__ */ new Map()
+  };
+  /** Create an empty relationship ledger for a fixed node universe. */
+  constructor(nodes, options = {}) {
+    this.#nodes = new Set([...nodes].filter((node) => typeof node === "string").map((node) => node.trim()).filter(Boolean));
+    this.#registry = options.registry ?? createRelationshipKindRegistry();
+  }
+  /** Current append sequence. */
+  get version() {
+    return this.#events.length;
+  }
+  /** Return an immutable copy of the full event stream. */
+  events() {
+    return Object.freeze([...this.#events]);
+  }
+  /** Add one active relationship to constant-time validation indexes. */
+  #indexActive(relationshipId, edge) {
+    const definition = this.#registry.require(edge.kind);
+    this.#cardinalityIndexes.identities.set(edgeIdentity(edge, this.#registry), relationshipId);
+    if (definition.outgoing === "one")
+      this.#cardinalityIndexes.outgoingOne.set(`${definition.kind}\0${edge.source}`, relationshipId);
+    if (definition.incoming === "one")
+      this.#cardinalityIndexes.incomingOne.set(`${definition.kind}\0${edge.target}`, relationshipId);
+  }
+  /** Remove one superseded or deleted relationship from validation indexes. */
+  #unindexActive(edge) {
+    const definition = this.#registry.require(edge.kind);
+    this.#cardinalityIndexes.identities.delete(edgeIdentity(edge, this.#registry));
+    if (definition.outgoing === "one")
+      this.#cardinalityIndexes.outgoingOne.delete(`${definition.kind}\0${edge.source}`);
+    if (definition.incoming === "one")
+      this.#cardinalityIndexes.incomingOne.delete(`${definition.kind}\0${edge.target}`);
+  }
+  /** Validate and append one attributable relationship mutation. */
+  append(input) {
+    const header = normalizeEventHeader(input, this.version, this.#eventIds);
+    const previous = this.#active.get(header.relationshipId);
+    const edge = resolveMutationEdge(input, header.relationshipId, this.#active, this.#nodes, this.#registry, this.#cardinalityIndexes);
+    const event = Object.freeze({
+      eventId: header.eventId,
+      relationshipId: header.relationshipId,
+      action: input.action,
+      ...edge === void 0 ? {} : { edge },
+      author: header.author,
+      timestamp: header.timestamp,
+      ...input.reason?.trim() ? { reason: input.reason.trim() } : {},
+      sequence: this.version + 1
+    });
+    this.#events.push(event);
+    this.#eventIds.add(header.eventId);
+    if (previous)
+      this.#unindexActive(previous);
+    if (input.action === "remove")
+      this.#active.delete(header.relationshipId);
+    else {
+      this.#active.set(header.relationshipId, edge);
+      this.#indexActive(header.relationshipId, edge);
+    }
+    return event;
+  }
+  /** Materialize an exact point-in-time graph without mutating the ledger. */
+  snapshot(options = {}) {
+    if (options.atVersion !== void 0 && options.atTimestamp !== void 0)
+      throw new TypeError("Relationship snapshot accepts one target");
+    let included;
+    if (options.atTimestamp !== void 0) {
+      const timestamp = Date.parse(options.atTimestamp);
+      if (!Number.isFinite(timestamp))
+        throw new TypeError("Relationship snapshot timestamp must be valid");
+      let lastIndex = -1;
+      for (let index = this.#events.length - 1; index >= 0; index -= 1) {
+        if (Date.parse(this.#events[index].timestamp) > timestamp)
+          continue;
+        lastIndex = index;
+        break;
+      }
+      included = lastIndex === -1 ? [] : this.#events.slice(0, lastIndex + 1);
+    } else {
+      const version = options.atVersion ?? this.version;
+      if (!Number.isInteger(version) || version < 0 || version > this.version)
+        throw new TypeError(`Relationship snapshot version out of range: ${version}`);
+      included = this.#events.slice(0, version);
+    }
+    const active = replayEvents(included);
+    const graph = new RelationshipGraph(this.#nodes, active.values(), this.#registry);
+    return Object.freeze({
+      version: included.length,
+      ...included.at(-1) ? { asOf: included.at(-1).timestamp } : {},
+      edges: graph.edges(),
+      graph
+    });
+  }
+  /** Page the immutable event stream with a cursor bound to this log version. */
+  page(options) {
+    if (!Number.isInteger(options.limit) || options.limit < 1)
+      throw new TypeError("Relationship event page limit must be positive");
+    const fingerprint = createQueryFingerprint("relationship-events", {
+      order: "append-sequence"
+    });
+    const snapshot = options.cursor === void 0 ? this.version : Number(decodeQueryCursorState(options.cursor, fingerprint).snapshot);
+    if (!Number.isSafeInteger(snapshot) || snapshot < 0 || snapshot > this.version)
+      throw new TypeError("Relationship event cursor snapshot version is invalid");
+    const page = paginateQueryRows(this.#events.slice(0, snapshot), {
+      cursor: options.cursor,
+      fingerprint,
+      limit: options.limit,
+      readId: (event) => event.eventId,
+      snapshot: String(snapshot)
+    });
+    return {
+      version: snapshot,
+      events: page.rows,
+      hasMore: page.has_more,
+      ...page.next_cursor ? { nextCursor: page.next_cursor } : {}
+    };
+  }
+};
+var RELATIONSHIP_STORE_LOCK_ID = "relationship-event-store";
+var RELATIONSHIP_NOFOLLOW_FLAG = constants.O_NOFOLLOW;
+function acquireRelationshipStoreLock(pmRoot) {
+  return acquireLock(pmRoot, RELATIONSHIP_STORE_LOCK_ID, 30, `relationship-store:${process.pid}`, false, false, 3e3);
+}
+async function resolveRelationshipEventStorePath(pmRoot, relativePath = "relationships/events.jsonl") {
+  const root = path.resolve(pmRoot);
+  const target = path.resolve(root, relativePath);
+  const relative = path.relative(root, target);
+  if (relative.length === 0)
+    throw new TypeError("Relationship event path must name a file within the tracker root");
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+    throw new TypeError("Relationship event path must stay within the tracker root");
+  await mkdir(root, { recursive: true });
+  const rootStats = await lstat(root);
+  if (rootStats.isSymbolicLink())
+    throw new TypeError("Relationship event tracker root must not be a symbolic link");
+  let current = root;
+  for (const segment of relative.split(path.sep)) {
+    current = path.join(current, segment);
+    try {
+      if ((await lstat(current)).isSymbolicLink())
+        throw new TypeError("Relationship event path must not contain symbolic links");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        break;
+      throw error;
+    }
+  }
+  return target;
+}
+async function loadRelationshipEventLog(target, nodes, registry) {
+  const log = new RelationshipEventLog(nodes, { registry });
+  let raw;
+  let handle;
+  try {
+    handle = await open(target, constants.O_RDONLY | RELATIONSHIP_NOFOLLOW_FLAG);
+    raw = await handle.readFile("utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return log;
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+  const lines = raw.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (!line)
+      continue;
+    let stored;
+    try {
+      stored = JSON.parse(line);
+    } catch {
+      throw new TypeError(`Invalid relationship event JSONL at line ${index + 1}`);
+    }
+    if (stored.sequence !== log.version + 1)
+      throw new TypeError(`Invalid relationship event sequence at line ${index + 1}`);
+    log.append({
+      eventId: stored.eventId,
+      relationshipId: stored.relationshipId,
+      action: stored.action,
+      ...stored.edge === void 0 ? {} : { edge: stored.edge },
+      author: stored.author,
+      timestamp: stored.timestamp,
+      ...stored.reason === void 0 ? {} : { reason: stored.reason },
+      expectedVersion: log.version
+    });
+  }
+  return log;
+}
+var RelationshipEventStore = class _RelationshipEventStore {
+  #pmRoot;
+  #nodes;
+  #registry;
+  #path;
+  #log;
+  constructor(options, nodes, target, log) {
+    this.#pmRoot = options.pmRoot;
+    this.#nodes = nodes;
+    this.#registry = options.registry;
+    this.#path = target;
+    this.#log = log;
+  }
+  /** Open and validate an existing stream or create an empty store view. */
+  static async open(options) {
+    const nodes = Object.freeze([...options.nodes]);
+    const target = await resolveRelationshipEventStorePath(options.pmRoot, options.relativePath);
+    const release2 = await acquireRelationshipStoreLock(options.pmRoot);
+    try {
+      await resolveRelationshipEventStorePath(options.pmRoot, target);
+      const log = await loadRelationshipEventLog(target, nodes, options.registry);
+      return new _RelationshipEventStore(options, nodes, target, log);
+    } finally {
+      await release2();
+    }
+  }
+  /** Absolute JSONL path, exposed for diagnostics and backup tooling. */
+  get path() {
+    return this.#path;
+  }
+  /** Refresh from durable history and return the current validated append sequence. */
+  async currentVersion() {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.version;
+  }
+  /** Append one event after refreshing under the shared workspace lock. */
+  async append(input) {
+    const release2 = await acquireRelationshipStoreLock(this.#pmRoot);
+    try {
+      const target = await resolveRelationshipEventStorePath(this.#pmRoot, this.#path);
+      const refreshed = await loadRelationshipEventLog(target, this.#nodes, this.#registry);
+      const event = refreshed.append(input);
+      await mkdir(path.dirname(target), { recursive: true });
+      await resolveRelationshipEventStorePath(this.#pmRoot, target);
+      const handle = await open(target, constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | RELATIONSHIP_NOFOLLOW_FLAG);
+      try {
+        await handle.appendFile(`${JSON.stringify(event)}
+`, "utf8");
+      } finally {
+        await handle.close();
+      }
+      this.#log = refreshed;
+      return event;
+    } finally {
+      await release2();
+    }
+  }
+  /** Refresh from durable history and materialize an exact validated snapshot. */
+  async snapshot(options = {}) {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.snapshot(options);
+  }
+  /** Refresh from durable history and page immutable events. */
+  async page(options) {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.page(options);
+  }
+  /** Serialize a durable refresh with writers so readers never observe a torn JSONL tail. */
+  async #refreshFromDurableHistory() {
+    const release2 = await acquireRelationshipStoreLock(this.#pmRoot);
+    try {
+      const target = await resolveRelationshipEventStorePath(this.#pmRoot, this.#path);
+      return await loadRelationshipEventLog(target, this.#nodes, this.#registry);
+    } finally {
+      await release2();
+    }
+  }
+};
 
 // dist/sdk/define.js
 !(function() {
@@ -579,7 +1307,7 @@ function defineOnIndexHook(hook) {
 !(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] = "571dc2bf-a6ef-5142-b7c9-a80e27ad1159");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d975f914-6acc-5da2-b7c4-d696f1b339b6");
   } catch (e2) {
   }
 })();
@@ -617,6 +1345,7 @@ export {
   CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
   CREATE_FLAG_CONTRACTS,
   CURRENT_ITEM_FORMAT_VERSION,
+  DEFAULT_CHILD_SAMPLE_LIMIT,
   DELETE_FLAG_CONTRACTS,
   DEPENDENCY_KIND_VALUES,
   DEPS_FLAG_CONTRACTS,
@@ -654,10 +1383,12 @@ export {
   GLOBAL_FLAG_CONTRACTS,
   GUIDE_FLAG_CONTRACTS,
   HEALTH_FLAG_CONTRACTS,
+  HISTORY_COMPACT_BULK_DEFAULT_MIN_ENTRIES,
   HISTORY_COMPACT_FLAG_CONTRACTS,
   HISTORY_FLAG_CONTRACTS,
   HISTORY_REDACT_FLAG_CONTRACTS,
   HISTORY_REPAIR_FLAG_CONTRACTS,
+  INIT_AGENT_GUIDANCE_MODE_VALUES,
   INIT_FLAG_CONTRACTS,
   INSTALL_FLAG_CONTRACTS,
   ISSUE_SEVERITY_VALUES,
@@ -665,6 +1396,7 @@ export {
   LEARNINGS_FLAG_CONTRACTS,
   LIST_COMMANDER_STRING_OPTION_CONTRACTS,
   LIST_FILTER_FLAG_CONTRACTS,
+  MAX_CHILD_PROJECTION_ITEMS,
   MEET_FLAG_CONTRACTS,
   NEXT_COMMANDER_STRING_OPTION_CONTRACTS,
   NEXT_FLAG_CONTRACTS,
@@ -697,6 +1429,7 @@ export {
   PROFILE_LINT_CODES,
   PROFILE_LINT_DIMENSIONS,
   PROFILE_NAMES,
+  PROFILE_SUBCOMMANDS,
   PmCliError,
   PmClient,
   QUERY_CURSOR_CONTRACT,
@@ -706,6 +1439,10 @@ export {
   RESERVED_ITEM_FIELD_NAMES,
   RESTORE_FLAG_CONTRACTS,
   RISK_VALUES,
+  RelationshipEventLog,
+  RelationshipEventStore,
+  RelationshipGraph,
+  RelationshipKindRegistry,
   SCHEMA_FLAG_CONTRACTS,
   SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
   SEARCH_FLAG_CONTRACTS,
@@ -713,6 +1450,7 @@ export {
   STATS_FLAG_CONTRACTS,
   STATUS_VALUES,
   SUBCOMMAND_GLOBAL_FLAG_CONTRACTS,
+  SUPPRESS_HOST_OUTPUT_MARKER,
   TELEMETRY_FLAG_CONTRACTS,
   TEST_ALL_FLAG_CONTRACTS,
   TEST_FLAG_CONTRACTS,
@@ -735,11 +1473,23 @@ export {
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   UPGRADE_FLAG_CONTRACTS,
+  _testOnly3 as _testOnly,
+  _testOnlyConfigCommand,
+  _testOnlyHealthCommand,
+  _testOnly2 as _testOnlyInit,
+  _testOnly as _testOnlyInitAgentGuidance,
+  _testOnly4 as _testOnlyTemplates,
+  _testOnlyValidateCommand,
   acquireLock,
   activateExtensionForTest,
   aggregate,
+  analyzeGraphImpact,
+  analyzeKnowledgeGraph,
+  analyzeRelationshipExecution,
   append,
   appendHistoryEntry,
+  applyHistoryPatch,
+  applyInvocationAuthorOverride,
   applyPathMigrations,
   applyStandaloneNote,
   artifactKey,
@@ -749,6 +1499,8 @@ export {
   assertExtensionManifestCompatible,
   assertExtensionManifestMatchesBlueprint,
   assertExtensionPreflight,
+  assertHistoryCompactTarget,
+  assertHistoryRepairTarget,
   assertPackageManifest,
   assertProjectProfile,
   assertRegisteredCommandContract,
@@ -767,6 +1519,10 @@ export {
   assertRegisteredSearchProvider,
   assertRegisteredServiceOverride,
   assertRegisteredVectorStoreAdapter,
+  buildItemChildrenRollup,
+  buildItemContextRelevanceCandidates,
+  buildItemSchedule,
+  buildRelationshipContext,
   canonicalDocument,
   checkExtensionManifestCompatibility,
   claim,
@@ -781,6 +1537,7 @@ export {
   comments,
   commitImportedItem,
   compactFlagAliasContracts,
+  compareRelationshipSnapshots,
   composeExtension,
   composeExtensionPackage,
   config,
@@ -790,7 +1547,9 @@ export {
   createExtensionTestHarness,
   createHistoryEntry,
   createPmCliExpectedError,
+  createPmCliProgram,
   createQueryFingerprint,
+  createRelationshipKindRegistry,
   deactivateExtensionForTest,
   decodeQueryCursor,
   decodeQueryCursorState,
@@ -820,6 +1579,7 @@ export {
   defineServiceOverride,
   defineVectorStoreAdapter,
   deleteItem,
+  dependencyToRelationship,
   deps,
   deriveExtensionCapabilities,
   describeExtensionActivation,
@@ -830,6 +1590,7 @@ export {
   effectiveItemFormatVersion,
   emptyImportedDocument,
   encodeQueryCursor,
+  ensureMaterializedHistoryTarget,
   ensureScope,
   ensureTrackerInitialized,
   evaluateContextRanking,
@@ -838,21 +1599,35 @@ export {
   extensionActivate,
   extensionDeactivate,
   extensionList,
+  extractPatchFailureContext,
   files,
   filesDiscover,
   focus,
+  formatProfileApplyHuman,
+  formatProfileLintHuman,
+  formatProfileListHuman,
+  formatProfileShowHuman,
   gc,
   generateItemId,
   get,
   getActiveExtensionRegistrations,
   getContracts,
   getHistoryPath,
+  getItemAt,
   getItemPath,
   getSettingsPath,
   getWorkspaceContracts,
   health,
+  historyCompact,
+  historyCompactBulk,
+  historyRedact,
+  historyRepair,
+  historyRepairAll,
   init,
+  inspectHistoryAuthorStream,
   isErrnoError,
+  isHostOutputSuppressed,
+  isOrderingRelationshipKind,
   isPmCliExpectedError,
   isPmExtensionCapabilityContract,
   isPmExtensionPolicyModeContract,
@@ -860,6 +1635,7 @@ export {
   isPmExtensionServiceNameContract,
   isPmToolAction,
   isTimestampLiteral,
+  itemHasSchedule,
   learnings,
   limitAnnotationEntries,
   lintExtensionBlueprint,
@@ -908,6 +1684,8 @@ export {
   profileLint,
   profileList,
   profileShow,
+  quoteCommandArg,
+  quoteWindowsCommandArg,
   readAnnotationEntries,
   readBooleanOption,
   readContextUsageAffinity,
@@ -915,6 +1693,7 @@ export {
   readFileIfExists,
   readFirstStringFromCommanderOptions,
   readFirstValueFromCommanderOptions,
+  readHistoryEntries,
   readLocatedItem,
   readPmPackageManifest,
   readRequiredString,
@@ -932,10 +1711,14 @@ export {
   renderCalendarToon,
   renderExtensionSurfaceMarkdown,
   renderGuideMarkdown,
+  renderPmCommand,
+  replayHistoryToTarget,
   resolveAnnotationIndex,
   resolveAnnotationInput,
   resolveCalendarOutputFormat,
   resolveGuideOutputFormat,
+  resolveHistorySubject,
+  resolveHistoryTarget,
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveProfile,
@@ -950,14 +1733,29 @@ export {
   runAnnotationCommand,
   runCalendar,
   runCompletion,
+  runConfig,
   runContextEvaluationCorpus,
   runContextEvaluationScenario,
   runDeps,
   runDocs,
+  runExtension,
   runFiles,
   runFilesDiscover,
+  runGc,
   runGuide,
+  runHealth,
+  runHistoryCompact,
+  runHistoryCompactBulk,
+  runHistoryRedact,
+  runHistoryRepair,
+  runHistoryRepairAll,
+  runInit,
+  runInitAgentGuidance,
   runLinkedArtifacts,
+  runProfileApply,
+  runProfileLint,
+  runProfileList,
+  runProfileShow,
   runRegisteredCommandForTest,
   runRegisteredCommandOverrideForTest,
   runRegisteredExporterForTest,
@@ -980,6 +1778,8 @@ export {
   runTestRunsResume,
   runTestRunsStatus,
   runTestRunsStop,
+  runValidate,
+  scanHistoryAuthorAttribution,
   scanItemFormatVersions,
   schema,
   schemaAddField,
@@ -1005,6 +1805,8 @@ export {
   startTask,
   stats,
   summarizeContextEvaluationReports,
+  summarizeInitResult,
+  suppressHostOutput,
   synthesizeExtensionManifest,
   toCompletionFlagString,
   toEstimatedMinutesValue,