@ted-galago/wave-cli 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -3,7 +3,7 @@
 
 // src/index.ts
 var import_commander2 = require("commander");
-var import_zod12 = require("zod");
+var import_zod16 = require("zod");
 
 // src/cli.ts
 var import_commander = require("commander");
@@ -188,6 +188,16 @@ function inferStatusFromGraphqlErrors(errors) {
   if (!Array.isArray(errors) || errors.length === 0) {
     return 400;
   }
+  const codes = extractGraphqlErrorCodes(errors);
+  if (codes.includes("UNAUTHORIZED")) {
+    return 401;
+  }
+  if (codes.includes("NOT_FOUND")) {
+    return 404;
+  }
+  if (codes.includes("INVALID_SCOPE") || codes.includes("UNSUPPORTED_BRANCH")) {
+    return 400;
+  }
   const text = JSON.stringify(errors).toLowerCase();
   if (text.includes("unauthorized") || text.includes("not authenticated")) {
     return 401;
@@ -203,13 +213,260 @@ function inferStatusFromGraphqlErrors(errors) {
   }
   return 400;
 }
+function extractGraphqlErrorCodes(errors) {
+  if (!Array.isArray(errors)) {
+    return [];
+  }
+  const codes = errors.map((entry) => {
+    if (!entry || typeof entry !== "object") return "";
+    const extensions = entry.extensions;
+    if (!extensions || typeof extensions !== "object") return "";
+    return String(extensions.code ?? "").toUpperCase();
+  }).filter((code) => code.length > 0);
+  return Array.from(new Set(codes));
+}
+function errorCodeFromGraphqlErrors(errors, status) {
+  const codes = extractGraphqlErrorCodes(errors);
+  if (codes.includes("UNAUTHORIZED")) {
+    return "missing_auth";
+  }
+  if (codes.includes("NOT_FOUND")) {
+    return "not_found";
+  }
+  if (codes.includes("INVALID_SCOPE")) {
+    return "invalid_scope";
+  }
+  if (codes.includes("UNSUPPORTED_BRANCH")) {
+    return "unsupported_branch";
+  }
+  if (status === 401) {
+    return "missing_auth";
+  }
+  if (status === 403) {
+    return "forbidden";
+  }
+  return `http_${status}`;
+}
 function errorFromGraphqlErrors(errors, status) {
   return {
-    code: status === 401 ? "missing_auth" : status === 403 ? "forbidden" : `http_${status}`,
+    code: errorCodeFromGraphqlErrors(errors, status),
     message: "GraphQL request failed.",
     details: { errors }
   };
 }
+function findParentContextFromVariables(variables) {
+  const directParent = Object.entries(variables).find(([key, value]) => {
+    if (key === "organization_id" || key === "organizationId") return false;
+    if (!key.endsWith("_id") && !key.endsWith("Id")) return false;
+    return typeof value === "string" && value.trim().length > 0;
+  });
+  if (directParent) {
+    return { parentKey: directParent[0], parentId: String(directParent[1]) };
+  }
+  const params = variables.params && typeof variables.params === "object" && !Array.isArray(variables.params) ? variables.params : void 0;
+  if (!params) {
+    return {};
+  }
+  const rootObjectEntry = Object.entries(params).find(
+    ([, value]) => value && typeof value === "object" && !Array.isArray(value)
+  );
+  if (!rootObjectEntry) {
+    return {};
+  }
+  const [, rootObject] = rootObjectEntry;
+  const parentEntry = Object.entries(rootObject).find(([key, value]) => {
+    if (!key.endsWith("_id") && !key.endsWith("Id")) return false;
+    return typeof value === "string" && value.trim().length > 0;
+  });
+  if (!parentEntry) {
+    return {};
+  }
+  return { parentKey: parentEntry[0], parentId: String(parentEntry[1]) };
+}
+function shouldAddSparse422Diagnostic(status, mutationPayload) {
+  if (status !== 422) {
+    return false;
+  }
+  const rawErrors = mutationPayload.errors && typeof mutationPayload.errors === "object" ? mutationPayload.errors : void 0;
+  if (!rawErrors) {
+    return true;
+  }
+  const dataErrors = rawErrors.data;
+  return Array.isArray(dataErrors) && dataErrors.length === 0;
+}
+function buildSparse422Diagnostic(input) {
+  const parentContext = findParentContextFromVariables(input.variables);
+  return {
+    operation: input.command,
+    field: input.field,
+    context: parentContext.parentKey && parentContext.parentId ? {
+      parentKey: parentContext.parentKey,
+      parentId: parentContext.parentId
+    } : {
+      message: "No explicit parent id found in request variables."
+    }
+  };
+}
+function isFeedbackCreateCommand(input) {
+  return input.operationType === "mutation" && input.command === "feedbacks.create";
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function extractFeedbackIdentity(variables) {
+  const organizationId = asNonEmptyString(variables.organization_id) ?? asNonEmptyString(variables.organizationId);
+  const params = asRecord(variables.params);
+  const feedback = params ? asRecord(params.feedback) : null;
+  const name = feedback ? asNonEmptyString(feedback.name) : null;
+  const quarter = feedback ? asNonEmptyString(feedback.quarter) : null;
+  const year = feedback ? asNonEmptyString(feedback.year) : null;
+  if (!organizationId || !name || !quarter || !year) {
+    return null;
+  }
+  return {
+    organizationId,
+    name,
+    quarter,
+    year
+  };
+}
+function collectMessageStrings(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectMessageStrings(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  return Object.values(value).flatMap(
+    (entry) => collectMessageStrings(entry)
+  );
+}
+function isDuplicateFeedbackMutationError(mutationPayload) {
+  const messages = collectMessageStrings(mutationPayload.errors);
+  return messages.some(
+    (message) => message.toLowerCase().includes("already been taken")
+  );
+}
+function extractFeedbackListNode(graph) {
+  const data = asRecord(graph.data);
+  const feedbacks = data ? asRecord(data.feedbacks) : null;
+  if (!feedbacks) {
+    return null;
+  }
+  const rows = Array.isArray(feedbacks.data) ? feedbacks.data : [];
+  const first = rows.find((entry) => asRecord(entry));
+  return first ? first : null;
+}
+function buildFeedbackReuseEnvelope(params) {
+  return {
+    envelope: buildEnvelope({
+      ok: true,
+      command: params.command,
+      status: params.status,
+      data: {
+        [params.field]: {
+          ok: true,
+          status: params.status,
+          errorCode: null,
+          data: {
+            data: params.feedbackNode
+          },
+          errors: null,
+          reusedExisting: true,
+          idempotency: {
+            reason: params.reason
+          }
+        }
+      },
+      error: null,
+      requestId: params.requestId
+    }),
+    exitCode: EXIT_CODES.success
+  };
+}
+function buildFeedbackFindRequestBody(command, identity) {
+  return buildGraphqlBody({
+    config: {
+      baseUrl: "http://localhost",
+      token: "placeholder",
+      timeoutMs: 1e3,
+      debug: false
+    },
+    command,
+    operationType: "query",
+    field: "feedbacks",
+    variables: {
+      organization_id: identity.organizationId,
+      name: identity.name,
+      quarter: identity.quarter,
+      year: identity.year,
+      page: 1,
+      per: 1
+    },
+    selectionSet: "{ data { id type attributes } count currentPage totalPages }"
+  });
+}
+async function requestGraphqlHttp(params) {
+  const response = await fetch(params.url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${params.input.config.token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-Origin": "langgraph-cli",
+      "X-Request-Id": params.requestId,
+      ...params.input.config.agentName ? { "X-Agent-Name": params.input.config.agentName } : {},
+      ...params.input.config.agentRunId ? { "X-Agent-Run-Id": params.input.config.agentRunId } : {}
+    },
+    body: JSON.stringify(params.body),
+    signal: params.controller.signal
+  });
+  const responseRequestId = response.headers.get("x-request-id") ?? params.requestId;
+  const text = await response.text();
+  const payload = text ? parseJsonSafely(text) : null;
+  const graph = payload && typeof payload === "object" ? payload : {};
+  return {
+    status: response.status,
+    requestId: responseRequestId,
+    graph
+  };
+}
+async function findExistingFeedback(params) {
+  const command = `${params.input.command}.find-existing`;
+  const body = buildFeedbackFindRequestBody(command, params.identity);
+  const http = await requestGraphqlHttp({
+    input: params.input,
+    url: params.url,
+    requestId: params.requestId,
+    body,
+    controller: params.controller
+  });
+  const gqlErrors = http.graph.errors;
+  if (Array.isArray(gqlErrors) && gqlErrors.length > 0) {
+    return null;
+  }
+  const feedbackNode = extractFeedbackListNode(http.graph);
+  if (!feedbackNode) {
+    return null;
+  }
+  return {
+    feedbackNode,
+    requestId: http.requestId
+  };
+}
 function graphqlTypeForValue(value) {
   if (Array.isArray(value)) {
     const firstNonNull = value.find((item) => item !== null && item !== void 0);
@@ -252,9 +509,14 @@ function normalizeGraphqlVariables(variables) {
 function buildGraphqlBody(input) {
   const graphqlField = toCamelCase(input.field);
   const graphqlVariables = normalizeGraphqlVariables(input.variables);
-  const operationName = graphqlOperationName(input.command);
+  const graphqlVariableTypes = normalizeGraphqlVariables(input.variableTypes ?? {});
+  const operationName = input.operationName ?? graphqlOperationName(input.command);
   const variableEntries = Object.entries(graphqlVariables).filter(([, value]) => value !== void 0);
-  const variableDecl = variableEntries.map(([name, value]) => `$${name}: ${withNonNull(graphqlTypeForVariable(name, value))}`).join(", ");
+  const variableDecl = variableEntries.map(([name, value]) => {
+    const overriddenType = graphqlVariableTypes[name];
+    const typeName = typeof overriddenType === "string" && overriddenType.trim().length > 0 ? overriddenType.trim() : graphqlTypeForVariable(name, value);
+    return `$${name}: ${withNonNull(typeName)}`;
+  }).join(", ");
   const fieldArgs = variableEntries.map(([name]) => `${name}: $${name}`).join(", ");
   const signature = variableDecl.length > 0 ? `(${variableDecl})` : "";
   const args = fieldArgs.length > 0 ? `(${fieldArgs})` : "";
@@ -279,24 +541,37 @@ async function graphqlRequest(input) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), input.config.timeoutMs);
   try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${input.config.token}`,
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        "X-Origin": "langgraph-cli",
-        "X-Request-Id": requestId,
-        ...input.config.agentName ? { "X-Agent-Name": input.config.agentName } : {},
-        ...input.config.agentRunId ? { "X-Agent-Run-Id": input.config.agentRunId } : {}
-      },
-      body: JSON.stringify(body),
-      signal: controller.signal
+    if (isFeedbackCreateCommand(input)) {
+      const feedbackIdentity = extractFeedbackIdentity(input.variables);
+      if (feedbackIdentity) {
+        const existing = await findExistingFeedback({
+          input,
+          url,
+          requestId,
+          controller,
+          identity: feedbackIdentity
+        });
+        if (existing) {
+          return buildFeedbackReuseEnvelope({
+            command: input.command,
+            field: input.field,
+            status: 200,
+            requestId: existing.requestId,
+            feedbackNode: existing.feedbackNode,
+            reason: "preexisting"
+          });
+        }
+      }
+    }
+    const http = await requestGraphqlHttp({
+      input,
+      url,
+      requestId,
+      body,
+      controller
     });
-    const responseRequestId = response.headers.get("x-request-id") ?? requestId;
-    const text = await response.text();
-    const payload = text ? parseJsonSafely(text) : null;
-    const graph = payload && typeof payload === "object" ? payload : {};
+    const responseRequestId = http.requestId;
+    const graph = http.graph;
     const gqlErrors = graph.errors;
     const gqlData = graph.data && typeof graph.data === "object" ? graph.data : {};
     if (Array.isArray(gqlErrors) && gqlErrors.length > 0) {
@@ -319,6 +594,36 @@ async function graphqlRequest(input) {
       const ok = Boolean(mutationPayload.ok);
       const status = typeof mutationPayload.status === "number" ? mutationPayload.status : ok ? 200 : 400;
       if (!ok) {
+        if (isFeedbackCreateCommand(input) && isDuplicateFeedbackMutationError(mutationPayload)) {
+          const feedbackIdentity = extractFeedbackIdentity(input.variables);
+          if (feedbackIdentity) {
+            const existing = await findExistingFeedback({
+              input,
+              url,
+              requestId: responseRequestId,
+              controller,
+              identity: feedbackIdentity
+            });
+            if (existing) {
+              return buildFeedbackReuseEnvelope({
+                command: input.command,
+                field: input.field,
+                status: 200,
+                requestId: existing.requestId,
+                feedbackNode: existing.feedbackNode,
+                reason: "duplicate_race"
+              });
+            }
+          }
+        }
+        const mutationErrors = mutationPayload.errors ?? null;
+        const details = {
+          errors: mutationErrors,
+          data: mutationPayload.data ?? null
+        };
+        if (shouldAddSparse422Diagnostic(status, mutationPayload)) {
+          details.fallbackDiagnostic = buildSparse422Diagnostic(input);
+        }
         return {
           envelope: buildEnvelope({
             ok: false,
@@ -330,10 +635,7 @@ async function graphqlRequest(input) {
                 mutationPayload.errorCode ?? mutationPayload.error_code ?? `http_${status}`
               ),
               message: "Mutation failed.",
-              details: {
-                errors: mutationPayload.errors ?? null,
-                data: mutationPayload.data ?? null
-              }
+              details
             },
             requestId: responseRequestId
           }),
@@ -373,7 +675,7 @@ async function graphqlRequest(input) {
       envelope: buildEnvelope({
         ok: true,
         command: input.command,
-        status: response.ok ? response.status : 200,
+        status: http.status >= 200 && http.status < 300 ? http.status : 200,
         data: { [input.field]: fieldPayload ?? null },
         error: null,
         requestId: responseRequestId
@@ -490,12 +792,33 @@ async function runGraphqlQueryCommand(input) {
     const result = await graphqlRequest({
       config,
       command: input.command,
+      operationName: input.operationName,
       operationType: "query",
       field: input.field,
       variables: input.variables ?? {},
+      variableTypes: input.variableTypes,
       selectionSet: input.selectionSet ?? defaultQuerySelectionSet(input.field, Boolean(input.isList)),
       isShow: input.isShow
     });
+    if (result.envelope.ok && input.transformData && result.envelope.data) {
+      const dataRecord = result.envelope.data;
+      const transformed = input.transformData(dataRecord[input.field]);
+      result.envelope.data = {
+        ...dataRecord,
+        [input.field]: transformed
+      };
+      if (input.isShow && (transformed === null || transformed === void 0)) {
+        result.envelope.ok = false;
+        result.envelope.status = 404;
+        result.envelope.data = null;
+        result.envelope.error = {
+          code: "not_found",
+          message: "Record not found.",
+          details: {}
+        };
+        result.exitCode = EXIT_CODES.notFound;
+      }
+    }
     printEnvelopeAndExit(result);
   } catch (error) {
     if (error instanceof CliError) {
@@ -528,9 +851,11 @@ async function runGraphqlMutationCommand(input) {
     const result = await graphqlRequest({
       config,
       command: input.command,
+      operationName: input.operationName,
       operationType: "mutation",
       field: input.field,
       variables: input.variables ?? {},
+      variableTypes: input.variableTypes,
       selectionSet: input.selectionSet ?? "{ ok status errorCode data errors }"
     });
     printEnvelopeAndExit(result);
@@ -840,7 +1165,7 @@ var dtoHelpCatalog = {
     create: [
       ["member_id", "string"],
       ["name", "string"],
-      ["type", "MeetingType"],
+      ["type", "enum(TeamMeeting|OneOnOneMeeting)"],
       ["date", "string"],
       ["status", "enum(upcoming|active|completed)"],
       ["start_time", "number"],
@@ -1465,37 +1790,70 @@ function registerEntityCrudCommands(program, config) {
     const id = idSchema.parse(opts.id);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
+    const defaultCommand = `${config.command}.show`;
+    const defaultField = config.resourcePath === "feedback" ? "feedback" : toSingularResourceName(config.resourcePath);
+    const defaultVariables = normalizeGraphqlVariables2({
+      organization_id: organizationId,
+      id
+    });
+    const showQuery = config.showQueryFactory ? config.showQueryFactory({
+      command: defaultCommand,
+      field: defaultField,
+      variables: defaultVariables,
+      id,
+      organizationId
+    }) : void 0;
     await runGraphqlQueryCommand({
-      command: `${config.command}.show`,
+      command: showQuery?.command ?? defaultCommand,
       runtimeOptions: context.runtimeOptions,
-      field: config.resourcePath === "feedback" ? "feedback" : toSingularResourceName(config.resourcePath),
-      variables: normalizeGraphqlVariables2({
-        organization_id: organizationId,
-        id
-      }),
-      isShow: true
+      operationName: showQuery?.operationName,
+      field: showQuery?.field ?? defaultField,
+      variables: showQuery?.variables ?? defaultVariables,
+      variableTypes: showQuery?.variableTypes,
+      selectionSet: showQuery?.selectionSet,
+      isShow: true,
+      transformData: showQuery?.transformData
     });
   });
   entityCommand.command("create").requiredOption("--data-json <dataJson>", createHelp4).action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
-    const body = normalizeBody(String(opts.dataJson), config.rootKey);
+    let body = normalizeBody(String(opts.dataJson), config.rootKey);
+    if (config.normalizeCreateBody) {
+      body = config.normalizeCreateBody(body);
+    }
     assertRequiredCreateFields(body, config.rootKey, config.requiredCreateFields);
+    const defaultCommand = `${config.command}.create`;
+    const defaultField = `create_${toSingularResourceName(config.resourcePath)}`;
+    const defaultVariables = {
+      organization_id: organizationId,
+      params: body
+    };
+    const createMutation = config.createMutationFactory ? config.createMutationFactory({
+      command: defaultCommand,
+      field: defaultField,
+      variables: defaultVariables,
+      body,
+      organizationId
+    }) : void 0;
     await runGraphqlMutationCommand({
-      command: `${config.command}.create`,
+      command: createMutation?.command ?? defaultCommand,
       runtimeOptions: context.runtimeOptions,
-      field: `create_${toSingularResourceName(config.resourcePath)}`,
-      variables: {
-        organization_id: organizationId,
-        params: body
-      }
+      operationName: createMutation?.operationName,
+      field: createMutation?.field ?? defaultField,
+      variables: createMutation?.variables ?? defaultVariables,
+      variableTypes: createMutation?.variableTypes,
+      selectionSet: createMutation?.selectionSet
     });
   });
   entityCommand.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>", updateHelp5).action(async (opts, cmd) => {
     const id = idSchema.parse(opts.id);
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
-    const body = normalizeBody(String(opts.dataJson), config.rootKey);
+    let body = normalizeBody(String(opts.dataJson), config.rootKey);
+    if (config.normalizeUpdateBody) {
+      body = config.normalizeUpdateBody(body);
+    }
     const singular = toSingularResourceName(config.resourcePath);
     await runGraphqlMutationCommand({
       command: `${config.command}.update`,
@@ -1647,7 +2005,8 @@ function registerProjectCommands(program) {
         member_id: opts.memberId,
         ...extra
       }),
-      isList: true
+      isList: true,
+      selectionSet: "{ data { id type } count currentPage totalPages }"
     });
   });
   projects.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
@@ -1662,7 +2021,8 @@ function registerProjectCommands(program) {
         organization_id: organizationId,
         id
       },
-      isShow: true
+      isShow: true,
+      selectionSet: "{ id type }"
     });
   });
   projects.command("create").requiredOption("--data-json <dataJson>", projectCreateDataJsonHelp).action(async (opts, cmd) => {
@@ -1692,6 +2052,11 @@ function registerProjectCommands(program) {
         organization_id: organizationId,
         project_id: id,
         params: body
+      },
+      variableTypes: {
+        organization_id: "ID!",
+        project_id: "ID!",
+        params: "UpdateProjectParamsInput!"
       }
     });
   });
@@ -1804,8 +2169,142 @@ function registerRockCommands(program) {
 var import_zod6 = require("zod");
 var idSchema5 = import_zod6.z.string().min(1);
 var notesSchema = import_zod6.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"]);
 var createHelp2 = buildDataJsonHelp("meeting", "create") ?? 'JSON object for meeting or {"meeting": {...}}';
 var updateHelp2 = buildDataJsonHelp("meeting", "update") ?? 'JSON object for meeting or {"meeting": {...}}';
+function asNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function toFiniteNumber(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    const parsed = Number(trimmed);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  throw new CliError({
+    message: `Invalid ${field}. Expected a numeric value.`,
+    kind: "invalid_args",
+    status: 400,
+    exitCode: EXIT_CODES.invalidArgs
+  });
+}
+function toStringArray(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const items = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : null;
+  if (!items) {
+    throw new CliError({
+      message: `Invalid ${field}. Expected an array or comma-separated string.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const normalized = items.map((item) => String(item).trim()).filter((item) => item.length > 0);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeMeetingCreateBody(body) {
+  const entity = body.meeting;
+  if (!entity || typeof entity !== "object" || Array.isArray(entity)) {
+    throw new CliError({
+      message: 'Invalid payload. Expected object at "meeting".',
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const meeting = { ...entity };
+  const type = asNonEmptyString2(meeting.type);
+  if (!type || !MEETING_TYPES.has(type)) {
+    throw new CliError({
+      message: "Invalid meeting.type. Use one of: TeamMeeting, OneOnOneMeeting.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { field: "meeting.type", allowed: Array.from(MEETING_TYPES) }
+    });
+  }
+  const memberId = asNonEmptyString2(meeting.member_id);
+  const date = asNonEmptyString2(meeting.date);
+  const startTime = toFiniteNumber(meeting.start_time, "meeting.start_time");
+  const missingRequired = [];
+  if (!memberId) missingRequired.push("member_id");
+  if (!date) missingRequired.push("date");
+  if (startTime === void 0) missingRequired.push("start_time");
+  if (missingRequired.length > 0) {
+    throw new CliError({
+      message: `Missing required create fields for meeting: ${missingRequired.join(", ")}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["member_id", "date", "start_time"], rootKey: "meeting" }
+    });
+  }
+  const status = asNonEmptyString2(meeting.status);
+  if (status && !MEETING_STATUSES.has(status)) {
+    throw new CliError({
+      message: "Invalid meeting.status. Use one of: upcoming, active, completed.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { field: "meeting.status", allowed: Array.from(MEETING_STATUSES) }
+    });
+  }
+  const repeats = asNonEmptyString2(meeting.repeats) ?? "never";
+  if (!MEETING_REPEATS.has(repeats)) {
+    throw new CliError({
+      message: "Invalid meeting.repeats. Use one of: never, weekly, biweekly, monthly, quarterly.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { field: "meeting.repeats", allowed: Array.from(MEETING_REPEATS) }
+    });
+  }
+  const teamsIds = toStringArray(meeting.teams_ids, "meeting.teams_ids");
+  if (type === "TeamMeeting" && (!teamsIds || teamsIds.length === 0)) {
+    throw new CliError({
+      message: "Missing required create fields for meeting: teams_ids.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["teams_ids"], rootKey: "meeting" }
+    });
+  }
+  const endTime = toFiniteNumber(meeting.end_time, "meeting.end_time");
+  meeting.type = type;
+  meeting.member_id = memberId;
+  meeting.date = date;
+  meeting.start_time = startTime;
+  meeting.repeats = repeats;
+  if (status) {
+    meeting.status = status;
+  }
+  if (endTime !== void 0) {
+    meeting.end_time = endTime;
+  }
+  if (teamsIds) {
+    meeting.teams_ids = teamsIds;
+  }
+  return { ...body, meeting };
+}
 function registerMeetingCommands(program) {
   const meetings = program.command("meetings").description("Meeting operations");
   meetings.command("list").option("--per <per>").option("--date <date>").option("--occurrence-date <occurrenceDate>").option("--past <past>").option("--start-time <startTime>").option("--today-and-active <todayAndActive>").option("--upcoming <upcoming>").option("--query-json <queryJson>").action(async (opts, cmd) => {
@@ -1868,7 +2367,8 @@ function registerMeetingCommands(program) {
   meetings.command("create").requiredOption("--data-json <dataJson>", createHelp2).action(async (opts, cmd) => {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
-    const body = __testables.normalizeBody(String(opts.dataJson), "meeting");
+    const rawBody = __testables.normalizeBody(String(opts.dataJson), "meeting");
+    const body = normalizeMeetingCreateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "meetings.create",
       runtimeOptions: context.runtimeOptions,
@@ -1973,7 +2473,9 @@ var import_zod8 = require("zod");
 var issueGroupIdSchema = import_zod8.z.string().min(1);
 var idSchema7 = import_zod8.z.string().min(1);
 var nameSchema = import_zod8.z.string().min(1);
-var issueTypeSchema = import_zod8.z.string().min(1);
+var issueTypeSchema = import_zod8.z.string().min(1).refine((value) => value === "short_term" || value === "long_term", {
+  message: "Invalid issue type. Use one of: short_term, long_term."
+});
 var updateHelp4 = buildDataJsonHelp("issue", "update") ?? 'JSON object for issue or {"issue": {...}}';
 function registerIssueCommands(program) {
   const issues = program.command("issues").description("Issue operations");
@@ -2016,7 +2518,7 @@ function registerIssueCommands(program) {
       isShow: true
     });
   });
-  issues.command("create").requiredOption("--issue-group-id <issueGroupId>").requiredOption("--name <name>").requiredOption("--issue-type <issueType>").option("--status <status>").option("--priority <priority>").option("--description <description>").option("--due-by <dueBy>").option("--member-id <memberId>").action(async (opts, cmd) => {
+  issues.command("create").requiredOption("--issue-group-id <issueGroupId>").requiredOption("--name <name>").requiredOption("--issue-type <issueType>", "Issue type: short_term | long_term").option("--status <status>").option("--priority <priority>").option("--description <description>").option("--due-by <dueBy>").option("--member-id <memberId>").action(async (opts, cmd) => {
     const issueGroupId = issueGroupIdSchema.parse(opts.issueGroupId);
     const name = nameSchema.parse(opts.name);
     const issueType = issueTypeSchema.parse(opts.issueType);
@@ -2061,55 +2563,702 @@ function registerIssueCommands(program) {
   });
 }
 
+// src/commands/smartKpiNames.ts
+var SMART_KPI_NAMES = [
+  "total_active_users",
+  "total_new_users",
+  "total_return_users",
+  "total_engaged_sessions",
+  "total_sessions",
+  "engagement_rate",
+  "bounce_rate",
+  "page_call_phone_clicks_logged_in_unique",
+  "page_cta_clicks_logged_in_unique",
+  "page_engaged_users",
+  "page_fan_adds_unique",
+  "page_fan_adds",
+  "page_fan_removes",
+  "page_fans",
+  "page_get_directions_clicks_logged_in_unique",
+  "page_impressions_unique",
+  "page_impressions",
+  "page_negative_feedback",
+  "page_positive_feedback_comment",
+  "page_positive_feedback_like",
+  "page_positive_feedback_other",
+  "page_positive_feedback_share",
+  "page_post_engagements",
+  "page_total_actions",
+  "page_views_logged_in_unique",
+  "page_views_total",
+  "page_website_clicks_logged_in_unique",
+  "post_clicks_by_type_unique",
+  "post_engaged_users",
+  "post_impressions_fan_paid",
+  "post_impressions_fan",
+  "post_impressions_organic",
+  "post_impressions_unique",
+  "post_impressions",
+  "post_reactions_like_total",
+  "get_directions_clicks",
+  "phone_call_clicks",
+  "profile_views",
+  "reach",
+  "text_message_clicks",
+  "website_clicks",
+  "online_followers",
+  "total_interactions",
+  "accounts_engaged",
+  "likes",
+  "comments",
+  "saves",
+  "shares",
+  "replies",
+  "impressions",
+  "email_contacts",
+  "follower_count",
+  "total_new_conversations",
+  "total_unassigned_conversations",
+  "total_closed_conversations",
+  "total_new_contacts",
+  "total_contacts",
+  "total_revenue",
+  "total_expenses",
+  "cash_flow",
+  "paid_invoices",
+  "unpaid_invoices",
+  "total_new_payments",
+  "total_new_invoices",
+  "total_paid_invoices",
+  "total_refunds",
+  "total_disputes",
+  "calls",
+  "sms",
+  "mms",
+  "verify_push",
+  "verify_totp",
+  "recordings",
+  "transcriptions",
+  "programmable_voice",
+  "authy_phone_verifications",
+  "authy_authentications",
+  "twilio_errors",
+  "twilio_warnings",
+  "twilio_notices",
+  "total_subscribers",
+  "total_subscribers_gained",
+  "total_subscribers_lost",
+  "total_engagement",
+  "total_views",
+  "total_comments",
+  "total_likes",
+  "total_dislikes",
+  "total_shares",
+  "total_card_impressions",
+  "total_card_clicks",
+  "total_card_click_rate",
+  "rock_total_new_rock_groups",
+  "rock_total_rock_groups",
+  "rock_total_new_rocks",
+  "rock_total_new_milestones",
+  "rock_total_completed_milestones",
+  "rock_total_incomplete_milestones",
+  "project_total_projects",
+  "project_total_new_projects",
+  "project_total_new_tasks",
+  "project_total_completed_tasks",
+  "project_total_incomplete_tasks",
+  "project_total_new_sub_tasks",
+  "project_total_completed_sub_tasks",
+  "project_total_incomplete_sub_tasks",
+  "list_total_list",
+  "list_total_new_list",
+  "list_total_new_list_items",
+  "list_total_completed_list_items",
+  "list_total_incomplete_list_items",
+  "list_total_new_sub_items",
+  "list_total_completed_sub_items",
+  "list_total_incomplete_sub_items",
+  "issue_total_issue_groups",
+  "issue_total_new_issue_groups",
+  "issue_total_new_issues",
+  "issue_total_completed_issues",
+  "issue_total_incomplete_issues",
+  "issue_total_new_sub_issues",
+  "issue_total_completed_sub_issues",
+  "issue_total_incomplete_sub_issues",
+  "todo_total_todo_groups",
+  "todo_total_new_todo_groups",
+  "todo_total_new_todos",
+  "todo_total_completed_todos",
+  "todo_total_incomplete_todos",
+  "todo_total_new_sub_todos",
+  "todo_total_completed_sub_todos",
+  "todo_total_incomplete_sub_todos",
+  "measurable_total_scorecards",
+  "measurable_total_new_scorecards",
+  "measurable_total_new_measurables",
+  "stand_up_daily_stand_up_completion_rate",
+  "stand_up_total_stand_ups_complete",
+  "stand_up_daily_stand_up_block_rate",
+  "stand_up_total_blocked_stand_ups",
+  "headline_total_new_headlines",
+  "content_total_content",
+  "content_total_new_content",
+  "question_total_questions",
+  "question_total_new_questions",
+  "question_total_questions_answered",
+  "survey_new_surveys_sent",
+  "member_total_new_members",
+  "member_total_members",
+  "responsibility_total_new_responsibilities_added",
+  "responsibility_total_responsibilities",
+  "customer_total_customers",
+  "customer_total_new_customers",
+  "customer_total_new_customer_logs",
+  "contact_total_contacts",
+  "contact_total_new_contacts",
+  "contact_total_new_contact_logs"
+];
+var SMART_KPI_NAME_SET = new Set(SMART_KPI_NAMES);
+
 // src/commands/systemTools.ts
-function registerSystemToolCommands(program) {
-  registerEntityCrudCommands(program, {
-    command: "lists",
-    description: "List operations",
-    resourcePath: "lists",
-    rootKey: "list",
-    listParams: ["include_archived", "member_id", "team_ids", "term"]
-  });
-  registerEntityCrudCommands(program, {
-    command: "list-items",
-    description: "List item operations",
-    resourcePath: "list_items",
-    rootKey: "list_item",
-    requiredCreateFields: ["list_id"],
-    listParams: [
-      "field_blank",
-      "field_name",
-      "field_value",
-      "include_archived",
-      "list_id",
-      "meeting_id",
-      "member_id",
-      "rank_direction",
-      "team_id",
-      "team_ids"
-    ]
-  });
-  registerEntityCrudCommands(program, {
-    command: "issue-groups",
-    description: "Issue group operations",
-    resourcePath: "issue_groups",
-    rootKey: "issue_group",
-    listParams: ["include_archived", "member_id", "team_ids", "term"]
-  });
-  registerEntityCrudCommands(program, {
-    command: "todo-groups",
-    description: "To-do group operations",
-    resourcePath: "todo_groups",
-    rootKey: "todo_group",
-    listParams: ["include_archived", "member_id", "team_ids", "term"]
+var TODO_STATUSES = /* @__PURE__ */ new Set(["open", "completed"]);
+var KNOWLEDGE_CONTENT_TYPES = /* @__PURE__ */ new Set(["company", "policy", "process"]);
+var KNOWLEDGE_STATUSES = /* @__PURE__ */ new Set(["draft", "published"]);
+var NEWS_STATUSES = /* @__PURE__ */ new Set(["active", "completed"]);
+var NEWS_HEADLINE_TYPES = /* @__PURE__ */ new Set(["team", "org_wide"]);
+var QUESTION_STATUSES = /* @__PURE__ */ new Set(["asked", "answered"]);
+var PULSE_STATUSES = /* @__PURE__ */ new Set(["on_track", "at_risk", "off_track"]);
+var SURVEY_RECIPIENT_TYPES = /* @__PURE__ */ new Set(["member", "team", "org_wide"]);
+var SURVEY_NAMES = /* @__PURE__ */ new Set([
+  "employee_net_promoter_score",
+  "continuous_performance_review",
+  "core_value_alignment",
+  "engagement",
+  "wellness_and_mental_health",
+  "workspace_culture",
+  "peer_review",
+  "manager_review",
+  "onboarding"
+]);
+var FEEDBACK_QUARTERS = /* @__PURE__ */ new Set(["q1", "q2", "q3", "q4"]);
+var FEEDBACK_NAMES = /* @__PURE__ */ new Set([
+  "productivity_and_focus",
+  "company_collaboration",
+  "project_management",
+  "employee_engagement",
+  "training_and_development",
+  "innovation_and_creativity",
+  "customer_insights",
+  "process_improvement",
+  "leadership_and_management",
+  "company_culture",
+  "roadmap_and_strategy",
+  "customer_testing_and_feedback"
+]);
+var SCORECARD_INTERVALS = /* @__PURE__ */ new Set([
+  "daily",
+  "weekly",
+  "monthly",
+  "quarterly",
+  "yearly"
+]);
+var SCORECARD_TRENDS = /* @__PURE__ */ new Set(["average", "total"]);
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function ensureEntityObject(body, rootKey) {
+  const entity = body[rootKey];
+  if (!isRecord(entity)) {
+    throw new CliError({
+      message: `Invalid payload. Expected object at "${rootKey}".`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return { ...entity };
+}
+function throwMissingRequiredCreateFields(rootKey, fields) {
+  throw new CliError({
+    message: `Missing required create fields for ${rootKey}: ${fields.join(", ")}.`,
+    kind: "invalid_args",
+    status: 400,
+    exitCode: EXIT_CODES.invalidArgs,
+    details: { requiredFields: fields, rootKey }
   });
-  registerEntityCrudCommands(program, {
-    command: "todos",
-    description: "To-do operations",
-    resourcePath: "todos",
-    rootKey: "todo",
-    requiredCreateFields: ["todo_group_id"],
-    listParams: [
+}
+function normalizeTodosCreateBody(body) {
+  const todo = ensureEntityObject(body, "todo");
+  const rawStatus = todo.status;
+  if (rawStatus === void 0 || rawStatus === null || String(rawStatus).trim().length === 0) {
+    todo.status = "open";
+    return { ...body, todo };
+  }
+  if (typeof rawStatus !== "string" || !TODO_STATUSES.has(rawStatus)) {
+    throw new CliError({
+      message: "Invalid todo status. Use one of: open, completed.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { allowed: Array.from(TODO_STATUSES) }
+    });
+  }
+  return { ...body, todo };
+}
+function asNonEmptyString3(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function validateEnumField(params) {
+  const value = asNonEmptyString3(params.rawValue);
+  if (!value) {
+    return void 0;
+  }
+  if (!params.allowed.has(value)) {
+    throw new CliError({
+      message: params.message,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { field: params.field, allowed: Array.from(params.allowed) }
+    });
+  }
+  return value;
+}
+function normalizeKnowledgeCreateBody(body) {
+  const content = ensureEntityObject(body, "content");
+  const contentType = validateEnumField({
+    rawValue: content.content_type,
+    field: "content.content_type",
+    allowed: KNOWLEDGE_CONTENT_TYPES,
+    message: "Invalid content.content_type. Use one of: company, policy, process."
+  });
+  if (!contentType) {
+    throwMissingRequiredCreateFields("content", ["content_type"]);
+  }
+  content.content_type = contentType;
+  const status = validateEnumField({
+    rawValue: content.status,
+    field: "content.status",
+    allowed: KNOWLEDGE_STATUSES,
+    message: "Invalid content.status. Use one of: draft, published."
+  });
+  content.status = status ?? "draft";
+  const memberId = asNonEmptyString3(content.member_id);
+  if (!memberId) {
+    throwMissingRequiredCreateFields("content", ["member_id"]);
+  }
+  content.member_id = memberId;
+  return { ...body, content };
+}
+function normalizeNewsCreateBody(body) {
+  const headline = ensureEntityObject(body, "headline");
+  const memberId = asNonEmptyString3(headline.member_id);
+  if (!memberId) {
+    throwMissingRequiredCreateFields("headline", ["member_id"]);
+  }
+  headline.member_id = memberId;
+  const status = validateEnumField({
+    rawValue: headline.status,
+    field: "headline.status",
+    allowed: NEWS_STATUSES,
+    message: "Invalid headline.status. Use one of: active, completed."
+  });
+  if (!status) {
+    throwMissingRequiredCreateFields("headline", ["status"]);
+  }
+  headline.status = status;
+  const headlineType = validateEnumField({
+    rawValue: headline.headline_type,
+    field: "headline.headline_type",
+    allowed: NEWS_HEADLINE_TYPES,
+    message: "Invalid headline.headline_type. Use one of: team, org_wide."
+  });
+  if (!headlineType) {
+    throwMissingRequiredCreateFields("headline", ["headline_type"]);
+  }
+  headline.headline_type = headlineType;
+  return { ...body, headline };
+}
+function normalizeQuestionsCreateBody(body) {
+  const question = ensureEntityObject(body, "question");
+  const summary = asNonEmptyString3(question.summary);
+  const currentName = asNonEmptyString3(question.name);
+  if (!currentName && summary) {
+    question.name = summary;
+  }
+  delete question.summary;
+  const name = asNonEmptyString3(question.name);
+  const memberId = asNonEmptyString3(question.member_id);
+  const missing = [];
+  if (!name) missing.push("name");
+  if (!memberId) missing.push("member_id");
+  if (missing.length > 0) {
+    throwMissingRequiredCreateFields("question", missing);
+  }
+  question.name = name;
+  question.member_id = memberId;
+  const status = validateEnumField({
+    rawValue: question.status,
+    field: "question.status",
+    allowed: QUESTION_STATUSES,
+    message: "Invalid question.status. Use one of: asked, answered."
+  });
+  if (status) {
+    question.status = status;
+  }
+  return { ...body, question };
+}
+function normalizeQuestionsUpdateBody(body) {
+  const question = ensureEntityObject(body, "question");
+  const summary = asNonEmptyString3(question.summary);
+  const currentName = asNonEmptyString3(question.name);
+  if (!currentName && summary) {
+    question.name = summary;
+  }
+  delete question.summary;
+  const name = asNonEmptyString3(question.name);
+  if (name) {
+    question.name = name;
+  }
+  const status = validateEnumField({
+    rawValue: question.status,
+    field: "question.status",
+    allowed: QUESTION_STATUSES,
+    message: "Invalid question.status. Use one of: asked, answered."
+  });
+  if (status) {
+    question.status = status;
+  }
+  return { ...body, question };
+}
+function normalizePulseCreateBody(body) {
+  const healthUpdate = ensureEntityObject(body, "health_update");
+  const healthUpdatableId = asNonEmptyString3(healthUpdate.health_updatable_id) ?? asNonEmptyString3(healthUpdate.updatable_id);
+  const healthUpdatableType = asNonEmptyString3(healthUpdate.health_updatable_type) ?? asNonEmptyString3(healthUpdate.updatable_type);
+  const memberId = asNonEmptyString3(healthUpdate.member_id);
+  const status = validateEnumField({
+    rawValue: healthUpdate.status,
+    field: "health_update.status",
+    allowed: PULSE_STATUSES,
+    message: "Invalid health_update.status. Use one of: on_track, at_risk, off_track."
+  });
+  const missing = [];
+  if (!healthUpdatableId) missing.push("health_updatable_id");
+  if (!healthUpdatableType) missing.push("health_updatable_type");
+  if (!memberId) missing.push("member_id");
+  if (!status) missing.push("status");
+  if (missing.length > 0) {
+    throwMissingRequiredCreateFields("health_update", missing);
+  }
+  healthUpdate.health_updatable_id = healthUpdatableId;
+  healthUpdate.health_updatable_type = healthUpdatableType;
+  healthUpdate.member_id = memberId;
+  healthUpdate.status = status;
+  delete healthUpdate.updatable_id;
+  delete healthUpdate.updatable_type;
+  return { ...body, health_update: healthUpdate };
+}
+function normalizeSurveysCreateBody(body) {
+  const survey = ensureEntityObject(body, "survey");
+  const title = asNonEmptyString3(survey.title);
+  const currentName = asNonEmptyString3(survey.name);
+  if (!currentName && title) {
+    survey.name = title;
+  }
+  delete survey.title;
+  const name = validateEnumField({
+    rawValue: survey.name,
+    field: "survey.name",
+    allowed: SURVEY_NAMES,
+    message: "Invalid survey.name. Use one of: employee_net_promoter_score, continuous_performance_review, core_value_alignment, engagement, wellness_and_mental_health, workspace_culture, peer_review, manager_review, onboarding."
+  });
+  const recipientType = validateEnumField({
+    rawValue: survey.recipient_type,
+    field: "survey.recipient_type",
+    allowed: SURVEY_RECIPIENT_TYPES,
+    message: "Invalid survey.recipient_type. Use one of: member, team, org_wide."
+  });
+  const missing = [];
+  if (!name) missing.push("name");
+  if (!recipientType) missing.push("recipient_type");
+  if (missing.length > 0) {
+    throwMissingRequiredCreateFields("survey", missing);
+  }
+  survey.name = name;
+  survey.recipient_type = recipientType;
+  return { ...body, survey };
+}
+function normalizeSurveysUpdateBody(body) {
+  const survey = ensureEntityObject(body, "survey");
+  const title = asNonEmptyString3(survey.title);
+  const currentName = asNonEmptyString3(survey.name);
+  if (!currentName && title) {
+    survey.name = title;
+  }
+  delete survey.title;
+  const name = validateEnumField({
+    rawValue: survey.name,
+    field: "survey.name",
+    allowed: SURVEY_NAMES,
+    message: "Invalid survey.name. Use one of: employee_net_promoter_score, continuous_performance_review, core_value_alignment, engagement, wellness_and_mental_health, workspace_culture, peer_review, manager_review, onboarding."
+  });
+  if (name) {
+    survey.name = name;
+  }
+  const recipientType = validateEnumField({
+    rawValue: survey.recipient_type,
+    field: "survey.recipient_type",
+    allowed: SURVEY_RECIPIENT_TYPES,
+    message: "Invalid survey.recipient_type. Use one of: member, team, org_wide."
+  });
+  if (recipientType) {
+    survey.recipient_type = recipientType;
+  }
+  return { ...body, survey };
+}
+function normalizeFeedbacksCreateBody(body) {
+  const feedback = ensureEntityObject(body, "feedback");
+  const title = asNonEmptyString3(feedback.title);
+  const currentName = asNonEmptyString3(feedback.name);
+  if (!currentName && title) {
+    feedback.name = title;
+  }
+  delete feedback.title;
+  const name = validateEnumField({
+    rawValue: feedback.name,
+    field: "feedback.name",
+    allowed: FEEDBACK_NAMES,
+    message: "Invalid feedback.name. Use one of: productivity_and_focus, company_collaboration, project_management, employee_engagement, training_and_development, innovation_and_creativity, customer_insights, process_improvement, leadership_and_management, company_culture, roadmap_and_strategy, customer_testing_and_feedback."
+  });
+  const quarter = validateEnumField({
+    rawValue: feedback.quarter,
+    field: "feedback.quarter",
+    allowed: FEEDBACK_QUARTERS,
+    message: "Invalid feedback.quarter. Use one of: q1, q2, q3, q4."
+  });
+  const year = asNonEmptyString3(feedback.year);
+  const missing = [];
+  if (!name) missing.push("name");
+  if (!quarter) missing.push("quarter");
+  if (!year) missing.push("year");
+  if (missing.length > 0) {
+    throwMissingRequiredCreateFields("feedback", missing);
+  }
+  feedback.name = name;
+  feedback.quarter = quarter;
+  feedback.year = year;
+  return { ...body, feedback };
+}
+function normalizeFeedbacksUpdateBody(body) {
+  const feedback = ensureEntityObject(body, "feedback");
+  const title = asNonEmptyString3(feedback.title);
+  const currentName = asNonEmptyString3(feedback.name);
+  if (!currentName && title) {
+    feedback.name = title;
+  }
+  delete feedback.title;
+  const name = validateEnumField({
+    rawValue: feedback.name,
+    field: "feedback.name",
+    allowed: FEEDBACK_NAMES,
+    message: "Invalid feedback.name. Use one of: productivity_and_focus, company_collaboration, project_management, employee_engagement, training_and_development, innovation_and_creativity, customer_insights, process_improvement, leadership_and_management, company_culture, roadmap_and_strategy, customer_testing_and_feedback."
+  });
+  if (name) {
+    feedback.name = name;
+  }
+  const quarter = validateEnumField({
+    rawValue: feedback.quarter,
+    field: "feedback.quarter",
+    allowed: FEEDBACK_QUARTERS,
+    message: "Invalid feedback.quarter. Use one of: q1, q2, q3, q4."
+  });
+  if (quarter) {
+    feedback.quarter = quarter;
+  }
+  return { ...body, feedback };
+}
+function normalizeAccountabilityCreateBody(body) {
+  const responsibility = ensureEntityObject(body, "responsibility");
+  const summary = asNonEmptyString3(responsibility.summary);
+  const currentName = asNonEmptyString3(responsibility.name);
+  if (!currentName && summary) {
+    responsibility.name = summary;
+  }
+  delete responsibility.summary;
+  const name = asNonEmptyString3(responsibility.name);
+  const memberId = asNonEmptyString3(responsibility.member_id);
+  const missing = [];
+  if (!name) missing.push("name");
+  if (!memberId) missing.push("member_id");
+  if (missing.length > 0) {
+    throwMissingRequiredCreateFields("responsibility", missing);
+  }
+  responsibility.name = name;
+  responsibility.member_id = memberId;
+  return { ...body, responsibility };
+}
+function normalizeAccountabilityUpdateBody(body) {
+  const responsibility = ensureEntityObject(body, "responsibility");
+  const summary = asNonEmptyString3(responsibility.summary);
+  const currentName = asNonEmptyString3(responsibility.name);
+  if (!currentName && summary) {
+    responsibility.name = summary;
+  }
+  delete responsibility.summary;
+  return { ...body, responsibility };
+}
+function normalizeScorecardsCreateBody(body) {
+  const measurable = ensureEntityObject(body, "measurable");
+  const interval = validateEnumField({
+    rawValue: measurable.interval,
+    field: "measurable.interval",
+    allowed: SCORECARD_INTERVALS,
+    message: "Invalid measurable.interval. Use one of: daily, weekly, monthly, quarterly, yearly."
+  });
+  measurable.interval = interval ?? "weekly";
+  const trend = validateEnumField({
+    rawValue: measurable.trend,
+    field: "measurable.trend",
+    allowed: SCORECARD_TRENDS,
+    message: "Invalid measurable.trend. Use one of: average, total."
+  });
+  measurable.trend = trend ?? "average";
+  return { ...body, measurable };
+}
+function buildKpisCreateMutation(params) {
+  const entity = params.body.smart_kpi;
+  if (!entity || typeof entity !== "object" || Array.isArray(entity)) {
+    throw new CliError({
+      message: 'Invalid payload. Expected object at "smart_kpi".',
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const smartKpi = { ...entity };
+  const name = asNonEmptyString3(smartKpi.name);
+  const smartKpiViewId = asNonEmptyString3(smartKpi.smart_kpi_view_id);
+  const measurableGroupId = asNonEmptyString3(smartKpi.measurable_group_id);
+  const hasAllowedName = typeof name === "string" && SMART_KPI_NAME_SET.has(name);
+  if (!name) {
+    throw new CliError({
+      message: "Missing required create fields for smart_kpi: name.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["name"], rootKey: "smart_kpi" }
+    });
+  }
+  if (measurableGroupId && !hasAllowedName) {
+    const measurable = {
+      measurable_group_id: measurableGroupId,
+      name,
+      interval: "daily",
+      trend: "average",
+      measurable_type: "number",
+      condition: "greater_than_or_equal_to"
+    };
+    const notes = asNonEmptyString3(smartKpi.notes);
+    if (notes) {
+      measurable.notes = notes;
+    }
+    return {
+      command: "measurables.create",
+      field: "create_measurable",
+      variables: {
+        organization_id: params.organizationId,
+        params: { measurable }
+      }
+    };
+  }
+  if (!smartKpiViewId) {
+    throw new CliError({
+      message: "Missing required create fields for smart_kpi: smart_kpi_view_id.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["smart_kpi_view_id"], rootKey: "smart_kpi" }
+    });
+  }
+  if (!hasAllowedName) {
+    throw new CliError({
+      message: "Invalid smart_kpi.name for kpis.create. Use an allowed enum value or route free-text KPI names to measurable create.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: {
+        field: "smart_kpi.name",
+        allowedValues: SMART_KPI_NAMES
+      }
+    });
+  }
+  delete smartKpi.measurable_group_id;
+  smartKpi.name = name;
+  smartKpi.smart_kpi_view_id = smartKpiViewId;
+  return {
+    command: "kpis.create",
+    field: "create_smart_kpi",
+    variables: {
+      organization_id: params.organizationId,
+      params: { smart_kpi: smartKpi }
+    }
+  };
+}
+function registerSystemToolCommands(program) {
+  registerEntityCrudCommands(program, {
+    command: "lists",
+    description: "List operations",
+    resourcePath: "lists",
+    rootKey: "list",
+    listParams: ["include_archived", "member_id", "team_ids", "term"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "list-items",
+    description: "List item operations",
+    resourcePath: "list_items",
+    rootKey: "list_item",
+    requiredCreateFields: ["list_id"],
+    listParams: [
+      "field_blank",
+      "field_name",
+      "field_value",
+      "include_archived",
+      "list_id",
+      "meeting_id",
+      "member_id",
+      "rank_direction",
+      "team_id",
+      "team_ids"
+    ]
+  });
+  registerEntityCrudCommands(program, {
+    command: "issue-groups",
+    description: "Issue group operations",
+    resourcePath: "issue_groups",
+    rootKey: "issue_group",
+    listParams: ["include_archived", "member_id", "team_ids", "term"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "todo-groups",
+    description: "To-do group operations",
+    resourcePath: "todo_groups",
+    rootKey: "todo_group",
+    listParams: ["include_archived", "member_id", "team_ids", "term"]
+  });
+  registerEntityCrudCommands(program, {
+    command: "todos",
+    description: "To-do operations",
+    resourcePath: "todos",
+    rootKey: "todo",
+    requiredCreateFields: ["todo_group_id"],
+    normalizeCreateBody: normalizeTodosCreateBody,
+    listParams: [
       "include_archived",
       "meeting_id",
       "member_id",
@@ -2131,6 +3280,7 @@ function registerSystemToolCommands(program) {
     description: "Knowledge content operations",
     resourcePath: "contents",
     rootKey: "content",
+    normalizeCreateBody: normalizeKnowledgeCreateBody,
     listParams: [
       "assigned",
       "contentable_id",
@@ -2161,13 +3311,40 @@ function registerSystemToolCommands(program) {
     description: "News operations",
     resourcePath: "headlines",
     rootKey: "headline",
-    listParams: ["meeting_id", "unread"]
+    requiredCreateFields: ["member_id", "status", "headline_type"],
+    normalizeCreateBody: normalizeNewsCreateBody,
+    listParams: ["meeting_id", "unread"],
+    showQueryFactory: ({ id, organizationId }) => ({
+      field: "headlines",
+      variables: {
+        organization_id: organizationId,
+        page: 1,
+        per: 200
+      },
+      selectionSet: "{ data { id type attributes } count currentPage totalPages }",
+      transformData: (value) => {
+        if (!value || typeof value !== "object") {
+          return null;
+        }
+        const payload = value;
+        const rows = Array.isArray(payload.data) ? payload.data : [];
+        return rows.find((row) => {
+          if (!row || typeof row !== "object") {
+            return false;
+          }
+          return String(row.id ?? "") === id;
+        }) ?? null;
+      }
+    })
   });
   registerEntityCrudCommands(program, {
     command: "questions",
     description: "Q&A forum operations",
     resourcePath: "questions",
     rootKey: "question",
+    requiredCreateFields: ["member_id", "name"],
+    normalizeCreateBody: normalizeQuestionsCreateBody,
+    normalizeUpdateBody: normalizeQuestionsUpdateBody,
     listParams: ["answered", "asked", "member_id", "team_id", "term"]
   });
   registerEntityCrudCommands(program, {
@@ -2175,6 +3352,8 @@ function registerSystemToolCommands(program) {
     description: "Pulse operations",
     resourcePath: "health_updates",
     rootKey: "health_update",
+    requiredCreateFields: ["health_updatable_id", "health_updatable_type", "member_id", "status"],
+    normalizeCreateBody: normalizePulseCreateBody,
     listParams: ["health_updatable_id", "health_updatable_type"]
   });
   registerEntityCrudCommands(program, {
@@ -2182,6 +3361,9 @@ function registerSystemToolCommands(program) {
     description: "Survey operations",
     resourcePath: "surveys",
     rootKey: "survey",
+    requiredCreateFields: ["name", "recipient_type"],
+    normalizeCreateBody: normalizeSurveysCreateBody,
+    normalizeUpdateBody: normalizeSurveysUpdateBody,
     listParams: ["completed", "current_member", "due", "exclude_completed"]
   });
   registerEntityCrudCommands(program, {
@@ -2189,6 +3371,9 @@ function registerSystemToolCommands(program) {
     description: "Feedback operations",
     resourcePath: "feedback",
     rootKey: "feedback",
+    requiredCreateFields: ["name", "quarter", "year"],
+    normalizeCreateBody: normalizeFeedbacksCreateBody,
+    normalizeUpdateBody: normalizeFeedbacksUpdateBody,
     listParams: ["last", "latest", "start_date"]
   });
   registerEntityCrudCommands(program, {
@@ -2196,6 +3381,9 @@ function registerSystemToolCommands(program) {
     description: "Accountability operations",
     resourcePath: "responsibilities",
     rootKey: "responsibility",
+    requiredCreateFields: ["name", "member_id"],
+    normalizeCreateBody: normalizeAccountabilityCreateBody,
+    normalizeUpdateBody: normalizeAccountabilityUpdateBody,
     listParams: ["meeting_id", "term"]
   });
   registerEntityCrudCommands(program, {
@@ -2203,6 +3391,10 @@ function registerSystemToolCommands(program) {
     description: "KPI operations",
     resourcePath: "smart_kpis",
     rootKey: "smart_kpi",
+    createMutationFactory: ({ body, organizationId }) => buildKpisCreateMutation({
+      body,
+      organizationId
+    }),
     listParams: [
       "annual_objective_id",
       "include_archived",
@@ -2228,6 +3420,7 @@ function registerSystemToolCommands(program) {
     resourcePath: "measurables",
     rootKey: "measurable",
     requiredCreateFields: ["measurable_group_id"],
+    normalizeCreateBody: normalizeScorecardsCreateBody,
     listParams: [
       "annual_objective_id",
       "include_archived",
@@ -2329,6 +3522,103 @@ function registerTeamCommands(program) {
 // src/commands/organizations.ts
 var import_zod10 = require("zod");
 var idSchema9 = import_zod10.z.string().min(1);
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function ensureRootObject(body, rootKey) {
+  const root = body[rootKey];
+  if (!isRecord2(root)) {
+    throw new CliError({
+      message: `Invalid payload. Expected object at "${rootKey}".`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return { ...root };
+}
+function asNonEmptyString4(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeOrganizationUpdateBody(body) {
+  const organization = ensureRootObject(body, "organization");
+  const detail = isRecord2(organization.organization_detail_attributes) ? { ...organization.organization_detail_attributes } : {};
+  const workspaceName = asNonEmptyString4(organization.workspace_name);
+  if (workspaceName) {
+    detail.workspace_name = workspaceName;
+  }
+  delete organization.workspace_name;
+  if (Object.keys(detail).length > 0) {
+    organization.organization_detail_attributes = detail;
+  }
+  return { organization };
+}
+function normalizeOrganizationMetaProfileUpdateBody(body) {
+  const root = ensureRootObject(body, "organization_meta_profile");
+  const profile = isRecord2(root.profile) ? { ...root.profile } : {};
+  const title = asNonEmptyString4(root.title);
+  if (title) {
+    const companyIdentity = isRecord2(profile.company_identity) ? { ...profile.company_identity } : {};
+    companyIdentity.one_sentence_summary = title;
+    profile.company_identity = companyIdentity;
+  }
+  const unsupported = Object.keys(root).filter((key) => key !== "profile" && key !== "title");
+  if (unsupported.length > 0) {
+    throw new CliError({
+      message: "Invalid organization_meta_profile update payload. Use organization_meta_profile.profile.<section>.<field>.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { unsupportedKeys: unsupported, expectedRootKey: "profile" }
+    });
+  }
+  if (Object.keys(profile).length === 0) {
+    throw new CliError({
+      message: "Missing required update fields for organization_meta_profile: profile.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["profile"], rootKey: "organization_meta_profile" }
+    });
+  }
+  return { organization_meta_profile: { profile } };
+}
+function normalizeKeyMetricMetaProfileUpdateBody(body) {
+  const root = ensureRootObject(body, "key_metric_meta_profile");
+  const profile = isRecord2(root.profile) ? { ...root.profile } : {};
+  const annualRevenue = asNonEmptyString4(root.annual_revenue);
+  if (annualRevenue) {
+    const financial = isRecord2(profile.financial) ? { ...profile.financial } : {};
+    financial.revenue = annualRevenue;
+    profile.financial = financial;
+  }
+  const unsupported = Object.keys(root).filter(
+    (key) => key !== "profile" && key !== "annual_revenue"
+  );
+  if (unsupported.length > 0) {
+    throw new CliError({
+      message: "Invalid key_metric_meta_profile update payload. Use key_metric_meta_profile.profile.<section>.<field>.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { unsupportedKeys: unsupported, expectedRootKey: "profile" }
+    });
+  }
+  if (Object.keys(profile).length === 0) {
+    throw new CliError({
+      message: "Missing required update fields for key_metric_meta_profile: profile.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { requiredFields: ["profile"], rootKey: "key_metric_meta_profile" }
+    });
+  }
+  return { key_metric_meta_profile: { profile } };
+}
 function registerOrganizationCommands(program) {
   const organizations = program.command("organizations").description("Organization operations");
   organizations.command("show").option("--id <id>", "Organization ID (defaults to resolved organization context)").action(async (opts, cmd) => {
@@ -2350,7 +3640,8 @@ function registerOrganizationCommands(program) {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const fallbackId = resolveOrganizationId(context.organizationId);
     const id = idSchema9.parse(opts.id ?? fallbackId);
-    const body = __testables.normalizeBody(String(opts.dataJson), "organization");
+    const rawBody = __testables.normalizeBody(String(opts.dataJson), "organization");
+    const body = normalizeOrganizationUpdateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "organizations.update",
       runtimeOptions: context.runtimeOptions,
@@ -2384,10 +3675,11 @@ function registerOrganizationCommands(program) {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const id = idSchema9.parse(opts.id ?? organizationId);
-    const body = __testables.normalizeBody(
+    const rawBody = __testables.normalizeBody(
       String(opts.dataJson),
       "organization_meta_profile"
     );
+    const body = normalizeOrganizationMetaProfileUpdateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "organizations.meta-profile.update",
       runtimeOptions: context.runtimeOptions,
@@ -2422,10 +3714,11 @@ function registerOrganizationCommands(program) {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const id = idSchema9.parse(opts.id ?? organizationId);
-    const body = __testables.normalizeBody(
+    const rawBody = __testables.normalizeBody(
       String(opts.dataJson),
       "key_metric_meta_profile"
     );
+    const body = normalizeKeyMetricMetaProfileUpdateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "organizations.key-metric-meta-profile.update",
       runtimeOptions: context.runtimeOptions,
@@ -2442,36 +3735,131 @@ function registerOrganizationCommands(program) {
 // src/commands/foundation.ts
 var import_zod11 = require("zod");
 var idSchema10 = import_zod11.z.string().min(1);
-function registerFoundationCommands(program) {
-  const foundation = program.command("foundation").description("Foundation operations");
-  const strategicPlans = foundation.command("strategic-plans").description("Strategic plan operations");
-  const strategicObjectives = foundation.command("strategic-objectives").description("Strategic objective operations");
-  strategicPlans.command("show").option("--id <id>", "Strategic plan ID (defaults to organization context)").option("--progress-scope <progressScope>").option("--all-progress <allProgress>").option("--all <all>").action(async (opts, cmd) => {
-    const context = await resolveCommandContext(cmd.optsWithGlobals());
-    const organizationId = resolveOrganizationId(context.organizationId);
-    const id = idSchema10.parse(opts.id ?? organizationId);
-    await runGraphqlQueryCommand({
-      command: "foundation.strategic-plans.show",
-      runtimeOptions: context.runtimeOptions,
-      field: "strategic_plan",
-      variables: normalizeGraphqlVariables2({
-        organization_id: organizationId,
-        id,
-        progress_scope: opts.progressScope,
-        all_progress: opts.allProgress,
-        all: opts.all
-      }),
-      isShow: true
+var STRATEGIC_PLAN_ALLOWED_UPDATE_KEYS = /* @__PURE__ */ new Set([
+  "published_at",
+  "profile",
+  "strategic_plan_reads_attributes"
+]);
+var STRATEGIC_OBJECTIVE_ALLOWED_UPDATE_KEYS = /* @__PURE__ */ new Set([
+  "summary",
+  "alignment_score",
+  "published_at",
+  "strategic_objective_reads_attributes"
+]);
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function ensureRootObject2(body, rootKey) {
+  const root = body[rootKey];
+  if (!isRecord3(root)) {
+    throw new CliError({
+      message: `Invalid payload. Expected object at "${rootKey}".`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
     });
-  });
-  strategicPlans.command("update").option("--id <id>", "Strategic plan ID (defaults to organization context)").requiredOption(
-    "--data-json <dataJson>",
-    'JSON object for strategic_plan or {"strategic_plan": {...}}'
-  ).action(async (opts, cmd) => {
-    const context = await resolveCommandContext(cmd.optsWithGlobals());
+  }
+  return { ...root };
+}
+function asNonEmptyString5(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeStrategicPlanUpdateBody(body) {
+  const strategicPlan = ensureRootObject2(body, "strategic_plan");
+  const unsupported = Object.keys(strategicPlan).filter(
+    (key) => !STRATEGIC_PLAN_ALLOWED_UPDATE_KEYS.has(key)
+  );
+  if (unsupported.length > 0) {
+    throw new CliError({
+      message: "Invalid strategic_plan update payload. Allowed keys: published_at, profile, strategic_plan_reads_attributes.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: {
+        unsupportedKeys: unsupported,
+        allowedKeys: Array.from(STRATEGIC_PLAN_ALLOWED_UPDATE_KEYS)
+      }
+    });
+  }
+  return { strategic_plan: strategicPlan };
+}
+function normalizeStrategicObjectiveUpdateBody(body) {
+  const strategicObjective = ensureRootObject2(body, "strategic_objective");
+  const title = asNonEmptyString5(strategicObjective.title);
+  if (!asNonEmptyString5(strategicObjective.summary) && title) {
+    strategicObjective.summary = title;
+  }
+  delete strategicObjective.title;
+  const unsupported = Object.keys(strategicObjective).filter(
+    (key) => !STRATEGIC_OBJECTIVE_ALLOWED_UPDATE_KEYS.has(key)
+  );
+  if (unsupported.length > 0) {
+    throw new CliError({
+      message: "Invalid strategic_objective update payload. Allowed keys: summary, alignment_score, published_at, strategic_objective_reads_attributes.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: {
+        unsupportedKeys: unsupported,
+        allowedKeys: Array.from(STRATEGIC_OBJECTIVE_ALLOWED_UPDATE_KEYS)
+      }
+    });
+  }
+  return { strategic_objective: strategicObjective };
+}
+function normalizeAnnualObjectiveCreateBody(body) {
+  const annualObjective = ensureRootObject2(body, "annual_objective");
+  const title = asNonEmptyString5(annualObjective.title);
+  if (!asNonEmptyString5(annualObjective.name) && title) {
+    annualObjective.name = title;
+  }
+  delete annualObjective.title;
+  return { annual_objective: annualObjective };
+}
+function normalizeQuarterlyObjectiveCreateBody(body) {
+  const quarterlyObjective = ensureRootObject2(body, "quarterly_objective");
+  const title = asNonEmptyString5(quarterlyObjective.title);
+  if (!asNonEmptyString5(quarterlyObjective.name) && title) {
+    quarterlyObjective.name = title;
+  }
+  delete quarterlyObjective.title;
+  return { quarterly_objective: quarterlyObjective };
+}
+function registerFoundationCommands(program) {
+  const foundation = program.command("foundation").description("Foundation operations");
+  const strategicPlans = foundation.command("strategic-plans").description("Strategic plan operations");
+  const strategicObjectives = foundation.command("strategic-objectives").description("Strategic objective operations");
+  strategicPlans.command("show").option("--id <id>", "Strategic plan ID (defaults to organization context)").option("--progress-scope <progressScope>").option("--all-progress <allProgress>").option("--all <all>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const id = idSchema10.parse(opts.id ?? organizationId);
+    await runGraphqlQueryCommand({
+      command: "foundation.strategic-plans.show",
+      runtimeOptions: context.runtimeOptions,
+      field: "strategic_plan",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        id,
+        progress_scope: opts.progressScope,
+        all_progress: opts.allProgress,
+        all: opts.all
+      }),
+      isShow: true
+    });
+  });
+  strategicPlans.command("update").option("--id <id>", "Strategic plan ID (defaults to organization context)").requiredOption(
+    "--data-json <dataJson>",
+    'JSON object for strategic_plan or {"strategic_plan": {...}}'
+  ).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const id = idSchema10.parse(opts.id ?? organizationId);
-    const body = __testables.normalizeBody(String(opts.dataJson), "strategic_plan");
+    const rawBody = __testables.normalizeBody(String(opts.dataJson), "strategic_plan");
+    const body = normalizeStrategicPlanUpdateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "foundation.strategic-plans.update",
       runtimeOptions: context.runtimeOptions,
@@ -2508,10 +3896,11 @@ function registerFoundationCommands(program) {
     const context = await resolveCommandContext(cmd.optsWithGlobals());
     const organizationId = resolveOrganizationId(context.organizationId);
     const id = idSchema10.parse(opts.id ?? organizationId);
-    const body = __testables.normalizeBody(
+    const rawBody = __testables.normalizeBody(
       String(opts.dataJson),
       "strategic_objective"
     );
+    const body = normalizeStrategicObjectiveUpdateBody(rawBody);
     await runGraphqlMutationCommand({
       command: "foundation.strategic-objectives.update",
       runtimeOptions: context.runtimeOptions,
@@ -2528,7 +3917,8 @@ function registerFoundationCommands(program) {
     description: "Foundation annual objective operations",
     resourcePath: "annual_objectives",
     rootKey: "annual_objective",
-    requiredCreateFields: ["strategic_objective_id"],
+    requiredCreateFields: ["strategic_objective_id", "name"],
+    normalizeCreateBody: normalizeAnnualObjectiveCreateBody,
     listParams: []
   });
   registerEntityCrudCommands(foundation, {
@@ -2536,13 +3926,1478 @@ function registerFoundationCommands(program) {
     description: "Foundation quarterly objective operations",
     resourcePath: "quarterly_objectives",
     rootKey: "quarterly_objective",
-    requiredCreateFields: ["strategic_objective_id", "annual_objective_id"],
+    requiredCreateFields: ["strategic_objective_id", "annual_objective_id", "name"],
+    normalizeCreateBody: normalizeQuarterlyObjectiveCreateBody,
     listParams: ["annual_objective_id"]
   });
 }
 
+// src/commands/childEntities.ts
+var import_zod12 = require("zod");
+var idSchema11 = import_zod12.z.string().min(1);
+var jsonObjectSchema = import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown());
+function parseJsonObject2(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return jsonObjectSchema.parse(parsed);
+  } catch (error) {
+    throw new CliError({
+      message: error instanceof Error ? `Invalid --data-json: ${error.message}` : "Invalid --data-json.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+}
+function normalizeBody2(raw, rootKey) {
+  const payload = parseJsonObject2(raw);
+  const rooted = payload[rootKey];
+  if (rooted && typeof rooted === "object" && !Array.isArray(rooted)) {
+    return payload;
+  }
+  return { [rootKey]: payload };
+}
+function assertRequiredParent(body, rootKey, parentKey) {
+  const entity = body[rootKey];
+  if (!entity || typeof entity !== "object" || Array.isArray(entity)) {
+    throw new CliError({
+      message: `Invalid payload. Expected object at "${rootKey}".`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const value = entity[parentKey];
+  if (!(typeof value === "string" && value.trim().length > 0)) {
+    throw new CliError({
+      message: `Missing required create field for ${rootKey}: ${parentKey}.`,
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+}
+function attrValue(attrs, keys) {
+  if (!attrs || typeof attrs !== "object" || Array.isArray(attrs)) {
+    return void 0;
+  }
+  const record = attrs;
+  for (const key of keys) {
+    if (record[key] !== void 0 && record[key] !== null && `${record[key]}`.trim() !== "") {
+      return record[key];
+    }
+  }
+  return void 0;
+}
+function normalizePlacementRow(row, parentKind, parentIdFallback, parentTypedField) {
+  const typedParent = parentTypedField ? row[parentTypedField] : void 0;
+  const parentId = (typeof typedParent === "string" && typedParent.trim().length > 0 ? typedParent : void 0) ?? parentIdFallback ?? null;
+  const attrs = row.attributes;
+  const memberId = (typeof row.memberId === "string" ? row.memberId : void 0) ?? attrValue(attrs, ["memberId", "member_id"]) ?? null;
+  const creatorId = (typeof row.creatorId === "string" ? row.creatorId : void 0) ?? attrValue(attrs, ["creatorId", "creator_id"]) ?? null;
+  const ownerRaw = attrValue(attrs, ["memberId", "member_id", "creatorId", "creator_id"]) ?? null;
+  const description = (typeof row.description === "string" && row.description.length > 0 ? row.description : attrValue(attrs, ["description"])) ?? null;
+  return {
+    id: row.id ?? null,
+    type: row.type ?? null,
+    parent: {
+      kind: parentKind,
+      id: parentId
+    },
+    owner: {
+      memberId,
+      creatorId,
+      raw: ownerRaw
+    },
+    description,
+    attributes: attrs ?? {}
+  };
+}
+function normalizeListPayload(payload, parentKind, parentIdFallback, parentTypedField) {
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const rows = Array.isArray(record.data) ? record.data : [];
+  const normalizedRows = rows.map(
+    (row) => normalizePlacementRow(
+      row,
+      parentKind,
+      parentIdFallback,
+      parentTypedField
+    )
+  );
+  return {
+    data: normalizedRows,
+    count: record.count ?? normalizedRows.length,
+    currentPage: record.currentPage ?? 1,
+    totalPages: record.totalPages ?? 1
+  };
+}
+function normalizeSubtaskCreateBody(body) {
+  const subtask = body.subtask;
+  if (!subtask || typeof subtask !== "object" || Array.isArray(subtask)) {
+    return body;
+  }
+  const subtaskRecord = subtask;
+  const summary = typeof subtaskRecord.summary === "string" ? subtaskRecord.summary.trim() : void 0;
+  const hasName = typeof subtaskRecord.name === "string" && subtaskRecord.name.trim().length > 0;
+  if (!hasName && summary && summary.length > 0) {
+    subtaskRecord.name = summary;
+  }
+  delete subtaskRecord.summary;
+  return 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 context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const parentId = idSchema11.parse(opts[config.parentFlag.replace(/-([a-z])/g, (_, c) => c.toUpperCase())]);
+    await runGraphqlQueryCommand({
+      command: `${config.command}.list`,
+      operationName: config.listOperationName,
+      runtimeOptions: context.runtimeOptions,
+      field: config.listField,
+      variables: {
+        organization_id: organizationId,
+        [config.parentFlag.replace(/-/g, "_")]: parentId,
+        page: opts.page,
+        per: opts.per
+      },
+      isList: true,
+      selectionSet: config.listSelectionSet,
+      transformData: (payload) => normalizeListPayload(
+        payload,
+        config.parentKind,
+        parentId,
+        config.listParentTypedField
+      )
+    });
+  });
+  command.command("create").requiredOption("--data-json <dataJson>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    let body = normalizeBody2(String(opts.dataJson), config.rootKey);
+    if (config.normalizeCreateBody) {
+      body = config.normalizeCreateBody(body);
+    }
+    assertRequiredParent(body, config.rootKey, config.parentFlag.replace(/-/g, "_"));
+    await runGraphqlMutationCommand({
+      command: `${config.command}.create`,
+      operationName: config.createOperationName,
+      runtimeOptions: context.runtimeOptions,
+      field: config.createField,
+      variables: {
+        organization_id: organizationId,
+        params: body
+      }
+    });
+  });
+  command.command("update").requiredOption("--id <id>").requiredOption("--data-json <dataJson>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const id = idSchema11.parse(opts.id);
+    const body = normalizeBody2(String(opts.dataJson), config.rootKey);
+    await runGraphqlMutationCommand({
+      command: `${config.command}.update`,
+      operationName: config.updateOperationName,
+      runtimeOptions: context.runtimeOptions,
+      field: config.updateField,
+      variables: {
+        organization_id: organizationId,
+        [config.idVariable]: id,
+        params: body
+      }
+    });
+  });
+  command.command("destroy").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const id = idSchema11.parse(opts.id);
+    await runGraphqlMutationCommand({
+      command: `${config.command}.destroy`,
+      operationName: config.destroyOperationName,
+      runtimeOptions: context.runtimeOptions,
+      field: config.destroyField,
+      variables: {
+        organization_id: organizationId,
+        [config.idVariable]: id
+      }
+    });
+  });
+}
+function registerChildEntityCommands(program) {
+  registerChildCommands(program, {
+    command: "subtasks",
+    description: "Subtask operations",
+    parentFlag: "task-id",
+    parentKind: "task",
+    rootKey: "subtask",
+    listField: "subtasks",
+    createField: "create_subtask",
+    updateField: "update_subtask",
+    destroyField: "destroy_subtask",
+    idVariable: "subtask_id",
+    listOperationName: "SubtasksForTask",
+    createOperationName: "CreateSubtask",
+    updateOperationName: "UpdateSubtask",
+    destroyOperationName: "DestroySubtask",
+    listSelectionSet: "{ data { id type name status taskId attributes } count currentPage totalPages }",
+    listParentTypedField: "taskId",
+    normalizeCreateBody: normalizeSubtaskCreateBody
+  });
+  registerChildCommands(program, {
+    command: "milestones",
+    description: "Milestone operations",
+    parentFlag: "rock-id",
+    parentKind: "rock",
+    rootKey: "milestone",
+    listField: "milestones",
+    createField: "create_milestone",
+    updateField: "update_milestone",
+    destroyField: "destroy_milestone",
+    idVariable: "milestone_id",
+    listOperationName: "MilestonesForRock",
+    createOperationName: "CreateMilestone",
+    updateOperationName: "UpdateMilestone",
+    destroyOperationName: "DestroyMilestone",
+    listSelectionSet: "{ data { id type name slug status attributes } count currentPage totalPages }"
+  });
+  registerChildCommands(program, {
+    command: "subitems",
+    description: "Subitem operations",
+    parentFlag: "list-item-id",
+    parentKind: "listItem",
+    rootKey: "subitem",
+    listField: "subitems",
+    createField: "create_subitem",
+    updateField: "update_subitem",
+    destroyField: "destroy_subitem",
+    idVariable: "subitem_id",
+    listOperationName: "SubitemsForListItem",
+    createOperationName: "CreateSubitem",
+    updateOperationName: "UpdateSubitem",
+    destroyOperationName: "DestroySubitem",
+    listSelectionSet: "{ data { id type name status listItemId attributes } count currentPage totalPages }",
+    listParentTypedField: "listItemId"
+  });
+  registerChildCommands(program, {
+    command: "subtodos",
+    description: "Subtodo operations",
+    parentFlag: "todo-id",
+    parentKind: "todo",
+    rootKey: "sub_todo",
+    listField: "sub_todos",
+    createField: "create_sub_todo",
+    updateField: "update_sub_todo",
+    destroyField: "destroy_sub_todo",
+    idVariable: "sub_todo_id",
+    listOperationName: "SubtodosForTodo",
+    createOperationName: "CreateSubTodo",
+    updateOperationName: "UpdateSubTodo",
+    destroyOperationName: "DestroySubTodo",
+    listSelectionSet: "{ data { id type name status todoId attributes } count currentPage totalPages }",
+    listParentTypedField: "todoId"
+  });
+  registerChildCommands(program, {
+    command: "subissues",
+    description: "Subissue operations",
+    parentFlag: "issue-id",
+    parentKind: "issue",
+    rootKey: "sub_issue",
+    listField: "sub_issues",
+    createField: "create_sub_issue",
+    updateField: "update_sub_issue",
+    destroyField: "destroy_sub_issue",
+    idVariable: "sub_issue_id",
+    listOperationName: "SubissuesForIssue",
+    createOperationName: "CreateSubIssue",
+    updateOperationName: "UpdateSubIssue",
+    destroyOperationName: "DestroySubIssue",
+    listSelectionSet: "{ data { id type name status issueId attributes } count currentPage totalPages }",
+    listParentTypedField: "issueId"
+  });
+  registerChildCommands(program, {
+    command: "talking-points",
+    description: "Talking point operations",
+    parentFlag: "meeting-id",
+    parentKind: "meeting",
+    rootKey: "talking_point",
+    listField: "talking_points",
+    createField: "create_talking_point",
+    updateField: "update_talking_point",
+    destroyField: "destroy_talking_point",
+    idVariable: "talking_point_id",
+    listOperationName: "TalkingPointsForMeeting",
+    createOperationName: "CreateTalkingPoint",
+    updateOperationName: "UpdateTalkingPoint",
+    destroyOperationName: "DestroyTalkingPoint",
+    listSelectionSet: "{ data { id type name description status priority rank dueDate memberId creatorId meetingId attributes } count currentPage totalPages }",
+    listParentTypedField: "meetingId"
+  });
+}
+
+// src/commands/notes.ts
+var import_zod13 = require("zod");
+var idSchema12 = import_zod13.z.string().min(1);
+var nonEmptyString = import_zod13.z.string().min(1);
+function assertUpdateFields(params) {
+  if (!params.name && !params.content && !params.status) {
+    throw new CliError({
+      message: "notes update requires at least one of --name, --body, or --status.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+}
+async function createContent(command, cmd, payload) {
+  const context = await resolveCommandContext(cmd.optsWithGlobals());
+  const organizationId = resolveOrganizationId(context.organizationId);
+  return runGraphqlMutationCommand({
+    command,
+    operationName: "CreateContent",
+    runtimeOptions: context.runtimeOptions,
+    field: "create_content",
+    variables: normalizeGraphqlVariables2({
+      organization_id: organizationId,
+      params: {
+        content: payload
+      }
+    })
+  });
+}
+function registerNoteCommands(program) {
+  const notes = program.command("notes").description("Content note operations");
+  notes.command("list").option("--contentable-type <contentableType>").option("--contentable-id <contentableId>").option("--member-id <memberId>").option("--focus-member-id <focusMemberId>").option("--focus-team-id <focusTeamId>").option("--page <page>").option("--per <per>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "notes.list",
+      operationName: "ContentsIndex",
+      runtimeOptions: context.runtimeOptions,
+      field: "contents",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        contentable_type: opts.contentableType,
+        contentable_id: opts.contentableId,
+        member_id: opts.memberId,
+        focus_member_id: opts.focusMemberId,
+        focus_team_id: opts.focusTeamId,
+        page: opts.page,
+        per: opts.per
+      }),
+      isList: true,
+      selectionSet: "{ count currentPage totalPages data { id type name contentableType contentableId memberId focusMemberId focusTeamId attributes } }"
+    });
+  });
+  notes.command("show").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const id = idSchema12.parse(opts.id);
+    await runGraphqlQueryCommand({
+      command: "notes.show",
+      operationName: "ContentShow",
+      runtimeOptions: context.runtimeOptions,
+      field: "content",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        id
+      }),
+      isShow: true,
+      selectionSet: "{ id type name contentableType contentableId memberId focusMemberId focusTeamId attributes }"
+    });
+  });
+  notes.command("update").requiredOption("--id <id>").option("--name <name>").option("--body <body>").option("--status <status>").action(async (opts, cmd) => {
+    assertUpdateFields({
+      name: opts.name,
+      content: opts.body,
+      status: opts.status
+    });
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const contentId = idSchema12.parse(opts.id);
+    await runGraphqlMutationCommand({
+      command: "notes.update",
+      operationName: "UpdateContent",
+      runtimeOptions: context.runtimeOptions,
+      field: "update_content",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        content_id: contentId,
+        params: {
+          content: normalizeGraphqlVariables2({
+            name: opts.name,
+            content: opts.body,
+            status: opts.status
+          })
+        }
+      })
+    });
+  });
+  notes.command("destroy").requiredOption("--id <id>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const contentId = idSchema12.parse(opts.id);
+    await runGraphqlMutationCommand({
+      command: "notes.destroy",
+      operationName: "DestroyContent",
+      runtimeOptions: context.runtimeOptions,
+      field: "destroy_content",
+      variables: normalizeGraphqlVariables2({
+        organization_id: organizationId,
+        content_id: contentId
+      })
+    });
+  });
+  notes.command("create-member").requiredOption("--target-member-id <targetMemberId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    const targetMemberId = nonEmptyString.parse(opts.targetMemberId);
+    await createContent("notes.create-member", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Member",
+      contentable_id: targetMemberId,
+      member_id: targetMemberId,
+      focus_member_id: null,
+      focus_team_id: null
+    });
+  });
+  notes.command("create-manager").requiredOption("--actor-member-id <actorMemberId>").requiredOption("--target-member-id <targetMemberId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    const actorMemberId = nonEmptyString.parse(opts.actorMemberId);
+    await createContent("notes.create-manager", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Member",
+      contentable_id: actorMemberId,
+      member_id: actorMemberId,
+      focus_member_id: nonEmptyString.parse(opts.targetMemberId)
+    });
+  });
+  notes.command("create-team").requiredOption("--actor-member-id <actorMemberId>").requiredOption("--team-id <teamId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    const actorMemberId = nonEmptyString.parse(opts.actorMemberId);
+    const teamId = nonEmptyString.parse(opts.teamId);
+    await createContent("notes.create-team", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Team",
+      contentable_id: teamId,
+      member_id: actorMemberId,
+      focus_team_id: teamId
+    });
+  });
+  notes.command("create-project").requiredOption("--actor-member-id <actorMemberId>").requiredOption("--project-id <projectId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    await createContent("notes.create-project", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Project",
+      contentable_id: nonEmptyString.parse(opts.projectId),
+      member_id: nonEmptyString.parse(opts.actorMemberId)
+    });
+  });
+  notes.command("create-customer").requiredOption("--actor-member-id <actorMemberId>").requiredOption("--customer-id <customerId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    await createContent("notes.create-customer", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Customer",
+      contentable_id: nonEmptyString.parse(opts.customerId),
+      member_id: nonEmptyString.parse(opts.actorMemberId)
+    });
+  });
+  notes.command("create-contact").requiredOption("--actor-member-id <actorMemberId>").requiredOption("--contact-id <contactId>").requiredOption("--name <name>").requiredOption("--body <body>").option("--status <status>", "draft").action(async (opts, cmd) => {
+    await createContent("notes.create-contact", cmd, {
+      type: "WrittenContent",
+      name: nonEmptyString.parse(opts.name),
+      content: nonEmptyString.parse(opts.body),
+      status: String(opts.status ?? "draft"),
+      contentable_type: "Contact",
+      contentable_id: nonEmptyString.parse(opts.contactId),
+      member_id: nonEmptyString.parse(opts.actorMemberId)
+    });
+  });
+}
+
+// src/commands/markdownTree.ts
+var import_zod14 = require("zod");
+var nonEmptyString2 = import_zod14.z.string().min(1);
+var nonNegativeInt = import_zod14.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");
+}
+function parseScopeOptions(raw) {
+  const parsed = {
+    toolKey: nonEmptyString2.parse(raw.toolKey),
+    nodeKey: nonEmptyString2.parse(raw.nodeKey)
+  };
+  if (typeof raw.parentId === "string" && raw.parentId.trim() !== "") {
+    parsed.parentId = raw.parentId.trim();
+  }
+  if (typeof raw.recordId === "string" && raw.recordId.trim() !== "") {
+    parsed.recordId = raw.recordId.trim();
+  }
+  if (typeof raw.memberId === "string" && raw.memberId.trim() !== "") {
+    parsed.memberId = raw.memberId.trim();
+  }
+  if (typeof raw.teamId === "string" && raw.teamId.trim() !== "") {
+    parsed.teamId = raw.teamId.trim();
+  }
+  if (typeof raw.contentType === "string" && raw.contentType.trim() !== "") {
+    parsed.contentType = raw.contentType.trim();
+  }
+  if (raw.treeView === true) {
+    parsed.treeView = true;
+  }
+  return parsed;
+}
+function baseNodeFields() {
+  return [
+    "toolKey",
+    "nodeKey",
+    "nodeKind",
+    "runtimeLabel",
+    "resolvedScope { parentId recordId memberId teamId contentType }",
+    "isLeaf",
+    "treeView",
+    "details"
+  ].join(" ");
+}
+function buildChildSelection(depth) {
+  if (depth <= 0) return "";
+  const nested = buildChildSelection(depth - 1);
+  return nested.length > 0 ? `children { ${baseNodeFields()} ${nested} }` : `children { ${baseNodeFields()} }`;
+}
+function buildNodeSelectionSet(depth) {
+  const nested = buildChildSelection(depth);
+  return nested.length > 0 ? `{ ${baseNodeFields()} ${nested} }` : `{ ${baseNodeFields()} }`;
+}
+function requireExplicitDepth(rawDepth) {
+  if (rawDepth === void 0 || rawDepth === null || rawDepth === "") {
+    throw new CliError({
+      message: "Missing required --depth for markdown-tree subtree.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return nonNegativeInt.parse(rawDepth);
+}
+function registerMarkdownTreeCommands(program) {
+  const markdownTree = program.command("markdown-tree").description("Markdown tree traversal operations");
+  markdownTree.command("root").option("--tree-view").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    await runGraphqlQueryCommand({
+      command: "markdown-tree.root",
+      operationName: "MarkdownTreeRoot",
+      runtimeOptions: context.runtimeOptions,
+      field: "markdown_tree_root",
+      variables: {
+        organization_id: organizationId,
+        tree_view: opts.treeView === true ? true : void 0
+      },
+      selectionSet: buildNodeSelectionSet(1),
+      isShow: true
+    });
+  });
+  addScopeOptions(markdownTree.command("resolve")).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const scope = parseScopeOptions(opts);
+    await runGraphqlQueryCommand({
+      command: "markdown-tree.resolve",
+      operationName: "MarkdownTreeNode",
+      runtimeOptions: context.runtimeOptions,
+      field: "markdown_tree_node",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView
+      },
+      selectionSet: buildNodeSelectionSet(1),
+      isShow: true
+    });
+  });
+  addScopeOptions(markdownTree.command("children")).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const scope = parseScopeOptions(opts);
+    await runGraphqlQueryCommand({
+      command: "markdown-tree.children",
+      operationName: "MarkdownTreeChildren",
+      runtimeOptions: context.runtimeOptions,
+      field: "markdown_tree_children",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView
+      },
+      selectionSet: buildNodeSelectionSet(1),
+      isShow: true
+    });
+  });
+  addScopeOptions(
+    markdownTree.command("subtree").requiredOption("--depth <depth>")
+  ).action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const scope = parseScopeOptions(opts);
+    const depth = requireExplicitDepth(opts.depth);
+    await runGraphqlQueryCommand({
+      command: "markdown-tree.subtree",
+      operationName: "MarkdownTreeSubtree",
+      runtimeOptions: context.runtimeOptions,
+      field: "markdown_tree_subtree",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView,
+        depth
+      },
+      selectionSet: buildNodeSelectionSet(depth + 1),
+      isShow: true
+    });
+  });
+}
+
+// src/commands/navigation.ts
+var import_zod15 = require("zod");
+
+// src/internalOptions.ts
+var INTERNAL_OPTIONS_KEY = "__waveInternalOptions";
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function setInternalCliOptions(program, options) {
+  if (!options) return;
+  const target = program;
+  target[INTERNAL_OPTIONS_KEY] = { ...options };
+}
+function getInternalCliOptions(command) {
+  let current = command;
+  while (current) {
+    const record = asRecord2(current[INTERNAL_OPTIONS_KEY]);
+    if (record) {
+      return {
+        enableRetryOnEmptyPhrase: record.enableRetryOnEmptyPhrase === true
+      };
+    }
+    current = current.parent ?? null;
+  }
+  return {};
+}
+
+// src/commands/navigation.ts
+var nonEmpty = import_zod15.z.string().min(1);
+var nonNegativeInt2 = import_zod15.z.coerce.number().int().min(0);
+var MIGRATED_BRANCHES = ["directory", "projects", "knowledge"];
+function normalizeText(input) {
+  if (typeof input !== "string") return "";
+  return input.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function toDisplay(input) {
+  if (typeof input !== "string") return "";
+  const value = input.trim();
+  return value.length > 0 ? value : "";
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function parseScopeFromOptions(raw) {
+  const scope = {
+    toolKey: nonEmpty.parse(raw.toolKey),
+    nodeKey: nonEmpty.parse(raw.nodeKey)
+  };
+  if (typeof raw.parentId === "string" && raw.parentId.trim() !== "") {
+    scope.parentId = raw.parentId.trim();
+  }
+  if (typeof raw.recordId === "string" && raw.recordId.trim() !== "") {
+    scope.recordId = raw.recordId.trim();
+  }
+  if (typeof raw.memberId === "string" && raw.memberId.trim() !== "") {
+    scope.memberId = raw.memberId.trim();
+  }
+  if (typeof raw.teamId === "string" && raw.teamId.trim() !== "") {
+    scope.teamId = raw.teamId.trim();
+  }
+  if (typeof raw.contentType === "string" && raw.contentType.trim() !== "") {
+    scope.contentType = raw.contentType.trim();
+  }
+  if (raw.treeView === true) {
+    scope.treeView = true;
+  }
+  return scope;
+}
+function parseOptionalScopeFromOptions(raw) {
+  if (typeof raw.toolKey !== "string" || raw.toolKey.trim() === "") {
+    return null;
+  }
+  if (typeof raw.nodeKey !== "string" || raw.nodeKey.trim() === "") {
+    return null;
+  }
+  return parseScopeFromOptions(raw);
+}
+function scopeFromCandidate(candidate, treeView) {
+  const scopeObj = asObject(candidate.scope);
+  const resolvedScopeObj = asObject(candidate.resolvedScope);
+  const normalizedScope = Object.keys(scopeObj).length > 0 ? scopeObj : resolvedScopeObj;
+  const toolKey = toDisplay(candidate.toolKey);
+  const nodeKey = toDisplay(candidate.nodeKey);
+  return {
+    toolKey,
+    nodeKey,
+    parentId: toDisplay(normalizedScope.parentId) || void 0,
+    recordId: toDisplay(normalizedScope.recordId) || void 0,
+    memberId: toDisplay(normalizedScope.memberId) || void 0,
+    teamId: toDisplay(normalizedScope.teamId) || void 0,
+    contentType: toDisplay(normalizedScope.contentType) || void 0,
+    treeView
+  };
+}
+function notFoundEnvelope(params) {
+  return {
+    ok: false,
+    command: params.command,
+    status: 404,
+    data: null,
+    error: {
+      code: "not_found",
+      message: params.message,
+      details: {}
+    },
+    meta: {
+      requestId: params.requestId ?? "local_error"
+    }
+  };
+}
+function ambiguityEnvelope(params) {
+  return {
+    ok: false,
+    command: params.command,
+    status: 409,
+    data: null,
+    error: {
+      code: "ambiguous_match",
+      message: params.message,
+      details: {
+        candidates: params.candidates
+      }
+    },
+    meta: {
+      requestId: params.requestId ?? "local_error"
+    }
+  };
+}
+function unsupportedBranchEnvelope(params) {
+  const tool = params.tool ?? "unknown";
+  return {
+    ok: false,
+    command: params.command,
+    status: 400,
+    data: null,
+    error: {
+      code: "unsupported_branch",
+      message: `This branch isn't migrated to markdown-tree yet: ${tool}. Try directory/projects/knowledge.`,
+      details: {
+        tool,
+        migratedBranches: [...MIGRATED_BRANCHES],
+        originalError: params.originalError ?? null
+      }
+    },
+    meta: {
+      requestId: params.requestId ?? "local_error"
+    }
+  };
+}
+function parseToolFromGraphqlError(errorBody) {
+  const errorObj = asObject(errorBody);
+  const details = asObject(errorObj.details);
+  const errors = asArray(details.errors);
+  for (const item of errors) {
+    const message = toDisplay(item.message);
+    if (message === "") continue;
+    const match = message.match(/tool_key=([a-zA-Z0-9_]+)/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function toolHintFromPathLike(value) {
+  const text = toDisplay(value);
+  if (text === "") return null;
+  const [first] = text.split("/");
+  return first ? first.trim() : null;
+}
+function unsupportedToolFromHints(params) {
+  const fromError = parseToolFromGraphqlError(params.envelopeError);
+  if (fromError) return fromError;
+  return toDisplay(params.explicitTool) || toolHintFromPathLike(params.underPath) || toolHintFromPathLike(params.queryLike) || "unknown";
+}
+async function requestTraversal(params) {
+  const config = getConfig(params.runtimeOptions);
+  const result = await graphqlRequest({
+    config,
+    command: params.command,
+    operationName: params.operationName,
+    operationType: "query",
+    field: params.field,
+    variables: params.variables,
+    selectionSet: buildNodeSelectionSet(params.depth),
+    isShow: true
+  });
+  if (!result.envelope.ok) {
+    if (result.envelope.error?.code === "unsupported_branch") {
+      printEnvelopeAndExit({
+        envelope: unsupportedBranchEnvelope({
+          command: params.command,
+          requestId: result.envelope.meta.requestId,
+          tool: unsupportedToolFromHints({
+            explicitTool: params.variables.tool_key,
+            envelopeError: result.envelope.error
+          }),
+          originalError: asObject(result.envelope.error)
+        }),
+        exitCode: result.exitCode
+      });
+    }
+    printEnvelopeAndExit({
+      envelope: result.envelope,
+      exitCode: result.exitCode
+    });
+  }
+  const data = asObject(result.envelope.data);
+  return asObject(data[params.field]);
+}
+function findSelectionSet() {
+  return `{
+    query
+    underPath
+    candidates {
+      label
+      canonicalPath
+      toolKey
+      nodeKey
+      nodeKind
+      isLeaf
+      scope { parentId recordId memberId teamId contentType }
+      resolvedScope { parentId recordId memberId teamId contentType }
+      matchType
+      rank
+      aliasMatched
+      breadcrumb
+    }
+  }`;
+}
+async function requestFind(params) {
+  const config = getConfig(params.runtimeOptions);
+  const result = await graphqlRequest({
+    config,
+    command: params.command,
+    operationName: "MarkdownTreeFind",
+    operationType: "query",
+    field: "markdown_tree_find",
+    variables: {
+      organization_id: params.organizationId,
+      query: params.query,
+      under_path: params.underPath,
+      tool_key: params.toolKey,
+      node_key: params.nodeKey,
+      limit: params.limit
+    },
+    selectionSet: findSelectionSet(),
+    isShow: true
+  });
+  if (!result.envelope.ok) {
+    if (result.envelope.error?.code === "unsupported_branch") {
+      printEnvelopeAndExit({
+        envelope: unsupportedBranchEnvelope({
+          command: params.command,
+          requestId: result.envelope.meta.requestId,
+          tool: unsupportedToolFromHints({
+            explicitTool: params.toolKey,
+            underPath: params.underPath,
+            queryLike: params.query,
+            envelopeError: result.envelope.error
+          }),
+          originalError: asObject(result.envelope.error)
+        }),
+        exitCode: result.exitCode
+      });
+    }
+    printEnvelopeAndExit({
+      envelope: result.envelope,
+      exitCode: result.exitCode
+    });
+  }
+  const data = asObject(result.envelope.data);
+  const payload = asObject(data.markdown_tree_find);
+  return {
+    ...payload,
+    candidates: asArray(payload.candidates)
+  };
+}
+function matchTypePrecedence(candidate) {
+  const matchType = toDisplay(candidate.matchType).toLowerCase();
+  const order = {
+    exact_label: 0,
+    exact_path: 1,
+    prefix_label: 2,
+    path_prefix: 3,
+    path_fragment: 4,
+    alias_match: 5,
+    fuzzy: 6
+  };
+  return order[matchType] ?? Number.POSITIVE_INFINITY;
+}
+function isTopCandidateDominant(candidates) {
+  if (candidates.length <= 1) {
+    return true;
+  }
+  const first = candidates[0];
+  const second = candidates[1];
+  if (typeof first.rank === "number" && typeof second.rank === "number") {
+    return first.rank < second.rank;
+  }
+  const firstMatch = matchTypePrecedence(first);
+  const secondMatch = matchTypePrecedence(second);
+  if (Number.isFinite(firstMatch) || Number.isFinite(secondMatch)) {
+    return firstMatch < secondMatch;
+  }
+  return false;
+}
+function findExactPathMatches(candidates, path) {
+  const target = normalizeText(path);
+  if (target === "") return [];
+  return candidates.filter((candidate) => {
+    const canonicalPath = toDisplay(candidate.canonicalPath);
+    return normalizeText(canonicalPath) === target;
+  });
+}
+async function resolvePathScope(params) {
+  const findPayload = await requestFind({
+    command: params.command,
+    runtimeOptions: params.runtimeOptions,
+    organizationId: params.organizationId,
+    query: params.path,
+    underPath: params.underPath,
+    limit: 25
+  });
+  const exactMatches = findExactPathMatches(findPayload.candidates, params.path);
+  if (exactMatches.length === 1) {
+    return {
+      scope: scopeFromCandidate(exactMatches[0], params.treeView),
+      match: exactMatches[0],
+      ambiguous: []
+    };
+  }
+  if (exactMatches.length > 1) {
+    return {
+      ambiguous: exactMatches.slice(0, 10)
+    };
+  }
+  return {
+    ambiguous: []
+  };
+}
+function isMultiWordQuery(query) {
+  const parts = query.trim().split(/\s+/).filter((part) => part.length > 0);
+  return parts.length > 1;
+}
+function reduceMultiWordQuery(query) {
+  const tokens = query.trim().split(/\s+/).map((token) => token.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")).filter((token) => token.length > 0);
+  if (tokens.length <= 1) return null;
+  const meaningful = tokens.filter((token) => token.length >= 3);
+  const selected = meaningful.length > 0 ? meaningful[meaningful.length - 1] : tokens[tokens.length - 1];
+  return selected ?? null;
+}
+function registerNavigationCommands(program) {
+  program.command("find <query>").description("Find nodes via backend-native markdown tree discovery").option("--under <under>").option("--path <path>").option("--tool-key <toolKey>").option("--node-key <nodeKey>").option("--limit <limit>").action(async (query, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const context = await resolveCommandContext(globals);
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const internalOptions = getInternalCliOptions(cmd);
+    const limit = typeof opts.limit === "string" && opts.limit.trim() !== "" ? Math.max(1, Number.parseInt(opts.limit, 10) || 20) : 20;
+    const underPath = typeof opts.under === "string" && opts.under.trim() !== "" ? opts.under.trim() : typeof opts.path === "string" && opts.path.trim() !== "" ? opts.path.trim() : void 0;
+    const payload = await requestFind({
+      command: "find",
+      runtimeOptions: context.runtimeOptions,
+      organizationId,
+      query,
+      underPath,
+      toolKey: typeof opts.toolKey === "string" ? opts.toolKey : void 0,
+      nodeKey: typeof opts.nodeKey === "string" ? opts.nodeKey : void 0,
+      limit
+    });
+    let finalPayload = payload;
+    let assistantRecovery;
+    if (internalOptions.enableRetryOnEmptyPhrase === true && payload.candidates.length === 0 && isMultiWordQuery(query)) {
+      const retryQuery = reduceMultiWordQuery(query);
+      if (retryQuery && normalizeText(retryQuery) !== normalizeText(query)) {
+        finalPayload = await requestFind({
+          command: "find",
+          runtimeOptions: context.runtimeOptions,
+          organizationId,
+          query: retryQuery,
+          underPath,
+          toolKey: typeof opts.toolKey === "string" ? opts.toolKey : void 0,
+          nodeKey: typeof opts.nodeKey === "string" ? opts.nodeKey : void 0,
+          limit
+        });
+        assistantRecovery = {
+          triggered: true,
+          originalQuery: query,
+          retryQuery,
+          reason: "empty_multi_word_query"
+        };
+      }
+    }
+    printEnvelopeAndExit({
+      envelope: {
+        ok: true,
+        command: "find",
+        status: 200,
+        data: assistantRecovery ? {
+          ...finalPayload,
+          assistantRecovery
+        } : finalPayload,
+        error: null,
+        meta: { requestId: context.runtimeOptions.requestId ?? "local" }
+      }
+    });
+  });
+  program.command("open <name>").description("Resolve one node by backend discovery").option("--under <under>").option("--path <path>").option("--tool-key <toolKey>").option("--node-key <nodeKey>").option("--limit <limit>").option("--tree-view").action(async (name, opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const limit = typeof opts.limit === "string" && opts.limit.trim() !== "" ? Math.max(1, Number.parseInt(opts.limit, 10) || 10) : 10;
+    const underPath = typeof opts.under === "string" && opts.under.trim() !== "" ? opts.under.trim() : typeof opts.path === "string" && opts.path.trim() !== "" ? opts.path.trim() : void 0;
+    const payload = await requestFind({
+      command: "open",
+      runtimeOptions: context.runtimeOptions,
+      organizationId,
+      query: name,
+      underPath,
+      toolKey: typeof opts.toolKey === "string" ? opts.toolKey : void 0,
+      nodeKey: typeof opts.nodeKey === "string" ? opts.nodeKey : void 0,
+      limit
+    });
+    const candidates = payload.candidates;
+    if (candidates.length === 0) {
+      printEnvelopeAndExit({
+        envelope: notFoundEnvelope({
+          command: "open",
+          message: `No node matched "${name}".`
+        }),
+        exitCode: EXIT_CODES.notFound
+      });
+    }
+    if (candidates.length > 1 && !isTopCandidateDominant(candidates)) {
+      printEnvelopeAndExit({
+        envelope: ambiguityEnvelope({
+          command: "open",
+          message: `Multiple nodes matched "${name}".`,
+          candidates: candidates.slice(0, 10)
+        }),
+        exitCode: EXIT_CODES.generic
+      });
+    }
+    const selected = candidates[0];
+    const scope = scopeFromCandidate(selected, opts.treeView === true);
+    const node = await requestTraversal({
+      command: "open",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "MarkdownTreeNode",
+      field: "markdown_tree_node",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView
+      },
+      depth: 1
+    });
+    printEnvelopeAndExit({
+      envelope: {
+        ok: true,
+        command: "open",
+        status: 200,
+        data: {
+          match: selected,
+          node
+        },
+        error: null,
+        meta: { requestId: context.runtimeOptions.requestId ?? "local" }
+      }
+    });
+  });
+  program.command("ls [query]").description("List direct children for a target").option("--path <path>").option("--under <under>").option("--tree-view").option("--tool-key <toolKey>").option("--node-key <nodeKey>").option("--parent-id <parentId>").option("--record-id <recordId>").option("--member-id <memberId>").option("--team-id <teamId>").option("--content-type <contentType>").action(async (query, opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    let scope = null;
+    let pathMatch = null;
+    if (typeof opts.path === "string" && opts.path.trim() !== "") {
+      const resolved = await resolvePathScope({
+        command: "ls",
+        runtimeOptions: context.runtimeOptions,
+        organizationId,
+        path: opts.path,
+        underPath: typeof opts.under === "string" ? opts.under : void 0,
+        treeView: opts.treeView === true
+      });
+      if (!resolved.scope) {
+        if (resolved.ambiguous.length > 0) {
+          printEnvelopeAndExit({
+            envelope: ambiguityEnvelope({
+              command: "ls",
+              message: `Path "${opts.path}" is ambiguous.`,
+              candidates: resolved.ambiguous
+            }),
+            exitCode: EXIT_CODES.generic
+          });
+        }
+        printEnvelopeAndExit({
+          envelope: notFoundEnvelope({
+            command: "ls",
+            message: `Path "${opts.path}" was not found.`
+          }),
+          exitCode: EXIT_CODES.notFound
+        });
+      }
+      scope = resolved.scope;
+      pathMatch = resolved.match ?? null;
+    } else {
+      scope = parseOptionalScopeFromOptions(opts);
+    }
+    if (!scope) {
+      printEnvelopeAndExit({
+        envelope: {
+          ok: false,
+          command: "ls",
+          status: 400,
+          data: null,
+          error: {
+            code: "invalid_args",
+            message: "Provide either --path or full scope args (--tool-key and --node-key).",
+            details: {}
+          },
+          meta: { requestId: context.runtimeOptions.requestId ?? "local_error" }
+        },
+        exitCode: EXIT_CODES.invalidArgs
+      });
+    }
+    const node = await requestTraversal({
+      command: "ls",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "MarkdownTreeChildren",
+      field: "markdown_tree_children",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView
+      },
+      depth: 1
+    });
+    const children = asArray(node.children);
+    const filtered = typeof query === "string" && query.trim() !== "" ? children.filter(
+      (child) => normalizeText(child.runtimeLabel).includes(normalizeText(query))
+    ) : children;
+    printEnvelopeAndExit({
+      envelope: {
+        ok: true,
+        command: "ls",
+        status: 200,
+        data: {
+          target: pathMatch,
+          children: filtered
+        },
+        error: null,
+        meta: { requestId: context.runtimeOptions.requestId ?? "local" }
+      }
+    });
+  });
+  program.command("cat").description("Read one node").option("--path <path>").option("--under <under>").option("--tree-view").option("--tool-key <toolKey>").option("--node-key <nodeKey>").option("--parent-id <parentId>").option("--record-id <recordId>").option("--member-id <memberId>").option("--team-id <teamId>").option("--content-type <contentType>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    let scope = null;
+    let pathMatch = null;
+    if (typeof opts.path === "string" && opts.path.trim() !== "") {
+      const resolved = await resolvePathScope({
+        command: "cat",
+        runtimeOptions: context.runtimeOptions,
+        organizationId,
+        path: opts.path,
+        underPath: typeof opts.under === "string" ? opts.under : void 0,
+        treeView: opts.treeView === true
+      });
+      if (!resolved.scope) {
+        if (resolved.ambiguous.length > 0) {
+          printEnvelopeAndExit({
+            envelope: ambiguityEnvelope({
+              command: "cat",
+              message: `Path "${opts.path}" is ambiguous.`,
+              candidates: resolved.ambiguous
+            }),
+            exitCode: EXIT_CODES.generic
+          });
+        }
+        printEnvelopeAndExit({
+          envelope: notFoundEnvelope({
+            command: "cat",
+            message: `Path "${opts.path}" was not found.`
+          }),
+          exitCode: EXIT_CODES.notFound
+        });
+      }
+      scope = resolved.scope;
+      pathMatch = resolved.match ?? null;
+    } else {
+      scope = parseOptionalScopeFromOptions(opts);
+    }
+    if (!scope) {
+      printEnvelopeAndExit({
+        envelope: {
+          ok: false,
+          command: "cat",
+          status: 400,
+          data: null,
+          error: {
+            code: "invalid_args",
+            message: "Provide either --path or full scope args (--tool-key and --node-key).",
+            details: {}
+          },
+          meta: { requestId: context.runtimeOptions.requestId ?? "local_error" }
+        },
+        exitCode: EXIT_CODES.invalidArgs
+      });
+    }
+    const node = await requestTraversal({
+      command: "cat",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "MarkdownTreeNode",
+      field: "markdown_tree_node",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView
+      },
+      depth: 1
+    });
+    printEnvelopeAndExit({
+      envelope: {
+        ok: true,
+        command: "cat",
+        status: 200,
+        data: {
+          target: pathMatch,
+          node
+        },
+        error: null,
+        meta: { requestId: context.runtimeOptions.requestId ?? "local" }
+      }
+    });
+  });
+  program.command("tree").description("Read bounded subtree").requiredOption("--depth <depth>").option("--path <path>").option("--under <under>").option("--tree-view").option("--tool-key <toolKey>").option("--node-key <nodeKey>").option("--parent-id <parentId>").option("--record-id <recordId>").option("--member-id <memberId>").option("--team-id <teamId>").option("--content-type <contentType>").action(async (opts, cmd) => {
+    const context = await resolveCommandContext(cmd.optsWithGlobals());
+    const organizationId = resolveOrganizationId(context.organizationId);
+    const depth = nonNegativeInt2.parse(opts.depth);
+    let scope = null;
+    let pathMatch = null;
+    if (typeof opts.path === "string" && opts.path.trim() !== "") {
+      const resolved = await resolvePathScope({
+        command: "tree",
+        runtimeOptions: context.runtimeOptions,
+        organizationId,
+        path: opts.path,
+        underPath: typeof opts.under === "string" ? opts.under : void 0,
+        treeView: opts.treeView === true
+      });
+      if (!resolved.scope) {
+        if (resolved.ambiguous.length > 0) {
+          printEnvelopeAndExit({
+            envelope: ambiguityEnvelope({
+              command: "tree",
+              message: `Path "${opts.path}" is ambiguous.`,
+              candidates: resolved.ambiguous
+            }),
+            exitCode: EXIT_CODES.generic
+          });
+        }
+        printEnvelopeAndExit({
+          envelope: notFoundEnvelope({
+            command: "tree",
+            message: `Path "${opts.path}" was not found.`
+          }),
+          exitCode: EXIT_CODES.notFound
+        });
+      }
+      scope = resolved.scope;
+      pathMatch = resolved.match ?? null;
+    } else {
+      scope = parseOptionalScopeFromOptions(opts);
+    }
+    if (!scope) {
+      printEnvelopeAndExit({
+        envelope: {
+          ok: false,
+          command: "tree",
+          status: 400,
+          data: null,
+          error: {
+            code: "invalid_args",
+            message: "Provide either --path or full scope args (--tool-key and --node-key).",
+            details: {}
+          },
+          meta: { requestId: context.runtimeOptions.requestId ?? "local_error" }
+        },
+        exitCode: EXIT_CODES.invalidArgs
+      });
+    }
+    const node = await requestTraversal({
+      command: "tree",
+      runtimeOptions: context.runtimeOptions,
+      operationName: "MarkdownTreeSubtree",
+      field: "markdown_tree_subtree",
+      variables: {
+        organization_id: organizationId,
+        tool_key: scope.toolKey,
+        node_key: scope.nodeKey,
+        parent_id: scope.parentId,
+        record_id: scope.recordId,
+        member_id: scope.memberId,
+        team_id: scope.teamId,
+        content_type: scope.contentType,
+        tree_view: scope.treeView,
+        depth
+      },
+      depth: depth + 1
+    });
+    printEnvelopeAndExit({
+      envelope: {
+        ok: true,
+        command: "tree",
+        status: 200,
+        data: {
+          target: pathMatch,
+          depth,
+          node
+        },
+        error: null,
+        meta: { requestId: context.runtimeOptions.requestId ?? "local" }
+      }
+    });
+  });
+}
+
+// src/commands/mutationCapability.ts
+function unsupportedMutationEnvelope(params) {
+  return {
+    ok: false,
+    command: params.command,
+    status: 400,
+    data: null,
+    error: {
+      code: "mutation_unsupported",
+      message: "No mutation command is supported for this node type.",
+      details: {
+        node: params.node
+      }
+    },
+    meta: {
+      requestId: "local_error"
+    }
+  };
+}
+function emitUnsupportedMutation(params) {
+  const canonicalPath = typeof params.canonicalPath === "string" && params.canonicalPath.trim().length > 0 ? params.canonicalPath.trim() : null;
+  printEnvelopeAndExit({
+    envelope: unsupportedMutationEnvelope({
+      command: params.command,
+      node: {
+        toolKey: params.toolKey,
+        nodeKey: params.nodeKey,
+        canonicalPath
+      }
+    }),
+    exitCode: EXIT_CODES.invalidArgs
+  });
+}
+function registerMutationCapabilityCommands(program) {
+  const projectNotes = program.command("project-notes").description("Project notes node (read-only in CLI mutation surface)");
+  projectNotes.command("create").option("--path <path>", "Canonical path for the selected node").action((opts) => {
+    emitUnsupportedMutation({
+      command: "project-notes.create",
+      toolKey: "projects",
+      nodeKey: "project_notes",
+      canonicalPath: opts.path
+    });
+  });
+  projectNotes.command("update").option("--path <path>", "Canonical path for the selected node").action((opts) => {
+    emitUnsupportedMutation({
+      command: "project-notes.update",
+      toolKey: "projects",
+      nodeKey: "project_notes",
+      canonicalPath: opts.path
+    });
+  });
+  projectNotes.command("destroy").option("--path <path>", "Canonical path for the selected node").action((opts) => {
+    emitUnsupportedMutation({
+      command: "project-notes.destroy",
+      toolKey: "projects",
+      nodeKey: "project_notes",
+      canonicalPath: opts.path
+    });
+  });
+}
+
 // src/cli.ts
-function buildCli() {
+function buildCli(options) {
   const program = new import_commander.Command();
   program.name("wave").description("Wave agent CLI").showHelpAfterError(false).allowExcessArguments(false).option("--token <token>", "API token (prefer WAVE_API_TOKEN env var)").option("--jwt <jwt>", "Legacy alias for --token (prefer WAVE_API_TOKEN env var)").option("--token-stdin", "Read API token from stdin").option(
     "--auth-json-stdin",
@@ -2563,6 +5418,7 @@ function buildCli() {
     "--openapi-version <openapiVersion>",
     "Optional pinned OpenAPI version/hash"
   ).exitOverride();
+  setInternalCliOptions(program, options?.internal);
   registerTaskCommands(program);
   registerProjectCommands(program);
   registerRockCommands(program);
@@ -2573,6 +5429,11 @@ function buildCli() {
   registerIssueCommands(program);
   registerSystemToolCommands(program);
   registerFoundationCommands(program);
+  registerChildEntityCommands(program);
+  registerNoteCommands(program);
+  registerMutationCapabilityCommands(program);
+  registerMarkdownTreeCommands(program);
+  registerNavigationCommands(program);
   return program;
 }
 
@@ -2621,13 +5482,13 @@ main().catch((error) => {
       exitCode: EXIT_CODES.invalidArgs
     });
   }
-  if (error instanceof import_zod12.ZodError || error instanceof import_commander2.InvalidArgumentError) {
+  if (error instanceof import_zod16.ZodError || error instanceof import_commander2.InvalidArgumentError) {
     printCliFailure({
       status: 400,
       code: "invalid_args",
       message: "Invalid command arguments.",
       details: {
-        issues: error instanceof import_zod12.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
+        issues: error instanceof import_zod16.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
       },
       exitCode: EXIT_CODES.invalidArgs
     });