@wave-ai-os/wave-cli 0.1.76 → 0.1.78

package/dist/index.cjs

@@ -3,13 +3,13 @@
 
 // src/index.ts
 var import_commander2 = require("commander");
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/cli.ts
 var import_commander = require("commander");
 
 // src/commands/tasks.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/config.ts
 var import_zod = require("zod");
@@ -2144,6 +2144,17 @@ async function authGraphqlRequest(params) {
   }
 }
 
+// src/machineRuntimeContext.ts
+var import_node_async_hooks = require("async_hooks");
+var machineRuntimeAuthStorage = new import_node_async_hooks.AsyncLocalStorage();
+function currentMachineRuntimeAuth() {
+  return machineRuntimeAuthStorage.getStore();
+}
+function withMachineRuntimeAuth(auth, callback) {
+  if (!auth) return callback();
+  return machineRuntimeAuthStorage.run(auth, callback);
+}
+
 // src/commands/runtimeOptions.ts
 var CLI_AUTH_STATUS_QUERY = "query WaveCliAuthenticatedOrganization { cliAuthStatus { authenticated baseAuthStatus organization { id slug } } }";
 var stdinPromise = null;
@@ -2170,6 +2181,11 @@ function parseBool(raw) {
   }
   return void 0;
 }
+function omitUndefined(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter(([, value]) => value !== void 0)
+  );
+}
 function parseAuthJson(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -2177,7 +2193,7 @@ function parseAuthJson(raw) {
       throw new Error("Expected JSON object.");
     }
     const obj = parsed;
-    return {
+    return omitUndefined({
       token: normalize3(obj.token),
       baseUrl: normalize3(obj.baseUrl ?? obj.base_url),
       timeoutMs: typeof obj.timeoutMs === "number" || typeof obj.timeoutMs === "string" ? obj.timeoutMs : typeof obj.timeout_ms === "number" || typeof obj.timeout_ms === "string" ? obj.timeout_ms : void 0,
@@ -2210,7 +2226,7 @@ function parseAuthJson(raw) {
       openapiPath: normalize3(obj.openapiPath ?? obj.openapi_path),
       openapiUrl: normalize3(obj.openapiUrl ?? obj.openapi_url),
       openapiVersion: normalize3(obj.openapiVersion ?? obj.openapi_version)
-    };
+    });
   } catch (error) {
     throw new CliError({
       message: error instanceof Error ? `Invalid --auth-json-stdin payload: ${error.message}` : "Invalid --auth-json-stdin payload.",
@@ -2258,13 +2274,14 @@ function firstDefined(...values) {
   return values.find((value) => value !== void 0);
 }
 function resolveAuthToken(options, stdin, config, env) {
+  const candidate = (source, token) => token ? { token, source } : { source };
   const candidates = [
-    { token: normalize3(options.token), source: "flag" },
-    { token: normalize3(stdin.token), source: "stdin" },
-    { token: normalize3(env.WAVE_API_TOKEN), source: "env" },
-    { token: normalize3(config.token), source: "config" }
+    candidate("flag", normalize3(options.token)),
+    candidate("stdin", normalize3(stdin.token)),
+    candidate("env", normalize3(env.WAVE_API_TOKEN)),
+    candidate("config", normalize3(config.token))
   ];
-  return candidates.find((candidate) => candidate.token) ?? { source: "none" };
+  return candidates.find((candidate2) => candidate2.token) ?? { source: "none" };
 }
 function resolveFromSources(options, stdin, config, env) {
   const baseUrl = firstDefined(
@@ -2363,10 +2380,9 @@ function resolveFromSources(options, stdin, config, env) {
     normalize3(config.openapiVersion)
   );
   const resolvedAuth = resolveAuthToken(options, stdin, config, env);
-  return {
-    organizationId,
+  const resolved = {
     organizationIdSource,
-    runtimeOptions: {
+    runtimeOptions: omitUndefined({
       token: resolvedAuth.token,
       tokenSource: resolvedAuth.token ? resolvedAuth.source : "none",
       baseUrl,
@@ -2386,8 +2402,10 @@ function resolveFromSources(options, stdin, config, env) {
       openapiPath,
       openapiUrl,
       openapiVersion
-    }
+    })
   };
+  if (organizationId) resolved.organizationId = organizationId;
+  return resolved;
 }
 async function resolveWithStoredToken(context) {
   if (context.runtimeOptions.token || !context.runtimeOptions.baseUrl) {
@@ -2411,11 +2429,11 @@ async function resolveWithAuthenticatedOrganization(context) {
   const baseUrl = normalize3(context.runtimeOptions.baseUrl);
   const token = normalize3(context.runtimeOptions.token);
   if (!baseUrl || !token) {
+    const runtimeOptions2 = { ...context.runtimeOptions };
+    delete runtimeOptions2.organizationId;
     return {
-      ...context,
-      organizationId: void 0,
       organizationIdSource: "none",
-      runtimeOptions: { ...context.runtimeOptions, organizationId: void 0 }
+      runtimeOptions: runtimeOptions2
     };
   }
   const response = await authGraphqlRequest({
@@ -2425,12 +2443,18 @@ async function resolveWithAuthenticatedOrganization(context) {
     query: CLI_AUTH_STATUS_QUERY
   });
   const organizationId = response.ok ? organizationIdFromCliAuthStatus(response.result.data) : void 0;
-  return {
-    ...context,
-    organizationId,
+  const runtimeOptions = { ...context.runtimeOptions };
+  if (organizationId) {
+    runtimeOptions.organizationId = organizationId;
+  } else {
+    delete runtimeOptions.organizationId;
+  }
+  const resolved = {
     organizationIdSource: organizationId ? "token" : "none",
-    runtimeOptions: { ...context.runtimeOptions, organizationId }
+    runtimeOptions
   };
+  if (organizationId) resolved.organizationId = organizationId;
+  return resolved;
 }
 function defaultConfigPath(env) {
   const explicitEnv = normalize3(env.WAVE_CONFIG_PATH);
@@ -2497,7 +2521,22 @@ async function resolveStdinContext(options) {
 async function resolveUnscopedCommandContext(options) {
   const stdin = await resolveStdinContext(options);
   const config = await resolveConfigFileContext(options, process.env);
-  return resolveWithStoredToken(resolveFromSources(options, stdin, config, process.env));
+  return resolveWithStoredToken(applyMachineRuntimeAuth(resolveFromSources(options, stdin, config, process.env)));
+}
+function applyMachineRuntimeAuth(resolved) {
+  const machineAuth = currentMachineRuntimeAuth();
+  if (!machineAuth) return resolved;
+  return {
+    organizationId: machineAuth.organizationId,
+    organizationIdSource: "flag",
+    runtimeOptions: {
+      ...resolved.runtimeOptions,
+      token: machineAuth.token,
+      tokenSource: "machine",
+      baseUrl: machineAuth.baseUrl,
+      organizationId: machineAuth.organizationId
+    }
+  };
 }
 async function resolveCommandContext(options) {
   return resolveWithAuthenticatedOrganization(await resolveUnscopedCommandContext(options));
@@ -2651,10 +2690,29 @@ function registerGraphqlSearchCommand(command, config) {
   });
 }
 
+// src/commands/taskPriority.ts
+var import_zod2 = require("zod");
+var taskPrioritySchema = import_zod2.z.enum(["no_priority", "urgent", "high", "medium", "low"]);
+var taskPriorityValues = taskPrioritySchema.options.join(", ");
+var taskPriorityHelp = `Filter by priority: ${taskPriorityValues}.`;
+function parseTaskPriority(value) {
+  if (value === void 0) return void 0;
+  const parsed = taskPrioritySchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError({
+      message: `Invalid task priority. Use one of: ${taskPriorityValues}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return parsed.data.toUpperCase();
+}
+
 // src/commands/tasks.ts
-var projectIdSchema = import_zod2.z.string().min(1);
-var idSchema = import_zod2.z.string().min(1);
-var summarySchema = import_zod2.z.string().min(1);
+var projectIdSchema = import_zod3.z.string().min(1);
+var idSchema = import_zod3.z.string().min(1);
+var summarySchema = import_zod3.z.string().min(1);
 function parseTaskUpdateJson(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -2681,7 +2739,7 @@ function parseLabelIds(raw) {
 }
 function registerTaskCommands(program) {
   const tasks = program.command("tasks").description("Task operations");
-  tasks.command("list").option("--project-id <projectId>").option("--page <page>").option("--per <per>").option("--team-id <teamId>").option("--team-ids <teamIds>").option("--member-id <memberId>").option("--meeting-id <meetingId>").option("--field-name <fieldName>").option("--field-value <fieldValue>").option("--field-blank <fieldBlank>").option("--open <open>").option("--rank-direction <rankDirection>").option("--include-archived <includeArchived>").action(async (opts, cmd) => {
+  tasks.command("list").option("--project-id <projectId>").option("--page <page>").option("--per <per>").option("--team-id <teamId>").option("--team-ids <teamIds>").option("--member-id <memberId>").option("--meeting-id <meetingId>").option("--field-name <fieldName>").option("--field-value <fieldValue>").option("--field-blank <fieldBlank>").option("--open <open>").option("--priority <priority>", taskPriorityHelp).option("--rank-direction <rankDirection>").option("--include-archived <includeArchived>").action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const projectId = opts.projectId ? projectIdSchema.parse(opts.projectId) : void 0;
@@ -2702,9 +2760,27 @@ function registerTaskCommands(program) {
         field_value: opts.fieldValue,
         field_blank: opts.fieldBlank,
         open: opts.open,
+        priority: parseTaskPriority(opts.priority),
         rank_direction: opts.rankDirection,
         include_archived: opts.includeArchived
       }),
+      variableTypes: {
+        organization_id: "ID!",
+        page: "Int",
+        per: "Int",
+        project_id: "ID",
+        team_id: "ID",
+        team_ids: "[ID!]",
+        member_id: "ID",
+        meeting_id: "ID",
+        field_name: "String",
+        field_value: "String",
+        field_blank: "Boolean",
+        open: "Boolean",
+        priority: "TaskPriority",
+        rank_direction: "String",
+        include_archived: "Boolean"
+      },
       isList: true
     });
   });
@@ -2799,10 +2875,10 @@ function registerTaskCommands(program) {
 }
 
 // src/commands/projects.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/commands/entityCrud.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/commands/dtoHelpCatalog.ts
 var dtoHelpCatalog = {
@@ -3383,7 +3459,7 @@ function buildDataJsonHelp(rootKey, mode) {
 }
 
 // src/commands/entityCrud.ts
-var idSchema2 = import_zod3.z.string().min(1);
+var idSchema2 = import_zod4.z.string().min(1);
 function toSingularResourceName(resourcePath) {
   if (resourcePath === "organization_meta_profiles") {
     return "organization_meta_profile";
@@ -3609,10 +3685,28 @@ var __testables = {
 };
 
 // src/commands/projects.ts
-var idSchema3 = import_zod4.z.string().min(1);
+var idSchema3 = import_zod5.z.string().min(1);
+var projectStatusSchema = import_zod5.z.enum([
+  "backlog",
+  "planned",
+  "in_progress",
+  "completed",
+  "cancelled"
+]);
+var projectStatusValues = projectStatusSchema.options.join(", ");
+var projectPrioritySchema = import_zod5.z.enum([
+  "no_priority",
+  "urgent",
+  "high",
+  "medium",
+  "low"
+]);
+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": {...}}';
-var projectsIndexMinimalSelectionSet = "{ count currentPage totalPages data { id type attributes { name slug status priority } } }";
+function projectsIndexMinimalSelectionSet(includeProjectTypes = false) {
+  return `{ count currentPage totalPages data { id type attributes { name slug status priority${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 }";
 var healthUpdateSummarySelectionSet = "id type value memberId status createdAt updatedAt updatableType updatableId parentUpdateId emojis { id name memberId } resources { ...ResourceSummaryFull }";
@@ -3623,6 +3717,32 @@ function asRecord3(value) {
 function toNonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
+function parseProjectStatus(value) {
+  if (value === void 0) return void 0;
+  const parsed = projectStatusSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError({
+      message: `Invalid project status. Use one of: ${projectStatusValues}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return parsed.data.toUpperCase();
+}
+function parseProjectPriority(value) {
+  if (value === void 0) return void 0;
+  const parsed = projectPrioritySchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError({
+      message: `Invalid project priority. Use one of: ${projectPriorityValues}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return parsed.data.toUpperCase();
+}
 function normalizeProjectRowForDisplay(row) {
   const record = asRecord3(row);
   if (!record) return row;
@@ -3650,7 +3770,13 @@ function normalizeProjectsListForDisplay(payload) {
 }
 function registerProjectCommands(program) {
   const projects = program.command("projects").description("Project operations");
-  projects.command("list").option("--page <page>").option("--per <per>").option("--team-ids <teamIds>").option("--member-id <memberId>").action(async (opts, cmd) => {
+  projects.command("list").option("--page <page>").option("--per <per>").option("--team-ids <teamIds>").option("--member-id <memberId>").option(
+    "--status <status>",
+    "Filter by status: backlog, planned, in_progress, completed, cancelled."
+  ).option(
+    "--priority <priority>",
+    "Filter by priority: no_priority, urgent, high, medium, low."
+  ).option("--include-project-types", "Include projectType in the list response (opt-in).").action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     await runGraphqlQueryCommand({
@@ -3663,17 +3789,21 @@ function registerProjectCommands(program) {
         page: opts.page,
         per: opts.per,
         team_ids: opts.teamIds,
-        member_id: opts.memberId
+        member_id: opts.memberId,
+        status: parseProjectStatus(opts.status),
+        priority: parseProjectPriority(opts.priority)
       }),
       variableTypes: {
         organization_id: "ID!",
         page: "Int",
         per: "Int",
         team_ids: "[ID!]",
-        member_id: "ID"
+        member_id: "ID",
+        status: "ProjectStatus",
+        priority: "ProjectPriority"
       },
       isList: true,
-      selectionSet: projectsIndexMinimalSelectionSet,
+      selectionSet: projectsIndexMinimalSelectionSet(opts.includeProjectTypes === true),
       transformData: normalizeProjectsListForDisplay
     });
   });
@@ -3681,7 +3811,7 @@ function registerProjectCommands(program) {
     command: "projects",
     operationName: "ProjectsSearch",
     field: "projects",
-    selectionSet: projectsIndexMinimalSelectionSet,
+    selectionSet: projectsIndexMinimalSelectionSet(),
     transformData: normalizeProjectsListForDisplay
   });
   projects.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
@@ -3740,10 +3870,10 @@ function registerProjectCommands(program) {
 }
 
 // src/commands/rocks.ts
-var import_zod5 = require("zod");
-var idSchema4 = import_zod5.z.string().min(1);
-var rockCollectionIdSchema = import_zod5.z.string().min(1);
-var statusSchema = import_zod5.z.enum(["on_track", "at_risk", "off_track"]);
+var import_zod6 = require("zod");
+var idSchema4 = import_zod6.z.string().min(1);
+var rockCollectionIdSchema = import_zod6.z.string().min(1);
+var statusSchema = import_zod6.z.enum(["on_track", "at_risk", "off_track"]);
 var createHelp = buildDataJsonHelp("rock", "create") ?? 'JSON object for rock or {"rock": {...}}';
 var updateHelp = buildDataJsonHelp("rock", "update") ?? 'JSON object for rock or {"rock": {...}}';
 function registerRockCommands(program) {
@@ -3841,9 +3971,9 @@ function registerRockCommands(program) {
 }
 
 // src/commands/meetings.ts
-var import_zod6 = require("zod");
-var idSchema5 = import_zod6.z.string().min(1);
-var notesSchema = import_zod6.z.string().min(1);
+var import_zod7 = require("zod");
+var idSchema5 = import_zod7.z.string().min(1);
+var notesSchema = import_zod7.z.string().min(1);
 var MEETING_TYPES = /* @__PURE__ */ new Set(["TeamMeeting", "OneOnOneMeeting"]);
 var MEETING_STATUSES = /* @__PURE__ */ new Set(["upcoming", "active", "completed"]);
 var MEETING_REPEATS = /* @__PURE__ */ new Set(["never", "weekly", "biweekly", "monthly", "quarterly"]);
@@ -4076,8 +4206,8 @@ function registerMeetingCommands(program) {
 }
 
 // src/commands/members.ts
-var import_zod7 = require("zod");
-var idSchema6 = import_zod7.z.string().min(1);
+var import_zod8 = require("zod");
+var idSchema6 = import_zod8.z.string().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 } }";
@@ -4206,9 +4336,9 @@ function registerMemberCommands(program) {
 }
 
 // src/commands/skills.ts
-var import_zod8 = require("zod");
-var idSchema7 = import_zod8.z.string().min(1);
-var limitSchema = import_zod8.z.coerce.number().int().positive();
+var import_zod9 = require("zod");
+var idSchema7 = import_zod9.z.string().min(1);
+var limitSchema = import_zod9.z.coerce.number().int().positive();
 var SKILL_SELECTION = `{
   id
   type
@@ -4284,17 +4414,24 @@ function registerSkillCommands(program) {
 }
 
 // src/commands/issues.ts
-var import_zod9 = require("zod");
-var issueGroupIdSchema = import_zod9.z.string().min(1);
-var idSchema8 = import_zod9.z.string().min(1);
-var nameSchema = import_zod9.z.string().min(1);
-var issueTypeSchema = import_zod9.z.string().min(1).refine((value) => value === "short_term" || value === "long_term", {
+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", {
   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", {
+  message: "Invalid issue status. Use one of: open, completed."
+});
 var updateHelp4 = buildDataJsonHelp("issue", "update") ?? 'JSON object for issue or {"issue": {...}}';
+function parseIssueIndexEnum(value, schema) {
+  if (value === void 0) return void 0;
+  return schema.parse(String(value)).toUpperCase();
+}
 function registerIssueCommands(program) {
   const issues = program.command("issues").description("Issue operations");
-  issues.command("list").option("--page <page>").option("--per <per>").option("--issue-group-id <issueGroupId>").option("--start-date <startDate>").option("--issue-type <issueType>").option("--team-id <teamId>").option("--member-id <memberId>").option("--meeting-id <meetingId>").action(async (opts, cmd) => {
+  issues.command("list").option("--page <page>").option("--per <per>").option("--issue-group-id <issueGroupId>").option("--start-date <startDate>").option("--issue-type <issueType>").option("--status <status>", "Issue status: open | completed").option("--team-id <teamId>").option("--member-id <memberId>").option("--meeting-id <meetingId>").action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     await runGraphqlQueryCommand({
@@ -4307,11 +4444,24 @@ function registerIssueCommands(program) {
         per: opts.per,
         issue_group_id: opts.issueGroupId,
         start_date: opts.startDate,
-        issue_type: opts.issueType,
+        issue_type: parseIssueIndexEnum(opts.issueType, issueTypeSchema),
+        status: parseIssueIndexEnum(opts.status, issueStatusSchema),
         team_id: opts.teamId,
         member_id: opts.memberId,
         meeting_id: opts.meetingId
       }),
+      variableTypes: {
+        organization_id: "ID!",
+        page: "Int",
+        per: "Int",
+        issue_group_id: "ID",
+        start_date: "String",
+        issue_type: "IssueType",
+        status: "IssueStatus",
+        team_id: "ID",
+        member_id: "ID",
+        meeting_id: "ID"
+      },
       isList: true
     });
   });
@@ -5335,8 +5485,8 @@ function registerSystemToolCommands(program) {
 }
 
 // src/commands/teams.ts
-var import_zod10 = require("zod");
-var idSchema9 = import_zod10.z.string().min(1);
+var import_zod11 = require("zod");
+var idSchema9 = import_zod11.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) => {
@@ -5402,8 +5552,8 @@ function registerTeamCommands(program) {
 }
 
 // src/commands/organizations.ts
-var import_zod11 = require("zod");
-var idSchema10 = import_zod11.z.string().min(1);
+var import_zod12 = require("zod");
+var idSchema10 = import_zod12.z.string().min(1);
 function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -5615,8 +5765,8 @@ function registerOrganizationCommands(program) {
 }
 
 // src/commands/foundation.ts
-var import_zod12 = require("zod");
-var idSchema11 = import_zod12.z.string().min(1);
+var import_zod13 = require("zod");
+var idSchema11 = import_zod13.z.string().min(1);
 var STRATEGIC_PLAN_ALLOWED_UPDATE_KEYS = /* @__PURE__ */ new Set([
   "published_at",
   "profile",
@@ -5817,9 +5967,9 @@ function registerFoundationCommands(program) {
 }
 
 // src/commands/childEntities.ts
-var import_zod13 = require("zod");
-var idSchema12 = import_zod13.z.string().min(1);
-var jsonObjectSchema = import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown());
+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 NOTE_DETAIL_FIELDS = [
   "notes",
   "hasNotes",
@@ -5967,10 +6117,17 @@ function normalizeSubtaskCreateBody(body) {
 }
 function registerChildCommands(program, config) {
   const command = program.command(config.command).description(config.description);
-  command.command("list").requiredOption(`--${config.parentFlag} <${config.parentFlag}>`).option("--page <page>").option("--per <per>").action(async (opts, cmd) => {
+  const listCommand = command.command("list").requiredOption(`--${config.parentFlag} <${config.parentFlag}>`).option("--page <page>").option("--per <per>");
+  if (config.priorityFilter) {
+    listCommand.option("--priority <priority>", config.priorityFilter.help);
+  }
+  listCommand.action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const parentId = idSchema12.parse(opts[config.parentFlag.replace(/-([a-z])/g, (_, c) => c.toUpperCase())]);
+    const priority = config.priorityFilter?.parse(opts.priority);
+    const priorityVariables = priority === void 0 ? {} : { priority };
+    const priorityVariableTypes = priority === void 0 || !config.priorityFilter ? {} : { priority: config.priorityFilter.variableType };
     await runGraphqlQueryCommand({
       command: `${config.command}.list`,
       operationName: config.listOperationName,
@@ -5980,13 +6137,15 @@ function registerChildCommands(program, config) {
         organization_id: organizationId,
         [config.parentFlag.replace(/-/g, "_")]: parentId,
         page: opts.page,
-        per: opts.per
+        per: opts.per,
+        ...priorityVariables
       }),
       variableTypes: {
         organization_id: "ID!",
         [config.parentFlag.replace(/-/g, "_")]: "ID!",
         page: "Int",
-        per: "Int"
+        per: "Int",
+        ...priorityVariableTypes
       },
       isList: true,
       selectionSet: config.listSelectionSet,
@@ -6106,6 +6265,11 @@ function registerChildEntityCommands(program) {
     destroyOperationName: "SubtasksDestroy",
     listSelectionSet: buildChildListSelectionSet("taskId"),
     listParentTypedField: "taskId",
+    priorityFilter: {
+      variableType: "TaskPriority",
+      help: taskPriorityHelp,
+      parse: parseTaskPriority
+    },
     searchRequiredOptions: requiredParentSearchOption("task-id", "task"),
     showField: "subtask",
     showOperationName: "SubtasksShow",
@@ -6221,9 +6385,9 @@ function registerChildEntityCommands(program) {
 }
 
 // src/commands/content.ts
-var import_zod14 = require("zod");
-var idSchema13 = import_zod14.z.string().min(1);
-var nonEmptyString = import_zod14.z.string().min(1);
+var import_zod15 = require("zod");
+var idSchema13 = import_zod15.z.string().min(1);
+var nonEmptyString = import_zod15.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) {
@@ -6411,9 +6575,9 @@ function registerContentCommands(program) {
 }
 
 // src/commands/markdownTree.ts
-var import_zod15 = require("zod");
-var nonEmptyString2 = import_zod15.z.string().min(1);
-var nonNegativeInt = import_zod15.z.coerce.number().int().min(0);
+var import_zod16 = require("zod");
+var nonEmptyString2 = import_zod16.z.string().min(1);
+var nonNegativeInt = import_zod16.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");
 }
@@ -6578,7 +6742,7 @@ function registerMarkdownTreeCommands(program) {
 }
 
 // src/commands/navigation.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/internalOptions.ts
 var INTERNAL_OPTIONS_KEY = "__waveInternalOptions";
@@ -6608,8 +6772,8 @@ function getInternalCliOptions(command) {
 }
 
 // src/commands/navigation.ts
-var nonEmpty = import_zod16.z.string().min(1);
-var nonNegativeInt2 = import_zod16.z.coerce.number().int().min(0);
+var nonEmpty = import_zod17.z.string().min(1);
+var nonNegativeInt2 = import_zod17.z.coerce.number().int().min(0);
 var MIGRATED_BRANCHES = ["directory", "projects", "knowledge"];
 function normalizeText(input) {
   if (typeof input !== "string") return "";
@@ -7392,11 +7556,11 @@ function registerMutationCapabilityCommands(program) {
 // src/commands/osmd.ts
 var import_promises3 = require("fs/promises");
 var import_node_path3 = require("path");
-var import_zod17 = require("zod");
-var sourceSchema = import_zod17.z.enum(["canonical_osmd", "agent_overlay", "agent_wiki"]);
-var accessSchema = import_zod17.z.enum(["read_only", "read_write", "append_only"]).catch("read_write");
-var ownerSchema = import_zod17.z.enum(["system", "atlas"]);
-var suggestedActionSchema = import_zod17.z.enum([
+var import_zod18 = require("zod");
+var sourceSchema = import_zod18.z.enum(["canonical_osmd", "agent_overlay", "agent_wiki"]);
+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([
   "read",
   "create",
   "init",
@@ -7405,7 +7569,7 @@ var suggestedActionSchema = import_zod17.z.enum([
   "forbidden",
   "invalid_parent"
 ]).catch("update");
-var agentMarkdownErrorCodeSchema = import_zod17.z.enum([
+var agentMarkdownErrorCodeSchema = import_zod18.z.enum([
   "canonical_osmd_read_only",
   "agent_parent_not_found",
   "agent_file_not_found",
@@ -7416,9 +7580,9 @@ var agentMarkdownErrorCodeSchema = import_zod17.z.enum([
   "invalid_agent_wiki_path"
 ]);
 var agentMarkdownErrorCodeFieldSchema = agentMarkdownErrorCodeSchema.nullable().catch(null);
-var nonEmptyString3 = import_zod17.z.string().min(1);
-var nonNegativeInt3 = import_zod17.z.coerce.number().int().min(0);
-var positiveInt = import_zod17.z.coerce.number().int().min(1);
+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 supportedAgentOverlaySystemFiles = ["notes.md", "summary.md"];
 var supportedWikiIndexFile = "index.md";
 var supportedWikiLogFile = "log.md";
@@ -7434,20 +7598,20 @@ var supportedWikiControlledPatterns = supportedWikiControlledFolders.map(
 );
 var controlledWikiSlugPattern = /^[a-z0-9][a-z0-9-]*$/;
 var agentMarkdownSlugPattern = /^[a-z0-9][a-z0-9-]*$/;
-var osmdSearchScopeSchema = import_zod17.z.enum([
+var osmdSearchScopeSchema = import_zod18.z.enum([
   "os-only",
   "agent-overlay-only",
   "agent-wiki-only",
   "combined"
 ]);
-var osmdLintScopeSchema = import_zod17.z.enum([
+var osmdLintScopeSchema = import_zod18.z.enum([
   "combined",
   "agent-overlay-only",
   "agent-wiki-only"
 ]);
-var osmdMemoryQualityScopeSchema = import_zod17.z.enum(["agent-overlay-only"]);
-var osmdIngestKindSchema = import_zod17.z.enum(["text", "file", "url", "transcript"]);
-var osmdRawSourceTypeSchema = import_zod17.z.enum([
+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([
   "pasted_text",
   "uploaded_markdown",
   "uploaded_text",
@@ -7456,31 +7620,30 @@ var osmdRawSourceTypeSchema = import_zod17.z.enum([
   "meeting_transcript",
   "url"
 ]);
-var defaultOsmdPhantomTimeoutMs = 12e4;
-var agentMarkdownFileSchema = import_zod17.z.preprocess(
+var agentMarkdownFileSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    path: import_zod17.z.string(),
+  import_zod18.z.object({
+    path: import_zod18.z.string(),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    exists: import_zod17.z.boolean(),
-    canCreate: import_zod17.z.boolean(),
-    canUpdate: import_zod17.z.boolean(),
-    canAppend: import_zod17.z.boolean(),
-    wikiRole: import_zod17.z.string().nullable().optional(),
-    formatVersion: import_zod17.z.string().nullable().optional(),
-    createdAt: import_zod17.z.string().nullable().optional(),
-    updatedAt: import_zod17.z.string().nullable().optional(),
-    ingestedAt: import_zod17.z.string().nullable().optional(),
-    lastSeenAt: import_zod17.z.string().nullable().optional(),
-    canonicalParentUpdatedAt: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    agentChildrenAllowed: import_zod17.z.boolean(),
+    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(),
     suggestedAction: suggestedActionSchema,
     errorCode: agentMarkdownErrorCodeFieldSchema.optional(),
-    content: import_zod17.z.string().nullable().optional(),
-    url: import_zod17.z.string().nullable().optional()
+    content: import_zod18.z.string().nullable().optional(),
+    url: import_zod18.z.string().nullable().optional()
   }).transform((value) => ({
     ...value,
     wikiRole: value.wikiRole ?? null,
@@ -7496,31 +7659,31 @@ var agentMarkdownFileSchema = import_zod17.z.preprocess(
     url: value.url ?? null
   }))
 );
-var agentMarkdownFilesSchema = import_zod17.z.array(agentMarkdownFileSchema);
-var agentMarkdownMutationDataSchema = import_zod17.z.union([
+var agentMarkdownFilesSchema = import_zod18.z.array(agentMarkdownFileSchema);
+var agentMarkdownMutationDataSchema = import_zod18.z.union([
   agentMarkdownFileSchema,
-  import_zod17.z.object({ files: agentMarkdownFilesSchema })
+  import_zod18.z.object({ files: agentMarkdownFilesSchema })
 ]);
-var osmdSearchCandidateSchema = import_zod17.z.preprocess(
+var osmdSearchCandidateSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    path: import_zod17.z.string(),
+  import_zod18.z.object({
+    path: import_zod18.z.string(),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    wikiRole: import_zod17.z.string().nullable().optional(),
-    formatVersion: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    exists: import_zod17.z.boolean(),
-    agentChildrenAllowed: import_zod17.z.boolean(),
-    title: import_zod17.z.string(),
-    label: import_zod17.z.string(),
-    snippet: import_zod17.z.string().nullable().optional(),
-    rank: import_zod17.z.number().int(),
-    matchReason: import_zod17.z.string().nullable().optional(),
-    toolKey: import_zod17.z.string().nullable().optional(),
-    nodeKey: import_zod17.z.string().nullable().optional(),
-    nodeKind: import_zod17.z.string().nullable().optional()
+    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()
   }).transform((value) => ({
     ...value,
     wikiRole: value.wikiRole ?? null,
@@ -7533,26 +7696,26 @@ var osmdSearchCandidateSchema = import_zod17.z.preprocess(
     nodeKind: value.nodeKind ?? null
   }))
 );
-var osmdSearchResultSchema = import_zod17.z.preprocess(
+var osmdSearchResultSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    query: import_zod17.z.string(),
-    scope: import_zod17.z.string(),
-    count: import_zod17.z.number().int().min(0),
-    candidates: import_zod17.z.array(osmdSearchCandidateSchema)
+  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)
   })
 );
-var osmdWikiLintIssueSchema = import_zod17.z.preprocess(
+var osmdWikiLintIssueSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    code: import_zod17.z.string(),
-    severity: import_zod17.z.string(),
-    path: import_zod17.z.string(),
-    source: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    message: import_zod17.z.string(),
-    suggestedAction: import_zod17.z.string().nullable().optional(),
-    canAutoFix: import_zod17.z.boolean()
+  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()
   }).transform((value) => ({
     ...value,
     source: value.source ?? null,
@@ -7560,37 +7723,37 @@ var osmdWikiLintIssueSchema = import_zod17.z.preprocess(
     suggestedAction: value.suggestedAction ?? null
   }))
 );
-var osmdWikiLintResultSchema = import_zod17.z.preprocess(
+var osmdWikiLintResultSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    status: import_zod17.z.string(),
-    summary: import_zod17.z.object({
-      totalIssues: import_zod17.z.number().int().min(0),
-      errors: import_zod17.z.number().int().min(0),
-      warnings: import_zod17.z.number().int().min(0),
-      suggestions: import_zod17.z.number().int().min(0)
+  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)
     }),
-    issues: import_zod17.z.array(osmdWikiLintIssueSchema)
+    issues: import_zod18.z.array(osmdWikiLintIssueSchema)
   })
 );
-var nullableCountSchema = import_zod17.z.preprocess(
+var nullableCountSchema = import_zod18.z.preprocess(
   (value) => value === void 0 || value === null || value === "" ? null : value,
-  import_zod17.z.coerce.number().int().min(0).nullable()
+  import_zod18.z.coerce.number().int().min(0).nullable()
 ).catch(null);
-var osmdMemoryQualityIssueSchema = import_zod17.z.preprocess(
+var osmdMemoryQualityIssueSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    code: import_zod17.z.string().nullable().optional(),
-    issueCode: import_zod17.z.string().nullable().optional(),
-    path: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    dimension: import_zod17.z.string().nullable().optional(),
-    evidence: import_zod17.z.string().nullable().optional(),
-    evidenceSnippet: import_zod17.z.string().nullable().optional(),
-    message: import_zod17.z.string().nullable().optional(),
-    severity: import_zod17.z.string().nullable().optional(),
-    suggestedAction: import_zod17.z.string().nullable().optional(),
-    canAutoFix: import_zod17.z.boolean().nullable().optional()
+  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()
   }).passthrough().transform((value) => ({
     ...value,
     code: value.code ?? value.issueCode ?? "unknown_issue",
@@ -7605,16 +7768,16 @@ var osmdMemoryQualityIssueSchema = import_zod17.z.preprocess(
     canAutoFix: value.canAutoFix === true ? true : false
   }))
 );
-var osmdMemoryQualityOverlaySchema = import_zod17.z.preprocess(
+var osmdMemoryQualityOverlaySchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    path: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    status: import_zod17.z.string().nullable().optional(),
-    score: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).nullable().optional(),
-    overallScore: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).nullable().optional(),
-    dimensions: import_zod17.z.unknown().nullable().optional(),
-    issues: import_zod17.z.array(osmdMemoryQualityIssueSchema).optional()
+  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()
   }).passthrough().transform((value) => ({
     ...value,
     path: value.path ?? null,
@@ -7626,9 +7789,9 @@ var osmdMemoryQualityOverlaySchema = import_zod17.z.preprocess(
     issues: value.issues ?? []
   }))
 );
-var osmdMemoryQualitySummarySchema = import_zod17.z.preprocess(
+var osmdMemoryQualitySummarySchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
+  import_zod18.z.object({
     evaluatedCount: nullableCountSchema.optional(),
     passCount: nullableCountSchema.optional(),
     warnCount: nullableCountSchema.optional(),
@@ -7646,19 +7809,19 @@ var osmdMemoryQualitySummarySchema = import_zod17.z.preprocess(
     failCount: value.failCount ?? value.failures ?? null
   }))
 );
-var osmdMemoryQualityResultSchema = import_zod17.z.preprocess(
+var osmdMemoryQualityResultSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    status: import_zod17.z.string(),
-    scope: import_zod17.z.string().nullable().optional(),
+  import_zod18.z.object({
+    status: import_zod18.z.string(),
+    scope: import_zod18.z.string().nullable().optional(),
     evaluatedCount: nullableCountSchema.optional(),
     passCount: nullableCountSchema.optional(),
     warnCount: nullableCountSchema.optional(),
     failCount: nullableCountSchema.optional(),
     summary: osmdMemoryQualitySummarySchema.optional(),
-    weakestOverlays: import_zod17.z.array(osmdMemoryQualityOverlaySchema).optional(),
-    issues: import_zod17.z.array(osmdMemoryQualityIssueSchema).optional(),
-    scores: import_zod17.z.array(osmdMemoryQualityOverlaySchema).optional()
+    weakestOverlays: import_zod18.z.array(osmdMemoryQualityOverlaySchema).optional(),
+    issues: import_zod18.z.array(osmdMemoryQualityIssueSchema).optional(),
+    scores: import_zod18.z.array(osmdMemoryQualityOverlaySchema).optional()
   }).passthrough().transform((value) => {
     const summary = isRecord5(value.summary) ? value.summary : null;
     return {
@@ -7682,24 +7845,24 @@ function normalizeOsmdIngestFileRecordInput(value) {
   }
   return normalized;
 }
-var osmdIngestFileRecordSchema = import_zod17.z.preprocess(
+var osmdIngestFileRecordSchema = import_zod18.z.preprocess(
   normalizeOsmdIngestFileRecordInput,
-  import_zod17.z.object({
-    path: import_zod17.z.string(),
-    source: import_zod17.z.string().nullable().optional(),
-    access: import_zod17.z.string().nullable().optional(),
-    owner: import_zod17.z.string().nullable().optional(),
-    parentRef: import_zod17.z.string().nullable().optional(),
-    exists: import_zod17.z.boolean().nullable().optional(),
-    canCreate: import_zod17.z.boolean().nullable().optional(),
-    canUpdate: import_zod17.z.boolean().nullable().optional(),
-    canAppend: import_zod17.z.boolean().nullable().optional(),
-    wikiRole: import_zod17.z.string().nullable().optional(),
-    formatVersion: import_zod17.z.string().nullable().optional(),
-    createdAt: import_zod17.z.string().nullable().optional(),
-    updatedAt: import_zod17.z.string().nullable().optional(),
-    suggestedAction: import_zod17.z.string().nullable().optional(),
-    errorCode: import_zod17.z.string().nullable().optional()
+  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()
   }).passthrough().transform((value) => ({
     ...value,
     source: value.source ?? null,
@@ -7718,17 +7881,17 @@ var osmdIngestFileRecordSchema = import_zod17.z.preprocess(
     errorCode: value.errorCode ?? null
   }))
 );
-var osmdIngestResultSchema = import_zod17.z.preprocess(
+var osmdIngestResultSchema = import_zod18.z.preprocess(
   normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    rawSourceId: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).nullable().optional(),
-    sourceSummaryPath: import_zod17.z.string().nullable().optional(),
+  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(),
     sourceSummaryFile: osmdIngestFileRecordSchema.nullable().optional(),
-    slug: import_zod17.z.string().nullable().optional(),
-    runLint: import_zod17.z.boolean().nullable().optional(),
-    createdFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    updatedFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    skippedUpdates: import_zod17.z.array(import_zod17.z.unknown()).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(),
     lintResult: osmdWikiLintResultSchema.nullable().optional()
   }).passthrough().transform((value) => ({
     ...value,
@@ -7743,127 +7906,37 @@ var osmdIngestResultSchema = import_zod17.z.preprocess(
     lintResult: value.lintResult ?? null
   }))
 );
-var osmdPhantomNotificationSchema = import_zod17.z.preprocess(
-  normalizeAgentMarkdownJsonKeys,
-  import_zod17.z.object({
-    id: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).nullable().optional(),
-    status: import_zod17.z.string().nullable().optional()
-  }).passthrough().transform((value) => ({
-    ...value,
-    id: value.id === void 0 || value.id === null ? null : String(value.id),
-    status: value.status ?? null
-  }))
-);
-var osmdPhantomResultSchema = import_zod17.z.preprocess(
-  normalizeOsmdPhantomResultKeys,
-  import_zod17.z.object({
-    runId: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).nullable().optional(),
-    organizationId: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).nullable().optional(),
-    triggerType: import_zod17.z.string().nullable().optional(),
-    scope: import_zod17.z.string().nullable().optional(),
-    subtree: import_zod17.z.string().nullable().optional(),
-    status: import_zod17.z.string().nullable().optional(),
-    createdAt: import_zod17.z.string().nullable().optional(),
-    updatedAt: import_zod17.z.string().nullable().optional(),
-    startedAt: import_zod17.z.string().nullable().optional(),
-    completedAt: import_zod17.z.string().nullable().optional(),
-    countSemantics: import_zod17.z.unknown().nullable().optional(),
-    scannedFileCount: nullableCountSchema,
-    changedFileCount: nullableCountSchema,
-    unchangedFileCount: nullableCountSchema,
-    updatedFileCount: nullableCountSchema,
-    skippedFileCount: nullableCountSchema,
-    lintStatus: import_zod17.z.string().nullable().optional(),
-    errorCount: nullableCountSchema,
-    warningCount: nullableCountSchema,
-    reportPath: import_zod17.z.string().nullable().optional(),
-    plannedReads: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    plannedReadFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    plannedWrites: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    plannedWriteFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    changedFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    unchangedFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    updatedFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    skippedFiles: import_zod17.z.array(osmdIngestFileRecordSchema).optional(),
-    lintPlan: import_zod17.z.unknown().nullable().optional(),
-    lintSummary: import_zod17.z.unknown().nullable().optional(),
-    lintResult: osmdWikiLintResultSchema.nullable().optional(),
-    notification: osmdPhantomNotificationSchema.nullable().optional(),
-    notificationId: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).nullable().optional(),
-    notificationStatus: import_zod17.z.string().nullable().optional()
-  }).passthrough().transform((value) => {
-    const lintResultSummary = isRecord5(value.lintResult?.summary) ? value.lintResult.summary : null;
-    const lintSummary = isRecord5(value.lintSummary) ? value.lintSummary : null;
-    const notification = value.notification ?? (value.notificationId !== void 0 || value.notificationStatus !== void 0 ? {
-      id: value.notificationId === void 0 || value.notificationId === null ? null : String(value.notificationId),
-      status: value.notificationStatus ?? null
-    } : null);
-    return {
-      ...value,
-      runId: value.runId === void 0 || value.runId === null ? null : String(value.runId),
-      organizationId: value.organizationId === void 0 || value.organizationId === null ? null : String(value.organizationId),
-      triggerType: value.triggerType ?? null,
-      scope: value.scope ?? null,
-      subtree: value.subtree ?? null,
-      status: value.status ?? null,
-      createdAt: value.createdAt ?? null,
-      updatedAt: value.updatedAt ?? null,
-      startedAt: value.startedAt ?? null,
-      completedAt: value.completedAt ?? null,
-      countSemantics: value.countSemantics ?? null,
-      scannedFileCount: value.scannedFileCount,
-      changedFileCount: value.changedFileCount,
-      unchangedFileCount: value.unchangedFileCount,
-      updatedFileCount: value.updatedFileCount,
-      skippedFileCount: value.skippedFileCount,
-      lintStatus: value.lintStatus ?? (typeof value.lintResult?.status === "string" ? value.lintResult.status : null) ?? (typeof lintSummary?.status === "string" ? lintSummary.status : null),
-      errorCount: value.errorCount ?? countFromRecord(lintResultSummary, "errors") ?? countFromRecord(lintSummary, "errors"),
-      warningCount: value.warningCount ?? countFromRecord(lintResultSummary, "warnings") ?? countFromRecord(lintSummary, "warnings"),
-      reportPath: value.reportPath ?? null,
-      plannedReads: value.plannedReads ?? value.plannedReadFiles ?? [],
-      plannedWrites: value.plannedWrites ?? value.plannedWriteFiles ?? [],
-      changedFiles: value.changedFiles ?? [],
-      unchangedFiles: dedupeOsmdFileRecords(value.unchangedFiles ?? []),
-      updatedFiles: value.updatedFiles ?? [],
-      skippedFiles: dedupeOsmdFileRecords(value.skippedFiles ?? []),
-      lintPlan: value.lintPlan ?? null,
-      lintSummary: value.lintSummary ?? null,
-      lintResult: value.lintResult ?? null,
-      notification
-    };
-  })
-);
-var mutationPayloadSchema = import_zod17.z.object({
-  ok: import_zod17.z.boolean(),
-  status: import_zod17.z.number(),
-  errorCode: import_zod17.z.string().nullable().optional(),
-  data: import_zod17.z.unknown().nullable().optional(),
-  errors: import_zod17.z.unknown().nullable().optional()
+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 markdownTreeNodeSchema = import_zod17.z.lazy(
-  () => import_zod17.z.object({
-    toolKey: import_zod17.z.string(),
-    nodeKey: import_zod17.z.string(),
-    nodeKind: import_zod17.z.string(),
-    runtimeLabel: import_zod17.z.string(),
-    path: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
+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),
     source: sourceSchema,
     access: accessSchema,
     owner: ownerSchema,
-    parentRef: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
-    agentChildrenAllowed: import_zod17.z.boolean(),
-    exists: import_zod17.z.boolean(),
-    resolvedScope: import_zod17.z.object({
-      parentId: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
-      recordId: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
-      memberId: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
-      teamId: import_zod17.z.string().nullable().optional().transform((value) => value ?? null),
-      contentType: import_zod17.z.string().nullable().optional().transform((value) => value ?? null)
+    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)
     }),
-    isLeaf: import_zod17.z.boolean(),
-    treeView: import_zod17.z.boolean(),
-    details: import_zod17.z.unknown().nullable(),
-    children: import_zod17.z.array(markdownTreeNodeSchema).optional().transform((value) => value ?? [])
+    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 ?? [])
   })
 );
 var AGENT_MARKDOWN_FILE_SELECTION = `{
@@ -8124,86 +8197,6 @@ function normalizeAgentMarkdownJsonKeys(value) {
   }
   return normalized;
 }
-function firstPresent(...values) {
-  for (const value of values) {
-    if (value !== void 0 && value !== null) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function normalizeOsmdPhantomResultKeys(value) {
-  const normalized = normalizeAgentMarkdownJsonKeys(value);
-  if (!isRecord5(normalized)) {
-    return normalized;
-  }
-  const run = isRecord5(normalized.run) ? normalizeAgentMarkdownJsonKeys(normalized.run) : null;
-  const result = run ? { ...run, ...normalized } : { ...normalized };
-  const runField = (key) => run ? run[key] : void 0;
-  const assignFirstPresent = (target, ...values) => {
-    const value2 = firstPresent(result[target], ...values);
-    if (value2 !== void 0) {
-      result[target] = value2;
-    }
-  };
-  assignFirstPresent("runId", normalized.id, runField("runId"), runField("id"));
-  assignFirstPresent("organizationId", runField("organizationId"));
-  assignFirstPresent("triggerType", runField("triggerType"));
-  assignFirstPresent("scope", runField("scope"));
-  assignFirstPresent("status", runField("status"));
-  assignFirstPresent("createdAt", runField("createdAt"));
-  assignFirstPresent("updatedAt", runField("updatedAt"));
-  assignFirstPresent("startedAt", runField("startedAt"));
-  assignFirstPresent("completedAt", runField("completedAt"));
-  assignFirstPresent("countSemantics", runField("countSemantics"));
-  assignFirstPresent(
-    "scannedFileCount",
-    normalized.scanned,
-    runField("scannedFileCount"),
-    runField("scanned")
-  );
-  assignFirstPresent(
-    "changedFileCount",
-    normalized.changed,
-    runField("changedFileCount"),
-    runField("changed")
-  );
-  assignFirstPresent(
-    "unchangedFileCount",
-    normalized.unchanged,
-    runField("unchangedFileCount"),
-    runField("unchanged")
-  );
-  assignFirstPresent(
-    "updatedFileCount",
-    normalized.updated,
-    runField("updatedFileCount"),
-    runField("updated")
-  );
-  assignFirstPresent(
-    "skippedFileCount",
-    normalized.skipped,
-    runField("skippedFileCount"),
-    runField("skipped")
-  );
-  assignFirstPresent("lintStatus", runField("lintStatus"));
-  assignFirstPresent("errorCount", runField("errorCount"));
-  assignFirstPresent("warningCount", runField("warningCount"));
-  assignFirstPresent("reportPath", runField("reportPath"));
-  assignFirstPresent("plannedReads", runField("plannedReads"), runField("plannedReadFiles"));
-  assignFirstPresent("plannedWrites", runField("plannedWrites"), runField("plannedWriteFiles"));
-  assignFirstPresent("changedFiles", runField("changedFiles"));
-  assignFirstPresent("unchangedFiles", runField("unchangedFiles"));
-  assignFirstPresent("updatedFiles", runField("updatedFiles"));
-  assignFirstPresent("skippedFiles", runField("skippedFiles"));
-  assignFirstPresent("lintPlan", runField("lintPlan"));
-  assignFirstPresent("lintSummary", runField("lintSummary"));
-  assignFirstPresent("lintResult", runField("lintResult"));
-  assignFirstPresent("notification", runField("notification"));
-  assignFirstPresent("notificationId", runField("notificationId"));
-  assignFirstPresent("notificationStatus", runField("notificationStatus"));
-  return result;
-}
 function buildSuccessEnvelope(params) {
   return {
     ok: true,
@@ -8623,51 +8616,6 @@ async function runOsmdIngestFlow(params) {
     })
   });
 }
-async function runOsmdPhantomPhaseOne(params) {
-  const runtimeOptions = {
-    ...params.runtimeOptions,
-    timeoutMs: params.runtimeOptions.timeoutMs ?? defaultOsmdPhantomTimeoutMs
-  };
-  const result = await requestOsmdMutationPayload({
-    command: params.command,
-    operationName: "RunPhantomOsmdMaintenance",
-    operationType: "mutation",
-    runtimeOptions,
-    field: "run_phantom_osmd_maintenance",
-    variables: {
-      organization_id: params.organizationId,
-      dry_run: params.dryRun
-    }
-  });
-  const parsedData = osmdPhantomResultSchema.safeParse(
-    normalizeAgentMarkdownJsonKeys(result.payload.data)
-  );
-  if (!parsedData.success) {
-    return printInvalidPayloadError({
-      command: params.command,
-      requestId: result.requestId,
-      issues: parsedData.error.issues
-    });
-  }
-  const data = {
-    ...parsedData.data,
-    organizationId: parsedData.data.organizationId ?? params.organizationId,
-    triggerType: parsedData.data.triggerType ?? "manual"
-  };
-  if (params.readable) {
-    return printTextAndExit({
-      text: formatOsmdPhantomHuman(data, params.dryRun)
-    });
-  }
-  return printEnvelopeAndExit({
-    envelope: buildSuccessEnvelope({
-      command: params.command,
-      status: result.payload.status,
-      data,
-      requestId: result.requestId
-    })
-  });
-}
 function normalizeAgentFilePath(file) {
   const trimmed = nonEmptyString3.parse(file).trim().replace(/^\/+|\/+$/g, "");
   const fileName = trimmed.startsWith(".agent/") ? trimmed.slice(".agent/".length) : trimmed;
@@ -9078,62 +9026,6 @@ function formatIngestFileList(files) {
     return `- ${path}${action}`;
   });
 }
-function fileRecordPath(file) {
-  return typeof file.path === "string" && file.path.trim() !== "" ? file.path : null;
-}
-function isAgentNotesWrite(file) {
-  const path = fileRecordPath(file);
-  return path !== null && /(?:^|\/)\.agent\/notes\.md$/.test(path);
-}
-function formatNotesWriteSummary(files) {
-  const notesWrites = files.filter(isAgentNotesWrite);
-  if (notesWrites.length === 0) {
-    return ["notes.md writes: none"];
-  }
-  return ["notes.md writes:", ...formatIngestFileList(notesWrites)];
-}
-function skippedReasonForFile(file) {
-  for (const key of ["reason", "skipReason", "errorCode", "suggestedAction", "status"]) {
-    const value = file[key];
-    if (typeof value === "string" && value.trim() !== "") {
-      return value;
-    }
-  }
-  return "unspecified";
-}
-function formatSkippedFilesByReason(files) {
-  if (files.length === 0) {
-    return ["- none"];
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const reason = skippedReasonForFile(file);
-    const existing = groups.get(reason) ?? [];
-    existing.push(file);
-    groups.set(reason, existing);
-  }
-  const lines = [];
-  for (const [reason, records] of groups.entries()) {
-    lines.push(`- ${reason}`);
-    for (const record of records) {
-      lines.push(`  - ${fileRecordPath(record) ?? "-"}`);
-    }
-  }
-  return lines;
-}
-function dedupeOsmdFileRecords(files) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const file of files) {
-    const key = file.path;
-    if (typeof key !== "string" || key.trim() === "" || seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    deduped.push(file);
-  }
-  return deduped;
-}
 function formatSkippedUpdateList(skippedUpdates) {
   if (skippedUpdates.length === 0) {
     return ["- none"];
@@ -9172,72 +9064,6 @@ function formatOsmdIngestHuman(data) {
 function formatNullableNumberHumanField(value) {
   return typeof value === "number" ? String(value) : "-";
 }
-function formatNotificationHuman(notification) {
-  if (!notification) {
-    return "-";
-  }
-  const id = formatNullableHumanField(notification.id);
-  const status = formatNullableHumanField(notification.status);
-  return `id=${id} status=${status}`;
-}
-function formatPhantomTimestampLines(data) {
-  const lines = [];
-  if (data.startedAt) {
-    lines.push(`Started at: ${data.startedAt}`);
-  }
-  if (data.completedAt) {
-    lines.push(`Completed at: ${data.completedAt}`);
-  }
-  if (data.createdAt) {
-    lines.push(`Created at: ${data.createdAt}`);
-  }
-  if (data.updatedAt) {
-    lines.push(`Updated at: ${data.updatedAt}`);
-  }
-  return lines;
-}
-function formatOsmdPhantomHuman(data, dryRun) {
-  const lines = [
-    dryRun ? "Phantom Phase 1 plan" : "Phantom Phase 1 run",
-    `Run ID: ${formatNullableHumanField(data.runId)}`,
-    `Status: ${formatNullableHumanField(data.status)}`,
-    ...formatPhantomTimestampLines(data),
-    `Organization ID: ${formatNullableHumanField(data.organizationId)}`,
-    `Trigger type: ${formatNullableHumanField(data.triggerType)}`,
-    `Scope: ${formatNullableHumanField(data.scope ?? data.subtree)}`,
-    ...data.countSemantics === null || data.countSemantics === void 0 ? [] : [`Count semantics: ${formatUnknownHuman(data.countSemantics)}`],
-    `Reviewed OSMD/agent markdown entries: ${formatNullableNumberHumanField(data.scannedFileCount)}`,
-    `Changed entries: ${formatNullableNumberHumanField(data.changedFileCount)}`,
-    `Unchanged entries: ${formatNullableNumberHumanField(data.unchangedFileCount)}`,
-    `Updated files: ${formatNullableNumberHumanField(data.updatedFileCount)}`,
-    `Skipped entries: ${formatNullableNumberHumanField(data.skippedFileCount)}`,
-    `Lint status: ${formatNullableHumanField(data.lintStatus)}`,
-    `Errors: ${formatNullableNumberHumanField(data.errorCount)}`,
-    `Warnings: ${formatNullableNumberHumanField(data.warningCount)}`,
-    `Report path: ${formatNullableHumanField(data.reportPath)}`,
-    `Notification: ${formatNotificationHuman(data.notification)}`,
-    "",
-    "Planned reads:",
-    ...formatIngestFileList(data.plannedReads),
-    "",
-    "Planned semantic memory writes:",
-    ...formatIngestFileList(data.plannedWrites),
-    ...dryRun ? formatNotesWriteSummary(data.plannedWrites) : [],
-    "",
-    "Changed entries:",
-    ...formatIngestFileList(data.changedFiles),
-    "",
-    "Updated files:",
-    ...formatIngestFileList(data.updatedFiles),
-    "",
-    "Skipped nodes by reason:",
-    ...formatSkippedFilesByReason(data.skippedFiles),
-    "",
-    "Lint plan:",
-    formatUnknownHuman(data.lintPlan)
-  ];
-  return lines.join("\n");
-}
 function parseSearchLimit(value) {
   const raw = value === void 0 || value === null || value === "" ? "10" : value;
   const parsed = positiveInt.safeParse(raw);
@@ -10005,18 +9831,6 @@ function registerOsmdCommands(program) {
       throw error;
     }
   });
-  const phantom = osmd.command("phantom").description("Backend-owned Phantom Phase 1 manual operations");
-  phantom.command("run").description("Manually run or plan Phantom Phase 1 for OSMD/agent semantic memory").option("--dry-run", "Ask backend for the Phantom Phase 1 plan without mutating").option("--readable", "Print a human-readable Phantom summary instead of JSON").action(async (opts, cmd) => {
-    const command = "osmd.phantom.run";
-    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
-    return runOsmdPhantomPhaseOne({
-      command,
-      runtimeOptions,
-      organizationId,
-      dryRun: opts.dryRun === true,
-      readable: opts.readable === true
-    });
-  });
   const agent = osmd.command("agent").description(".agent markdown attached to canonical OSMD parents");
   agent.command("status <parent-ref> <file>").description("Show .agent file metadata without creating files").action(async (parentRef, file, _opts, cmd) => {
     const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
@@ -13012,14 +12826,14 @@ function registerMailCommands(program) {
 }
 
 // src/commands/phantom.ts
-var import_zod18 = require("zod");
-var nonNegativeInt4 = import_zod18.z.coerce.number().int().min(0);
-var nullableString = import_zod18.z.string().nullable().optional().transform((value) => value ?? null);
-var idString = import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).transform((value) => String(value));
-var nullableIdString = import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).nullable().optional().transform(
+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(
   (value) => value === void 0 || value === null ? null : String(value)
 );
-var jsonObject = import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown());
+var jsonObject = import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown());
 var PHANTOM_LEDGER_INVENTORY_SELECTION = `{
   schemaVersion
   runsCount
@@ -13232,10 +13046,10 @@ var PHANTOM_LEDGER_KEY_ALIASES = {
   content_hash: "contentHash",
   observed_at: "observedAt"
 };
-var phantomLedgerInventorySchema = import_zod18.z.preprocess(
+var phantomLedgerInventorySchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
-    schemaVersion: import_zod18.z.string(),
+  import_zod19.z.object({
+    schemaVersion: import_zod19.z.string(),
     runsCount: nonNegativeInt4,
     observationsCount: nonNegativeInt4,
     candidatesCount: nonNegativeInt4,
@@ -13245,16 +13059,16 @@ var phantomLedgerInventorySchema = import_zod18.z.preprocess(
     reportsCount: nonNegativeInt4
   })
 );
-var phantomRunSchema = import_zod18.z.preprocess(
+var phantomRunSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
-    notificationId: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).nullable().optional().transform(
+    notificationId: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).nullable().optional().transform(
       (value) => value === void 0 || value === null ? null : String(value)
     ),
-    status: import_zod18.z.string(),
-    triggerType: import_zod18.z.string(),
+    status: import_zod19.z.string(),
+    triggerType: import_zod19.z.string(),
     startedAt: nullableString,
     completedAt: nullableString,
     scannedFileCount: nonNegativeInt4,
@@ -13264,163 +13078,163 @@ var phantomRunSchema = import_zod18.z.preprocess(
     errorCount: nonNegativeInt4,
     warningCount: nonNegativeInt4,
     errorMessage: nullableString,
-    dryRun: import_zod18.z.boolean(),
-    schemaVersion: import_zod18.z.string(),
+    dryRun: import_zod19.z.boolean(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
     idempotencyKey: nullableString,
     ledgerMetadata: jsonObject.catch({}),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomRunListItemSchema = import_zod18.z.preprocess(
+var phantomRunListItemSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
-    status: import_zod18.z.string(),
-    triggerType: import_zod18.z.string(),
-    dryRun: import_zod18.z.boolean(),
-    schemaVersion: import_zod18.z.string(),
+    status: import_zod19.z.string(),
+    triggerType: import_zod19.z.string(),
+    dryRun: import_zod19.z.boolean(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomReportSchema = import_zod18.z.preprocess(
+var phantomReportSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
-    status: import_zod18.z.string(),
-    reportType: import_zod18.z.string(),
-    schemaVersion: import_zod18.z.string(),
+    status: import_zod19.z.string(),
+    reportType: import_zod19.z.string(),
+    schemaVersion: import_zod19.z.string(),
     markdownPath: nullableString,
     payload: jsonObject.catch({}),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomObservationSchema = import_zod18.z.preprocess(
+var phantomObservationSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
-    status: import_zod18.z.string(),
-    observationType: import_zod18.z.string(),
+    status: import_zod19.z.string(),
+    observationType: import_zod19.z.string(),
     targetType: nullableString,
     targetId: nullableString,
     sourceTable: nullableString,
     sourceRecordId: nullableString,
     sourceEventId: nullableString,
     contentHash: nullableString,
-    observedAt: import_zod18.z.string(),
-    confidence: import_zod18.z.coerce.number(),
+    observedAt: import_zod19.z.string(),
+    confidence: import_zod19.z.coerce.number(),
     payload: jsonObject.catch({}),
-    schemaVersion: import_zod18.z.string(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomCandidateSchema = import_zod18.z.preprocess(
+var phantomCandidateSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomObservationId: nullableString,
-    status: import_zod18.z.string(),
-    candidateType: import_zod18.z.string(),
+    status: import_zod19.z.string(),
+    candidateType: import_zod19.z.string(),
     targetType: nullableString,
     targetId: nullableString,
     title: nullableString,
-    dryRun: import_zod18.z.boolean(),
+    dryRun: import_zod19.z.boolean(),
     payload: jsonObject.catch({}),
-    approvalStatus: import_zod18.z.string(),
+    approvalStatus: import_zod19.z.string(),
     approvedById: nullableIdString,
     approvedAt: nullableString,
     approvalSource: nullableString,
     approvalReason: nullableString,
     approvalMetadata: jsonObject.catch({}),
-    schemaVersion: import_zod18.z.string(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomCandidateEvidenceSchema = import_zod18.z.preprocess(
+var phantomCandidateEvidenceSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomCandidateId: idString,
     phantomObservationId: nullableString,
-    evidenceType: import_zod18.z.string(),
+    evidenceType: import_zod19.z.string(),
     sourceType: nullableString,
     sourceId: nullableString,
     contentHash: nullableString,
     payload: jsonObject.catch({}),
-    schemaVersion: import_zod18.z.string(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomValidationSchema = import_zod18.z.preprocess(
+var phantomValidationSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomCandidateId: idString,
-    status: import_zod18.z.string(),
-    validationType: import_zod18.z.string(),
-    dryRun: import_zod18.z.boolean(),
+    status: import_zod19.z.string(),
+    validationType: import_zod19.z.string(),
+    dryRun: import_zod19.z.boolean(),
     payload: jsonObject.catch({}),
     resultPayload: jsonObject.catch({}),
-    schemaVersion: import_zod18.z.string(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomApplyOperationSchema = import_zod18.z.preprocess(
+var phantomApplyOperationSchema = import_zod19.z.preprocess(
   normalizePhantomLedgerKeys,
-  import_zod18.z.object({
+  import_zod19.z.object({
     id: idString,
     organizationId: idString,
     phantomRunId: idString,
     phantomCandidateId: idString,
-    status: import_zod18.z.string(),
-    operationType: import_zod18.z.string(),
-    dryRun: import_zod18.z.boolean(),
+    status: import_zod19.z.string(),
+    operationType: import_zod19.z.string(),
+    dryRun: import_zod19.z.boolean(),
     targetType: nullableString,
     targetId: nullableString,
     payload: jsonObject.catch({}),
     resultPayload: jsonObject.catch({}),
-    schemaVersion: import_zod18.z.string(),
+    schemaVersion: import_zod19.z.string(),
     testRunId: nullableString,
-    idempotencyKey: import_zod18.z.string(),
-    createdAt: import_zod18.z.string(),
-    updatedAt: import_zod18.z.string()
+    idempotencyKey: import_zod19.z.string(),
+    createdAt: import_zod19.z.string(),
+    updatedAt: import_zod19.z.string()
   })
 );
-var phantomRunsSchema = import_zod18.z.array(phantomRunListItemSchema);
-var phantomReportsSchema = import_zod18.z.array(phantomReportSchema);
-var phantomObservationsSchema = import_zod18.z.array(phantomObservationSchema);
-var phantomCandidatesSchema = import_zod18.z.array(phantomCandidateSchema);
-var phantomCandidateEvidencesSchema = import_zod18.z.array(phantomCandidateEvidenceSchema);
-var phantomValidationsSchema = import_zod18.z.array(phantomValidationSchema);
-var phantomApplyOperationsSchema = import_zod18.z.array(phantomApplyOperationSchema);
+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);
 function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -14877,72 +14691,72 @@ function registerDatasheetsCommands(program) {
 }
 
 // src/commands/atlasAuthoring.ts
-var import_zod19 = require("zod");
-var idSchema14 = import_zod19.z.string().trim().min(1);
-var idempotencyKeySchema = import_zod19.z.string().min(1).refine((value) => value.trim() === value, "Idempotency key must not have leading or trailing whitespace.");
-var skillScopeSchema = import_zod19.z.enum(["ADMIN_GLOBAL", "MEMBER_PERSONAL"]);
-var isoDateSchema = import_zod19.z.iso.date();
-var nonEmptyStringSchema = import_zod19.z.string().trim().min(1);
+var import_zod20 = require("zod");
+var idSchema14 = 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 AUTOMATION_RUN_HTTP_TIMEOUT_MS = 6e4;
-var agentToolAccessSchema = import_zod19.z.array(
-  import_zod19.z.object({
+var agentToolAccessSchema = import_zod20.z.array(
+  import_zod20.z.object({
     tool_key: nonEmptyStringSchema,
     scope_value: nonEmptyStringSchema
   }).strict()
 ).min(1);
 var agentToolAccessUpdateSchema = agentToolAccessSchema.min(0);
-var agentPluginConnectionsSchema = import_zod19.z.array(
-  import_zod19.z.object({
+var agentPluginConnectionsSchema = import_zod20.z.array(
+  import_zod20.z.object({
     external_tool_connection_id: nonEmptyStringSchema,
     tool_key: nonEmptyStringSchema,
     scope_value: nonEmptyStringSchema.optional(),
-    allowed_tools: import_zod19.z.array(nonEmptyStringSchema).optional(),
-    allowed_scopes: import_zod19.z.array(nonEmptyStringSchema).optional(),
-    requires_confirmation: import_zod19.z.boolean().optional(),
-    enabled: import_zod19.z.boolean().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()
   }).strict()
 ).min(1);
-var agentPluginConnectionUpdateSchema = import_zod19.z.array(
-  import_zod19.z.union([
-    import_zod19.z.object({
+var agentPluginConnectionUpdateSchema = import_zod20.z.array(
+  import_zod20.z.union([
+    import_zod20.z.object({
       id: nonEmptyStringSchema,
-      _destroy: import_zod19.z.literal(true)
+      _destroy: import_zod20.z.literal(true)
     }).strict(),
-    import_zod19.z.object({
+    import_zod20.z.object({
       id: nonEmptyStringSchema.optional(),
       external_tool_connection_id: nonEmptyStringSchema.optional(),
       tool_key: nonEmptyStringSchema.optional(),
       scope_value: nonEmptyStringSchema.optional(),
-      allowed_tools: import_zod19.z.array(nonEmptyStringSchema).optional(),
-      allowed_scopes: import_zod19.z.array(nonEmptyStringSchema).optional(),
-      requires_confirmation: import_zod19.z.boolean().optional(),
-      enabled: import_zod19.z.boolean().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()
     }).strict().superRefine((value, context) => {
       if (value.id || value.external_tool_connection_id && value.tool_key) return;
       context.addIssue({
-        code: import_zod19.z.ZodIssueCode.custom,
+        code: import_zod20.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_zod19.z.object({
-  trigger_type: import_zod19.z.literal("cron"),
+var agentTriggerSchema = import_zod20.z.object({
+  trigger_type: import_zod20.z.literal("cron"),
   cron_expression: nonEmptyStringSchema,
   timezone: nonEmptyStringSchema,
-  starts_at: import_zod19.z.iso.datetime({ offset: true }).nullable().optional(),
-  ends_at: import_zod19.z.iso.datetime({ offset: true }).nullable().optional(),
-  max_runs: import_zod19.z.number().int().positive().nullable().optional(),
-  enabled: import_zod19.z.boolean().optional()
+  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()
 }).strict();
-var agentTriggerUpdateSchema = import_zod19.z.union([
+var agentTriggerUpdateSchema = import_zod20.z.union([
   agentTriggerSchema.extend({ id: nonEmptyStringSchema.optional() }).strict(),
-  import_zod19.z.object({
+  import_zod20.z.object({
     id: nonEmptyStringSchema,
-    _destroy: import_zod19.z.literal(true)
+    _destroy: import_zod20.z.literal(true)
   }).strict()
 ]);
-var automationConfigSchema = import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown());
+var automationConfigSchema = import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown());
 var AGENT_SELECTION = `{
   id
   type
@@ -15018,6 +14832,11 @@ var AUTOMATION_SELECTION = `{
   organizationId
   memberId
   agentId
+  agentTriggerId
+  scheduleStatus
+  triggerEnabled
+  cronExpression
+  timezone
   createdAt
   updatedAt
   updateVersion
@@ -15224,7 +15043,16 @@ function normalizeAutomationRunPayload(payload) {
   };
 }
 function parseAutomationConfig(value) {
-  return automationConfigSchema.parse(parseJson(String(value), "--ai-task-config"));
+  const config = automationConfigSchema.parse(parseJson(String(value), "--ai-task-config"));
+  if (Object.hasOwn(config, "agent_id") || Object.hasOwn(config, "agentId")) {
+    throw new CliError({
+      message: "Automation executor agent_id must be supplied through --agent-id, not --ai-task-config.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return config;
 }
 function parseExpectedUpdateVersion(value) {
   return nonEmptyStringSchema.parse(String(value));
@@ -15433,7 +15261,7 @@ function registerAtlasAuthoringCommands(program) {
     "--service <service>",
     "Supported service: gmail, calendar, slack, or stripe"
   ).action(async (opts, cmd) => {
-    const service = import_zod19.z.enum(["gmail", "calendar", "slack", "stripe"]).parse(opts.service);
+    const service = import_zod20.z.enum(["gmail", "calendar", "slack", "stripe"]).parse(opts.service);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     await runGraphqlQueryCommand({
@@ -15447,7 +15275,7 @@ function registerAtlasAuthoringCommands(program) {
     });
   });
   const automations = program.command("automations").description("Bounded Automation authoring operations");
-  automations.command("create").description("Create a Backlog Automation through the API-owned createAutomation contract").requiredOption("--summary <summary>").requiredOption("--ai-task-config <json>", "Valid JSON for the API-owned ai_task_config field").requiredOption("--idempotency-key <key>", "Required create idempotency key").option("--description <description>").option("--notes <notes>").option("--member-id <memberId>").option("--agent-id <agentId>", "Optional executor Agent id for a repeat Automation").option("--priority <priority>").option("--due-date <date>", "ISO-8601 date (YYYY-MM-DD)").action(async (opts, cmd) => {
+  automations.command("create").description("Create a Backlog Automation through the API-owned createAutomation contract").requiredOption("--summary <summary>").requiredOption("--ai-task-config <json>", "Valid JSON for the API-owned ai_task_config field").requiredOption("--idempotency-key <key>", "Required create idempotency key").option("--description <description>").option("--notes <notes>").option("--member-id <memberId>").requiredOption("--agent-id <agentId>", "Required executor Agent id").option("--priority <priority>").option("--due-date <date>", "ISO-8601 date (YYYY-MM-DD)").action(async (opts, cmd) => {
     const idempotencyKey = idempotencyKeySchema.parse(opts.idempotencyKey);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
@@ -15465,7 +15293,7 @@ function registerAtlasAuthoringCommands(program) {
         organization_id: organizationId,
         input: {
           summary: idSchema14.parse(opts.summary),
-          ai_task_config: parseJson(String(opts.aiTaskConfig), "--ai-task-config"),
+          ai_task_config: parseAutomationConfig(opts.aiTaskConfig),
           ...opts.description !== void 0 ? { description: String(opts.description) } : {},
           ...opts.notes !== void 0 ? { notes: String(opts.notes) } : {},
           ...opts.memberId !== void 0 ? { member_id: idSchema14.parse(opts.memberId) } : {},
@@ -15536,20 +15364,17 @@ function registerAtlasAuthoringCommands(program) {
     "Exact opaque updateVersion value from automations show; rejects stale writes"
   ).option("--summary <summary>").option("--description <description>").option("--notes <notes>").option("--priority <priority>").option("--due-date <date>", "ISO-8601 date (YYYY-MM-DD)").option("--ai-task-config <json>", "Complete replacement ai_task_config JSON object").option(
     "--agent-id <agentId>",
-    "Executor Agent id; requires --ai-task-config and is stored in that config"
+    "Rejected: executor ownership is immutable after Automation creation"
   ).action(async (opts, cmd) => {
-    if (opts.agentId !== void 0 && opts.aiTaskConfig === void 0) {
+    if (opts.agentId !== void 0) {
       throw new CliError({
-        message: "automations update requires --ai-task-config whenever --agent-id is supplied.",
+        message: "automations update cannot change executor ownership; create a new Automation instead.",
         kind: "invalid_args",
         status: 400,
         exitCode: EXIT_CODES.invalidArgs
       });
     }
-    const aiTaskConfig = opts.aiTaskConfig === void 0 ? void 0 : {
-      ...parseAutomationConfig(opts.aiTaskConfig),
-      ...opts.agentId !== void 0 ? { agent_id: idSchema14.parse(opts.agentId) } : {}
-    };
+    const aiTaskConfig = opts.aiTaskConfig === void 0 ? void 0 : parseAutomationConfig(opts.aiTaskConfig);
     const patch = {
       ...opts.summary !== void 0 ? { summary: String(opts.summary) } : {},
       ...opts.description !== void 0 ? { description: String(opts.description) } : {},
@@ -15672,7 +15497,7 @@ var import_node_path4 = require("path");
 var import_node_crypto3 = require("crypto");
 
 // src/version.ts
-var CLI_VERSION = "0.1.76";
+var CLI_VERSION = "0.1.77";
 
 // src/operationMetadata.ts
 var DISCOVERY_OPERATION_IDS = [
@@ -16076,7 +15901,6 @@ var WRITE_OPERATION_IDS = [
   "osmd.ingest.text",
   "osmd.ingest.transcript",
   "osmd.ingest.url",
-  "osmd.phantom.run",
   "osmd.wiki.append-log",
   "osmd.wiki.create",
   "osmd.wiki.index-upsert",
@@ -16395,22 +16219,21 @@ var NAMESPACE_DOCS = {
   osmd: {
     name: "osmd",
     tier: "primary",
-    description: "Canonical OSMD, .agent overlay, Agent Wiki, ingest, lint, and Phantom operations.",
+    description: "Canonical OSMD, .agent overlay, Agent Wiki, ingest, and lint operations.",
     examples: [
       "wave osmd tree --depth 2",
       "wave osmd lint --json",
       'wave osmd ingest text "Notes" --slug notes --parent-ref "projects/Wave Tools" --summary "Source notes" --dry-run',
-      'wave osmd agent update "projects/Wave Tools" notes.md --content "# Notes"',
-      "wave osmd phantom run --dry-run"
+      'wave osmd agent update "projects/Wave Tools" notes.md --content "# Notes"'
     ],
     schema: {
       output: "json-envelope-default",
       safety: [
         "Canonical OSMD writes are blocked before mutation.",
         "Agent Wiki log is append-only.",
-        "Ingest and Phantom support dry-run paths."
+        "Ingest supports dry-run paths."
       ],
-      commands: ["tree", "status", "read", "children", "search", "lint", "memory-quality", "ingest", "phantom", "agent", "wiki"]
+      commands: ["tree", "status", "read", "children", "search", "lint", "memory-quality", "ingest", "agent", "wiki"]
     }
   },
   phantom: {
@@ -17216,7 +17039,7 @@ function registerDiscoveryCommands(program) {
   const phantom = program.commands.find((command) => command.name() === "phantom");
   phantom?.addHelpText(
     "after",
-    "\nExamples:\n  wave phantom inventory --json\n  wave phantom observations --run-id 123 --json\n  wave phantom candidates --candidate-type organization_meta_profile_update_candidate --json\n  wave phantom apply-operations --status succeeded --operation-type organization_meta_profile_patch --json\n  wave phantom report latest --json\n  wave osmd phantom run --dry-run\n"
+    "\nExamples:\n  wave phantom inventory --json\n  wave phantom observations --run-id 123 --json\n  wave phantom candidates --candidate-type organization_meta_profile_update_candidate --json\n  wave phantom apply-operations --status succeeded --operation-type organization_meta_profile_patch --json\n  wave phantom report latest --json\n"
   );
 }
 function attachNamespaceDiscovery(program) {
@@ -17282,12 +17105,11 @@ function attachDiscoveryHelp(program) {
       "  wave capabilities list",
       "  wave capabilities tools",
       "  wave osmd lint --json",
-      "  wave osmd phantom run --dry-run",
       "  wave doctor"
     ].join("\n")
   );
   const helpByName = /* @__PURE__ */ new Map([
-    ["osmd", '\nExamples:\n  wave osmd tree --depth 2\n  wave osmd lint --json\n  wave osmd agent update "projects/Wave Tools" notes.md --content "# Notes"\n  wave osmd phantom run --dry-run\n'],
+    ["osmd", '\nExamples:\n  wave osmd tree --depth 2\n  wave osmd lint --json\n  wave osmd agent update "projects/Wave Tools" notes.md --content "# Notes"\n'],
     ["broadcast", "\nExamples:\n  wave broadcast list\n  wave broadcast workspace\n  wave broadcast community\n  wave broadcast open\n"],
     ["support", "\nExamples:\n  wave support counts --status open\n  wave support tickets --status open --page 1 --per 20\n  wave support knowledge-articles --collection-id 123 --visibility public\n  wave support settings\n  wave support open\n"],
     ["markdown-tree", "\nExamples:\n  wave markdown-tree root --tree-view\n  wave markdown-tree resolve --tool-key projects --node-key tasks --parent-id 123\n"],
@@ -17386,19 +17208,30 @@ function buildCli(options) {
 
 // src/machine.ts
 var import_node_crypto4 = require("crypto");
+var import_node_fs5 = require("fs");
 var MACHINE_FLAGS = /* @__PURE__ */ new Set([
   "--machine",
   "--operation",
   "--phase",
-  "--input-json"
+  "--input-json",
+  "--machine-auth-fd",
+  "--machine-approval-fd"
 ]);
+var MACHINE_AUTH_FD = 3;
+var MACHINE_APPROVAL_FD = 4;
+var MAX_MACHINE_SECRET_BYTES = 64 * 1024;
+var MAX_MACHINE_INPUT_BYTES = 128 * 1024;
 function machineEnvelope(params) {
   return {
     ok: params.ok,
     command: params.command,
     status: params.status,
     data: params.data ?? null,
-    error: params.error ?? null,
+    error: params.error ? {
+      code: params.error.code,
+      message: params.error.message,
+      details: params.error.details ?? {}
+    } : null,
     meta: { requestId: "machine" }
   };
 }
@@ -17420,7 +17253,7 @@ function commandId(command) {
 function parseMachineArgs(argv) {
   const values = {};
   for (let index = 0; index < argv.length; index += 1) {
-    const flag = argv[index];
+    const flag = argv[index] ?? "";
     if (!MACHINE_FLAGS.has(flag)) {
       return { error: `Unsupported machine flag: ${flag}` };
     }
@@ -17435,19 +17268,45 @@ function parseMachineArgs(argv) {
   if (values["--machine"] !== "execute") {
     return { error: '--machine must be "execute".' };
   }
+  const authFd = parseReservedMachineFd(values["--machine-auth-fd"], MACHINE_AUTH_FD);
+  if (authFd instanceof Error) return { error: authFd.message };
+  const approvalFd = parseReservedMachineFd(
+    values["--machine-approval-fd"],
+    MACHINE_APPROVAL_FD
+  );
+  if (approvalFd instanceof Error) return { error: approvalFd.message };
   return {
-    operation: values["--operation"],
-    phase: values["--phase"],
-    inputJson: values["--input-json"]
+    ...values["--operation"] ? { operation: values["--operation"] } : {},
+    ...values["--phase"] ? { phase: values["--phase"] } : {},
+    ...values["--input-json"] ? { inputJson: values["--input-json"] } : {},
+    ...authFd !== void 0 ? { authFd } : {},
+    ...approvalFd !== void 0 ? { approvalFd } : {}
   };
 }
+function parseReservedMachineFd(value, expected) {
+  if (value === void 0) return void 0;
+  if (!/^\d+$/.test(value) || Number(value) !== expected) {
+    return new Error(`The machine secret descriptor must be fd ${expected}.`);
+  }
+  return expected;
+}
 async function readMachineInput(location) {
   if (location !== "-") {
     throw new Error('Machine input must be supplied with "--input-json -".');
   }
   let raw = "";
+  let bytes = 0;
   process.stdin.setEncoding("utf8");
-  for await (const chunk of process.stdin) raw += chunk;
+  for await (const chunk of process.stdin) {
+    const text = String(chunk);
+    bytes += Buffer.byteLength(text, "utf8");
+    if (bytes > MAX_MACHINE_INPUT_BYTES) {
+      throw new Error(
+        `Machine input exceeds the maximum size of ${MAX_MACHINE_INPUT_BYTES} bytes.`
+      );
+    }
+    raw += text;
+  }
   if (!raw.trim()) throw new Error("Machine input JSON is required.");
   const parsed = JSON.parse(raw);
   if (!isPlainObject(parsed)) throw new Error("Machine input must be a JSON object.");
@@ -17468,11 +17327,20 @@ function normalizeInput(input) {
     Object.keys(input).sort().map((key) => [key, input[key]])
   );
 }
-function parseTrustedJson(name, predicate) {
-  const raw = process.env[name];
-  if (!raw) return null;
+function parseTrustedJsonFromFd(fd, predicate) {
+  if (fd === void 0) return null;
   try {
-    const parsed = JSON.parse(raw);
+    const chunks = [];
+    const buffer = Buffer.allocUnsafe(8 * 1024);
+    let bytes = 0;
+    while (true) {
+      const read = (0, import_node_fs5.readSync)(fd, buffer, 0, buffer.length, null);
+      if (read === 0) break;
+      bytes += read;
+      if (bytes > MAX_MACHINE_SECRET_BYTES) return null;
+      chunks.push(Buffer.from(buffer.subarray(0, read)));
+    }
+    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
     return predicate(parsed) ? parsed : null;
   } catch {
     return null;
@@ -17547,13 +17415,9 @@ function withTrustedMachineAuth(auth, callback) {
   for (const key of Object.keys(process.env)) {
     if (key.startsWith("WAVE_")) delete process.env[key];
   }
-  if (auth) {
-    process.env.WAVE_API_TOKEN = auth.token;
-    process.env.WAVE_API_BASE_URL = auth.baseUrl;
-  }
   process.env.WAVE_CLI_AUTH_STORAGE = "disabled";
   process.env.WAVE_CLI_HOME = "/dev/null";
-  return callback().finally(() => {
+  return withMachineRuntimeAuth(auth, callback).finally(() => {
     for (const key of Object.keys(process.env)) {
       if (key.startsWith("WAVE_")) delete process.env[key];
     }
@@ -17705,7 +17569,7 @@ async function maybeRunMachineExecute(argv, program) {
       })
     });
   }
-  const auth = parseTrustedJson("WAVE_MACHINE_AUTH_JSON", isTrustedAuth);
+  const auth = parseTrustedJsonFromFd(parsed.authFd, isTrustedAuth);
   if (needsTrustedAuth(resolved.operation) && !auth) {
     return printEnvelopeAndExit({
       envelope: machineEnvelope({
@@ -17721,7 +17585,7 @@ async function maybeRunMachineExecute(argv, program) {
     });
   }
   if (resolved.operation.classification === "write") {
-    const approval = parseTrustedJson("WAVE_MACHINE_APPROVAL_JSON", isTrustedApproval);
+    const approval = parseTrustedJsonFromFd(parsed.approvalFd, isTrustedApproval);
     if (!approval || approval.operation !== resolved.operation.id || approval.inputDigest !== digest || approval.cliVersion !== manifest.cli.version || approval.registryDigest !== manifest.registryDigest || approval.organizationId !== auth?.organizationId || approval.actorId !== auth?.actorId) {
       return printEnvelopeAndExit({
         envelope: machineEnvelope({
@@ -17801,13 +17665,13 @@ main().catch((error) => {
     });
     return;
   }
-  if (error instanceof import_zod20.ZodError || error instanceof import_commander2.InvalidArgumentError) {
+  if (error instanceof import_zod21.ZodError || error instanceof import_commander2.InvalidArgumentError) {
     printCliFailure({
       status: 400,
       code: "invalid_args",
       message: "Invalid command arguments.",
       details: {
-        issues: error instanceof import_zod20.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
+        issues: error instanceof import_zod21.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
       },
       exitCode: EXIT_CODES.invalidArgs
     });