@native-marketing/sdk 0.3.7 → 0.3.8

package/dist/index.js

@@ -2570,6 +2570,7 @@ var permissionSchema = z32.enum([
   "feedback.manage",
   "recommendation.create",
   "package.download",
+  "presentation.share",
   "source.read",
   "source.ingest",
   "source.content.read"
@@ -6934,7 +6935,13 @@ var surveyRejections = [
   "PERSONAL_SURVEY_DRAFT_TRANSITION_IMMUTABLE"
 ];
 function isKnownCapabilityRejection(code2, name) {
-  return capabilityRejectedErrorCodes.includes(code2) || name === "cf_repair_knowledge_reference" && [
+  return name === "cf_issue_human_read_link" && [
+    "HUMAN_TARGET_NOT_FOUND",
+    "HUMAN_CONTENT_TOO_LARGE",
+    "HUMAN_LINK_REQUEST_CONFLICT",
+    "HUMAN_LINK_LIMIT",
+    "HUMAN_LINK_SECRET_UNAVAILABLE"
+  ].includes(code2) || name === "cf_revoke_human_read_link" && code2 === "HUMAN_LINK_REQUEST_CONFLICT" || name === "cf_cleanup_human_read_links" && code2 === "HUMAN_CLEANUP_INPUT_INVALID" || capabilityRejectedErrorCodes.includes(code2) || name === "cf_repair_knowledge_reference" && [
     "KNOWLEDGE_REFERENCE_REPAIR_CONFLICT",
     "KNOWLEDGE_REFERENCE_REPAIR_NOT_SUPPORTED",
     "KNOWLEDGE_REFERENCE_REPAIR_IDENTITY_MISMATCH",
@@ -7008,6 +7015,8 @@ function capabilityRecovery(code2, outcome, name) {
   const change2 = changeCapabilityRecovery(code2, outcome, name);
   if (change2) return change2;
   if (outcome === "UNKNOWN") {
+    if (name === "cf_issue_human_read_link") return "FIND_ORIGINAL_RECEIPT";
+    if (name === "cf_revoke_human_read_link") return "READ_ORIGINAL_LINK_STATE";
     if ([
       "cf_material_verification_start",
       "cf_material_verification_advance",
@@ -7305,6 +7314,110 @@ var knowledgeReferenceRepairCommandSchema = knowledgeReferenceRepairQuerySchema.
 }).strict();
 var knowledgeReferenceRepairReceiptQuerySchema = knowledgeAdoptionReceiptQuerySchema;
 
+// packages/contracts/src/agent/human-presentation.ts
+import { z as z103 } from "zod";
+var reference = z103.string().min(1).max(512);
+var digest = z103.string().regex(/^[a-f0-9]{64}$/u);
+var webUrl = z103.string().url().max(4096).refine((value) => {
+  try {
+    const url = new URL(value);
+    return !url.username && !url.password && !url.search && (url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname));
+  } catch {
+    return false;
+  }
+});
+var packageCode = z103.string().regex(/^PKG-[0-9]{6,}$/u);
+var humanPresentationCapability = "com.native-marketing/human-presentation";
+var humanPresentationFeatures = Object.freeze({
+  version: 1,
+  subjects: ["CONTENT_PACKAGE"],
+  interactions: ["CONTENT_PACKAGE_REVIEW"],
+  links: ["AUTHENTICATED", "TEMPORARY_PUBLIC_READ"],
+  publicRead: "SNAPSHOT"
+});
+var humanPresentationInputSchema = z103.object({ packageCode }).strict();
+var common3 = {
+  linkRef: reference,
+  kind: z103.literal("READABLE_CONTENT"),
+  title: z103.string().min(1).max(500),
+  subjectRef: reference,
+  url: webUrl
+};
+var humanReadLinkSchema = z103.discriminatedUnion("access", [
+  z103.object({
+    ...common3,
+    access: z103.literal("AUTHENTICATED"),
+    representation: z103.literal("CURRENT_VIEW"),
+    expiresAt: z103.null()
+  }).strict(),
+  z103.object({
+    ...common3,
+    access: z103.literal("TEMPORARY_PUBLIC_READ"),
+    representation: z103.literal("SNAPSHOT"),
+    snapshotRef: reference,
+    contentSha256: digest,
+    createdAt: z103.string().datetime(),
+    expiresAt: z103.string().datetime()
+  }).strict()
+]);
+var humanInteractionSchema = z103.object({
+  interactionRef: reference,
+  kind: z103.literal("CONTENT_PACKAGE_REVIEW"),
+  subjectRef: reference,
+  title: z103.string().min(1).max(500),
+  summary: z103.string().max(2e3),
+  state: z103.enum(["PENDING", "APPROVED", "REJECTED", "RESOLVED"]),
+  sourceState: z103.string().min(1).max(80),
+  actionDigest: digest,
+  expiresAt: z103.null(),
+  reviewUrl: webUrl,
+  canReview: z103.boolean()
+}).strict();
+var humanPresentationSchema = z103.object({
+  schemaVersion: z103.literal(1),
+  interactions: z103.array(humanInteractionSchema).max(16),
+  links: z103.array(humanReadLinkSchema).max(16)
+}).strict();
+var humanReadableDocumentSchema = z103.object({
+  schemaVersion: z103.literal(1),
+  title: z103.string().min(1).max(500),
+  subjectRef: reference,
+  manifestHash: digest,
+  sections: z103.array(
+    z103.object({ heading: z103.string().min(1).max(500), text: z103.string().max(131072) }).strict()
+  ).min(1).max(128)
+}).strict();
+var issueHumanReadLinkInputSchema = z103.object({
+  requestId: z103.string().min(1).max(128),
+  packageCode,
+  expectedManifestHash: digest,
+  access: z103.literal("TEMPORARY_PUBLIC_READ"),
+  targetKeys: z103.array(z103.string().min(1).max(64)).min(1).max(32).refine((keys) => new Set(keys).size === keys.length),
+  ttlSeconds: z103.number().int().min(60).max(86400).default(3600)
+}).strict();
+var humanReadLinkLookupSchema = z103.object({ linkRef: z103.string().uuid() }).strict();
+var humanReadLinkReceiptQuerySchema = z103.object({ requestId: z103.string().min(1).max(128) }).strict();
+var revokeHumanReadLinkInputSchema = humanReadLinkLookupSchema.extend({ requestId: z103.string().min(1).max(128) }).strict();
+var humanReadLinkResultSchema = z103.object({
+  linkRef: z103.string().uuid(),
+  issuanceRequestId: z103.string().min(1).max(128),
+  state: z103.enum(["ACTIVE", "EXPIRED", "REVOKED", "UNAVAILABLE"]),
+  packageCode,
+  manifestHash: digest,
+  expiresAt: z103.string().datetime(),
+  human: humanPresentationSchema
+}).strict();
+var humanReadLinkReceiptSchema = z103.discriminatedUnion("status", [
+  z103.object({ status: z103.literal("FOUND"), receipt: humanReadLinkResultSchema }).strict(),
+  z103.object({ status: z103.literal("NOT_FOUND") }).strict()
+]);
+var cleanupHumanReadLinksInputSchema = z103.object({ limit: z103.number().int().min(1).max(32).default(16) }).strict();
+var cleanupHumanReadLinksResultSchema = z103.object({
+  reclaimed: z103.number().int().nonnegative().max(32),
+  limit: z103.number().int().min(1).max(32)
+}).strict();
+var humanPresentationResultSchema = z103.object({ human: humanPresentationSchema }).strict();
+
 // packages/contracts/src/agent/capability-receipts.ts
 var rule = (capability, schema2, operation, keys = [], field) => ({ capability, schema: schema2, operation, keys, field });
 var foundation = (operation, field) => rule(
@@ -7531,6 +7644,18 @@ var rules = {
 };
 var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function capabilityReceiptRead(name, input) {
+  if (name === "cf_issue_human_read_link") {
+    const parsed2 = humanReadLinkReceiptQuerySchema.safeParse({
+      requestId: object(input).requestId
+    });
+    if (!parsed2.success) return void 0;
+    return {
+      capability: "cf_get_human_read_link_receipt",
+      arguments: parsed2.data,
+      requiresDescription: true,
+      requiresCurrentAuthorization: true
+    };
+  }
   const r = name && Object.hasOwn(rules, name) ? rules[name] : void 0;
   if (!r) return void 0;
   const raw = object(input), source = r.field ? object(Object.hasOwn(raw, r.field) ? raw[r.field] : void 0) : raw;
@@ -7553,13 +7678,18 @@ function capabilityReceiptRead(name, input) {
 }
 
 // packages/contracts/src/agent/capability-status.ts
-import { z as z103 } from "zod";
+import { z as z104 } from "zod";
 var verification = {
   capability: "cf_material_verification_status",
   schema: materialVerificationIdSchema,
   key: "jobId"
 };
 var rules2 = {
+  cf_revoke_human_read_link: {
+    capability: "cf_get_human_read_link",
+    schema: humanReadLinkLookupSchema,
+    key: "linkRef"
+  },
   cf_material_verification_start: { ...verification, from: "requestId" },
   cf_material_verification_advance: verification,
   cf_material_verification_retry: verification,
@@ -7571,7 +7701,7 @@ var rules2 = {
   },
   cf_tenant_material_scan_advance: {
     capability: "cf_tenant_material_scan_status",
-    schema: z103.object({}).strict()
+    schema: z104.object({}).strict()
   },
   cf_sync_materials: {
     capability: "cf_reconcile_materials",
@@ -7599,13 +7729,13 @@ function capabilityStatusRead(name, input) {
 }
 
 // packages/contracts/src/client-lifecycle.ts
-import { z as z104 } from "zod";
+import { z as z105 } from "zod";
 
 // packages/contracts/src/generated/client-release.ts
 var nativeClientRelease = {
   schemaVersion: 1,
   product: "native-marketing",
-  version: "0.3.7",
+  version: "0.3.8",
   packages: {
     sdk: "@native-marketing/sdk",
     cli: "@native-marketing/cli"
@@ -7615,41 +7745,41 @@ var nativeClientRelease = {
   apiMajor: 1,
   nodeMajor: 24,
   changes: [
-    "Unified SDK, CLI and MCP release discovery and compatibility checks.",
-    "Configurable CLI update notifications, pins and compatible automatic updates.",
-    "Upgrade verification and explicit continuation without replaying business commands."
+    "Unified typed human interaction cards and authenticated reading links across SDK, CLI and MCP.",
+    "Explicitly authorized expiring public read-only package text snapshots with original request recovery and revocation.",
+    "Bound human presentation responses to the configured Project, original issuance request and source version."
   ]
 };
 
 // packages/contracts/src/client-lifecycle.ts
 var nativeReleaseCapability = "com.native-marketing/client-release";
-var releaseVersionSchema = z104.string().max(128).regex(
+var releaseVersionSchema = z105.string().max(128).regex(
   /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/
 );
-var clientIdentitySchema = z104.object({
+var clientIdentitySchema = z105.object({
   version: releaseVersionSchema,
-  contractVersion: z104.number().int().positive(),
-  apiMajor: z104.number().int().positive()
+  contractVersion: z105.number().int().positive(),
+  apiMajor: z105.number().int().positive()
 });
-var clientReleaseSchema = z104.object({
-  schemaVersion: z104.literal(1),
-  product: z104.literal("native-marketing"),
+var clientReleaseSchema = z105.object({
+  schemaVersion: z105.literal(1),
+  product: z105.literal("native-marketing"),
   version: releaseVersionSchema,
-  packages: z104.object({
-    sdk: z104.literal("@native-marketing/sdk"),
-    cli: z104.literal("@native-marketing/cli")
+  packages: z105.object({
+    sdk: z105.literal("@native-marketing/sdk"),
+    cli: z105.literal("@native-marketing/cli")
   }),
-  contractVersion: z104.number().int().positive(),
+  contractVersion: z105.number().int().positive(),
   minimumClientVersion: releaseVersionSchema,
-  apiMajor: z104.number().int().positive(),
-  nodeMajor: z104.number().int().positive(),
-  changes: z104.array(z104.string().min(1).max(240)).max(8).default([])
+  apiMajor: z105.number().int().positive(),
+  nodeMajor: z105.number().int().positive(),
+  changes: z105.array(z105.string().min(1).max(240)).max(8).default([])
 });
-var updatePolicySchema = z104.object({
-  mode: z104.enum(["off", "notify", "auto"]).default("notify"),
-  channel: z104.enum(["latest", "next", "beta"]).default("latest"),
+var updatePolicySchema = z105.object({
+  mode: z105.enum(["off", "notify", "auto"]).default("notify"),
+  channel: z105.enum(["latest", "next", "beta"]).default("latest"),
   pin: releaseVersionSchema.nullable().default(null),
-  intervalHours: z104.number().int().min(1).max(168).default(24)
+  intervalHours: z105.number().int().min(1).max(168).default(24)
 }).strict();
 var defaultUpdatePolicy = updatePolicySchema.parse({});
 function compareReleaseVersions(left, right) {
@@ -7687,30 +7817,30 @@ function assessNativeCompatibility(client, server) {
 }
 
 // packages/contracts/src/client-update-policy.ts
-import { z as z105 } from "zod";
-var registryReleaseSchema = z105.object({
-  name: z105.enum(["@native-marketing/sdk", "@native-marketing/cli"]),
+import { z as z106 } from "zod";
+var registryReleaseSchema = z106.object({
+  name: z106.enum(["@native-marketing/sdk", "@native-marketing/cli"]),
   version: releaseVersionSchema,
-  deprecated: z105.string().optional(),
-  nativeMarketing: z105.object({
-    contractVersion: z105.number().int().positive(),
-    apiMajor: z105.number().int().positive(),
-    nodeMajor: z105.number().int().positive(),
-    changes: z105.array(z105.string().min(1).max(240)).max(8).optional()
+  deprecated: z106.string().optional(),
+  nativeMarketing: z106.object({
+    contractVersion: z106.number().int().positive(),
+    apiMajor: z106.number().int().positive(),
+    nodeMajor: z106.number().int().positive(),
+    changes: z106.array(z106.string().min(1).max(240)).max(8).optional()
   }).optional(),
-  dist: z105.object({
-    integrity: z105.string().max(512).regex(/^sha512-[A-Za-z0-9+/]{86}==$/)
+  dist: z106.object({
+    integrity: z106.string().max(512).regex(/^sha512-[A-Za-z0-9+/]{86}==$/)
   })
 });
-var clientUpdateStateSchema = z105.object({
-  schemaVersion: z105.literal(1),
+var clientUpdateStateSchema = z106.object({
+  schemaVersion: z106.literal(1),
   policy: updatePolicySchema,
-  lastCheck: z105.object({
-    at: z105.number().int().nonnegative(),
-    selector: z105.string().max(160),
+  lastCheck: z106.object({
+    at: z106.number().int().nonnegative(),
+    selector: z106.string().max(160),
     target: registryReleaseSchema
   }).strict().optional(),
-  lastAttempt: z105.object({ at: z105.number().int().nonnegative(), selector: z105.string().max(160) }).strict().optional()
+  lastAttempt: z106.object({ at: z106.number().int().nonnegative(), selector: z106.string().max(160) }).strict().optional()
 }).strict();
 function planNativeUpdate(input) {
   const target = registryReleaseSchema.parse(input.target);
@@ -7768,6 +7898,48 @@ function planNativeUpdate(input) {
   return compatibleLine && stable ? result2("UPDATE_AVAILABLE", "COMPATIBLE_UPDATE", true) : result2("UPDATE_AVAILABLE", "REVIEW_REQUIRED");
 }
 
+// packages/contracts/src/agent/human-presentation-validation.ts
+function validateHumanPresentationResource(human, resource, packageCode2) {
+  try {
+    const base2 = new URL(resource);
+    const project = /^\/mcp\/projects\/(PRJ-[0-9]{6,})$/u.exec(base2.pathname)?.[1];
+    if (!project || base2.username || base2.password || base2.search || base2.hash) return false;
+    const review = (raw) => {
+      const url = new URL(raw);
+      return url.origin === base2.origin && !url.username && !url.password && !url.search && !url.hash && (packageCode2 ? url.pathname === `/projects/${project}/packages/${packageCode2}` : new RegExp(`^/projects/${project}/packages/PKG-[0-9]{6,}$`, "u").test(url.pathname));
+    };
+    return human.interactions.every((item) => review(item.reviewUrl)) && human.links.every((link) => {
+      if (link.access === "AUTHENTICATED") return review(link.url);
+      const url = new URL(link.url);
+      return url.origin === base2.origin && !url.username && !url.password && !url.search && url.pathname === `/api/v1/human-read/${link.linkRef}` && /^#[A-Za-z0-9_-]{43}$/u.test(url.hash) && link.snapshotRef === `sha256:${link.contentSha256}` && Date.parse(link.expiresAt) > Date.parse(link.createdAt);
+    });
+  } catch {
+    return false;
+  }
+}
+function validateHumanPresentationResponse(parsed, resource, input, operation) {
+  const value = parsed.status === "FOUND" ? parsed.receipt : parsed;
+  if (!("human" in value)) return true;
+  const human = value.human;
+  if (!validateHumanPresentationResource(
+    human,
+    resource,
+    typeof value.packageCode === "string" ? value.packageCode : input.packageCode
+  ))
+    return false;
+  if (input.packageCode && value.packageCode && value.packageCode !== input.packageCode)
+    return false;
+  if (input.expectedManifestHash && value.manifestHash !== input.expectedManifestHash) return false;
+  if (input.linkRef && value.linkRef !== input.linkRef) return false;
+  if (input.requestId && operation !== "cf_revoke_human_read_link" && value.issuanceRequestId !== input.requestId)
+    return false;
+  const links = human.links;
+  if (value.state === "ACTIVE" && (links.length !== 1 || links[0]?.access !== "TEMPORARY_PUBLIC_READ" || links[0].linkRef !== value.linkRef || links[0].expiresAt !== value.expiresAt))
+    return false;
+  if (value.state && value.state !== "ACTIVE" && links.length) return false;
+  return true;
+}
+
 // packages/cli-client/src/errors.ts
 var CliError = class extends Error {
   constructor(code2, message, outcome = "NOT_SENT", details) {
@@ -8243,6 +8415,7 @@ async function refreshNativeServerVersion(client, timeout) {
 }
 
 // packages/cli-client/src/transport.ts
+var resources = /* @__PURE__ */ new WeakMap();
 async function withClient(profile, timeout, operation, options = {}) {
   const resource = resourceUrl(profile.resource);
   const accessToken = tokenText(profile.accessToken);
@@ -8271,6 +8444,7 @@ async function withClient(profile, timeout, operation, options = {}) {
       reconnectionDelayGrowFactor: 1
     }
   });
+  resources.set(client, resource.href);
   try {
     try {
       await client.connect(transport, { timeout });
@@ -8286,6 +8460,7 @@ async function withClient(profile, timeout, operation, options = {}) {
     options.onVersion?.(version);
     return await operation(client);
   } finally {
+    resources.delete(client);
     await client.close().catch(() => void 0);
   }
 }
@@ -8293,13 +8468,14 @@ async function callTool(client, tool5, input, timeout, readOnly, errorToolName =
   if (["cf_call_capability", "cf_read_capability", "cf_write_capability"].includes(tool5.name) && errorToolName === tool5.name && typeof input.name === "string" && /^cf_[a-z0-9_]{1,100}$/.test(input.name))
     errorToolName = input.name;
   const original = ["cf_call_capability", "cf_read_capability", "cf_write_capability"].includes(tool5.name) && input.name === errorToolName ? input.arguments : input;
-  const unknown = (code2, message) => {
+  const unknown = (code2, message, human) => {
     const receipt = capabilityReceiptRead(errorToolName, original);
     const status = capabilityStatusRead(errorToolName, original);
     return new CliError(code2, message, "UNKNOWN", {
       recovery: capabilityRecovery(code2, "UNKNOWN", errorToolName),
       ...receipt ? { receipt } : {},
-      ...status ? { status } : {}
+      ...status ? { status } : {},
+      ...human ? { human } : {}
     });
   };
   let result2;
@@ -8321,16 +8497,21 @@ async function callTool(client, tool5, input, timeout, readOnly, errorToolName =
     );
   }
   if ("resultType" in result2 && result2.resultType === "input_required") {
+    const raw = result2._meta?.[humanPresentationCapability];
+    const parsed = raw && Buffer.byteLength(JSON.stringify(raw)) <= 128 * 1024 ? humanPresentationSchema.safeParse(raw) : null;
+    const resource = resources.get(client);
+    const human = parsed?.success && resource && validateHumanPresentationResource(parsed.data, resource) ? parsed.data : void 0;
     if (!readOnly)
       throw unknown(
         "INPUT_REQUIRED",
-        "Resolve additional input explicitly after confirming the original outcome. No automatic fulfilment or retry was made."
+        "Resolve additional input explicitly after confirming the original outcome. No automatic fulfilment or retry was made.",
+        human
       );
     throw new CliError(
       "INPUT_REQUIRED",
       "Resolve additional input explicitly; no automatic fulfilment or retry was made.",
       "REJECTED",
-      { recovery: "RESOLVE_INPUT_EXPLICITLY" }
+      { recovery: "RESOLVE_INPUT_EXPLICITLY", ...human ? { human } : {} }
     );
   }
   if (result2.isError) {
@@ -9094,6 +9275,185 @@ async function uploadNativeMaterial(connection, file, timeout = 3e4) {
   return materialUploadCommandResultSchema.parse(await uploadFile(connection, file, timeout));
 }
 
+// packages/cli-client/src/human-presentation.ts
+var humanCommands = {
+  "human show": {
+    name: "cf_get_human_presentation",
+    input: humanPresentationInputSchema,
+    output: humanPresentationResultSchema,
+    readOnly: true
+  },
+  "human issue-link": {
+    name: "cf_issue_human_read_link",
+    input: issueHumanReadLinkInputSchema,
+    output: humanReadLinkResultSchema,
+    readOnly: false
+  },
+  "human link": {
+    name: "cf_get_human_read_link",
+    input: humanReadLinkLookupSchema,
+    output: humanReadLinkResultSchema,
+    readOnly: true
+  },
+  "human receipt": {
+    name: "cf_get_human_read_link_receipt",
+    input: humanReadLinkReceiptQuerySchema,
+    output: humanReadLinkReceiptSchema,
+    readOnly: true
+  },
+  "human revoke-link": {
+    name: "cf_revoke_human_read_link",
+    input: revokeHumanReadLinkInputSchema,
+    output: humanReadLinkResultSchema,
+    readOnly: false
+  },
+  "human cleanup-links": {
+    name: "cf_cleanup_human_read_links",
+    input: cleanupHumanReadLinksInputSchema,
+    output: cleanupHumanReadLinksResultSchema,
+    readOnly: false
+  }
+};
+function invalid6() {
+  return new CliError(
+    "INVALID_HUMAN_PRESENTATION",
+    "The human presentation cannot be verified against this exact product resource."
+  );
+}
+async function invoke2(client, resource, raw, name, inputSchema, outputSchema, readOnly, timeout) {
+  const request = inputSchema.safeParse(raw);
+  if (!request.success)
+    throw new CliError("INVALID_HUMAN_INPUT", "Use the exact human presentation input schema.");
+  const capability = client.getServerCapabilities()?.experimental?.[humanPresentationCapability];
+  if (capability?.version !== 1)
+    throw new CliError(
+      "HUMAN_PRESENTATION_UNSUPPORTED",
+      "This service has not declared human presentation version 1."
+    );
+  const tool5 = {
+    name,
+    inputSchema: {
+      type: "object",
+      ...inputSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" })
+    },
+    annotations: { readOnlyHint: readOnly }
+  };
+  const result2 = await callTool(client, tool5, request.data, timeout, readOnly);
+  try {
+    const parsed = outputSchema.parse(result2);
+    if (Buffer.byteLength(JSON.stringify(parsed)) > 128 * 1024) throw invalid6();
+    if (!validateHumanPresentationResponse(
+      parsed,
+      resource,
+      request.data,
+      name
+    ))
+      throw invalid6();
+    return parsed;
+  } catch {
+    const outcome = readOnly ? "REJECTED" : "UNKNOWN";
+    const receipt = capabilityReceiptRead(name, request.data);
+    const status = capabilityStatusRead(name, request.data);
+    throw new CliError(
+      "INVALID_HUMAN_PRESENTATION",
+      "Cannot verify this exact response. Query the original request before another write.",
+      outcome,
+      {
+        recovery: capabilityRecovery("INVALID_HUMAN_PRESENTATION", outcome, name),
+        ...!readOnly && receipt ? { receipt } : {},
+        ...!readOnly && status ? { status } : {},
+        ...request.data.requestId ? { requestId: request.data.requestId } : {},
+        ...request.data.linkRef ? { linkRef: request.data.linkRef } : {}
+      }
+    );
+  }
+}
+function getNativeHumanPresentation(client, resource, input, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_get_human_presentation",
+    humanPresentationInputSchema,
+    humanPresentationResultSchema,
+    true,
+    timeout
+  );
+}
+function issueNativeHumanReadLink(client, resource, input, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_issue_human_read_link",
+    issueHumanReadLinkInputSchema,
+    humanReadLinkResultSchema,
+    false,
+    timeout
+  );
+}
+function getNativeHumanReadLink(client, resource, input, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_get_human_read_link",
+    humanReadLinkLookupSchema,
+    humanReadLinkResultSchema,
+    true,
+    timeout
+  );
+}
+function getNativeHumanReadLinkReceipt(client, resource, input, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_get_human_read_link_receipt",
+    humanReadLinkReceiptQuerySchema,
+    humanReadLinkReceiptSchema,
+    true,
+    timeout
+  );
+}
+function revokeNativeHumanReadLink(client, resource, input, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_revoke_human_read_link",
+    revokeHumanReadLinkInputSchema,
+    humanReadLinkResultSchema,
+    false,
+    timeout
+  );
+}
+function cleanupNativeHumanReadLinks(client, resource, input = {}, timeout = 3e4) {
+  return invoke2(
+    client,
+    resource,
+    input,
+    "cf_cleanup_human_read_links",
+    cleanupHumanReadLinksInputSchema,
+    cleanupHumanReadLinksResultSchema,
+    false,
+    timeout
+  );
+}
+async function runHumanCommand(client, resource, name, input, timeout) {
+  const spec = humanCommands[name];
+  return invoke2(
+    client,
+    resource,
+    input,
+    spec.name,
+    spec.input,
+    spec.output,
+    spec.readOnly,
+    timeout
+  );
+}
+
 // packages/cli-client/src/business-search.ts
 var tool4 = (name, schema2) => ({
   name,
@@ -9108,17 +9468,17 @@ var document = tool4("cf_read_business_document", businessDocumentInputSchema);
 async function searchNativeBusiness(client, raw = {}, timeout = 3e4) {
   checkTimeout3(timeout);
   const input = businessSearchQuerySchema.safeParse(raw);
-  if (!input.success) throw invalid6("INVALID_BUSINESS_SEARCH_QUERY", "NOT_SENT");
+  if (!input.success) throw invalid7("INVALID_BUSINESS_SEARCH_QUERY", "NOT_SENT");
   const value = await callTool(client, search, input.data, timeout, true);
   const parsed = businessSearchPageSchema.safeParse(value);
   if (!parsed.success || Buffer.byteLength(JSON.stringify(value)) > 16 * 1024)
-    throw invalid6("INVALID_BUSINESS_SEARCH_REPLY");
+    throw invalid7("INVALID_BUSINESS_SEARCH_REPLY");
   return parsed.data;
 }
 async function readNativeBusinessPage(client, raw, timeout = 3e4) {
   checkTimeout3(timeout);
   const input = businessContentPageReadSchema.safeParse(raw);
-  if (!input.success) throw invalid6("INVALID_BUSINESS_CONTENT_QUERY", "NOT_SENT");
+  if (!input.success) throw invalid7("INVALID_BUSINESS_CONTENT_QUERY", "NOT_SENT");
   const { offset, expectedDocumentHash, ...sourceInput } = input.data;
   const args = businessDocumentInputSchema.parse({
     sourceTool: "cf_read_business_content",
@@ -9129,18 +9489,18 @@ async function readNativeBusinessPage(client, raw, timeout = 3e4) {
   const value = await callTool(client, document, args, timeout, true);
   const parsed = businessContentPageSchema.safeParse(value);
   if (!parsed.success || Buffer.byteLength(JSON.stringify(value)) > 6e3)
-    throw invalid6("INVALID_BUSINESS_CONTENT_REPLY");
+    throw invalid7("INVALID_BUSINESS_CONTENT_REPLY");
   const p = parsed.data;
   if (p.sourceInput.ref !== sourceInput.ref || p.sourceInput.expectedVersion !== sourceInput.expectedVersion || p.offset !== offset || expectedDocumentHash && p.documentHash !== expectedDocumentHash || (p.hasMore ? p.nextOffset !== offset + [...p.text].length : p.nextOffset !== null) || p.hasMore !== offset + [...p.text].length < p.totalCharacters)
-    throw invalid6("INVALID_BUSINESS_CONTENT_REPLY");
+    throw invalid7("INVALID_BUSINESS_CONTENT_REPLY");
   return p;
 }
-function invalid6(code2, outcome = "REJECTED") {
+function invalid7(code2, outcome = "REJECTED") {
   return new CliError(code2, "Use the exact bounded search or content-page contract.", outcome);
 }
 function checkTimeout3(value) {
   if (!Number.isInteger(value) || value < 100 || value > 12e4)
-    throw invalid6("INVALID_TIMEOUT", "NOT_SENT");
+    throw invalid7("INVALID_TIMEOUT", "NOT_SENT");
 }
 
 // packages/cli-client/src/client.ts
@@ -9160,6 +9520,12 @@ async function withNativeAgentClient(connection, action, options = {}) {
       return action(
         new Proxy(
           {
+            getHumanPresentation: (input) => getNativeHumanPresentation(client, connection.resource, input, timeout),
+            issueHumanReadLink: (input) => issueNativeHumanReadLink(client, connection.resource, input, timeout),
+            getHumanReadLink: (input) => getNativeHumanReadLink(client, connection.resource, input, timeout),
+            getHumanReadLinkReceipt: (input) => getNativeHumanReadLinkReceipt(client, connection.resource, input, timeout),
+            revokeHumanReadLink: (input) => revokeNativeHumanReadLink(client, connection.resource, input, timeout),
+            cleanupHumanReadLinks: (input = {}) => cleanupNativeHumanReadLinks(client, connection.resource, input, timeout),
             getVersion: () => structuredClone(version),
             refreshVersion: async () => {
               definitions.clear();
@@ -9695,6 +10061,7 @@ var fullHelp = {
     "tools inspect <cf_tool>",
     "tools call <cf_tool> [--input-file <file>|--stdin]",
     ...Object.keys(commandTools).map((name) => `${name} [--input-file <file>|--stdin]`),
+    ...Object.keys(humanCommands).map((name) => `${name} [--input-file <file>|--stdin]`),
     "task read <kind> --job JOB-000001",
     "result submit <kind> (--input-file <file>|--stdin)"
   ],
@@ -9754,6 +10121,13 @@ function groupHelp(group) {
 function resolveBaseCommand(parsed) {
   const { words, options } = parsed;
   const name = words.join(" ");
+  if (Object.hasOwn(humanCommands, name)) {
+    if (Object.keys(options).some(
+      (key2) => !["input-file", "stdin", "profile", "json", "timeout-ms"].includes(key2)
+    ))
+      throw new CliError("INVALID_OPTION", "Unsupported human presentation option.");
+    return { mode: "human" };
+  }
   if (name === "media file" || name === "packages file") {
     if (Object.keys(options).some(
       (k) => !["output-file", "profile", "input-file", "stdin", "timeout-ms", "json"].includes(k)
@@ -9907,6 +10281,14 @@ function resolveCommand(parsed) {
 async function businessCommand(client, parsed, input, resource) {
   const resolved = resolveCommand(parsed);
   const { timeout, options } = parsed;
+  if (resolved.mode === "human")
+    return runHumanCommand(
+      client,
+      resource,
+      parsed.words.join(" "),
+      input,
+      timeout
+    );
   if (resolved.mode === "document")
     return readNativeDocumentPage(
       client,
@@ -9974,6 +10356,8 @@ async function businessCommand(client, parsed, input, resource) {
 // packages/cli-client/src/cli/command-input.ts
 function validateCommandInput(parsed, input) {
   const mode = resolveCommand(parsed).mode;
+  if (mode === "human" && !humanCommands[parsed.words.join(" ")].input.safeParse(input).success)
+    throw new CliError("INVALID_HUMAN_INPUT", "Use the exact human presentation JSON input.");
   if (mode === "upload" && parsed.words.join(" ") === "media upload" && !projectMediaWebUploadSchema.omit({ requestId: true }).safeParse(input).success)
     throw new CliError("INVALID_UPLOAD_INPUT", "Supply explicit real-media provenance JSON.");
   const schemas = {
@@ -10564,19 +10948,55 @@ async function runNetworkCli(args, env = process.env, io = {}, executable = "cf"
 function success(command5, data) {
   return { exitCode: 0, envelope: { ok: true, command: command5, data, error: null } };
 }
+
+// packages/cli-client/src/cli/output.ts
+function formatNetworkCliResult(result2, json = false) {
+  const { envelope } = result2;
+  if (!json && envelope.ok && envelope.command.startsWith("human ")) {
+    const data = envelope.data;
+    const value = data.status === "FOUND" ? data.receipt : data;
+    const parsed = humanPresentationSchema.safeParse(value.human);
+    if (parsed.success) {
+      const lines = [envelope.command, ...value.state ? [`\u72B6\u6001\uFF1A${value.state}`] : []];
+      for (const card of parsed.data.interactions)
+        lines.push(
+          `${card.title} \xB7 ${card.state}`,
+          card.summary,
+          `\u6B63\u5F0F\u5BA1\u6838\u5165\u53E3\uFF08\u9700\u8981\u767B\u5F55\uFF09\uFF1A${card.reviewUrl}`
+        );
+      for (const link of parsed.data.links)
+        lines.push(
+          `${link.title} \xB7 \u9605\u8BFB`,
+          link.access === "TEMPORARY_PUBLIC_READ" ? `\u4E34\u65F6\u516C\u5F00\u53EA\u8BFB\u5FEB\u7167\uFF1B\u6301\u94FE\u63A5\u8005\u65E0\u9700\u767B\u5F55\u3002\u5230\u671F\uFF1A${link.expiresAt}` : "\u5F53\u524D\u5185\u5BB9\uFF1B\u9700\u8981\u767B\u5F55\u3002",
+          link.url
+        );
+      if (value.issuanceRequestId) lines.push(`\u539F\u7B7E\u53D1\u8BF7\u6C42\uFF1A${value.issuanceRequestId}`);
+      if (!parsed.data.links.length && !parsed.data.interactions.length)
+        lines.push("\u5F53\u524D\u65E0\u53EF\u7528\u9605\u8BFB\u94FE\u63A5\u6216\u4EA4\u4E92\u3002");
+      return lines.join("\n") + "\n";
+    }
+  }
+  return JSON.stringify(envelope, null, json ? void 0 : 2) + "\n";
+}
 export {
   CliError as NativeAgentClientError,
   assessNativeCompatibility,
   callNativeCapability,
   callNativeTool,
   checkNativeUpdates,
+  cleanupNativeHumanReadLinks,
   defaultUpdatePolicy,
   describeNativeCapability,
   findAgentCapabilities,
   findNativeCapabilities,
+  formatNetworkCliResult,
   getNativeBusinessSummary,
   getNativeClientVersion,
+  getNativeHumanPresentation,
+  getNativeHumanReadLink,
+  getNativeHumanReadLinkReceipt,
   inspectNativeTool,
+  issueNativeHumanReadLink,
   listNativeToolsPage,
   planNativeUpdate,
   projectMediaFileQuerySchema,
@@ -10587,6 +11007,7 @@ export {
   readNativeDocumentPage,
   readNativePackageFile,
   readNativeProjectMediaFile,
+  revokeNativeHumanReadLink,
   runNetworkCli,
   searchNativeBusiness,
   uploadNativeMaterial,