@ted-galago/wave-cli 0.1.14 → 0.1.16

package/dist/index.cjs

@@ -3,7 +3,7 @@
 
 // src/index.ts
 var import_commander2 = require("commander");
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/cli.ts
 var import_commander = require("commander");
@@ -5143,6 +5143,13 @@ function baseNodeFields() {
     "nodeKey",
     "nodeKind",
     "runtimeLabel",
+    "path",
+    "source",
+    "access",
+    "owner",
+    "parentRef",
+    "agentChildrenAllowed",
+    "exists",
     "resolvedScope { parentId recordId memberId teamId contentType }",
     "isLeaf",
     "treeView",
@@ -6077,6 +6084,778 @@ function registerMutationCapabilityCommands(program) {
   });
 }
 
+// src/commands/osmd.ts
+var import_promises = require("fs/promises");
+var import_zod16 = require("zod");
+var sourceSchema = import_zod16.z.enum(["canonical_osmd", "agent_overlay", "agent_wiki"]);
+var accessSchema = import_zod16.z.enum(["read_only", "read_write", "append_only"]);
+var ownerSchema = import_zod16.z.enum(["system", "atlas"]);
+var suggestedActionSchema = import_zod16.z.enum([
+  "read",
+  "create",
+  "init",
+  "update",
+  "append",
+  "forbidden",
+  "invalid_parent"
+]);
+var agentMarkdownErrorCodeSchema = import_zod16.z.enum([
+  "canonical_osmd_read_only",
+  "agent_parent_not_found",
+  "agent_file_not_found",
+  "agent_file_already_exists",
+  "agent_path_forbidden",
+  "append_only_violation",
+  "unsupported_agent_file",
+  "invalid_agent_wiki_path"
+]);
+var nonEmptyString3 = import_zod16.z.string().min(1);
+var nonNegativeInt3 = import_zod16.z.coerce.number().int().min(0);
+var agentOverlayFileSchema = import_zod16.z.enum(["notes.md", "log.md"]);
+var agentMarkdownFileSchema = import_zod16.z.object({
+  path: import_zod16.z.string(),
+  source: sourceSchema,
+  access: accessSchema,
+  owner: ownerSchema,
+  exists: import_zod16.z.boolean(),
+  canCreate: import_zod16.z.boolean(),
+  canUpdate: import_zod16.z.boolean(),
+  canAppend: import_zod16.z.boolean(),
+  parentRef: import_zod16.z.string().nullable().optional(),
+  agentChildrenAllowed: import_zod16.z.boolean(),
+  suggestedAction: suggestedActionSchema,
+  errorCode: agentMarkdownErrorCodeSchema.nullable().optional(),
+  content: import_zod16.z.string().nullable().optional(),
+  url: import_zod16.z.string().nullable().optional()
+}).transform((value) => ({
+  ...value,
+  parentRef: value.parentRef ?? null,
+  errorCode: value.errorCode ?? null,
+  content: value.content ?? null,
+  url: value.url ?? null
+}));
+var agentMarkdownFilesSchema = import_zod16.z.array(agentMarkdownFileSchema);
+var agentMarkdownMutationDataSchema = import_zod16.z.union([
+  agentMarkdownFileSchema,
+  import_zod16.z.object({ files: agentMarkdownFilesSchema })
+]);
+var mutationPayloadSchema = import_zod16.z.object({
+  ok: import_zod16.z.boolean(),
+  status: import_zod16.z.number(),
+  errorCode: import_zod16.z.string().nullable().optional(),
+  data: import_zod16.z.unknown().nullable().optional(),
+  errors: import_zod16.z.unknown().nullable().optional()
+});
+var markdownTreeNodeSchema = import_zod16.z.lazy(
+  () => import_zod16.z.object({
+    toolKey: import_zod16.z.string(),
+    nodeKey: import_zod16.z.string(),
+    nodeKind: import_zod16.z.string(),
+    runtimeLabel: import_zod16.z.string(),
+    path: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+    source: sourceSchema,
+    access: accessSchema,
+    owner: ownerSchema,
+    parentRef: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+    agentChildrenAllowed: import_zod16.z.boolean(),
+    exists: import_zod16.z.boolean(),
+    resolvedScope: import_zod16.z.object({
+      parentId: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+      recordId: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+      memberId: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+      teamId: import_zod16.z.string().nullable().optional().transform((value) => value ?? null),
+      contentType: import_zod16.z.string().nullable().optional().transform((value) => value ?? null)
+    }),
+    isLeaf: import_zod16.z.boolean(),
+    treeView: import_zod16.z.boolean(),
+    details: import_zod16.z.unknown().nullable(),
+    children: import_zod16.z.array(markdownTreeNodeSchema).optional().transform((value) => value ?? [])
+  })
+);
+var AGENT_MARKDOWN_FILE_SELECTION = `{
+  path
+  source
+  access
+  owner
+  exists
+  canCreate
+  canUpdate
+  canAppend
+  parentRef
+  agentChildrenAllowed
+  suggestedAction
+  errorCode
+  content
+  url
+}`;
+var MUTATION_RESULT_SELECTION = "{ ok status errorCode data errors }";
+var AGENT_JSON_KEY_ALIASES = {
+  can_create: "canCreate",
+  can_update: "canUpdate",
+  can_append: "canAppend",
+  parent_ref: "parentRef",
+  agent_children_allowed: "agentChildrenAllowed",
+  suggested_action: "suggestedAction",
+  error_code: "errorCode"
+};
+var contentStdinPromise = null;
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeAgentMarkdownJsonKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeAgentMarkdownJsonKeys(entry));
+  }
+  if (!isRecord5(value)) {
+    return value;
+  }
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const normalizedKey = AGENT_JSON_KEY_ALIASES[key] ?? key;
+    normalized[normalizedKey] = normalizeAgentMarkdownJsonKeys(entry);
+  }
+  return normalized;
+}
+function buildSuccessEnvelope(params) {
+  return {
+    ok: true,
+    command: params.command,
+    status: params.status,
+    data: params.data,
+    error: null,
+    meta: { requestId: params.requestId }
+  };
+}
+function buildErrorEnvelope(params) {
+  return {
+    ok: false,
+    command: params.command,
+    status: params.status,
+    data: params.data,
+    error: {
+      code: params.code,
+      message: params.message,
+      suggestedAction: params.suggestedAction,
+      details: params.details ?? {}
+    },
+    meta: { requestId: params.requestId }
+  };
+}
+function printLocalError(params) {
+  return printEnvelopeAndExit({
+    envelope: buildErrorEnvelope(params),
+    exitCode: mapStatusToExitCode(params.status)
+  });
+}
+function printInvalidPayloadError(params) {
+  return printLocalError({
+    command: params.command,
+    status: 502,
+    code: "upstream_error",
+    message: "GraphQL response did not match the expected OSMD contract.",
+    requestId: params.requestId,
+    data: null,
+    details: { issues: params.issues }
+  });
+}
+async function requestOsmdQuery(params) {
+  const result = await graphqlRequest({
+    config: getConfig(params.runtimeOptions),
+    command: params.command,
+    operationName: params.operationName,
+    operationType: "query",
+    field: params.field,
+    variables: params.variables,
+    selectionSet: params.selectionSet,
+    isShow: true
+  });
+  if (!result.envelope.ok) {
+    return printEnvelopeAndExit(result);
+  }
+  const dataRecord = isRecord5(result.envelope.data) ? result.envelope.data : {};
+  const parsed = params.schema.safeParse(dataRecord[params.field]);
+  if (!parsed.success) {
+    return printInvalidPayloadError({
+      command: params.command,
+      requestId: result.envelope.meta.requestId,
+      issues: parsed.error.issues
+    });
+  }
+  return {
+    data: parsed.data,
+    status: result.envelope.status,
+    requestId: result.envelope.meta.requestId
+  };
+}
+async function requestAgentMarkdownStatus(params) {
+  return requestOsmdQuery({
+    command: params.command,
+    operationName: "AgentMarkdownStatus",
+    runtimeOptions: params.runtimeOptions,
+    field: "agent_markdown_status",
+    variables: {
+      organization_id: params.organizationId,
+      path: params.path,
+      parent_ref: params.parentRef
+    },
+    selectionSet: AGENT_MARKDOWN_FILE_SELECTION,
+    schema: agentMarkdownFileSchema
+  });
+}
+async function requestAgentMarkdownFile(params) {
+  return requestOsmdQuery({
+    command: params.command,
+    operationName: "AgentMarkdownFile",
+    runtimeOptions: params.runtimeOptions,
+    field: "agent_markdown_file",
+    variables: {
+      organization_id: params.organizationId,
+      path: params.path,
+      parent_ref: params.parentRef
+    },
+    selectionSet: AGENT_MARKDOWN_FILE_SELECTION,
+    schema: agentMarkdownFileSchema
+  });
+}
+async function requestAgentMarkdownChildren(params) {
+  return requestOsmdQuery({
+    command: params.command,
+    operationName: "AgentMarkdownChildren",
+    runtimeOptions: params.runtimeOptions,
+    field: "agent_markdown_children",
+    variables: {
+      organization_id: params.organizationId,
+      path: params.path,
+      parent_ref: params.parentRef,
+      source: params.source
+    },
+    selectionSet: AGENT_MARKDOWN_FILE_SELECTION,
+    schema: agentMarkdownFilesSchema
+  });
+}
+async function runAgentMarkdownMutation(params) {
+  const result = await graphqlRequest({
+    config: getConfig(params.runtimeOptions),
+    command: params.command,
+    operationName: params.operationName,
+    operationType: "mutation",
+    field: params.field,
+    variables: params.variables,
+    selectionSet: MUTATION_RESULT_SELECTION
+  });
+  if (!result.envelope.ok) {
+    return printEnvelopeAndExit(result);
+  }
+  const dataRecord = isRecord5(result.envelope.data) ? result.envelope.data : {};
+  const parsedPayload = mutationPayloadSchema.safeParse(dataRecord[params.field]);
+  if (!parsedPayload.success) {
+    return printInvalidPayloadError({
+      command: params.command,
+      requestId: result.envelope.meta.requestId,
+      issues: parsedPayload.error.issues
+    });
+  }
+  const mutationPayload = parsedPayload.data;
+  const parsedData = agentMarkdownMutationDataSchema.safeParse(
+    normalizeAgentMarkdownJsonKeys(mutationPayload.data)
+  );
+  if (!parsedData.success) {
+    return printInvalidPayloadError({
+      command: params.command,
+      requestId: result.envelope.meta.requestId,
+      issues: parsedData.error.issues
+    });
+  }
+  return printEnvelopeAndExit({
+    envelope: buildSuccessEnvelope({
+      command: params.command,
+      status: mutationPayload.status,
+      data: parsedData.data,
+      requestId: result.envelope.meta.requestId
+    })
+  });
+}
+function normalizeAgentFilePath(file) {
+  const trimmed = nonEmptyString3.parse(file).trim().replace(/^\/+|\/+$/g, "");
+  const fileName = trimmed.startsWith(".agent/") ? trimmed.slice(".agent/".length) : trimmed;
+  const parsed = agentOverlayFileSchema.safeParse(fileName);
+  if (!parsed.success) {
+    throw new CliError({
+      message: ".agent supports only notes.md and log.md in this CLI slice.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { supportedFiles: ["notes.md", "log.md"] }
+    });
+  }
+  return `.agent/${parsed.data}`;
+}
+function normalizeWikiPath(path) {
+  const trimmed = nonEmptyString3.parse(path).trim().replace(/^\/+/, "");
+  if (trimmed.localeCompare("Agent Wiki", void 0, { sensitivity: "accent" }) === 0) {
+    return "Agent Wiki";
+  }
+  if (trimmed.toLowerCase().startsWith("agent wiki/")) {
+    return `Agent Wiki/${trimmed.slice("Agent Wiki/".length)}`;
+  }
+  return `Agent Wiki/${trimmed}`;
+}
+function parseOptionalParentRef(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function parseOptionalSource(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = sourceSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError({
+      message: "Invalid OSMD source. Use canonical_osmd, agent_overlay, or agent_wiki.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs,
+      details: { supportedSources: sourceSchema.options }
+    });
+  }
+  return parsed.data;
+}
+function parseDepth(value) {
+  if (value === void 0 || value === null || value === "") {
+    return 1;
+  }
+  return nonNegativeInt3.parse(value);
+}
+function readContentStdin() {
+  if (!contentStdinPromise) {
+    contentStdinPromise = new Promise((resolve, reject) => {
+      if (process.stdin.isTTY) {
+        resolve("");
+        return;
+      }
+      let data = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => resolve(data));
+      process.stdin.on("error", reject);
+    });
+  }
+  return contentStdinPromise;
+}
+async function resolveContentInput(opts, globals) {
+  const hasContent = typeof opts.content === "string";
+  const hasFile = typeof opts.file === "string" && opts.file.trim() !== "";
+  if (hasContent && hasFile) {
+    throw new CliError({
+      message: "Use only one markdown content source: --content, --file, or stdin.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  if (hasContent) {
+    return String(opts.content);
+  }
+  if (hasFile) {
+    try {
+      return await (0, import_promises.readFile)(opts.file, "utf8");
+    } catch (error) {
+      throw new CliError({
+        message: `Unable to read markdown file: ${opts.file}`,
+        kind: "invalid_args",
+        status: 400,
+        exitCode: EXIT_CODES.invalidArgs,
+        details: {
+          cause: error instanceof Error ? error.message : String(error)
+        }
+      });
+    }
+  }
+  if (globals.tokenStdin === true || globals.authJsonStdin === true) {
+    throw new CliError({
+      message: "Markdown content cannot share stdin with --token-stdin or --auth-json-stdin. Use --content or --file.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  const stdin = await readContentStdin();
+  if (stdin.length === 0) {
+    throw new CliError({
+      message: "Provide markdown content with --content, --file, or stdin.",
+      kind: "invalid_args",
+      status: 400,
+      exitCode: EXIT_CODES.invalidArgs
+    });
+  }
+  return stdin;
+}
+function writePreflightError(status, action) {
+  if (status.errorCode) {
+    return {
+      code: status.errorCode,
+      message: `OSMD write is not allowed: ${status.errorCode}.`,
+      suggestedAction: status.suggestedAction,
+      status: statusCodeForAgentError(status.errorCode)
+    };
+  }
+  if (status.source === "canonical_osmd" || status.access === "read_only") {
+    return {
+      code: "canonical_osmd_read_only",
+      message: "Canonical OSMD files are read-only. Write to .agent overlays or Agent Wiki.",
+      suggestedAction: status.suggestedAction,
+      status: 403
+    };
+  }
+  if (action === "create") {
+    if (status.exists) {
+      return {
+        code: "agent_file_already_exists",
+        message: `Agent markdown file already exists: ${status.path}`,
+        suggestedAction: status.suggestedAction,
+        status: 409
+      };
+    }
+    if (!status.canCreate) {
+      return {
+        code: status.access === "append_only" ? "append_only_violation" : "agent_path_forbidden",
+        message: `Create is not allowed for ${status.path}.`,
+        suggestedAction: status.suggestedAction,
+        status: 403
+      };
+    }
+  }
+  if (action === "update") {
+    if (!status.exists) {
+      return {
+        code: "agent_file_not_found",
+        message: `Agent markdown file does not exist: ${status.path}`,
+        suggestedAction: status.suggestedAction,
+        status: 404
+      };
+    }
+    if (!status.canUpdate) {
+      return {
+        code: status.access === "append_only" ? "append_only_violation" : "agent_path_forbidden",
+        message: `Update is not allowed for ${status.path}.`,
+        suggestedAction: status.suggestedAction,
+        status: 403
+      };
+    }
+  }
+  return null;
+}
+function statusCodeForAgentError(code) {
+  if (code === "agent_parent_not_found" || code === "agent_file_not_found") {
+    return 404;
+  }
+  if (code === "agent_file_already_exists") {
+    return 409;
+  }
+  if (code === "unsupported_agent_file" || code === "invalid_agent_wiki_path") {
+    return 422;
+  }
+  return 403;
+}
+async function runWriteFlow(params) {
+  const status = await requestAgentMarkdownStatus({
+    command: `${params.command}.status`,
+    runtimeOptions: params.runtimeOptions,
+    organizationId: params.organizationId,
+    path: params.path,
+    parentRef: params.parentRef
+  });
+  const preflightError = writePreflightError(status.data, params.action);
+  if (preflightError) {
+    return printLocalError({
+      command: params.command,
+      status: preflightError.status,
+      code: preflightError.code,
+      message: preflightError.message,
+      suggestedAction: preflightError.suggestedAction,
+      requestId: status.requestId,
+      data: status.data
+    });
+  }
+  const mutation = {
+    create: {
+      operationName: "CreateAgentMarkdownFile",
+      field: "create_agent_markdown_file"
+    },
+    update: {
+      operationName: "UpdateAgentMarkdownFile",
+      field: "update_agent_markdown_file"
+    }
+  }[params.action];
+  return runAgentMarkdownMutation({
+    command: params.command,
+    operationName: mutation.operationName,
+    runtimeOptions: params.runtimeOptions,
+    field: mutation.field,
+    variables: {
+      organization_id: params.organizationId,
+      path: status.data.path,
+      parent_ref: status.data.parentRef ?? params.parentRef,
+      content: params.content
+    }
+  });
+}
+function addContentOptions(command) {
+  return command.option("--content <content>", "Markdown content").option("--file <file>", "Read markdown content from a local file");
+}
+async function resolveOsmdContext(cmd) {
+  const context = await resolveCommandContext(cmd.optsWithGlobals());
+  return {
+    organizationId: resolveOrganizationId(context.organizationId),
+    runtimeOptions: context.runtimeOptions
+  };
+}
+function registerOsmdCommands(program) {
+  const osmd = program.command("osmd").description("OSMD and agent markdown operations; canonical OSMD is read-only");
+  osmd.command("tree").description("Read the canonical OSMD tree with source/access metadata").option("--depth <depth>", "Selection depth for nested children", "1").option("--tree-view").action(async (opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const depth = parseDepth(opts.depth);
+    const result = await requestOsmdQuery({
+      command: "osmd.tree",
+      operationName: "MarkdownTreeRoot",
+      runtimeOptions,
+      field: "markdown_tree_root",
+      variables: {
+        organization_id: organizationId,
+        tree_view: opts.treeView === true ? true : void 0
+      },
+      selectionSet: buildNodeSelectionSet(depth),
+      schema: markdownTreeNodeSchema
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.tree",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  osmd.command("status <path>").description("Inspect canonical OSMD, .agent overlay, or Agent Wiki file metadata").option("--parent-ref <parentRef>", "Canonical OSMD parent ref for .agent files").action(async (path, opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownStatus({
+      command: "osmd.status",
+      runtimeOptions,
+      organizationId,
+      path: nonEmptyString3.parse(path).trim(),
+      parentRef: parseOptionalParentRef(opts.parentRef)
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.status",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  osmd.command("read <path>").description("Read canonical OSMD, .agent overlay, or Agent Wiki markdown without creating files").option("--parent-ref <parentRef>", "Canonical OSMD parent ref for .agent files").action(async (path, opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownFile({
+      command: "osmd.read",
+      runtimeOptions,
+      organizationId,
+      path: nonEmptyString3.parse(path).trim(),
+      parentRef: parseOptionalParentRef(opts.parentRef)
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.read",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  osmd.command("children [path]").description("List backend-supported agent markdown children; search remains canonical-only").option("--parent-ref <parentRef>", "Canonical OSMD parent ref for .agent files").option("--source <source>", "Filter by canonical_osmd, agent_overlay, or agent_wiki").action(async (path, opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownChildren({
+      command: "osmd.children",
+      runtimeOptions,
+      organizationId,
+      path: typeof path === "string" && path.trim() !== "" ? path.trim() : void 0,
+      parentRef: parseOptionalParentRef(opts.parentRef),
+      source: parseOptionalSource(opts.source)
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.children",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  const agent = osmd.command("agent").description(".agent overlay files writable by agents; supports notes.md and log.md");
+  agent.command("status <parent-ref> <file>").action(async (parentRef, file, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownStatus({
+      command: "osmd.agent.status",
+      runtimeOptions,
+      organizationId,
+      path: normalizeAgentFilePath(file),
+      parentRef: nonEmptyString3.parse(parentRef).trim()
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.agent.status",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  agent.command("init <parent-ref>").action(async (parentRef, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    return runAgentMarkdownMutation({
+      command: "osmd.agent.init",
+      operationName: "InitAgentMarkdown",
+      runtimeOptions,
+      field: "init_agent_markdown",
+      variables: {
+        organization_id: organizationId,
+        path: ".agent",
+        parent_ref: nonEmptyString3.parse(parentRef).trim()
+      }
+    });
+  });
+  agent.command("read <parent-ref> <file>").action(async (parentRef, file, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownFile({
+      command: "osmd.agent.read",
+      runtimeOptions,
+      organizationId,
+      path: normalizeAgentFilePath(file),
+      parentRef: nonEmptyString3.parse(parentRef).trim()
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.agent.read",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  addContentOptions(agent.command("create <parent-ref> <file>")).action(
+    async (parentRef, file, opts, cmd) => {
+      const globals = cmd.optsWithGlobals();
+      const content = await resolveContentInput(opts, globals);
+      const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+      return runWriteFlow({
+        command: "osmd.agent.create",
+        action: "create",
+        runtimeOptions,
+        organizationId,
+        path: normalizeAgentFilePath(file),
+        parentRef: nonEmptyString3.parse(parentRef).trim(),
+        content
+      });
+    }
+  );
+  addContentOptions(agent.command("update <parent-ref> <file>")).action(
+    async (parentRef, file, opts, cmd) => {
+      const globals = cmd.optsWithGlobals();
+      const content = await resolveContentInput(opts, globals);
+      const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+      return runWriteFlow({
+        command: "osmd.agent.update",
+        action: "update",
+        runtimeOptions,
+        organizationId,
+        path: normalizeAgentFilePath(file),
+        parentRef: nonEmptyString3.parse(parentRef).trim(),
+        content
+      });
+    }
+  );
+  const wiki = osmd.command("wiki").description("Agent Wiki files writable by agents; first slice should use index.md and log.md");
+  wiki.command("status <path>").action(async (path, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownStatus({
+      command: "osmd.wiki.status",
+      runtimeOptions,
+      organizationId,
+      path: normalizeWikiPath(path)
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.wiki.status",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  wiki.command("read <path>").action(async (path, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownFile({
+      command: "osmd.wiki.read",
+      runtimeOptions,
+      organizationId,
+      path: normalizeWikiPath(path)
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.wiki.read",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  wiki.command("children [path]").action(async (path, _opts, cmd) => {
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    const result = await requestAgentMarkdownChildren({
+      command: "osmd.wiki.children",
+      runtimeOptions,
+      organizationId,
+      path: typeof path === "string" && path.trim() !== "" ? normalizeWikiPath(path) : "Agent Wiki",
+      source: "agent_wiki"
+    });
+    return printEnvelopeAndExit({
+      envelope: buildSuccessEnvelope({
+        command: "osmd.wiki.children",
+        status: result.status,
+        data: result.data,
+        requestId: result.requestId
+      })
+    });
+  });
+  addContentOptions(wiki.command("create <path>")).action(async (path, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const content = await resolveContentInput(opts, globals);
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    return runWriteFlow({
+      command: "osmd.wiki.create",
+      action: "create",
+      runtimeOptions,
+      organizationId,
+      path: normalizeWikiPath(path),
+      content
+    });
+  });
+  addContentOptions(wiki.command("update <path>")).action(async (path, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const content = await resolveContentInput(opts, globals);
+    const { organizationId, runtimeOptions } = await resolveOsmdContext(cmd);
+    return runWriteFlow({
+      command: "osmd.wiki.update",
+      action: "update",
+      runtimeOptions,
+      organizationId,
+      path: normalizeWikiPath(path),
+      content
+    });
+  });
+}
+
 // src/cli.ts
 function buildCli(options) {
   const program = new import_commander.Command();
@@ -6114,6 +6893,7 @@ function buildCli(options) {
   registerContentCommands(program);
   registerMutationCapabilityCommands(program);
   registerMarkdownTreeCommands(program);
+  registerOsmdCommands(program);
   registerNavigationCommands(program);
   return program;
 }
@@ -6169,13 +6949,13 @@ main().catch((error) => {
     });
     return;
   }
-  if (error instanceof import_zod16.ZodError || error instanceof import_commander2.InvalidArgumentError) {
+  if (error instanceof import_zod17.ZodError || error instanceof import_commander2.InvalidArgumentError) {
     printCliFailure({
       status: 400,
       code: "invalid_args",
       message: "Invalid command arguments.",
       details: {
-        issues: error instanceof import_zod16.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
+        issues: error instanceof import_zod17.ZodError ? error.issues : [{ message: error.message, code: "invalid_argument" }]
       },
       exitCode: EXIT_CODES.invalidArgs
     });