@wave-ai-os/wave-cli 0.1.86 → 0.1.87

package/dist/index.cjs

@@ -3,7 +3,7 @@
 
 // src/index.ts
 var import_commander3 = require("commander");
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/cli.ts
 var import_commander2 = require("commander");
@@ -1165,6 +1165,8 @@ var RESOURCE_QUERY_FIELDS = {
     "archivedAt",
     "organizationId",
     "memberId",
+    "member",
+    "assignee",
     "creatorId",
     "projectId",
     "projectSlug",
@@ -1212,6 +1214,7 @@ var RESOURCE_QUERY_FIELDS = {
     "role",
     "status",
     "title",
+    "rolePurpose",
     "firstName",
     "lastName",
     "createdAt",
@@ -1662,7 +1665,8 @@ function defaultQuerySelectionSet(field, isList) {
   const canonicalField = RESOURCE_FIELD_ALIASES[field] ?? field;
   const explicitFields = RESOURCE_QUERY_FIELDS[canonicalField];
   if (explicitFields) {
-    const attributes = explicitFields.length > 0 ? `attributes { ${Array.from(/* @__PURE__ */ new Set(["id", ...explicitFields])).join(" ")} }` : "attributes";
+    const detailFields = canonicalField === "smart_kpi" && !isList ? ["smartKpiMetrics { id date value }", "smartKpiGoals { id date value }"] : [];
+    const attributes = explicitFields.length > 0 ? `attributes { ${Array.from(/* @__PURE__ */ new Set(["id", ...explicitFields, ...detailFields])).join(" ")} }` : "attributes";
     if (isList) {
       return `{ data { id type ${attributes} } count currentPage totalPages }`;
     }
@@ -4038,7 +4042,7 @@ var projectPriorityValues = projectPrioritySchema.options.join(", ");
 var projectCreateDataJsonHelp = buildDataJsonHelp("project", "create") ?? 'JSON object for project or {"project": {...}}';
 var projectUpdateDataJsonHelp = buildDataJsonHelp("project", "update") ?? 'JSON object for project or {"project": {...}}';
 function projectsIndexMinimalSelectionSet(includeProjectTypes = false) {
-  return `{ count currentPage totalPages data { id type attributes { name slug status priority${includeProjectTypes ? " projectType" : ""} } } }`;
+  return `{ count currentPage totalPages data { id type attributes { name slug status priority createdAt updatedAt${includeProjectTypes ? " projectType" : ""} } } }`;
 }
 var displayPreferenceAttributesSelectionSet = "attributes { id viewType favorite groupingField groupToggleState memberId focusMemberId focusTeamId displayableId displayableType preferenceType agendaItemId }";
 var filterPreferenceAttributesSelectionSet = "attributes { id filterType filter memberId focusMemberId focusTeamId filterableId filterableType preferenceType agendaItemId }";
@@ -4485,6 +4489,22 @@ function registerMeetingCommands(program) {
       isShow: true
     });
   });
+  meetings.command("note-show").description("Read the authorized AI note context for a meeting").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const meetingId = idSchema5.parse(opts.id);
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "meetings.note-show",
+      runtimeOptions: context.runtimeOptions,
+      field: "meeting_note_by_meeting",
+      variables: {
+        organization_id: organizationId,
+        meeting_id: meetingId
+      },
+      selectionSet: "{ answerContext }",
+      isShow: true
+    });
+  });
   meetings.command("notes").requiredOption("--id <id>").requiredOption("--content <content>").action(async (opts, cmd) => {
     const id = idSchema5.parse(opts.id);
     const notes = notesSchema.parse(opts.content);
@@ -4540,10 +4560,25 @@ function registerMeetingCommands(program) {
 
 // src/commands/members.ts
 var import_zod8 = require("zod");
-var idSchema6 = import_zod8.z.string().min(1);
+var idSchema6 = import_zod8.z.string().trim().min(1);
 var createHelp3 = buildDataJsonHelp("member", "create") ?? 'JSON object for member or {"member": {...}}';
 var updateHelp3 = buildDataJsonHelp("member", "update") ?? 'JSON object for member or {"member": {...}}';
 var MEMBER_META_PROFILE_SELECTION = "{ id type memberId summary profile attributes { id memberId summary profile } }";
+var MEMBER_REFERENCE_RESOLUTION_SELECTION = `{
+  status
+  reasonCode
+  organizationId
+  reference
+  eligibilityPolicy
+  complete
+  source
+  asOf
+  traceId
+  receiptId
+  memberId
+  memberName
+  candidates { memberId memberName status eligible }
+}`;
 function parseStrictBooleanOption(value, optionName) {
   if (typeof value === "boolean") {
     return value;
@@ -4600,6 +4635,29 @@ function registerMemberCommands(program) {
     command: "members",
     field: "members"
   });
+  members.command("resolve").description("Resolve a member reference within the authenticated organization").requiredOption("--query <query>", "Member name or email reference").action(async (opts, cmd) => {
+    const reference = idSchema6.parse(opts.query);
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "members.resolve",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "MemberReferenceResolution",
+      field: "member_reference_resolution",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        reference,
+        trace_id: context.runtimeOptions.requestId
+      }),
+      variableTypes: {
+        organization_id: "ID!",
+        reference: "String!",
+        trace_id: "String"
+      },
+      selectionSet: MEMBER_REFERENCE_RESOLUTION_SELECTION,
+      isShow: true
+    });
+  });
   members.command("meta-profile").description("Read a member meta profile by member id").requiredOption("--member-id <memberId>", "Member id").requiredOption("--json", "Emit the stable JSON envelope").action(async (opts, cmd) => {
     const memberId = idSchema6.parse(opts.memberId);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
@@ -4668,10 +4726,69 @@ function registerMemberCommands(program) {
   });
 }
 
-// src/commands/skills.ts
+// src/commands/resources.ts
 var import_zod9 = require("zod");
-var idSchema7 = import_zod9.z.string().min(1);
-var limitSchema = import_zod9.z.coerce.number().int().positive();
+var resourceTypeSchema = import_zod9.z.enum([
+  "project",
+  "team",
+  "agent",
+  "automation",
+  "file"
+]);
+var referenceSchema = import_zod9.z.string().trim().min(1);
+var RESOURCE_REFERENCE_RESOLUTION_SELECTION = `{
+  status
+  reasonCode
+  organizationId
+  resourceType
+  reference
+  eligibilityPolicy
+  complete
+  source
+  asOf
+  traceId
+  receiptId
+  resourceId
+  resourceName
+  candidates { resourceId resourceName resourceType status eligible }
+}`;
+function registerResourceCommands(program) {
+  const resources = program.command("resources").description("Organization-scoped resource resolution");
+  resources.command("resolve").description("Resolve a project, team, agent, automation, or file reference").requiredOption(
+    "--type <type>",
+    "Resource type: project, team, agent, automation, or file"
+  ).requiredOption("--query <query>", "Resource name or reference").action(async (opts, cmd) => {
+    const resourceType = resourceTypeSchema.parse(opts.type);
+    const reference = referenceSchema.parse(opts.query);
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "resources.resolve",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "OrganizationResourceReferenceResolution",
+      field: "organization_resource_reference_resolution",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        resource_type: resourceType,
+        reference,
+        trace_id: context.runtimeOptions.requestId
+      }),
+      variableTypes: {
+        organization_id: "ID!",
+        resource_type: "String!",
+        reference: "String!",
+        trace_id: "String"
+      },
+      selectionSet: RESOURCE_REFERENCE_RESOLUTION_SELECTION,
+      isShow: true
+    });
+  });
+}
+
+// src/commands/skills.ts
+var import_zod10 = require("zod");
+var idSchema7 = import_zod10.z.string().min(1);
+var limitSchema = import_zod10.z.coerce.number().int().positive();
 var SKILL_SELECTION = `{
   id
   type
@@ -4747,14 +4864,14 @@ function registerSkillCommands(program) {
 }
 
 // src/commands/issues.ts
-var import_zod10 = require("zod");
-var issueGroupIdSchema = import_zod10.z.string().min(1);
-var idSchema8 = import_zod10.z.string().min(1);
-var nameSchema = import_zod10.z.string().min(1);
-var issueTypeSchema = import_zod10.z.string().min(1).refine((value) => value === "short_term" || value === "long_term", {
+var import_zod11 = require("zod");
+var issueGroupIdSchema = import_zod11.z.string().min(1);
+var idSchema8 = import_zod11.z.string().min(1);
+var nameSchema = import_zod11.z.string().min(1);
+var issueTypeSchema = import_zod11.z.string().min(1).refine((value) => value === "short_term" || value === "long_term", {
   message: "Invalid issue type. Use one of: short_term, long_term."
 });
-var issueStatusSchema = import_zod10.z.string().min(1).refine((value) => value === "open" || value === "completed", {
+var issueStatusSchema = import_zod11.z.string().min(1).refine((value) => value === "open" || value === "completed", {
   message: "Invalid issue status. Use one of: open, completed."
 });
 var updateHelp4 = buildDataJsonHelp("issue", "update") ?? 'JSON object for issue or {"issue": {...}}';
@@ -5818,8 +5935,8 @@ function registerSystemToolCommands(program) {
 }
 
 // src/commands/teams.ts
-var import_zod11 = require("zod");
-var idSchema9 = import_zod11.z.string().min(1);
+var import_zod12 = require("zod");
+var idSchema9 = import_zod12.z.string().min(1);
 function registerTeamCommands(program) {
   const teams = program.command("teams").description("Team operations");
   teams.command("list").option("--page <page>").option("--per <per>").action(async (opts, cmd) => {
@@ -5885,8 +6002,8 @@ function registerTeamCommands(program) {
 }
 
 // src/commands/organizations.ts
-var import_zod12 = require("zod");
-var idSchema10 = import_zod12.z.string().min(1);
+var import_zod13 = require("zod");
+var idSchema10 = import_zod13.z.string().min(1);
 function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -6111,8 +6228,8 @@ function registerOrganizationCommands(program) {
 }
 
 // src/commands/foundation.ts
-var import_zod13 = require("zod");
-var idSchema11 = import_zod13.z.string().min(1);
+var import_zod14 = require("zod");
+var idSchema11 = import_zod14.z.string().min(1);
 var STRATEGIC_PLAN_ALLOWED_UPDATE_KEYS = /* @__PURE__ */ new Set([
   "published_at",
   "profile",
@@ -6313,9 +6430,9 @@ function registerFoundationCommands(program) {
 }
 
 // src/commands/childEntities.ts
-var import_zod14 = require("zod");
-var idSchema12 = import_zod14.z.string().min(1);
-var jsonObjectSchema = import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown());
+var import_zod15 = require("zod");
+var idSchema12 = import_zod15.z.string().min(1);
+var jsonObjectSchema = import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown());
 var NOTE_DETAIL_FIELDS = [
   "notes",
   "hasNotes",
@@ -6739,9 +6856,9 @@ function registerChildEntityCommands(program) {
 }
 
 // src/commands/content.ts
-var import_zod15 = require("zod");
-var idSchema13 = import_zod15.z.string().min(1);
-var nonEmptyString = import_zod15.z.string().min(1);
+var import_zod16 = require("zod");
+var idSchema13 = import_zod16.z.string().min(1);
+var nonEmptyString = import_zod16.z.string().min(1);
 var contentAttributesSelection = "attributes { id type name slug content firstChildSlug rootParentSlug status contentType lastEdited organizationId memberId focusMemberId focusTeamId teamId creatorId createdAt updatedAt childCount assignmentType contentableId contentableSlug contentableType votesTotal labelIds rootContentId parentContentId }";
 function assertUpdateFields(params) {
   if (!params.name && !params.content && !params.status) {
@@ -6929,9 +7046,9 @@ function registerContentCommands(program) {
 }
 
 // src/commands/markdownTree.ts
-var import_zod16 = require("zod");
-var nonEmptyString2 = import_zod16.z.string().min(1);
-var nonNegativeInt = import_zod16.z.coerce.number().int().min(0);
+var import_zod17 = require("zod");
+var nonEmptyString2 = import_zod17.z.string().min(1);
+var nonNegativeInt = import_zod17.z.coerce.number().int().min(0);
 function addScopeOptions(command) {
   return command.requiredOption("--tool-key <toolKey>").requiredOption("--node-key <nodeKey>").option("--parent-id <parentId>").option("--record-id <recordId>").option("--member-id <memberId>").option("--team-id <teamId>").option("--content-type <contentType>").option("--tree-view");
 }
@@ -7096,7 +7213,7 @@ function registerMarkdownTreeCommands(program) {
 }
 
 // src/commands/navigation.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/internalOptions.ts
 var INTERNAL_OPTIONS_KEY = "__waveInternalOptions";
@@ -7126,8 +7243,8 @@ function getInternalCliOptions(command) {
 }
 
 // src/commands/navigation.ts
-var nonEmpty = import_zod17.z.string().min(1);
-var nonNegativeInt2 = import_zod17.z.coerce.number().int().min(0);
+var nonEmpty = import_zod18.z.string().min(1);
+var nonNegativeInt2 = import_zod18.z.coerce.number().int().min(0);
 var MIGRATED_BRANCHES = ["directory", "projects", "knowledge"];
 function normalizeText(input) {
   if (typeof input !== "string") return "";
@@ -7910,14 +8027,14 @@ function registerMutationCapabilityCommands(program) {
 // src/commands/osmd.ts
 var import_promises3 = require("fs/promises");
 var import_node_path3 = require("path");
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var import_commander = require("commander");
 
 // src/operationManifest.ts
 var import_node_crypto3 = require("crypto");
 
 // src/version.ts
-var CLI_VERSION = "0.1.85";
+var CLI_VERSION = "0.1.87";
 
 // src/operationMetadata.ts
 var DISCOVERY_OPERATION_IDS = [
@@ -7945,6 +8062,8 @@ var DISCOVERY_OPERATION_IDS = [
   "customers.examples",
   "customers.schema",
   "datasheets.examples",
+  "data-pipeline.examples",
+  "data-pipeline.schema",
   "datasheets.schema",
   "desktop-context.examples",
   "desktop-context.schema",
@@ -8060,7 +8179,13 @@ var READ_OPERATION_IDS = [
   "customers.show",
   "datasheets.list",
   "datasheets.open",
+  "data-pipeline.execute-source-action",
+  "data-pipeline.overview",
+  "data-pipeline.source-actions",
+  "data-pipeline.sources",
   "datasheets.show",
+  "desktop-context.activity",
+  "desktop-context.member-statuses",
   "desktop-context.recent",
   "desktop-context.status",
   "feedbacks.list",
@@ -8112,12 +8237,15 @@ var READ_OPERATION_IDS = [
   "markdown-tree.root",
   "markdown-tree.subtree",
   "meetings.list",
+  "meetings.note-show",
   "meetings.search",
   "meetings.show",
   "members.list",
   "members.meta-profile",
+  "members.resolve",
   "members.search",
   "members.show",
+  "resources.resolve",
   "milestones.list",
   "milestones.search",
   "milestones.show",
@@ -8426,6 +8554,14 @@ var OPERATION_IDS_BY_CLASSIFICATION = {
   auth: AUTH_OPERATION_IDS
 };
 var metadataByOperationId = /* @__PURE__ */ new Map();
+function assertDataPipelineReadOnlyRegistration(id, metadata) {
+  if (!id.startsWith("data-pipeline.")) return;
+  const isReadOnlyOperation = metadata.classification === "read" && metadata.atlasSafetyClass === "read_only" || metadata.classification === "discovery" && metadata.atlasSafetyClass === "discovery";
+  if (isReadOnlyOperation && !metadata.requiresApproval && !metadata.machine.supportsPreview) {
+    return;
+  }
+  throw new Error(`Data Pipeline operations must remain read-only: ${id}`);
+}
 for (const [classification, operationIds] of Object.entries(OPERATION_IDS_BY_CLASSIFICATION)) {
   for (const id of operationIds) {
     if (metadataByOperationId.has(id)) {
@@ -8435,7 +8571,7 @@ for (const [classification, operationIds] of Object.entries(OPERATION_IDS_BY_CLA
     if (DESTRUCTIVE_OPERATION_IDS.has(id) && classification !== "write") {
       throw new Error(`Destructive Wave CLI operation must be a write: ${id}`);
     }
-    metadataByOperationId.set(id, {
+    const metadata = {
       classification,
       requiresApproval: classification === "write" && !DIRECT_MACHINE_WRITE_OPERATION_IDS.has(id),
       atlasSafetyClass,
@@ -8445,7 +8581,9 @@ for (const [classification, operationIds] of Object.entries(OPERATION_IDS_BY_CLA
         supportsExecute: true,
         executionMode: "sync"
       }
-    });
+    };
+    assertDataPipelineReadOnlyRegistration(id, metadata);
+    metadataByOperationId.set(id, metadata);
   }
 }
 function registeredOperationMetadata(id) {
@@ -8607,15 +8745,15 @@ function buildOperationManifest(program) {
 }
 
 // src/commands/osmd.ts
-var sourceSchema = import_zod18.z.enum([
+var sourceSchema = import_zod19.z.enum([
   "canonical_osmd",
   "agent_overlay",
   "agent_wiki",
   "thread_workspace"
 ]);
-var accessSchema = import_zod18.z.enum(["read_only", "read_write", "append_only"]).catch("read_write");
-var ownerSchema = import_zod18.z.enum(["system", "atlas"]);
-var suggestedActionSchema = import_zod18.z.enum([
+var accessSchema = import_zod19.z.enum(["read_only", "read_write", "append_only"]).catch("read_write");
+var ownerSchema = import_zod19.z.enum(["system", "atlas"]);
+var suggestedActionSchema = import_zod19.z.enum([
   "read",
   "create",
   "init",
@@ -8624,7 +8762,7 @@ var suggestedActionSchema = import_zod18.z.enum([
   "forbidden",
   "invalid_parent"
 ]).catch("update");
-var agentMarkdownErrorCodeSchema = import_zod18.z.enum([
+var agentMarkdownErrorCodeSchema = import_zod19.z.enum([
   "canonical_osmd_read_only",
   "agent_parent_not_found",
   "agent_file_not_found",
@@ -8635,9 +8773,9 @@ var agentMarkdownErrorCodeSchema = import_zod18.z.enum([
   "invalid_agent_wiki_path"
 ]);
 var agentMarkdownErrorCodeFieldSchema = agentMarkdownErrorCodeSchema.nullable().catch(null);
-var nonEmptyString3 = import_zod18.z.string().min(1);
-var nonNegativeInt3 = import_zod18.z.coerce.number().int().min(0);
-var positiveInt = import_zod18.z.coerce.number().int().min(1);
+var nonEmptyString3 = import_zod19.z.string().min(1);
+var nonNegativeInt3 = import_zod19.z.coerce.number().int().min(0);
+var positiveInt = import_zod19.z.coerce.number().int().min(1);
 var supportedAgentOverlaySystemFiles = ["notes.md", "summary.md"];
 var supportedWikiIndexFile = "index.md";
 var supportedWikiLogFile = "log.md";
@@ -8653,20 +8791,20 @@ var supportedWikiControlledPatterns = supportedWikiControlledFolders.map(
 );
 var controlledWikiSlugPattern = /^[a-z0-9][a-z0-9-]*$/;
 var agentMarkdownSlugPattern = /^[a-z0-9][a-z0-9-]*$/;
-var osmdSearchScopeSchema = import_zod18.z.enum([
+var osmdSearchScopeSchema = import_zod19.z.enum([
   "os-only",
   "agent-overlay-only",
   "agent-wiki-only",
   "combined"
 ]);
-var osmdLintScopeSchema = import_zod18.z.enum([
+var osmdLintScopeSchema = import_zod19.z.enum([
   "combined",
   "agent-overlay-only",
   "agent-wiki-only"
 ]);
-var osmdMemoryQualityScopeSchema = import_zod18.z.enum(["agent-overlay-only"]);
-var osmdIngestKindSchema = import_zod18.z.enum(["text", "file", "url", "transcript"]);
-var osmdRawSourceTypeSchema = import_zod18.z.enum([
+var osmdMemoryQualityScopeSchema = import_zod19.z.enum(["agent-overlay-only"]);
+var osmdIngestKindSchema = import_zod19.z.enum(["text", "file", "url", "transcript"]);
+var osmdRawSourceTypeSchema = import_zod19.z.enum([
   "pasted_text",
   "uploaded_markdown",
   "uploaded_text",
@@ -8675,37 +8813,37 @@ var osmdRawSourceTypeSchema = import_zod18.z.enum([
   "meeting_transcript",
   "url"
 ]);
-var agentMarkdownFileSchema = import_zod18.z.preprocess(
+var agentMarkdownFileSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    path: import_zod18.z.string(),
+  import_zod19.z.object({
+    path: import_zod19.z.string(),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    exists: import_zod18.z.boolean(),
-    canCreate: import_zod18.z.boolean(),
-    canUpdate: import_zod18.z.boolean(),
-    canAppend: import_zod18.z.boolean(),
-    wikiRole: import_zod18.z.string().nullable().optional(),
-    formatVersion: import_zod18.z.string().nullable().optional(),
-    createdAt: import_zod18.z.string().nullable().optional(),
-    updatedAt: import_zod18.z.string().nullable().optional(),
-    ingestedAt: import_zod18.z.string().nullable().optional(),
-    lastSeenAt: import_zod18.z.string().nullable().optional(),
-    canonicalParentUpdatedAt: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    agentChildrenAllowed: import_zod18.z.boolean(),
+    exists: import_zod19.z.boolean(),
+    canCreate: import_zod19.z.boolean(),
+    canUpdate: import_zod19.z.boolean(),
+    canAppend: import_zod19.z.boolean(),
+    wikiRole: import_zod19.z.string().nullable().optional(),
+    formatVersion: import_zod19.z.string().nullable().optional(),
+    createdAt: import_zod19.z.string().nullable().optional(),
+    updatedAt: import_zod19.z.string().nullable().optional(),
+    ingestedAt: import_zod19.z.string().nullable().optional(),
+    lastSeenAt: import_zod19.z.string().nullable().optional(),
+    canonicalParentUpdatedAt: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    agentChildrenAllowed: import_zod19.z.boolean(),
     suggestedAction: suggestedActionSchema,
     errorCode: agentMarkdownErrorCodeFieldSchema.optional(),
-    content: import_zod18.z.string().nullable().optional(),
-    url: import_zod18.z.string().nullable().optional(),
-    workspaceId: import_zod18.z.string().nullable().optional(),
-    fileId: import_zod18.z.string().nullable().optional(),
-    name: import_zod18.z.string().nullable().optional(),
-    displayName: import_zod18.z.string().nullable().optional(),
-    contentSha: import_zod18.z.string().nullable().optional(),
-    versionSha: import_zod18.z.string().nullable().optional(),
-    mediaType: import_zod18.z.string().nullable().optional()
+    content: import_zod19.z.string().nullable().optional(),
+    url: import_zod19.z.string().nullable().optional(),
+    workspaceId: import_zod19.z.string().nullable().optional(),
+    fileId: import_zod19.z.string().nullable().optional(),
+    name: import_zod19.z.string().nullable().optional(),
+    displayName: import_zod19.z.string().nullable().optional(),
+    contentSha: import_zod19.z.string().nullable().optional(),
+    versionSha: import_zod19.z.string().nullable().optional(),
+    mediaType: import_zod19.z.string().nullable().optional()
   }).transform((value) => ({
     ...value,
     wikiRole: value.wikiRole ?? null,
@@ -8728,31 +8866,31 @@ var agentMarkdownFileSchema = import_zod18.z.preprocess(
     mediaType: value.mediaType ?? null
   }))
 );
-var agentMarkdownFilesSchema = import_zod18.z.array(agentMarkdownFileSchema);
-var agentMarkdownMutationDataSchema = import_zod18.z.union([
+var agentMarkdownFilesSchema = import_zod19.z.array(agentMarkdownFileSchema);
+var agentMarkdownMutationDataSchema = import_zod19.z.union([
   agentMarkdownFileSchema,
-  import_zod18.z.object({ files: agentMarkdownFilesSchema })
+  import_zod19.z.object({ files: agentMarkdownFilesSchema })
 ]);
-var osmdSearchCandidateSchema = import_zod18.z.preprocess(
+var osmdSearchCandidateSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    path: import_zod18.z.string(),
+  import_zod19.z.object({
+    path: import_zod19.z.string(),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    wikiRole: import_zod18.z.string().nullable().optional(),
-    formatVersion: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    exists: import_zod18.z.boolean(),
-    agentChildrenAllowed: import_zod18.z.boolean(),
-    title: import_zod18.z.string(),
-    label: import_zod18.z.string(),
-    snippet: import_zod18.z.string().nullable().optional(),
-    rank: import_zod18.z.number().int(),
-    matchReason: import_zod18.z.string().nullable().optional(),
-    toolKey: import_zod18.z.string().nullable().optional(),
-    nodeKey: import_zod18.z.string().nullable().optional(),
-    nodeKind: import_zod18.z.string().nullable().optional()
+    wikiRole: import_zod19.z.string().nullable().optional(),
+    formatVersion: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    exists: import_zod19.z.boolean(),
+    agentChildrenAllowed: import_zod19.z.boolean(),
+    title: import_zod19.z.string(),
+    label: import_zod19.z.string(),
+    snippet: import_zod19.z.string().nullable().optional(),
+    rank: import_zod19.z.number().int(),
+    matchReason: import_zod19.z.string().nullable().optional(),
+    toolKey: import_zod19.z.string().nullable().optional(),
+    nodeKey: import_zod19.z.string().nullable().optional(),
+    nodeKind: import_zod19.z.string().nullable().optional()
   }).transform((value) => ({
     ...value,
     wikiRole: value.wikiRole ?? null,
@@ -8765,26 +8903,26 @@ var osmdSearchCandidateSchema = import_zod18.z.preprocess(
     nodeKind: value.nodeKind ?? null
   }))
 );
-var osmdSearchResultSchema = import_zod18.z.preprocess(
+var osmdSearchResultSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    query: import_zod18.z.string(),
-    scope: import_zod18.z.string(),
-    count: import_zod18.z.number().int().min(0),
-    candidates: import_zod18.z.array(osmdSearchCandidateSchema)
+  import_zod19.z.object({
+    query: import_zod19.z.string(),
+    scope: import_zod19.z.string(),
+    count: import_zod19.z.number().int().min(0),
+    candidates: import_zod19.z.array(osmdSearchCandidateSchema)
   })
 );
-var osmdWikiLintIssueSchema = import_zod18.z.preprocess(
+var osmdWikiLintIssueSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    code: import_zod18.z.string(),
-    severity: import_zod18.z.string(),
-    path: import_zod18.z.string(),
-    source: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    message: import_zod18.z.string(),
-    suggestedAction: import_zod18.z.string().nullable().optional(),
-    canAutoFix: import_zod18.z.boolean()
+  import_zod19.z.object({
+    code: import_zod19.z.string(),
+    severity: import_zod19.z.string(),
+    path: import_zod19.z.string(),
+    source: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    message: import_zod19.z.string(),
+    suggestedAction: import_zod19.z.string().nullable().optional(),
+    canAutoFix: import_zod19.z.boolean()
   }).transform((value) => ({
     ...value,
     source: value.source ?? null,
@@ -8792,37 +8930,37 @@ var osmdWikiLintIssueSchema = import_zod18.z.preprocess(
     suggestedAction: value.suggestedAction ?? null
   }))
 );
-var osmdWikiLintResultSchema = import_zod18.z.preprocess(
+var osmdWikiLintResultSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    status: import_zod18.z.string(),
-    summary: import_zod18.z.object({
-      totalIssues: import_zod18.z.number().int().min(0),
-      errors: import_zod18.z.number().int().min(0),
-      warnings: import_zod18.z.number().int().min(0),
-      suggestions: import_zod18.z.number().int().min(0)
+  import_zod19.z.object({
+    status: import_zod19.z.string(),
+    summary: import_zod19.z.object({
+      totalIssues: import_zod19.z.number().int().min(0),
+      errors: import_zod19.z.number().int().min(0),
+      warnings: import_zod19.z.number().int().min(0),
+      suggestions: import_zod19.z.number().int().min(0)
     }),
-    issues: import_zod18.z.array(osmdWikiLintIssueSchema)
+    issues: import_zod19.z.array(osmdWikiLintIssueSchema)
   })
 );
-var nullableCountSchema = import_zod18.z.preprocess(
+var nullableCountSchema = import_zod19.z.preprocess(
   (value) => value === void 0 || value === null || value === "" ? null : value,
-  import_zod18.z.coerce.number().int().min(0).nullable()
+  import_zod19.z.coerce.number().int().min(0).nullable()
 ).catch(null);
-var osmdMemoryQualityIssueSchema = import_zod18.z.preprocess(
+var osmdMemoryQualityIssueSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    code: import_zod18.z.string().nullable().optional(),
-    issueCode: import_zod18.z.string().nullable().optional(),
-    path: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    dimension: import_zod18.z.string().nullable().optional(),
-    evidence: import_zod18.z.string().nullable().optional(),
-    evidenceSnippet: import_zod18.z.string().nullable().optional(),
-    message: import_zod18.z.string().nullable().optional(),
-    severity: import_zod18.z.string().nullable().optional(),
-    suggestedAction: import_zod18.z.string().nullable().optional(),
-    canAutoFix: import_zod18.z.boolean().nullable().optional()
+  import_zod19.z.object({
+    code: import_zod19.z.string().nullable().optional(),
+    issueCode: import_zod19.z.string().nullable().optional(),
+    path: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    dimension: import_zod19.z.string().nullable().optional(),
+    evidence: import_zod19.z.string().nullable().optional(),
+    evidenceSnippet: import_zod19.z.string().nullable().optional(),
+    message: import_zod19.z.string().nullable().optional(),
+    severity: import_zod19.z.string().nullable().optional(),
+    suggestedAction: import_zod19.z.string().nullable().optional(),
+    canAutoFix: import_zod19.z.boolean().nullable().optional()
   }).passthrough().transform((value) => ({
     ...value,
     code: value.code ?? value.issueCode ?? "unknown_issue",
@@ -8837,16 +8975,16 @@ var osmdMemoryQualityIssueSchema = import_zod18.z.preprocess(
     canAutoFix: value.canAutoFix === true ? true : false
   }))
 );
-var osmdMemoryQualityOverlaySchema = import_zod18.z.preprocess(
+var osmdMemoryQualityOverlaySchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    path: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    status: import_zod18.z.string().nullable().optional(),
-    score: import_zod18.z.union([import_zod18.z.number(), import_zod18.z.string()]).nullable().optional(),
-    overallScore: import_zod18.z.union([import_zod18.z.number(), import_zod18.z.string()]).nullable().optional(),
-    dimensions: import_zod18.z.unknown().nullable().optional(),
-    issues: import_zod18.z.array(osmdMemoryQualityIssueSchema).optional()
+  import_zod19.z.object({
+    path: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    status: import_zod19.z.string().nullable().optional(),
+    score: import_zod19.z.union([import_zod19.z.number(), import_zod19.z.string()]).nullable().optional(),
+    overallScore: import_zod19.z.union([import_zod19.z.number(), import_zod19.z.string()]).nullable().optional(),
+    dimensions: import_zod19.z.unknown().nullable().optional(),
+    issues: import_zod19.z.array(osmdMemoryQualityIssueSchema).optional()
   }).passthrough().transform((value) => ({
     ...value,
     path: value.path ?? null,
@@ -8858,9 +8996,9 @@ var osmdMemoryQualityOverlaySchema = import_zod18.z.preprocess(
     issues: value.issues ?? []
   }))
 );
-var osmdMemoryQualitySummarySchema = import_zod18.z.preprocess(
+var osmdMemoryQualitySummarySchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     evaluatedCount: nullableCountSchema.optional(),
     passCount: nullableCountSchema.optional(),
     warnCount: nullableCountSchema.optional(),
@@ -8878,19 +9016,19 @@ var osmdMemoryQualitySummarySchema = import_zod18.z.preprocess(
     failCount: value.failCount ?? value.failures ?? null
   }))
 );
-var osmdMemoryQualityResultSchema = import_zod18.z.preprocess(
+var osmdMemoryQualityResultSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    status: import_zod18.z.string(),
-    scope: import_zod18.z.string().nullable().optional(),
+  import_zod19.z.object({
+    status: import_zod19.z.string(),
+    scope: import_zod19.z.string().nullable().optional(),
     evaluatedCount: nullableCountSchema.optional(),
     passCount: nullableCountSchema.optional(),
     warnCount: nullableCountSchema.optional(),
     failCount: nullableCountSchema.optional(),
     summary: osmdMemoryQualitySummarySchema.optional(),
-    weakestOverlays: import_zod18.z.array(osmdMemoryQualityOverlaySchema).optional(),
-    issues: import_zod18.z.array(osmdMemoryQualityIssueSchema).optional(),
-    scores: import_zod18.z.array(osmdMemoryQualityOverlaySchema).optional()
+    weakestOverlays: import_zod19.z.array(osmdMemoryQualityOverlaySchema).optional(),
+    issues: import_zod19.z.array(osmdMemoryQualityIssueSchema).optional(),
+    scores: import_zod19.z.array(osmdMemoryQualityOverlaySchema).optional()
   }).passthrough().transform((value) => {
     const summary = isRecord5(value.summary) ? value.summary : null;
     return {
@@ -8914,24 +9052,24 @@ function normalizeOsmdIngestFileRecordInput(value) {
   }
   return normalized;
 }
-var osmdIngestFileRecordSchema = import_zod18.z.preprocess(
+var osmdIngestFileRecordSchema = import_zod19.z.preprocess(
   normalizeOsmdIngestFileRecordInput,
-  import_zod18.z.object({
-    path: import_zod18.z.string(),
-    source: import_zod18.z.string().nullable().optional(),
-    access: import_zod18.z.string().nullable().optional(),
-    owner: import_zod18.z.string().nullable().optional(),
-    parentRef: import_zod18.z.string().nullable().optional(),
-    exists: import_zod18.z.boolean().nullable().optional(),
-    canCreate: import_zod18.z.boolean().nullable().optional(),
-    canUpdate: import_zod18.z.boolean().nullable().optional(),
-    canAppend: import_zod18.z.boolean().nullable().optional(),
-    wikiRole: import_zod18.z.string().nullable().optional(),
-    formatVersion: import_zod18.z.string().nullable().optional(),
-    createdAt: import_zod18.z.string().nullable().optional(),
-    updatedAt: import_zod18.z.string().nullable().optional(),
-    suggestedAction: import_zod18.z.string().nullable().optional(),
-    errorCode: import_zod18.z.string().nullable().optional()
+  import_zod19.z.object({
+    path: import_zod19.z.string(),
+    source: import_zod19.z.string().nullable().optional(),
+    access: import_zod19.z.string().nullable().optional(),
+    owner: import_zod19.z.string().nullable().optional(),
+    parentRef: import_zod19.z.string().nullable().optional(),
+    exists: import_zod19.z.boolean().nullable().optional(),
+    canCreate: import_zod19.z.boolean().nullable().optional(),
+    canUpdate: import_zod19.z.boolean().nullable().optional(),
+    canAppend: import_zod19.z.boolean().nullable().optional(),
+    wikiRole: import_zod19.z.string().nullable().optional(),
+    formatVersion: import_zod19.z.string().nullable().optional(),
+    createdAt: import_zod19.z.string().nullable().optional(),
+    updatedAt: import_zod19.z.string().nullable().optional(),
+    suggestedAction: import_zod19.z.string().nullable().optional(),
+    errorCode: import_zod19.z.string().nullable().optional()
   }).passthrough().transform((value) => ({
     ...value,
     source: value.source ?? null,
@@ -8950,17 +9088,17 @@ var osmdIngestFileRecordSchema = import_zod18.z.preprocess(
     errorCode: value.errorCode ?? null
   }))
 );
-var osmdIngestResultSchema = import_zod18.z.preprocess(
+var osmdIngestResultSchema = import_zod19.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod18.z.object({
-    rawSourceId: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).nullable().optional(),
-    sourceSummaryPath: import_zod18.z.string().nullable().optional(),
+  import_zod19.z.object({
+    rawSourceId: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).nullable().optional(),
+    sourceSummaryPath: import_zod19.z.string().nullable().optional(),
     sourceSummaryFile: osmdIngestFileRecordSchema.nullable().optional(),
-    slug: import_zod18.z.string().nullable().optional(),
-    runLint: import_zod18.z.boolean().nullable().optional(),
-    createdFiles: import_zod18.z.array(osmdIngestFileRecordSchema).optional(),
-    updatedFiles: import_zod18.z.array(osmdIngestFileRecordSchema).optional(),
-    skippedUpdates: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+    slug: import_zod19.z.string().nullable().optional(),
+    runLint: import_zod19.z.boolean().nullable().optional(),
+    createdFiles: import_zod19.z.array(osmdIngestFileRecordSchema).optional(),
+    updatedFiles: import_zod19.z.array(osmdIngestFileRecordSchema).optional(),
+    skippedUpdates: import_zod19.z.array(import_zod19.z.unknown()).optional(),
     lintResult: osmdWikiLintResultSchema.nullable().optional()
   }).passthrough().transform((value) => ({
     ...value,
@@ -8975,37 +9113,37 @@ var osmdIngestResultSchema = import_zod18.z.preprocess(
     lintResult: value.lintResult ?? null
   }))
 );
-var mutationPayloadSchema = import_zod18.z.object({
-  ok: import_zod18.z.boolean(),
-  status: import_zod18.z.number(),
-  errorCode: import_zod18.z.string().nullable().optional(),
-  data: import_zod18.z.unknown().nullable().optional(),
-  errors: import_zod18.z.unknown().nullable().optional()
+var mutationPayloadSchema = import_zod19.z.object({
+  ok: import_zod19.z.boolean(),
+  status: import_zod19.z.number(),
+  errorCode: import_zod19.z.string().nullable().optional(),
+  data: import_zod19.z.unknown().nullable().optional(),
+  errors: import_zod19.z.unknown().nullable().optional()
 });
-var markdownTreeNodeSchema = import_zod18.z.lazy(
-  () => import_zod18.z.object({
-    toolKey: import_zod18.z.string(),
-    nodeKey: import_zod18.z.string(),
-    nodeKind: import_zod18.z.string(),
-    runtimeLabel: import_zod18.z.string(),
-    path: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
+var markdownTreeNodeSchema = import_zod19.z.lazy(
+  () => import_zod19.z.object({
+    toolKey: import_zod19.z.string(),
+    nodeKey: import_zod19.z.string(),
+    nodeKind: import_zod19.z.string(),
+    runtimeLabel: import_zod19.z.string(),
+    path: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    parentRef: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
-    agentChildrenAllowed: import_zod18.z.boolean(),
-    exists: import_zod18.z.boolean(),
-    resolvedScope: import_zod18.z.object({
-      parentId: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
-      recordId: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
-      memberId: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
-      teamId: import_zod18.z.string().nullable().optional().transform((value) => value ?? null),
-      contentType: import_zod18.z.string().nullable().optional().transform((value) => value ?? null)
+    parentRef: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
+    agentChildrenAllowed: import_zod19.z.boolean(),
+    exists: import_zod19.z.boolean(),
+    resolvedScope: import_zod19.z.object({
+      parentId: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
+      recordId: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
+      memberId: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
+      teamId: import_zod19.z.string().nullable().optional().transform((value) => value ?? null),
+      contentType: import_zod19.z.string().nullable().optional().transform((value) => value ?? null)
     }),
-    isLeaf: import_zod18.z.boolean(),
-    treeView: import_zod18.z.boolean(),
-    details: import_zod18.z.unknown().nullable(),
-    children: import_zod18.z.array(markdownTreeNodeSchema).optional().transform((value) => value ?? [])
+    isLeaf: import_zod19.z.boolean(),
+    treeView: import_zod19.z.boolean(),
+    details: import_zod19.z.unknown().nullable(),
+    children: import_zod19.z.array(markdownTreeNodeSchema).optional().transform((value) => value ?? [])
   })
 );
 var AGENT_MARKDOWN_FILE_SELECTION = `{
@@ -13932,14 +14070,14 @@ function registerMailCommands(program) {
 }
 
 // src/commands/phantom.ts
-var import_zod19 = require("zod");
-var nonNegativeInt4 = import_zod19.z.coerce.number().int().min(0);
-var nullableString = import_zod19.z.string().nullable().optional().transform((value) => value ?? null);
-var idString = import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).transform((value) => String(value));
-var nullableIdString = import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).nullable().optional().transform(
+var import_zod20 = require("zod");
+var nonNegativeInt4 = import_zod20.z.coerce.number().int().min(0);
+var nullableString = import_zod20.z.string().nullable().optional().transform((value) => value ?? null);
+var idString = import_zod20.z.union([import_zod20.z.string(), import_zod20.z.number()]).transform((value) => String(value));
+var nullableIdString = import_zod20.z.union([import_zod20.z.string(), import_zod20.z.number()]).nullable().optional().transform(
   (value) => value === void 0 || value === null ? null : String(value)
 );
-var jsonObject = import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown());
+var jsonObject = import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown());
 var PHANTOM_LEDGER_INVENTORY_SELECTION = `{
   schemaVersion
   runsCount
@@ -14152,10 +14290,10 @@ var PHANTOM_LEDGER_KEY_ALIASES = {
   content_hash: "contentHash",
   observed_at: "observedAt"
 };
-var phantomLedgerInventorySchema = import_zod19.z.preprocess(
+var phantomLedgerInventorySchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
-    schemaVersion: import_zod19.z.string(),
+  import_zod20.z.object({
+    schemaVersion: import_zod20.z.string(),
     runsCount: nonNegativeInt4,
     observationsCount: nonNegativeInt4,
     candidatesCount: nonNegativeInt4,
@@ -14165,16 +14303,16 @@ var phantomLedgerInventorySchema = import_zod19.z.preprocess(
     reportsCount: nonNegativeInt4
   })
 );
-var phantomRunSchema = import_zod19.z.preprocess(
+var phantomRunSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
-    notificationId: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).nullable().optional().transform(
+    notificationId: import_zod20.z.union([import_zod20.z.string(), import_zod20.z.number()]).nullable().optional().transform(
       (value) => value === void 0 || value === null ? null : String(value)
     ),
-    status: import_zod19.z.string(),
-    triggerType: import_zod19.z.string(),
+    status: import_zod20.z.string(),
+    triggerType: import_zod20.z.string(),
     startedAt: nullableString,
     completedAt: nullableString,
     scannedFileCount: nonNegativeInt4,
@@ -14184,163 +14322,163 @@ var phantomRunSchema = import_zod19.z.preprocess(
     errorCount: nonNegativeInt4,
     warningCount: nonNegativeInt4,
     errorMessage: nullableString,
-    dryRun: import_zod19.z.boolean(),
-    schemaVersion: import_zod19.z.string(),
+    dryRun: import_zod20.z.boolean(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
     idempotencyKey: nullableString,
     ledgerMetadata: jsonObject.catch({}),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomRunListItemSchema = import_zod19.z.preprocess(
+var phantomRunListItemSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
-    status: import_zod19.z.string(),
-    triggerType: import_zod19.z.string(),
-    dryRun: import_zod19.z.boolean(),
-    schemaVersion: import_zod19.z.string(),
+    status: import_zod20.z.string(),
+    triggerType: import_zod20.z.string(),
+    dryRun: import_zod20.z.boolean(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomReportSchema = import_zod19.z.preprocess(
+var phantomReportSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
-    status: import_zod19.z.string(),
-    reportType: import_zod19.z.string(),
-    schemaVersion: import_zod19.z.string(),
+    status: import_zod20.z.string(),
+    reportType: import_zod20.z.string(),
+    schemaVersion: import_zod20.z.string(),
     markdownPath: nullableString,
     payload: jsonObject.catch({}),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomObservationSchema = import_zod19.z.preprocess(
+var phantomObservationSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
-    status: import_zod19.z.string(),
-    observationType: import_zod19.z.string(),
+    status: import_zod20.z.string(),
+    observationType: import_zod20.z.string(),
     targetType: nullableString,
     targetId: nullableString,
     sourceTable: nullableString,
     sourceRecordId: nullableString,
     sourceEventId: nullableString,
     contentHash: nullableString,
-    observedAt: import_zod19.z.string(),
-    confidence: import_zod19.z.coerce.number(),
+    observedAt: import_zod20.z.string(),
+    confidence: import_zod20.z.coerce.number(),
     payload: jsonObject.catch({}),
-    schemaVersion: import_zod19.z.string(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomCandidateSchema = import_zod19.z.preprocess(
+var phantomCandidateSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomObservationId: nullableString,
-    status: import_zod19.z.string(),
-    candidateType: import_zod19.z.string(),
+    status: import_zod20.z.string(),
+    candidateType: import_zod20.z.string(),
     targetType: nullableString,
     targetId: nullableString,
     title: nullableString,
-    dryRun: import_zod19.z.boolean(),
+    dryRun: import_zod20.z.boolean(),
     payload: jsonObject.catch({}),
-    approvalStatus: import_zod19.z.string(),
+    approvalStatus: import_zod20.z.string(),
     approvedById: nullableIdString,
     approvedAt: nullableString,
     approvalSource: nullableString,
     approvalReason: nullableString,
     approvalMetadata: jsonObject.catch({}),
-    schemaVersion: import_zod19.z.string(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomCandidateEvidenceSchema = import_zod19.z.preprocess(
+var phantomCandidateEvidenceSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomCandidateId: idString,
     phantomObservationId: nullableString,
-    evidenceType: import_zod19.z.string(),
+    evidenceType: import_zod20.z.string(),
     sourceType: nullableString,
     sourceId: nullableString,
     contentHash: nullableString,
     payload: jsonObject.catch({}),
-    schemaVersion: import_zod19.z.string(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomValidationSchema = import_zod19.z.preprocess(
+var phantomValidationSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomCandidateId: idString,
-    status: import_zod19.z.string(),
-    validationType: import_zod19.z.string(),
-    dryRun: import_zod19.z.boolean(),
+    status: import_zod20.z.string(),
+    validationType: import_zod20.z.string(),
+    dryRun: import_zod20.z.boolean(),
     payload: jsonObject.catch({}),
     resultPayload: jsonObject.catch({}),
-    schemaVersion: import_zod19.z.string(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomApplyOperationSchema = import_zod19.z.preprocess(
+var phantomApplyOperationSchema = import_zod20.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomCandidateId: idString,
-    status: import_zod19.z.string(),
-    operationType: import_zod19.z.string(),
-    dryRun: import_zod19.z.boolean(),
+    status: import_zod20.z.string(),
+    operationType: import_zod20.z.string(),
+    dryRun: import_zod20.z.boolean(),
     targetType: nullableString,
     targetId: nullableString,
     payload: jsonObject.catch({}),
     resultPayload: jsonObject.catch({}),
-    schemaVersion: import_zod19.z.string(),
+    schemaVersion: import_zod20.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod19.z.string(),
-    createdAt: import_zod19.z.string(),
-    updatedAt: import_zod19.z.string()
+    idempotencyKey: import_zod20.z.string(),
+    createdAt: import_zod20.z.string(),
+    updatedAt: import_zod20.z.string()
   })
 );
-var phantomRunsSchema = import_zod19.z.array(phantomRunListItemSchema);
-var phantomReportsSchema = import_zod19.z.array(phantomReportSchema);
-var phantomObservationsSchema = import_zod19.z.array(phantomObservationSchema);
-var phantomCandidatesSchema = import_zod19.z.array(phantomCandidateSchema);
-var phantomCandidateEvidencesSchema = import_zod19.z.array(phantomCandidateEvidenceSchema);
-var phantomValidationsSchema = import_zod19.z.array(phantomValidationSchema);
-var phantomApplyOperationsSchema = import_zod19.z.array(phantomApplyOperationSchema);
+var phantomRunsSchema = import_zod20.z.array(phantomRunListItemSchema);
+var phantomReportsSchema = import_zod20.z.array(phantomReportSchema);
+var phantomObservationsSchema = import_zod20.z.array(phantomObservationSchema);
+var phantomCandidatesSchema = import_zod20.z.array(phantomCandidateSchema);
+var phantomCandidateEvidencesSchema = import_zod20.z.array(phantomCandidateEvidenceSchema);
+var phantomValidationsSchema = import_zod20.z.array(phantomValidationSchema);
+var phantomApplyOperationsSchema = import_zod20.z.array(phantomApplyOperationSchema);
 function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -16269,72 +16407,72 @@ function registerSignatureCommands(program) {
 }
 
 // src/commands/atlasAuthoring.ts
-var import_zod20 = require("zod");
-var idSchema15 = import_zod20.z.string().trim().min(1);
-var idempotencyKeySchema = import_zod20.z.string().min(1).refine((value) => value.trim() === value, "Idempotency key must not have leading or trailing whitespace.");
-var skillScopeSchema = import_zod20.z.enum(["ADMIN_GLOBAL", "MEMBER_PERSONAL"]);
-var isoDateSchema = import_zod20.z.iso.date();
-var nonEmptyStringSchema = import_zod20.z.string().trim().min(1);
+var import_zod21 = require("zod");
+var idSchema15 = import_zod21.z.string().trim().min(1);
+var idempotencyKeySchema = import_zod21.z.string().min(1).refine((value) => value.trim() === value, "Idempotency key must not have leading or trailing whitespace.");
+var skillScopeSchema = import_zod21.z.enum(["ADMIN_GLOBAL", "MEMBER_PERSONAL"]);
+var isoDateSchema = import_zod21.z.iso.date();
+var nonEmptyStringSchema = import_zod21.z.string().trim().min(1);
 var AUTOMATION_RUN_HTTP_TIMEOUT_MS = 6e4;
-var agentToolAccessSchema = import_zod20.z.array(
-  import_zod20.z.object({
+var agentToolAccessSchema = import_zod21.z.array(
+  import_zod21.z.object({
     tool_key: nonEmptyStringSchema,
     scope_value: nonEmptyStringSchema
   }).strict()
 ).min(1);
 var agentToolAccessUpdateSchema = agentToolAccessSchema.min(0);
-var agentPluginConnectionsSchema = import_zod20.z.array(
-  import_zod20.z.object({
+var agentPluginConnectionsSchema = import_zod21.z.array(
+  import_zod21.z.object({
     external_tool_connection_id: nonEmptyStringSchema,
     tool_key: nonEmptyStringSchema,
     scope_value: nonEmptyStringSchema.optional(),
-    allowed_tools: import_zod20.z.array(nonEmptyStringSchema).optional(),
-    allowed_scopes: import_zod20.z.array(nonEmptyStringSchema).optional(),
-    requires_confirmation: import_zod20.z.boolean().optional(),
-    enabled: import_zod20.z.boolean().optional()
+    allowed_tools: import_zod21.z.array(nonEmptyStringSchema).optional(),
+    allowed_scopes: import_zod21.z.array(nonEmptyStringSchema).optional(),
+    requires_confirmation: import_zod21.z.boolean().optional(),
+    enabled: import_zod21.z.boolean().optional()
   }).strict()
 ).min(1);
-var agentPluginConnectionUpdateSchema = import_zod20.z.array(
-  import_zod20.z.union([
-    import_zod20.z.object({
+var agentPluginConnectionUpdateSchema = import_zod21.z.array(
+  import_zod21.z.union([
+    import_zod21.z.object({
       id: nonEmptyStringSchema,
-      _destroy: import_zod20.z.literal(true)
+      _destroy: import_zod21.z.literal(true)
     }).strict(),
-    import_zod20.z.object({
+    import_zod21.z.object({
       id: nonEmptyStringSchema.optional(),
       external_tool_connection_id: nonEmptyStringSchema.optional(),
       tool_key: nonEmptyStringSchema.optional(),
       scope_value: nonEmptyStringSchema.optional(),
-      allowed_tools: import_zod20.z.array(nonEmptyStringSchema).optional(),
-      allowed_scopes: import_zod20.z.array(nonEmptyStringSchema).optional(),
-      requires_confirmation: import_zod20.z.boolean().optional(),
-      enabled: import_zod20.z.boolean().optional()
+      allowed_tools: import_zod21.z.array(nonEmptyStringSchema).optional(),
+      allowed_scopes: import_zod21.z.array(nonEmptyStringSchema).optional(),
+      requires_confirmation: import_zod21.z.boolean().optional(),
+      enabled: import_zod21.z.boolean().optional()
     }).strict().superRefine((value, context) => {
       if (value.id || value.external_tool_connection_id && value.tool_key) return;
       context.addIssue({
-        code: import_zod20.z.ZodIssueCode.custom,
+        code: import_zod21.z.ZodIssueCode.custom,
         message: "Plugin updates require an id, or both external_tool_connection_id and tool_key for a new grant."
       });
     })
   ])
 );
-var agentTriggerSchema = import_zod20.z.object({
-  trigger_type: import_zod20.z.literal("cron"),
+var agentTriggerSchema = import_zod21.z.object({
+  trigger_type: import_zod21.z.literal("cron"),
   cron_expression: nonEmptyStringSchema,
   timezone: nonEmptyStringSchema,
-  starts_at: import_zod20.z.iso.datetime({ offset: true }).nullable().optional(),
-  ends_at: import_zod20.z.iso.datetime({ offset: true }).nullable().optional(),
-  max_runs: import_zod20.z.number().int().positive().nullable().optional(),
-  enabled: import_zod20.z.boolean().optional()
+  starts_at: import_zod21.z.iso.datetime({ offset: true }).nullable().optional(),
+  ends_at: import_zod21.z.iso.datetime({ offset: true }).nullable().optional(),
+  max_runs: import_zod21.z.number().int().positive().nullable().optional(),
+  enabled: import_zod21.z.boolean().optional()
 }).strict();
-var agentTriggerUpdateSchema = import_zod20.z.union([
+var agentTriggerUpdateSchema = import_zod21.z.union([
   agentTriggerSchema.extend({ id: nonEmptyStringSchema.optional() }).strict(),
-  import_zod20.z.object({
+  import_zod21.z.object({
     id: nonEmptyStringSchema,
-    _destroy: import_zod20.z.literal(true)
+    _destroy: import_zod21.z.literal(true)
   }).strict()
 ]);
-var automationConfigSchema = import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown());
+var automationConfigSchema = import_zod21.z.record(import_zod21.z.string(), import_zod21.z.unknown());
 var AGENT_SELECTION = `{
   id
   type
@@ -17012,7 +17150,7 @@ function registerAtlasAuthoringCommands(program) {
     "--service <service>",
     "Supported service: gmail, calendar, slack, or stripe"
   ).action(async (opts, cmd) => {
-    const service = import_zod20.z.enum(["gmail", "calendar", "slack", "stripe"]).parse(opts.service);
+    const service = import_zod21.z.enum(["gmail", "calendar", "slack", "stripe"]).parse(opts.service);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     await runGraphqlQueryCommand({
@@ -17297,6 +17435,15 @@ var VARIABLE_TYPES = {
   organization_id: "ID!",
   member_id: "ID"
 };
+var ACTIVITY_VARIABLE_TYPES = {
+  ...VARIABLE_TYPES,
+  start_at: "ISO8601DateTime!",
+  end_at: "ISO8601DateTime!"
+};
+var MEMBER_STATUSES_VARIABLE_TYPES = {
+  organization_id: "ID!",
+  member_ids: "[ID!]!"
+};
 function parseRecentLimit(value) {
   const limit = Number(value);
   if (!Number.isInteger(limit) || limit < 1 || limit > 50) {
@@ -17304,6 +17451,25 @@ function parseRecentLimit(value) {
   }
   return limit;
 }
+function parseIsoDateTime(optionName, value) {
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp) || !value.includes("T")) {
+    throw new Error(`${optionName} must be an ISO 8601 date-time`);
+  }
+  return value;
+}
+function validateActivityRange(startAt, endAt) {
+  if (Date.parse(endAt) <= Date.parse(startAt)) {
+    throw new Error("end-at must be after start-at");
+  }
+}
+function parseMemberIds(value) {
+  const memberIds = [...new Set(value.split(",").map((id) => id.trim()).filter(Boolean))];
+  if (memberIds.length < 1 || memberIds.length > 100) {
+    throw new Error("member-ids must contain between 1 and 100 unique member IDs");
+  }
+  return memberIds;
+}
 async function runDesktopContextQuery(cmd, params) {
   const context = await resolveCommandContext(cmd.optsWithGlobals());
   await runGraphqlQueryCommand({
@@ -17314,9 +17480,12 @@ async function runDesktopContextQuery(cmd, params) {
     variables: normalizeGraphqlVariables2({
       organization_id: resolveOrganizationId(context.organizationId),
       member_id: params.memberId,
-      limit: params.limit
+      member_ids: params.memberIds,
+      limit: params.limit,
+      start_at: params.startAt,
+      end_at: params.endAt
     }),
-    variableTypes: {
+    variableTypes: params.command === "desktop-context.activity" ? ACTIVITY_VARIABLE_TYPES : params.command === "desktop-context.member-statuses" ? MEMBER_STATUSES_VARIABLE_TYPES : {
       ...VARIABLE_TYPES,
       ...params.command === "desktop-context.recent" ? { limit: "Int" } : {}
     },
@@ -17334,6 +17503,18 @@ function registerDesktopContextCommands(program) {
       memberId: opts.memberId
     });
   });
+  desktopContext.command("member-statuses").description("Read capture and enrollment status for up to 100 organization members").requiredOption(
+    "--member-ids <memberIds>",
+    "Comma-separated organization member IDs (1-100)",
+    parseMemberIds
+  ).action(async (opts, cmd) => {
+    await runDesktopContextQuery(cmd, {
+      command: "desktop-context.member-statuses",
+      operationName: "DesktopContextMemberStatuses",
+      field: "desktop_context_member_statuses",
+      memberIds: opts.memberIds
+    });
+  });
   desktopContext.command("recent").description("Read recent sanitized evidence excerpts").option("--member-id <memberId>", "Member scope; defaults to the authenticated member").option("--limit <limit>", "Maximum observations (1-50)", parseRecentLimit).action(async (opts, cmd) => {
     await runDesktopContextQuery(cmd, {
       command: "desktop-context.recent",
@@ -17343,6 +17524,380 @@ function registerDesktopContextCommands(program) {
       limit: opts.limit
     });
   });
+  desktopContext.command("activity").description("Read canonical active, AFK, gap, and app duration for a bounded range").requiredOption(
+    "--start-at <dateTime>",
+    "Inclusive ISO 8601 range start",
+    (value) => parseIsoDateTime("start-at", value)
+  ).requiredOption(
+    "--end-at <dateTime>",
+    "Exclusive ISO 8601 range end",
+    (value) => parseIsoDateTime("end-at", value)
+  ).option("--member-id <memberId>", "Member scope; defaults to the authenticated member").action(async (opts, cmd) => {
+    validateActivityRange(opts.startAt, opts.endAt);
+    await runDesktopContextQuery(cmd, {
+      command: "desktop-context.activity",
+      operationName: "DesktopContextActivity",
+      field: "desktop_context_activity_summary",
+      memberId: opts.memberId,
+      startAt: opts.startAt,
+      endAt: opts.endAt
+    });
+  });
+}
+
+// src/commands/dataPipeline.ts
+var MAX_PARAMETERS_JSON_BYTES = 16384;
+var SECRET_LIKE_PARAMETER_KEY = /(?:^|_)(?:api_?key|authorization|credential|password|secret|token)(?:$|_)/i;
+var UNSAFE_PARAMETER_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var ORGANIZATION_VARIABLE_TYPES = {
+  organization_id: "ID!"
+};
+var SOURCES_VARIABLE_TYPES = {
+  ...ORGANIZATION_VARIABLE_TYPES,
+  category_key: "String!"
+};
+var SOURCE_ACTIONS_VARIABLE_TYPES = {
+  ...ORGANIZATION_VARIABLE_TYPES,
+  source_id: "ID!"
+};
+var EXECUTE_SOURCE_ACTION_VARIABLE_TYPES = {
+  ...SOURCE_ACTIONS_VARIABLE_TYPES,
+  category_key: "String!",
+  provider_key: "String!",
+  action_key: "String!",
+  parameters: "JSON"
+};
+var PROVIDER_SELECTION = `
+organizationPluginId
+key
+name
+categories
+availability
+integrationKey
+arcadeProvider
+arcadeService
+logoAssetPath
+`.trim();
+var OVERVIEW_SELECTION = `
+{
+totalSourceCount
+connectedSourceCount
+categoriesConfiguredCount
+actionRequiredCount
+categories {
+  key
+  name
+  description
+  iconKey
+  sortOrder
+  allowedSourceTypes
+  suggestedSourceLabels
+  sourceCount
+  activeSourceCount
+  attentionSourceCount
+  status
+  providers {
+    ${PROVIDER_SELECTION}
+  }
+}
+}
+`.trim();
+var SOURCE_SELECTION = `
+{
+id
+type
+organizationId
+categoryKey
+sourceType
+providerKey
+organizationPluginId
+name
+url
+status
+connection
+configuration
+metadata
+lastSyncedAt
+lastSuccessfulSyncAt
+lastErrorAt
+lastErrorMessage
+createdById
+createdAt
+updatedAt
+}
+`.trim();
+var SOURCE_ACTION_SELECTION = `
+{
+key
+displayName
+inputSchema
+safetyClass
+requiresApproval
+}
+`.trim();
+var SOURCE_ACTION_RESULT_SELECTION = `
+{
+ok
+status
+errorCode
+errors
+traceId
+organizationId
+categoryKey
+providerKey
+sourceId
+actionKey
+records
+pageInfo
+metadata
+}
+`.trim();
+function invalidParameters(message, details = {}) {
+  return new CliError({
+    message,
+    kind: "invalid_args",
+    status: 400,
+    exitCode: EXIT_CODES.invalidArgs,
+    details
+  });
+}
+function parseNonBlank(value, optionName) {
+  const parsed = value.trim();
+  if (!parsed) {
+    throw invalidParameters(`${optionName} must not be blank`);
+  }
+  return parsed;
+}
+function parseCategoryKey(value) {
+  return parseNonBlank(value, "category-key");
+}
+function secretLikeParameterPath(value, path = []) {
+  if (!value || typeof value !== "object") return null;
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      const nestedPath = secretLikeParameterPath(value[index], [...path, String(index)]);
+      if (nestedPath) return nestedPath;
+    }
+    return null;
+  }
+  for (const [key, nestedValue] of Object.entries(value)) {
+    const keyPath = [...path, key];
+    if (UNSAFE_PARAMETER_KEYS.has(key) || SECRET_LIKE_PARAMETER_KEY.test(key)) {
+      return keyPath.join(".");
+    }
+    const nestedPath = secretLikeParameterPath(nestedValue, keyPath);
+    if (nestedPath) return nestedPath;
+  }
+  return null;
+}
+function parseSourceActionParameters(raw) {
+  if (Buffer.byteLength(raw, "utf8") > MAX_PARAMETERS_JSON_BYTES) {
+    throw invalidParameters(
+      `parameters-json must not exceed ${MAX_PARAMETERS_JSON_BYTES} bytes`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw invalidParameters("parameters-json must be a valid JSON object");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw invalidParameters("parameters-json must be a JSON object");
+  }
+  const secretPath = secretLikeParameterPath(parsed);
+  if (secretPath) {
+    throw invalidParameters(
+      `parameters-json contains a secret-like parameter key: ${secretPath}`,
+      { parameterPath: secretPath }
+    );
+  }
+  return parsed;
+}
+function isJsonRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function sourceActionFailureKind(errorCode, status) {
+  if (errorCode === "AUTH_REQUIRED" || errorCode === "UNAUTHORIZED") return "missing_auth";
+  if (errorCode === "NOT_FOUND") return "not_found";
+  if (errorCode === "PROVIDER_ERROR") return "upstream_error";
+  if (errorCode === "ACTION_NOT_ALLOWED") return "forbidden";
+  if (errorCode === "INVALID_INPUT" || errorCode === "INVALID_SOURCE") {
+    return "validation";
+  }
+  if (status === 403) return "forbidden";
+  if (status === 404) return "not_found";
+  if (status >= 500) return "upstream_error";
+  if (status === 400 || status === 422) return "validation";
+  return "generic_error";
+}
+function sourceActionFailureExitCode(kind, status) {
+  if (kind === "missing_auth") return EXIT_CODES.missingOrInvalidAuth;
+  if (kind === "forbidden") return EXIT_CODES.forbidden;
+  if (kind === "not_found") return EXIT_CODES.notFound;
+  if (kind === "validation") return EXIT_CODES.validationFailure;
+  if (kind === "upstream_error" || kind === "malformed_response") {
+    return EXIT_CODES.networkOrUpstream;
+  }
+  return mapStatusToExitCode(status);
+}
+function transformSourceActionResult(value) {
+  if (!isJsonRecord(value) || typeof value.ok !== "boolean") {
+    throw new CliError({
+      message: "Data Pipeline source action returned a malformed response",
+      kind: "malformed_response",
+      status: 502,
+      exitCode: EXIT_CODES.networkOrUpstream
+    });
+  }
+  if (value.ok) return value;
+  const status = typeof value.status === "number" && Number.isInteger(value.status) ? value.status : 500;
+  const errorCode = typeof value.errorCode === "string" && value.errorCode.length > 0 ? value.errorCode.toUpperCase() : "SOURCE_ACTION_FAILED";
+  const errors = Array.isArray(value.errors) ? value.errors.filter((error) => typeof error === "string") : [];
+  const traceId = typeof value.traceId === "string" ? value.traceId : null;
+  const kind = sourceActionFailureKind(errorCode, status);
+  throw new CliError({
+    message: errors.find((error) => error.trim().length > 0) ?? "Data Pipeline source action failed",
+    kind,
+    status,
+    exitCode: sourceActionFailureExitCode(kind, status),
+    details: { errorCode, traceId, errors }
+  });
+}
+function transformSourceActions(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError({
+      message: "Data Pipeline source action discovery returned a malformed response",
+      kind: "malformed_response",
+      status: 502,
+      exitCode: EXIT_CODES.networkOrUpstream
+    });
+  }
+  for (const action of value) {
+    if (!isJsonRecord(action) || typeof action.key !== "string") {
+      throw new CliError({
+        message: "Data Pipeline source action discovery returned a malformed action",
+        kind: "malformed_response",
+        status: 502,
+        exitCode: EXIT_CODES.networkOrUpstream
+      });
+    }
+    if (action.safetyClass !== "read_only" || action.requiresApproval !== false) {
+      throw new CliError({
+        message: `Data Pipeline source action discovery returned a non-read-only action: ${action.key}`,
+        kind: "malformed_response",
+        status: 502,
+        exitCode: EXIT_CODES.networkOrUpstream,
+        details: {
+          actionKey: action.key,
+          safetyClass: action.safetyClass,
+          requiresApproval: action.requiresApproval
+        }
+      });
+    }
+  }
+  return value;
+}
+function registerDataPipelineCommands(program) {
+  const dataPipeline = program.command("data-pipeline").description("Inspect the organization's configured Data Pipeline control plane");
+  dataPipeline.command("overview").description("Read source counts, category status, and available organization plugins").action(async (_opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    await runGraphqlQueryCommand({
+      command: "data-pipeline.overview",
+      operationName: "DataPipelineOverview",
+      runtimeOptions: context.runtimeOptions,
+      field: "data_pipeline_overview",
+      variables: {
+        organization_id: resolveOrganizationId(context.organizationId)
+      },
+      variableTypes: ORGANIZATION_VARIABLE_TYPES,
+      isShow: true,
+      selectionSet: OVERVIEW_SELECTION
+    });
+  });
+  dataPipeline.command("sources").description("Read the saved source records configured for one Data Pipeline category").requiredOption(
+    "--category-key <categoryKey>",
+    "Data Pipeline category key from the overview response",
+    parseCategoryKey
+  ).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    await runGraphqlQueryCommand({
+      command: "data-pipeline.sources",
+      operationName: "DataPipelineSources",
+      runtimeOptions: context.runtimeOptions,
+      field: "data_pipeline_sources",
+      variables: {
+        organization_id: resolveOrganizationId(context.organizationId),
+        category_key: opts.categoryKey
+      },
+      variableTypes: SOURCES_VARIABLE_TYPES,
+      isList: true,
+      selectionSet: SOURCE_SELECTION
+    });
+  });
+  dataPipeline.command("source-actions").description("Read the certified provider actions available for one configured source").requiredOption(
+    "--source-id <sourceId>",
+    "Configured Data Pipeline source ID",
+    (value) => parseNonBlank(value, "source-id")
+  ).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    await runGraphqlQueryCommand({
+      command: "data-pipeline.source-actions",
+      operationName: "DataPipelineSourceActions",
+      runtimeOptions: context.runtimeOptions,
+      field: "data_pipeline_source_actions",
+      variables: {
+        organization_id: resolveOrganizationId(context.organizationId),
+        source_id: opts.sourceId
+      },
+      variableTypes: SOURCE_ACTIONS_VARIABLE_TYPES,
+      isList: true,
+      transformData: transformSourceActions,
+      selectionSet: SOURCE_ACTION_SELECTION
+    });
+  });
+  dataPipeline.command("execute-source-action").description("Execute one backend-certified read-only action for a configured source").requiredOption(
+    "--category-key <categoryKey>",
+    "Data Pipeline category key",
+    parseCategoryKey
+  ).requiredOption(
+    "--provider-key <providerKey>",
+    "Provider key from the configured source",
+    (value) => parseNonBlank(value, "provider-key")
+  ).requiredOption(
+    "--source-id <sourceId>",
+    "Configured Data Pipeline source ID",
+    (value) => parseNonBlank(value, "source-id")
+  ).requiredOption(
+    "--action-key <actionKey>",
+    "Action key returned by source-actions",
+    (value) => parseNonBlank(value, "action-key")
+  ).option(
+    "--parameters-json <parametersJson>",
+    "Bounded JSON object matching the discovered action input schema",
+    parseSourceActionParameters,
+    {}
+  ).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    await runGraphqlQueryCommand({
+      command: "data-pipeline.execute-source-action",
+      operationName: "DataPipelineExecuteSourceAction",
+      runtimeOptions: context.runtimeOptions,
+      field: "data_pipeline_execute_source_action",
+      variables: {
+        organization_id: resolveOrganizationId(context.organizationId),
+        category_key: opts.categoryKey,
+        provider_key: opts.providerKey,
+        source_id: opts.sourceId,
+        action_key: opts.actionKey,
+        parameters: opts.parametersJson
+      },
+      variableTypes: EXECUTE_SOURCE_ACTION_VARIABLE_TYPES,
+      isShow: true,
+      transformData: transformSourceActionResult,
+      selectionSet: SOURCE_ACTION_RESULT_SELECTION
+    });
+  });
 }
 
 // src/commands/discovery.ts
@@ -17358,6 +17913,7 @@ var PRIMARY_NAMESPACES = [
   "planner",
   "mail",
   "datasheets",
+  "data-pipeline",
   "desktop-context",
   "phantom",
   "tasks",
@@ -17446,7 +18002,9 @@ var NAMESPACE_DOCS = {
     description: "Sanitized desktop capture health and recent evidence for Atlas grounding.",
     examples: [
       "wave desktop-context status",
+      "wave desktop-context member-statuses --member-ids 123,456",
       "wave desktop-context recent --limit 20",
+      "wave desktop-context activity --start-at 2026-08-18T08:00:00Z --end-at 2026-08-18T09:00:00Z",
       "wave desktop-context status --member-id 123"
     ],
     schema: {
@@ -17457,7 +18015,28 @@ var NAMESPACE_DOCS = {
         "Does not expose screenshots, raw audio, accessibility trees, clipboard contents, keystrokes, URLs, or filesystem paths.",
         "Cross-member reads remain subject to backend organization policy and every response carries backend trace correlation when available."
       ],
-      commands: ["status", "recent"]
+      commands: ["status", "member-statuses", "recent", "activity"]
+    }
+  },
+  "data-pipeline": {
+    name: "data-pipeline",
+    tier: "primary",
+    description: "Organization Data Pipeline configuration, saved sources, and certified provider reads.",
+    examples: [
+      "wave data-pipeline overview",
+      "wave data-pipeline sources --category-key communication_meetings",
+      "wave data-pipeline source-actions --source-id 123",
+      `wave data-pipeline execute-source-action --category-key marketing_analytics --provider-key posthog --source-id 123 --action-key posthog.list_dashboards --parameters-json '{"limit":10,"offset":0}'`
+    ],
+    schema: {
+      output: "json-envelope-default",
+      readOnly: true,
+      safety: [
+        "Reads organization-scoped Data Pipeline configuration and backend-certified provider records only.",
+        "Provider actions are discovered from the backend and remain read-only and approval-free.",
+        "Does not install, enable, disable, or uninstall plugins; manage credentials; or create, update, or delete sources."
+      ],
+      commands: ["overview", "sources", "source-actions", "execute-source-action"]
     }
   },
   phantom: {
@@ -18403,6 +18982,7 @@ function buildCli(options) {
   registerRockCommands(program);
   registerMeetingCommands(program);
   registerMemberCommands(program);
+  registerResourceCommands(program);
   registerSkillCommands(program);
   registerAtlasAuthoringCommands(program);
   registerTeamCommands(program);
@@ -18427,6 +19007,7 @@ function buildCli(options) {
   registerDatasheetsCommands(program);
   registerSignatureCommands(program);
   registerDesktopContextCommands(program);
+  registerDataPipelineCommands(program);
   registerAuthCommands(program);
   registerDiscoveryCommands(program);
   attachNamespaceDiscovery(program);
@@ -18953,13 +19534,13 @@ main().catch((error) => {
     });
     return;
   }
-  if (error instanceof import_zod21.ZodError || error instanceof import_commander3.InvalidArgumentError) {
+  if (error instanceof import_zod22.ZodError || error instanceof import_commander3.InvalidArgumentError) {
     printCliFailure({
       status: 400,
       code: "invalid_args",
       message: "Invalid command arguments.",
       details: {
-        issues: error instanceof import_zod21.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
+        issues: error instanceof import_zod22.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
       },
       exitCode: EXIT_CODES.invalidArgs
     });