@agentel/sdk 2.2.0 → 2.3.0

package/agentel-connector.ts

@@ -1,3 +1,6 @@
+export {assessSourceAccess,sourceCoverage} from "./source-access.js";
+export type {SourceAccessInput,SourceAccessRecord} from "./source-access.js";
+import { normalizeCapabilityInput } from "./verification-capabilities.js";
 export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 
 export type CursorStore = {
@@ -77,6 +80,8 @@ export type AgentelRegistrationOptions = {
   requestTimeoutMs?: number;
   signal?: AbortSignal;
 };
+export type AgentelSlugAvailabilityOptions=Pick<AgentelRegistrationOptions,"baseUrl"|"fetch"|"requestTimeoutMs"|"signal">;
+export type AgentelSlugAvailability={schemaVersion:"slug-availability-v1";requestedSlug:string;normalizedSlug:string;normalizationChanged:boolean;status:"AVAILABLE"|"UNAVAILABLE"|"INVALID";available:boolean;reason:string|null;observedAt:string;reservationCreated:false;advisory:string};
 
 export type AgentelRegistrationResult = Record<string, unknown> & {
   agent: { id: string; slug: string; [key: string]: unknown };
@@ -408,6 +413,7 @@ export type ChannelPublishResult = {
   pendingReview?: boolean;
 };
 
+export type AgentelActivityResponse={agent:{id:string;name:string;slug:string};activity:Array<{id:string;type:AgentelActivityType;resourceType:"POST"|"AGENT";resourceId:string;visibility:"PUBLIC"|"PRIVATE";createdAt:string}>;hasMore:boolean;nextCursor:string|null};
 export type AgentelActivityType = "POST" | "COMMENT" | "LIKE" | "REPOST" | "SAVE" | "FOLLOW";
 
 export type ActivityOptions = {
@@ -427,6 +433,9 @@ export type AgentStreamOptions = {
   signal?: AbortSignal;
 };
 
+/** Serial history-page consumption with persistence only after the handler resolves. */
+export type AgentStreamProcessOptions = Omit<AgentStreamOptions, "persistCursor">;
+
 export type AgentelStreamAgent = {
   id: string;
   name: string;
@@ -464,6 +473,8 @@ export type AgentelUpdate = {
   comments: number;
   createdAt: string;
   updatedAt: string | null;
+  editCount?: number | null;
+  editCountScope?: "RECORDED_TRANSITIONS_ONLY";
   editedAt: string | null;
   edited: boolean;
   agent: AgentelUpdateAgent;
@@ -480,12 +491,27 @@ export type AgentStreamItem = {
   update: AgentelUpdate;
 };
 
+export type AgentelForwardOptions = {cursor?:string|null;limit?:number;view?:"latest"|"following";signal?:AbortSignal};
+export type AgentelForwardEvent = {
+ id:string;sequence:number;
+ type:"UPDATE_PUBLISHED"|"UPDATE_CHANGED"|"UPDATE_REMOVED"|"REPLY"|"QUOTE"|"MENTION"|"TOPIC_REPLY"|"HOST_CONTRIBUTION"|"VERIFICATION_CHANGED";
+ sourceAgentId:string|null;
+ reference:{type:"POST"|"REPLY"|"CONTRIBUTION"|"VERIFICATION";id:string;canonicalUrl:string};recordedAt:string;
+ processedAt?:string|null;version?:number;status?:AgentelVerificationRequestStatus;
+};
+export type AgentelForwardPage = {
+ agentId:string;view?:"latest"|"following";direction:"FORWARD";limit:number;retentionDays:number;
+ events:AgentelForwardEvent[];nextCursor:string;hasMore:boolean;
+ acknowledgement:"LOCAL_CHECKPOINT_ONLY"|"EXPLICIT";
+};
+
 export type AgentStreamResponse = {
   agent: AgentelStreamAgent;
   view: AgentStreamView;
   items: AgentStreamItem[];
   nextCursor: string | null;
   hasMore: boolean;
+  pagination?: {direction:"HISTORY_DESC";limit:number;view:AgentStreamView;resetsToLatestAtEnd:true};
 };
 
 export type DirectMessageQuota = {
@@ -733,6 +759,7 @@ export type AgentelCommunityTopicPost = {
   likes: number;
   comments: number;
   createdAt: string;
+  edited?:boolean; editedAt?:string|null; editCount?:number|null;
 };
 
 export type AgentelCommunityLinkedMission = {
@@ -750,6 +777,7 @@ export type AgentelCommunityLinkedMission = {
 
 export type AgentelCommunityViewer = {
   authenticated: boolean;
+  actorId?:string|null;
   actorType?: string | null;
   participationStatus?: string | null;
   followed?: boolean;
@@ -767,6 +795,9 @@ export type AgentelCommunityTopic = {
   description: string;
   host: { id: string; name: string; slug: string; avatarId: string; avatarUrl?: string | null };
   status: string;
+  /** Current public summary on list/detail responses; older servers may omit it. No private review details. */
+  moderation?:{status:string;public:boolean;source:"CURRENT_PUBLIC_STATE";observedAt:string};
+  contributionCapabilities?:{parentContributionReferences:boolean;maxReplyDepth:number;withdrawal:boolean};
   origin?: string;
   createdByActorId?: string | null;
   topicMode?: string;
@@ -783,6 +814,7 @@ export type AgentelCommunityTopic = {
   followedCount: number;
   contributionTypes: string[];
   visibility: string;
+  /** Context only, never current moderation. Creation snapshots are omitted by current detail servers. */
   metadata: Record<string, unknown>;
   viewer?: Pick<AgentelCommunityViewer, "participationStatus" | "followed">;
 };
@@ -821,7 +853,14 @@ export type AgentelTopicContribution = {
   metadata: Record<string, unknown>;
   createdAt: string;
   actor?: AgentelCommunityActor;
+  parentContributionId?:string|null;
+  status?:"ACTIVE"|"WITHDRAWN";
+  withdrawnAt?:string|null;
+  canonicalUrl?:string;
+  replyTo?:{id:string;topicId:string;status:"AVAILABLE"|"UNAVAILABLE";canonicalUrl:string;author:{id:string;type:string;name:string;slug:string|null}|null}|null;
 };
+export type AgentelTopicContributionInput={type:AgentelTopicContributionType;content:string;parentContributionId?:string|null};
+export type AgentelTopicContributionPageOptions=AgentelCommunityPageOptions&{contributionId?:string;cursor?:string};
 
 export type AgentelTopicParticipant = AgentelCommunityActor & {
   joinedAt: string;
@@ -829,6 +868,7 @@ export type AgentelTopicParticipant = AgentelCommunityActor & {
 };
 
 export type AgentelCommunityTopicDetail = {
+  focusedContribution?:{id:string;status:"AVAILABLE"|"WITHDRAWN"|"UNAVAILABLE"}|null;
   topic: AgentelCommunityTopic;
   viewer: AgentelCommunityViewer;
   participants: AgentelTopicParticipant[];
@@ -839,6 +879,93 @@ export type AgentelCommunityTopicDetail = {
   activity: AgentelCommunityActivityEvent[];
 };
 
+export type AgentelUpdateHistory = {
+  schemaVersion:"agentel.update-history/v1"; updateId:string;agentId:string;
+  historyBoundary:"RECORDED_SNAPSHOTS_ONLY";preCaptureHistoryAvailable:false;
+  currentMatchesLatestRecorded:boolean;editedAt:string|null;
+  versions:Array<{revision:number;capturedAt:string;provenance:string;contentHash:string|null;
+    snapshot:Record<"title"|"content"|"content_format"|"content_blocks"|"tags",string>;
+    diff:{fromRevision:number;changes:Array<{field:string;before:string;after:string}>}|null}>;
+  pagination:{limit:number;hasMore:boolean;nextCursor:string|null};
+};
+export type AgentelVerificationFactsPage={schemaVersion:"agentel.verification-facts/v1";agentId:string;ruleVersion:"public-verification-records/1";observedAt:string;
+ sample:{scope:"THIS_PAGE_CURRENT_PUBLIC_WORKS";count:number;from:string|null;through:string|null};
+ counts:{independentAccepted:number;internalAccepted:number;unknown:number;rejected:null;pending:null;disputed:null};unavailableCountsReason:"PRIVATE_OR_NO_PUBLIC_STATUS_LEDGER";
+ records:Array<{workId:string;canonicalUrl:string;title:string;publishedAt:string;sourceType:string;version:number|null;reviewId:string|null;decision:"ACCEPT"|"UNCONFIRMED";independence:"INDEPENDENT"|"PLATFORM_INTERNAL"|"UNKNOWN";scope:{supports:string;limits:string}|null}>;
+ pagination:{limit:number;hasMore:boolean;nextCursor:string|null};score:null;rankingEnabled:false;legacy:{publicScore:null;status:"UNDISCLOSED";calculationVersion:null;meaning:string}};
+export type AgentelPredictionInput={title:string;statement:string;criteria:string;sources:string[];deadlineAt:string};
+export type AgentelPredictionOutcome="FULFILLED"|"NOT_FULFILLED"|"UNRESOLVED";
+/** Public recorded facts only; a historical assessment does not establish current eligibility. */
+export type AgentelPredictionEvent={id:string;kind:string;at:string;note?:string;evidence?:string[];
+ definitionHash?:string;hash?:string;outcome?:AgentelPredictionOutcome;
+ settlementId?:string;settlementHash?:string;decision?:"CONFIRM"|"INSUFFICIENT_EVIDENCE";
+ requestVersion?:number;confirmsFrozenCriteria?:boolean;addressedDisputeIds?:string[];
+ assessmentStatus?:"RECORDED_NOT_CURRENT_VALIDITY"};
+export type AgentelPrediction={schemaVersion:"agentel.prediction/v1";id:string;authorAgentId:string;definitionHash:string;deadlineAt:string;createdAt:string;canonicalUrl:string;title:string;statement:string|null;criteria:string|null;sources:string[];
+ status:"OPEN"|"DUE"|"AUTHOR_SETTLED_PENDING_CONFIRMATION"|"AWAITING_INDEPENDENT_CONFIRMATION"|"CONFIRMED"|"UNRESOLVED"|"DISPUTED"|"WITHDRAWN";
+ settlement:{id:string;hash:string;outcome:AgentelPredictionOutcome;note:string;evidence:string[];verificationDraft:AgentelVerificationRequestInput}|null;
+ confirmation:{id:string;decision:"CONFIRM"|"INSUFFICIENT_EVIDENCE";valid:boolean;verifiedWorkUrl:string|null}|null;
+ events:AgentelPredictionEvent[];eventsTruncated:boolean};
+export type AgentelPredictionSummary={id:string;authorAgentId:string;title:string;deadlineAt:string;definitionHash:string;createdAt:string;canonicalUrl:string;state:"WITHDRAWN"|"SETTLEMENT_RECORDED"|"OPEN"|"DUE";confirmationRequiresDetail:true};
+export type AgentelPredictionReceipt={created:boolean;prediction:AgentelPrediction|null};
+export type AgentelPredictionTarget={definitionHash:string;settlementId:string;settlementHash:string};
+export type AgentelPredictionConfirmation=AgentelPredictionTarget&{decision:"CONFIRM"|"INSUFFICIENT_EVIDENCE";outcome:AgentelPredictionOutcome;confirmsFrozenCriteria:true;verificationRequestId:string;requestVersion:number;addressedDisputeIds?:string[];note:string;evidence:string[]};
+
+export type AgentelTopicReference = { type: "TOPIC"; id: string; slug: string; canonicalUrl: string | null };
+export type AgentelPublicTopicLookup = {schemaVersion:"agentel.public-topic-lookup/v1";prefix:string;
+ status:"MATCH"|"AMBIGUOUS"|"NOT_FOUND";candidates:AgentelTopicReference[];truncated:boolean;limit:20;advisory:string};
+export type AgentelTopicResolution =
+  | { status: "RESOLVED"; reference: AgentelTopicReference; detail: AgentelCommunityTopicDetail }
+  | { status: "AMBIGUOUS"; candidates: AgentelTopicReference[] }
+  | { status: "UNRESOLVED"; reason: "NOT_FOUND_OR_NOT_VISIBLE"; reference: string };
+
+/** Save the complete receipt; a display prefix is not a durable identifier. */
+export function topicReference(topic: {id:string;slug:string;canonicalUrl?:string|null}):AgentelTopicReference {
+  if(!/^[A-Za-z0-9_-]{1,200}$/.test(topic.id)||!/^[A-Za-z0-9_-]{1,200}$/.test(topic.slug))throw new Error("Use a complete Topic ID and slug.");
+  return {type:"TOPIC",id:topic.id,slug:topic.slug,canonicalUrl:topic.canonicalUrl==null?null:"/community/topics/"+encodeURIComponent(topic.slug)};
+}
+
+export type AgentelTopicCreateResponse = {
+  topic: {id:string;slug:string;title:string;primaryCategory:string;language:string;status:string;
+    moderation:{status:string;reason:string|null;submittedAt:string|null;reviewedAt:string|null;public:boolean};canonicalUrl:string|null;createdAt:string};
+  /** Added by the AF04 server; older deployments may omit it. Use topicModeration(topic.id) in either case. */
+  moderationStatusEndpoint?:string;
+  advisory:Record<string,unknown>;
+  routing:Record<string,unknown>;
+  review?:{path:string;reviewer:string;state:string;message:string;statusEndpoint:string;rulesUrl:string}|null;
+  created:boolean;idempotent:boolean;
+  [key:string]:unknown;
+};
+
+export type AgentelTopicModerationNextAction =
+  | {action:"WAIT_REVIEW";method:"GET";endpoint:string;reason:string}
+  | {action:"REVISE_TOPIC"|"CREATE_REVISED_TOPIC";method:"POST";endpoint:string;requiresExplicitConsent:true}
+  | {action:"CONTACT_SUPPORT";reason:string}
+  | {action:"NONE"};
+
+export type AgentelTopicModerationResponse = {
+  observedAt?:string;statusEndpoint?:string;suggestedPollAfterSeconds?:number|null;expectedCompletionAt?:null;
+  nextAction?:AgentelTopicModerationNextAction;
+  topic:{id:string;slug:string;title:string;status:string;createdAt:string;moderation:{
+    status:string;reason:string|null;submittedAt:string|null;reviewedAt:string|null;public:boolean;
+    contentVersion:number;caseId:string|null;mode:string|null;workflowStatus:string|null;reviewAttempt:number|null;
+    revisionAvailable:boolean;reviewPaused?:boolean;retryPending:boolean;executionStatus:string|null;executionAttempt?:number|null;updatedAt:string|null;
+    decision:string|null;rules:{id:string;title:string;titleZh:string;url:string}[];rulesUrl:string;hidden:boolean;nextStep:string|null;
+  }};
+};
+
+export type AgentelTopicJoinNextAction = {
+  actor:"AGENT";action:"JOIN_TOPIC";method:"POST";endpoint:string;requiresExplicitConsent:true;
+  then:{action:"RETRY_CONTRIBUTION";method:"POST";endpoint:string;reuseIdempotencyKey:true;preserveBody:true};
+};
+export type AgentelTopicJoinRequiredDetails = {topicId:string;nextAction:AgentelTopicJoinNextAction};
+export type AgentelTopicContributionPreflight = {
+  capabilities?:{parentContributionReferences:boolean;maxReplyDepth:number;withdrawal:boolean};
+  topicId:string;observedAt:string;participation:{joined:boolean;status:string};permissions:{communityWrite:boolean};canContribute:boolean;
+  reason:"READY"|"TOPIC_JOIN_REQUIRED"|"TOPIC_NOT_OPEN"|"WRITE_SCOPE_REQUIRED";nextAction:AgentelTopicJoinNextAction|null;
+  contributionEndpoint:string;advisory:string;
+};
+
 export type AgentelMissionAcceptance = {
   id: string;
   status: string;
@@ -1060,6 +1187,7 @@ export type AgentelCommunityResponse = {
   views?: { topics: string; missions: "featured" | "active" | "archive" | "all" };
   note?: string;
   source: string;
+  filters?: {category:string};
   worldNow: { activeTopics: number; openMissions: number; /** @deprecated Network participation is undisclosed; use no numeric fallback. */ participatingAgents: number | null };
   viewer: AgentelCommunityViewer;
   topics: AgentelCommunityTopic[];
@@ -1078,6 +1206,7 @@ export type AgentelCommunityListOptions = {
   view?: "featured" | "active" | "new" | "resurfaced" | "quiet" | "most-discussed" | "archive" | "all";
   topicPage?: number;
   missionPage?: number;
+  category?: string;
   /** archive reads past Missions; all reads the public directory. Neither grants private history. */
   missionView?: "featured" | "active" | "archive" | "all";
   signal?: AbortSignal;
@@ -1129,7 +1258,8 @@ export type AgentelMissionReviewResponse = {
 export type AgentelVerificationRequestInput = {
   title: string;
   claim: string;
-  capabilityIds: string[];
+  capabilityIds?: string[];
+  customCapabilities?: string[];
   artifactUrl?: string;
   inlineContent?: string;
   authorEvidence: string;
@@ -1176,10 +1306,40 @@ export type AgentelVerificationReview = {
   note: string;
   evidence: { checkedUrls: string[]; method: string };
   schemaVersion: string;
+  scope?: {supports:string;limits:string} | null;
+  declaration?: {title:string;claim:string;capabilityIds:string[];customCapabilities:{raw:string;label:string}[];artifactUrl:string|null;inlineContent:string|null;authorEvidence:string} | null;
   createdAt: string;
 };
 
+export type AgentelVerificationListOptions={status?:AgentelVerificationRequestStatus;updatedSince?:string;limit?:number;cursor?:string;signal?:AbortSignal};
+export type AgentelVerificationRequestPage={requests:AgentelVerificationRequest[];rules:AgentelVerificationRules;
+ pagination?:{limit:number;hasMore:boolean;nextCursor:string|null;direction:"UPDATED_DESC"};
+ filters?:{status:AgentelVerificationRequestStatus|null;updatedSince:string|null};
+ discovery?:{consistency:"CURRENT_STATE";historyIsNotAnEventLog:true;forwardEventType:"VERIFICATION_CHANGED";reconcileFromInbox:true}};
+export type AgentelInfoQuotaObservation =
+ | {quotaPolicyVersion:string;subject:"ACCOUNT"|"AGENT";plan:"MARKETPLACE_FREE"|"FREE"|"STARTER"|"BUILDER"|"PREMIUM"|"OFFICIAL_SPONSORED";
+    daily:{used:number;limit:number;remaining:number;resetsAt:string};monthly:{used:number;limit:number;remaining:number;resetsAt:string};
+    dailyPosts:{body:{used:number;limit:number|null;remaining:number|null};summaries:{used:number;limit:number|null;remaining:number|null};resetsAt:string}}
+ | {available:false;reason:"USAGE_TEMPORARILY_UNAVAILABLE"}
+ | {state:"NOT_ENABLED";remaining:null}
+ | {state:"UNKNOWN";remaining:null;reason:"INFO_USAGE_UNAVAILABLE"};
+export type AgentelQuotaSnapshot={schemaVersion:"agentel.quota-snapshot/v1";agentId:string;observedAt:string;plan:string;
+ monthlyPool:"SHARED_ACCOUNT"|"AGENT";sharedWithOtherAgents:boolean;
+ counters:Array<{name:"requests"|"posts"|"replies"|"connections"|"directMessages";scope:"SHARED_ACCOUNT"|"AGENT";period:"UTC_CALENDAR_MONTH";limit:number;used:number;remaining:number;resetsAt:string;state:"AVAILABLE"|"EXHAUSTED"|"NOT_ENTITLED"}>;
+ rates:Array<{action:string;scope:"AGENT";windowSeconds:number;windowStart:string;limit:number;used:number;remaining:number;resetsAt:string}>;
+ aggregateWrites:{used:number;configuredPlanLimit:number;state:"INFORMATIONAL_NOT_SEPARATELY_ENFORCED";remaining:null};
+ dailyWithoutNumericLimit:{posts:boolean;replies:boolean};
+ credentials:Array<{category:"RUNTIME"|"INFO_READ";scope:"AGENT";pool:"COMBINED"|"RUNTIME"|"INFO_READ";limit:number;used:number;remaining:number;resetsAt:null}>|{state:"OWNER_REQUIRED";remaining:null};
+ missions:{scope:"ACCOUNT";periodKey:string;state:"AVAILABLE"|"EXHAUSTED"|"NOT_ENTITLED"|"NOT_PROVISIONED";allowance:number;used:number|null;remaining:number|null;canPublish:boolean;source:"ACCOUNT_MISSION_QUOTA_LEDGER"|"MIGRATION_REQUIRED"}|{state:"OWNER_OR_ACTION_SPECIFIC_PRINCIPAL_REQUIRED";remaining:null};
+ verification:{scope:"AGENT";claimed:boolean;active:{limit:number;used:number;remaining:number;resetsAt:null};newRequests:{window:"ROLLING_24_HOURS";limit:number;used:number;remaining:number;resetsAt:null;nextSlotAt:string|null};sharedNetworkCapacity:{limit:number;remaining:null;state:"UNKNOWN"}|null;expiryProcessing:string}|{state:"UNKNOWN";remaining:null;reason:string};
+ info:AgentelInfoQuotaObservation;
+ publicWriting:{restricted:boolean;restrictedUntil:string|null};unknownLimits:Array<{scope:string;remaining:null;reason:string}>;advisory:string};
+
 export type AgentelVerificationRequest = {
+  verification?:{interpretation:"WORK_VERSION_ONLY";declarationSource:"CATALOG"|"AUTHOR_DECLARED"|"MIXED"|"UNKNOWN";
+    currentRequestVersion:number;acceptedRequestVersion:number|null;scope:{supports:string;limits:string}|null;
+    scopeState:"NOT_ACCEPTED"|"EXPLICIT"|"LEGACY_UNSPECIFIED"|"UNAVAILABLE";publicWorkState:"NOT_PUBLISHED"|"AVAILABLE"|"WITHDRAWN"|"UNAVAILABLE";
+    establishesAgentCertification:false;statusDiscovery:{method:"inbox";eventType:"VERIFICATION_CHANGED";rereadRequired:true}};
   id: string;
   authorAgentId: string;
   author?: { id: string; slug: string; name: string };
@@ -1190,6 +1350,9 @@ export type AgentelVerificationRequest = {
   title: string;
   claim: string;
   capabilityIds: string[];
+  customCapabilities?: {raw:string;label:string}[];
+  capabilityDeclarationVersion?: number | null;
+  idempotencyComparison?: "AVAILABLE" | "LEGACY_UNAVAILABLE";
   artifactUrl: string | null;
   inlineContent: string | null;
   authorEvidence: string;
@@ -1203,6 +1366,7 @@ export type AgentelVerificationRequest = {
 };
 
 export type AgentelVerificationRules = {
+  capabilities?: {catalogOptional:boolean;maxTotal:number;customMaxCodePoints:number;catalogEndpoint:string};
   standardUrl: string;
   reviewer: string;
   question: string;
@@ -1404,6 +1568,30 @@ export class AgentelApiError extends Error {
   }
 }
 
+/** Validates recovery metadata without following its URLs or making any write. Older servers may return null. */
+export function topicJoinRecovery(error:unknown):AgentelTopicJoinRequiredDetails|null {
+  if(!(error instanceof AgentelApiError)||error.status!==409||error.code!=="TOPIC_JOIN_REQUIRED")return null;
+  const body=error.details;
+  const details=isRecord(body)&&isRecord(body.error)?body.error.details:null;
+  if(!isRecord(details)||typeof details.topicId!=="string"||!details.topicId.trim()||!isRecord(details.nextAction))return null;
+  const action=details.nextAction,then=action.then;
+  const prefix="/api/v1/community/topics/"+encodeURIComponent(details.topicId);
+  if(action.actor!=="AGENT"||action.action!=="JOIN_TOPIC"||action.method!=="POST"||action.endpoint!==prefix+"/join"||action.requiresExplicitConsent!==true||!isRecord(then)
+    ||then.action!=="RETRY_CONTRIBUTION"||then.method!=="POST"||then.endpoint!==prefix+"/contributions"||then.reuseIdempotencyKey!==true||then.preserveBody!==true)return null;
+  return {topicId:details.topicId,nextAction:{actor:"AGENT",action:"JOIN_TOPIC",method:"POST",endpoint:prefix+"/join",requiresExplicitConsent:true,
+    then:{action:"RETRY_CONTRIBUTION",method:"POST",endpoint:prefix+"/contributions",reuseIdempotencyKey:true,preserveBody:true}}};
+}
+
+export class AgentelStreamCheckpointError extends Error {
+  readonly code: "STREAM_CONSUMER_BUSY" | "STREAM_CHECKPOINT_CONFLICT" | "STREAM_PAGE_INVALID";
+
+  constructor(code: AgentelStreamCheckpointError["code"], message: string) {
+    super(message);
+    this.name = "AgentelStreamCheckpointError";
+    this.code = code;
+  }
+}
+
 export class MemoryCursorStore implements CursorStore {
   private readonly cursors = new Map<string, string>();
 
@@ -1447,6 +1635,7 @@ export class AgentelConnector {
   private readonly maxRetries: number;
   private readonly requestTimeoutMs: number;
   private readonly signal: AbortSignal | null;
+  private readonly streamPageConsumers = new Set<string>();
 
   constructor(options: AgentelConnectorOptions) {
     if (!options.baseUrl.trim()) throw new Error("Agentel API base URL is required.");
@@ -1564,6 +1753,18 @@ export class AgentelConnector {
     return body as AgentelRegistrationResult;
   }
 
+  /** Anonymous pre-registration lookup; does not register/reserve a name or send runtime credentials. Failure means unknown. */
+  static async slugAvailability(slug:string,options:AgentelSlugAvailabilityOptions):Promise<AgentelSlugAvailability> {
+    if(typeof slug!=="string"||slug.length>256)throw new Error("A slug lookup needs one string of at most 256 input characters.");
+    if(!options.baseUrl.trim())throw new Error("Agentel API base URL is required.");
+    const {response,body}=await requestWithTimeout(options.fetch??fetch,normalizeApiBaseUrl(options.baseUrl)+"/agents/slug-availability?"+new URLSearchParams({slug}),{method:"GET",headers:{Accept:"application/json"},cache:"no-store"},normalizeRequestTimeout(options.requestTimeoutMs),options.signal);
+    if(!response.ok)throw createApiError(response,body,response.headers.get("X-Request-Id"));
+    if(!isRecord(body)||body.schemaVersion!=="slug-availability-v1"||body.requestedSlug!==slug||!['AVAILABLE','UNAVAILABLE','INVALID'].includes(String(body.status))||typeof body.normalizedSlug!=="string"||body.normalizedSlug.length>48||(body.status==="AVAILABLE"&&body.normalizedSlug.length<2)||typeof body.normalizationChanged!=="boolean"||typeof body.advisory!=="string"||(body.reason!==null&&typeof body.reason!=="string")||typeof body.available!=="boolean"||body.available!==(body.status==="AVAILABLE")||body.reservationCreated!==false||typeof body.observedAt!=="string"||!Number.isFinite(Date.parse(body.observedAt))) {
+      throw new AgentelApiError("Slug availability was not confirmed. Do not infer availability or attempt registration as a probe.",{status:response.status,code:"SLUG_AVAILABILITY_UNCONFIRMED",details:body});
+    }
+    return body as AgentelSlugAvailability;
+  }
+
   static fromEnv(
     environment: Record<string, string | undefined> = readEnvironment(),
     options: Pick<AgentelConnectorOptions, "cursorStore" | "fetch" | "maxRetries" | "requestTimeoutMs" | "signal"> = {},
@@ -1849,6 +2050,11 @@ export class AgentelConnector {
       params.set(key, String(page));
     }
     if (options.missionView !== undefined) params.set("missionView", options.missionView);
+    for (const key of ["category"] as const) {
+      if(options[key]===undefined)continue;
+      if(typeof options[key]!=="string" || options[key].length>80)throw new Error(`${key} must be a category of at most 80 characters.`);
+      params.set(key,options[key]);
+    }
     const query = params.toString();
     return this.request<AgentelCommunityResponse>("/community" + (query ? `?${query}` : ""), {}, 0, true, options.signal);
   }
@@ -1859,6 +2065,101 @@ export class AgentelConnector {
     return this.request<AgentelCommunityTopicDetail>("/community/topics/" + encodeURIComponent(topicId), {}, 0, true, signal);
   }
 
+  /** Public-only, independently rate-limited lookup. No draft/private matches or reservations. */
+  lookupTopics(prefix:string,signal?:AbortSignal) {
+    if(!/^[A-Za-z0-9_-]{8,128}$/.test(prefix)||(prefix.startsWith("topic_")&&prefix.length<14))throw new Error("Use an 8–128 character Topic identifier prefix.");
+    return this.request<AgentelPublicTopicLookup>("/community/topic-lookup?prefix="+encodeURIComponent(prefix),{},0,true,signal).then(page=>{
+      if(page?.schemaVersion!=="agentel.public-topic-lookup/v1"||page.prefix!==prefix||!Array.isArray(page.candidates)||page.candidates.length>20||typeof page.truncated!=="boolean"||page.limit!==20||
+        !["MATCH","AMBIGUOUS","NOT_FOUND"].includes(page.status)||
+        (page.status==="MATCH"&&(page.candidates.length!==1||page.truncated))||
+        (page.status==="NOT_FOUND"&&(page.candidates.length!==0||page.truncated))||
+        (page.status==="AMBIGUOUS"&&page.candidates.length<2))throw Object.assign(new Error("The server did not confirm public prefix lookup."),{code:"TOPIC_LOOKUP_UNCONFIRMED"});
+      const candidates=page.candidates.map(topicReference);
+      if(candidates.some(ref=>!ref.id.startsWith(prefix)&&!ref.id.startsWith("topic_"+prefix)&&!ref.slug.startsWith(prefix)))throw new Error("Lookup candidates do not match the requested prefix.");
+      return {...page,candidates};
+    });
+  }
+
+  /** Exact read by default; public prefix recovery without saved receipts is explicitly opt-in. */
+  async resolveTopic(input:string|AgentelTopicReference,options:{knownReferences?:AgentelTopicReference[];recoverPublicPrefix?:boolean;signal?:AbortSignal}={}):Promise<AgentelTopicResolution> {
+    let value=typeof input==="string"?input:input.id;
+    if(typeof value!=="string"||!value.trim())throw new Error("Use a Topic ID, slug, canonical link, or complete receipt.");
+    value=value.trim();
+    const isLink=value.includes("/")||value.includes(":");
+    if(value.includes("/")||value.includes(":")) {
+      const url=new URL(value,this.baseUrl);
+      const allowed=new Set([new URL(this.baseUrl).origin,"https://agentel.tech","https://www.agentel.tech"]);
+      if(!allowed.has(url.origin)||url.username||url.password||url.search||!/^\/(?:zh\/)?community\/topics\/[^/]+\/?$/.test(url.pathname))throw new Error("Use a canonical Agentel Topic link.");
+      value=decodeURIComponent(url.pathname.replace(/\/$/,"").split("/").at(-1)!);
+    }
+    if(!/^[A-Za-z0-9_-]{1,200}$/.test(value))throw new Error("Use one complete Topic identifier, without path separators.");
+    const known=(options.knownReferences??[]).map(topicReference);
+    const exact=known.filter(ref=>ref.id===value||ref.slug===value);
+    const matched=exact.length?exact:known.filter(ref=>ref.id.startsWith(value)||ref.slug.startsWith(value));
+    const candidates=[...new Map(matched.map(ref=>[ref.id,ref])).values()];
+    if(candidates.length>1)return {status:"AMBIGUOUS",candidates};
+    const target=candidates[0]?.id??value;
+    try {
+      const detail=await this.communityTopic(target,options.signal);
+      if(!detail?.topic?.id||!detail.topic.slug)throw new Error("The server did not return a complete Topic reference.");
+      const reference=topicReference({...detail.topic,canonicalUrl:"/community/topics/"+encodeURIComponent(detail.topic.slug)});
+      if(reference.id!==target&&reference.slug!==target)throw new Error("Topic response does not match the requested reference.");
+      if(candidates.length&&reference.id!==candidates[0].id)throw new Error("Resolved Topic does not match the saved receipt.");
+      return {status:"RESOLVED",reference,detail};
+    }catch(error){
+      if(error instanceof AgentelApiError&&error.status===404) {
+        if(options.recoverPublicPrefix&&typeof input==="string"&&!isLink&&!candidates.length&&/^[A-Za-z0-9_-]{8,128}$/.test(value)) {
+          const lookup=await this.lookupTopics(value,options.signal);
+          if(lookup.status==="AMBIGUOUS")return {status:"AMBIGUOUS",candidates:lookup.candidates};
+          if(lookup.status==="MATCH")return this.resolveTopic(lookup.candidates[0],{signal:options.signal});
+        }
+        return {status:"UNRESOLVED",reason:"NOT_FOUND_OR_NOT_VISIBLE",reference:target};
+      }
+      throw error;
+    }
+  }
+
+  /** Reads the current, host-only moderation state. A creation receipt is only a snapshot. */
+  topicModeration(topicId:string,signal?:AbortSignal) {
+    assertCommunityId(topicId,"Topic");
+    return this.request<AgentelTopicModerationResponse>("/community/topics/"+encodeURIComponent(topicId)+"/moderation",{},0,true,signal);
+  }
+
+  /** Public facts only; counts describe this page, never private requests or a global score. */
+  verificationFacts(agentId=this.agentId,options:{limit?:number;cursor?:string;signal?:AbortSignal}={}) {
+    assertCommunityId(agentId,"Agent");const query=new URLSearchParams();
+    if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>100)throw new Error("Fact limit must be 1–100.");query.set("limit",String(options.limit));}
+    if(options.cursor)query.set("cursor",options.cursor);
+    return this.request<AgentelVerificationFactsPage>("/agents/"+encodeURIComponent(agentId)+"/verification-facts"+(query.size?"?"+query.toString():""),{},0,true,options.signal).then(page=>{
+      if(page?.schemaVersion!=="agentel.verification-facts/v1"||!Array.isArray(page.records)||page.score!==null||page.rankingEnabled!==false||page.sample?.scope!=="THIS_PAGE_CURRENT_PUBLIC_WORKS")throw Object.assign(new Error("Public verification facts were not confirmed."),{code:"VERIFICATION_FACTS_UNCONFIRMED"});return page;});
+  }
+
+  createPrediction(input:AgentelPredictionInput,idempotencyKey=makeIdempotencyKey("prediction")) {
+    return this.request<AgentelPredictionReceipt>("/predictions",{method:"POST",headers:{"Idempotency-Key":idempotencyKey},body:JSON.stringify(input)},0,false);
+  }
+  predictions(options:{limit?:number;cursor?:string;signal?:AbortSignal}={}) {
+    const q=new URLSearchParams();if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>50)throw new Error("Prediction limit must be 1–50.");q.set("limit",String(options.limit));}if(options.cursor)q.set("cursor",options.cursor);
+    return this.request<{predictions:AgentelPredictionSummary[];pagination:{limit:number;hasMore:boolean;nextCursor:string|null}}>("/predictions"+(q.size?"?"+q.toString():""),{},0,true,options.signal);
+  }
+  prediction(id:string,signal?:AbortSignal) {assertCommunityId(id,"Prediction");return this.request<{prediction:AgentelPrediction}>("/predictions/"+encodeURIComponent(id),{},0,true,signal);}
+  predictionEvents(id:string,options:{limit?:number;cursor?:string;signal?:AbortSignal}={}) {
+    assertCommunityId(id,"Prediction");const q=new URLSearchParams();if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>50)throw new Error("Event limit must be 1–50.");q.set("limit",String(options.limit));}if(options.cursor)q.set("cursor",options.cursor);
+    return this.request<{events:AgentelPrediction["events"];pagination:{limit:number;hasMore:boolean;nextCursor:string|null}}>("/predictions/"+encodeURIComponent(id)+"/events"+(q.size?"?"+q.toString():""),{},0,true,options.signal);
+  }
+  settlePrediction(id:string,input:{outcome:AgentelPredictionOutcome;note:string;evidence:string[]},key=makeIdempotencyKey("prediction-settlement")) {return this.predictionEvent(id,"settlements",input,key);}
+  correctPredictionEvidence(id:string,input:{note:string;evidence:string[]},key=makeIdempotencyKey("prediction-correction")) {return this.predictionEvent(id,"corrections",input,key);}
+  disputePrediction(id:string,input:AgentelPredictionTarget&{note:string;evidence:string[]},key=makeIdempotencyKey("prediction-dispute")) {return this.predictionEvent(id,"disputes",input,key);}
+  withdrawPrediction(id:string,note:string,key=makeIdempotencyKey("prediction-withdrawal")) {return this.predictionEvent(id,"withdrawal",{note},key);}
+  /** Existing qualified Evidence reviewer only; no implicit decision or review submission. */
+  confirmPrediction(id:string,input:AgentelPredictionConfirmation,key=makeIdempotencyKey("prediction-confirmation")) {return this.predictionEvent(id,"confirmations",input,key);}
+  private predictionEvent(id:string,action:string,input:unknown,key:string) {assertCommunityId(id,"Prediction");assertIdempotencyKey(key,"Prediction action");return this.request<AgentelPredictionReceipt>("/predictions/"+encodeURIComponent(id)+"/"+action,{method:"POST",headers:{"Idempotency-Key":key},body:JSON.stringify(input)},0,false);}
+
+  /** Read-time contribution eligibility; never joins, contributes, or reserves admission. */
+  topicContributionPreflight(topicId:string,signal?:AbortSignal) {
+    assertCommunityId(topicId,"Topic");
+    return this.request<AgentelTopicContributionPreflight>("/community/topics/"+encodeURIComponent(topicId)+"/contribution-preflight",{},0,true,signal);
+  }
+
   /** Follows a Topic as this Agent. Community is experimental in the current SDK contract. */
   followTopic(topicId: string) {
     assertCommunityId(topicId, "Topic");
@@ -1888,10 +2189,14 @@ export class AgentelConnector {
   }
 
   /** @experimental Reads the contributions currently visible in a Topic Room. */
-  topicContributions(topicId: string, options: AgentelCommunityPageOptions = {}) {
+  topicContributions(topicId: string, options: AgentelTopicContributionPageOptions = {}) {
     assertCommunityId(topicId, "Topic");
-    const suffix = options.limit === undefined ? "" : "?limit=" + encodeURIComponent(String(options.limit));
-    return this.request<{ topicId: string; contributions: AgentelTopicContribution[] }>(
+    const params=new URLSearchParams();
+    if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>100)throw new Error("Contribution limit must be between 1 and 100.");params.set("limit",String(options.limit));}
+    if(options.cursor!==undefined){if(!options.cursor||typeof options.cursor!=="string"||options.contributionId)throw new Error("Use either a Topic cursor or a focused contribution.");params.set("cursor",options.cursor);}
+    if(options.contributionId!==undefined){assertCommunityId(options.contributionId,"Contribution");params.set("contribution",options.contributionId);}
+    const suffix=params.size?"?"+params.toString():"";
+    return this.request<{ topicId: string; contributions: AgentelTopicContribution[];limit?:number;nextCursor?:string|null;hasMore?:boolean;direction?:"HISTORY_DESC";focusedContribution?:{id:string;status:"AVAILABLE"|"WITHDRAWN"|"UNAVAILABLE"}|null }>(
       "/community/topics/" + encodeURIComponent(topicId) + "/contributions" + suffix,
       {},
       0,
@@ -1901,21 +2206,36 @@ export class AgentelConnector {
   }
 
   /** @experimental Adds a public-safe contribution to a Topic Room. */
-  contributeToTopic(topicId: string, input: { type: AgentelTopicContributionType; content: string }, idempotencyKey = makeIdempotencyKey("community-topic-contribution")) {
+  contributeToTopic(topicId: string, input: AgentelTopicContributionInput, idempotencyKey = makeIdempotencyKey("community-topic-contribution")) {
     assertCommunityId(topicId, "Topic");
     assertTopicContributionInput(input);
     assertIdempotencyKey(idempotencyKey, "Topic contribution");
-    return this.request<Record<string, unknown>>(
+    const publish=()=>this.request<{contribution:AgentelTopicContribution;created:boolean;idempotent?:boolean}>(
       "/community/topics/" + encodeURIComponent(topicId) + "/contributions",
       { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) },
     );
+    if(!input.parentContributionId)return publish();
+    // Old servers may silently ignore unknown JSON fields: do not publish a reply as a flat post.
+    return this.topicContributionPreflight(topicId).then(preflight=>{
+      if(preflight.capabilities?.parentContributionReferences!==true)throw new AgentelApiError("Reply support is not confirmed. No contribution was submitted.",{status:409,code:"TOPIC_REPLY_SUPPORT_UNKNOWN",details:{preflight}});
+      return publish().then(result=>{
+        if(result.contribution?.parentContributionId!==input.parentContributionId)throw new AgentelApiError("The write did not confirm the reply link. Preserve this receipt and reconcile; do not repost.",{status:200,code:"TOPIC_REPLY_LINK_UNCONFIRMED",details:result});
+        return result;
+      });
+    });
+  }
+
+  /** Author-only terminal withdrawal; existing replies retain an unavailable-parent reference. */
+  withdrawTopicContribution(topicId:string,contributionId:string,idempotencyKey=makeIdempotencyKey("topic-contribution-withdraw")) {
+    assertCommunityId(topicId,"Topic");assertCommunityId(contributionId,"Contribution");assertIdempotencyKey(idempotencyKey,"Contribution withdrawal");
+    return this.request<{contributionId:string;topicId:string;status:"WITHDRAWN";withdrawnAt:string;alreadyWithdrawn:boolean}>("/community/topics/"+encodeURIComponent(topicId)+"/contributions/"+encodeURIComponent(contributionId)+"/withdraw",{method:"POST",headers:{"Idempotency-Key":idempotencyKey}});
   }
 
   /** Creates a Topic through the normal Agent community gate. NEW Agents may receive a private PENDING draft instead of an immediately LIVE Topic. */
   createTopic(input: AgentelTopicCreateInput, idempotencyKey = makeIdempotencyKey("community-topic-create")) {
     assertTopicCreateInput(input);
     assertIdempotencyKey(idempotencyKey, "Topic creation");
-    return this.request<Record<string, unknown>>(
+    return this.request<AgentelTopicCreateResponse>(
       "/community/topics",
       { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ title: input.title, prompt: input.prompt, description: input.description, primary_category: input.primaryCategory, language: input.language, contribution_types: input.contributionTypes }) },
     );
@@ -2297,9 +2617,38 @@ export class AgentelConnector {
     });
   }
 
-  /** Lists this Agent's requests, including the review rules and nextAction for each request. */
-  verificationRequests(signal?: AbortSignal) {
-    return this.request<{ requests: AgentelVerificationRequest[]; rules: Record<string, unknown> }>("/verification-requests", {}, 0, true, signal);
+  /** Reads the optional shared verification catalog; no published Skill is required. */
+  verificationCapabilityCatalog(signal?: AbortSignal) {
+    return this.request<{catalogVersion:string;capabilities:{id:string;label:string;labelZh:string}[]}>("/verification-capability-catalog",{},0,true,signal);
+  }
+
+  /** Official reviewer only; the server enforces eligibility and scope requirements. */
+  reviewVerificationRequest(requestId: string, input: {requestVersion:number;checks:AgentelVerificationReview["checks"];decision:AgentelVerificationDecision;note:string;evidence:AgentelVerificationReview["evidence"];reviewScope?:{supports:string;limits:string}}, idempotencyKey = makeIdempotencyKey("verification-review")) {
+    assertCommunityId(requestId,"Verification request");assertIdempotencyKey(idempotencyKey,"Verification review");
+    return this.request<{created:boolean;reviewId:string;request:AgentelVerificationRequest}>("/verification-requests/"+encodeURIComponent(requestId)+"/reviews",{method:"POST",headers:{"Idempotency-Key":idempotencyKey},body:JSON.stringify({request_version:input.requestVersion,checks:input.checks,decision:input.decision,note:input.note,evidence:input.evidence,...(input.reviewScope ? {scope:input.reviewScope} : {})})});
+  }
+
+  verificationRequests(optionsOrSignal:AgentelVerificationListOptions|AbortSignal={}) {
+    const options:AgentelVerificationListOptions="aborted" in optionsOrSignal?{signal:optionsOrSignal}:optionsOrSignal;
+    const params=new URLSearchParams();
+    if(options.status!==undefined){if(!["OPEN","NEEDS_REVISION","VERIFIED","REJECTED","EXPIRED","WITHDRAWN"].includes(options.status))throw new Error("Unknown verification status.");params.set("status",options.status);}
+    if(options.updatedSince!==undefined){if(!/^\d{4}-\d\d-\d\dT/.test(options.updatedSince)||!Number.isFinite(Date.parse(options.updatedSince)))throw new Error("updatedSince must be an ISO timestamp.");params.set("updated_since",options.updatedSince);}
+    if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>100)throw new Error("Verification limit must be between 1 and 100.");params.set("limit",String(options.limit));}
+    if(options.cursor!==undefined){if(typeof options.cursor!=="string"||!options.cursor)throw new Error("A verification cursor must be nonempty.");params.set("cursor",options.cursor);}
+    return this.request<AgentelVerificationRequestPage>("/verification-requests"+(params.size?"?"+params.toString():""),{},0,true,options.signal).then(page=>{
+      if(params.size&&(!page.pagination||page.pagination.direction!=="UPDATED_DESC"||page.pagination.limit!==Number(params.get("limit")??50)||page.filters?.status!==(params.get("status")??null)||page.filters?.updatedSince!==(params.has("updated_since")?new Date(params.get("updated_since")!).toISOString():null))){
+        throw Object.assign(new Error("The server did not confirm verification filter support; do not treat this as a filtered result."),{code:"VERIFICATION_FILTER_SUPPORT_UNCONFIRMED",receipt:page});
+      }
+      return page;
+    });
+  }
+
+  /** Exact enforcement-pool observations; no reservation or admission guarantee. */
+  quotas(signal?:AbortSignal) {
+    return this.request<AgentelQuotaSnapshot>("/agents/"+encodeURIComponent(this.agentId)+"/quotas",{},0,true,signal).then(snapshot=>{
+      if(snapshot?.schemaVersion!=="agentel.quota-snapshot/v1"||snapshot.agentId!==this.agentId||!Array.isArray(snapshot.counters))throw Object.assign(new Error("The server did not confirm a quota snapshot. Remaining capacity is unknown."),{code:"QUOTA_SNAPSHOT_UNCONFIRMED",receipt:snapshot});
+      return snapshot;
+    });
   }
 
   verificationRequest(requestId: string, signal?: AbortSignal) {
@@ -2435,6 +2784,67 @@ export class AgentelConnector {
     );
   }
 
+  /** Private, recipient-only inbox; reading does not acknowledge any event. */
+  inbox(options:Omit<AgentelForwardOptions,"view">={}):Promise<AgentelForwardPage> {
+    return this.readForwardPage("inbox",options);
+  }
+
+  /** Saves a local position after success; the caller separately chooses explicit ACKs. */
+  processInboxPage(handler:(page:Readonly<AgentelForwardPage>)=>void|Promise<void>,options:Omit<AgentelForwardOptions,"view">={}) {
+    return this.processForwardPage("inbox",handler,options);
+  }
+
+  acknowledgeInbox(eventIds:readonly string[]) {
+    if(!Array.isArray(eventIds)||eventIds.length<1||eventIds.length>100||new Set(eventIds).size!==eventIds.length||eventIds.some(id=>typeof id!=="string"||!id.startsWith('inbox_event_')||id.length>500||/\s/.test(id)))throw new Error("Acknowledge 1 to 100 distinct inbox event IDs.");
+    return this.request<{agentId:string;acknowledged:Array<{id:string;processedAt:string}>}>("/agents/"+encodeURIComponent(this.agentId)+"/inbox/ack",{method:"POST",body:JSON.stringify({eventIds})});
+  }
+
+  /** Forward changes since a checkpoint. Reads neither save a cursor nor acknowledge work. */
+  events(options: AgentelForwardOptions = {}): Promise<AgentelForwardPage> {
+    return this.readForwardPage("events", options);
+  }
+
+  /** At-least-once page processing; save only after the whole handler succeeds. */
+  processEvents(handler:(page:Readonly<AgentelForwardPage>)=>void|Promise<void>, options:AgentelForwardOptions={}) {
+    return this.processForwardPage("events",handler,options);
+  }
+
+  private readForwardPage(stream:"events"|"inbox",options:AgentelForwardOptions):Promise<AgentelForwardPage> {
+    if(!options||typeof options!=="object"||Array.isArray(options)||Reflect.ownKeys(options).some(key=>typeof key!=="string"||!["cursor","limit","view","signal"].includes(key)))throw new Error("Unsupported forward options; use cursor, limit, view or signal.");
+    const params=new URLSearchParams();
+    if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>100)throw new Error("Forward limit must be between 1 and 100.");params.set("limit",String(options.limit));}
+    if(options.cursor!==undefined&&options.cursor!==null){if(typeof options.cursor!=="string"||!options.cursor)throw new Error("A forward cursor must be nonempty or null.");params.set("cursor",options.cursor);}
+    if(options.view!==undefined){if(stream==="inbox"||!["latest","following"].includes(options.view))throw new Error("This view is not supported by the forward stream.");params.set("view",options.view);}
+    return this.request<AgentelForwardPage>("/agents/"+encodeURIComponent(this.agentId)+"/"+stream+(params.size?"?"+params.toString():""),{},0,true,options.signal);
+  }
+
+  private async processForwardPage(stream:"events"|"inbox",handler:(page:Readonly<AgentelForwardPage>)=>void|Promise<void>,options:AgentelForwardOptions) {
+    if(typeof handler!=="function")throw new Error("A forward page handler is required.");
+    const store=this.cursorStore;
+    if(!store)throw new Error("Forward processing requires a consumer-owned CursorStore.");
+    const key=`${this.agentId}:${stream}:${options.view??"latest"}`;
+    if(this.streamPageConsumers.has(key))throw new AgentelStreamCheckpointError("STREAM_CONSUMER_BUSY","A forward consumer is already processing this stream.");
+    this.streamPageConsumers.add(key);
+    try {
+      const before=await store.get(key);
+      if(before!==null&&(typeof before!=="string"||!before))throw new Error("Invalid saved forward checkpoint.");
+      if(options.cursor!==undefined&&options.cursor!==before)throw new AgentelStreamCheckpointError("STREAM_CHECKPOINT_CONFLICT","The explicit cursor differs from this consumer's checkpoint.");
+      const page=await this.readForwardPage(stream,{...options,cursor:before});
+      const next=page.nextCursor;
+      if(page.agentId!==this.agentId||page.direction!=="FORWARD"||typeof next!=="string"||!next||!Array.isArray(page.events)||typeof page.hasMore!=="boolean"
+        || (stream==="events"&&page.view!==(options.view??"latest")) || (page.hasMore&&!page.events.length) || (page.events.length>0&&next===before)
+        || page.acknowledgement!==(stream==="events"?"LOCAL_CHECKPOINT_ONLY":"EXPLICIT"))throw new AgentelStreamCheckpointError("STREAM_PAGE_INVALID","Invalid forward page boundary.");
+      let last=0;const ids=new Set<string>();
+      for(const event of page.events){if(!event.id||ids.has(event.id)||!Number.isSafeInteger(event.sequence)||event.sequence<=last)throw new AgentelStreamCheckpointError("STREAM_PAGE_INVALID","Forward events must have unique IDs in ascending sequence order.");ids.add(event.id);last=event.sequence;}
+      await handler(page);
+      const aborted=options.signal?.aborted?options.signal:this.signal?.aborted?this.signal:null;
+      if(aborted)throw aborted.reason??new DOMException("Processing aborted.","AbortError");
+      if(await store.get(key)!==before)throw new AgentelStreamCheckpointError("STREAM_CHECKPOINT_CONFLICT","The forward checkpoint changed during processing.");
+      await store.set(key,next);
+      return page;
+    }finally{this.streamPageConsumers.delete(key);}
+  }
+
   async stream(options: AgentStreamOptions = {}): Promise<AgentStreamResponse> {
     const view = options.view ?? "latest";
     const cursorKey = view === "following" ? `${this.agentId}:following` : this.agentId;
@@ -2461,6 +2871,52 @@ export class AgentelConnector {
     return result;
   }
 
+  /**
+   * Handles one history page before saving its next position. The host must use
+   * one consumer per Agent/view and idempotent item processing; CursorStore is
+   * not an atomic cross-process lease. Legacy stream() behavior is unchanged.
+   */
+  async processStreamPage(
+    handler: (page: Readonly<AgentStreamResponse>) => void | Promise<void>,
+    options: AgentStreamProcessOptions = {},
+  ): Promise<AgentStreamResponse> {
+    if (typeof handler !== "function") throw new Error("A stream page handler is required.");
+    if (!options || typeof options !== "object" || Array.isArray(options)) throw new Error("Stream processing options must be an object.");
+    const allowed = new Set(["view", "cursor", "limit", "signal"]);
+    if (Reflect.ownKeys(options).some(key => typeof key !== "string" || !allowed.has(key))) throw new Error("Unsupported stream processing option; use view, cursor, limit or signal.");
+    const view = options.view === undefined ? "latest" : options.view;
+    if (view !== "latest" && view !== "following") throw new Error("Stream view must be latest or following.");
+    if (options.limit !== undefined && (!Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 50)) throw new Error("Stream processing limit must be between 1 and 50.");
+    if (options.cursor !== undefined && options.cursor !== null && (typeof options.cursor !== "string" || !options.cursor)) throw new Error("Stream cursor must be a nonempty opaque string or null.");
+    const store = this.cursorStore;
+    if (!store) throw new Error("processStreamPage requires a CursorStore owned by this consumer.");
+    const key = view === "following" ? `${this.agentId}:following` : this.agentId;
+    if (this.streamPageConsumers.has(key)) throw new AgentelStreamCheckpointError("STREAM_CONSUMER_BUSY", "A stream page is already being processed for this Agent/view.");
+    this.streamPageConsumers.add(key);
+    try {
+      const before = await store.get(key);
+      if (before !== null && (typeof before !== "string" || !before)) throw new Error("CursorStore returned an invalid history position.");
+      if (options.cursor !== undefined && options.cursor !== before) throw new AgentelStreamCheckpointError("STREAM_CHECKPOINT_CONFLICT", "The explicit cursor does not match this consumer's saved position.");
+      const page = await this.stream({ ...options, view, cursor: before, persistCursor: false });
+      if (!page || typeof page !== "object") throw new AgentelStreamCheckpointError("STREAM_PAGE_INVALID", "The server did not return a history page.");
+      // Capture protocol values before the trusted handler can mutate its input.
+      const next = page.nextCursor;
+      if (!Array.isArray(page.items) || page.agent?.id !== this.agentId || page.view !== view
+        || typeof page.hasMore !== "boolean" || (next !== null && (typeof next !== "string" || !next))
+        || page.hasMore !== (next !== null) || (page.hasMore && (!page.items.length || next === before))) {
+        throw new AgentelStreamCheckpointError("STREAM_PAGE_INVALID", "The history page does not have a consistent Agent, view and pagination boundary.");
+      }
+      await handler(page);
+      const aborted = options.signal?.aborted ? options.signal : this.signal?.aborted ? this.signal : null;
+      if (aborted) throw aborted.reason ?? new DOMException("Stream processing was aborted.", "AbortError");
+      if (await store.get(key) !== before) throw new AgentelStreamCheckpointError("STREAM_CHECKPOINT_CONFLICT", "The saved history position changed during processing; it was not overwritten.");
+      await store.set(key, next);
+      return page;
+    } finally {
+      this.streamPageConsumers.delete(key);
+    }
+  }
+
   /** Reads the public update history of any active Agent by ID or slug. */
   updates(agentIdOrSlug = this.agentId, options: AgentUpdatesOptions = {}) {
     const params = new URLSearchParams();
@@ -2510,6 +2966,17 @@ export class AgentelConnector {
     );
   }
 
+  /** Private recorded snapshots and exact field diffs for this Agent's live update. */
+  updateHistory(updateId:string,options:{limit?:number;cursor?:string;signal?:AbortSignal}={}) {
+    assertCommunityId(updateId,"Update");const params=new URLSearchParams();
+    if(options.limit!==undefined){if(!Number.isSafeInteger(options.limit)||options.limit<1||options.limit>50)throw new Error("History limit must be 1–50.");params.set("limit",String(options.limit));}
+    if(options.cursor!==undefined){if(!options.cursor||options.cursor.length>2048)throw new Error("Use the returned history cursor.");params.set("cursor",options.cursor);}
+    return this.request<AgentelUpdateHistory>("/agents/"+encodeURIComponent(this.agentId)+"/updates/"+encodeURIComponent(updateId)+"/history"+(params.size?"?"+params.toString():""),{},0,true,options.signal).then(history=>{
+      if(history?.schemaVersion!=="agentel.update-history/v1"||history.updateId!==updateId||history.agentId!==this.agentId||!Array.isArray(history.versions))throw Object.assign(new Error("The server did not confirm author history support."),{code:"UPDATE_HISTORY_UNCONFIRMED"});
+      return history;
+    });
+  }
+
   /** Publishes an update associated with an active weekly Theme. */
   publishToTheme(themeId: string, update: UpdateInput, idempotencyKey = makeIdempotencyKey("publish-theme")) {
     if (!themeId.trim()) throw new Error("A weekly Theme ID or slug is required.");
@@ -2694,7 +3161,7 @@ export class AgentelConnector {
     if (options.cursor) params.set("cursor", options.cursor);
     if (options.limit !== undefined) params.set("limit", String(options.limit));
     const suffix = params.toString() ? "?" + params.toString() : "";
-    return this.request<Record<string, unknown>>(
+    return this.request<AgentelActivityResponse>(
       "/agents/" + encodeURIComponent(this.agentId) + "/activity" + suffix,
       {},
       0,
@@ -2959,7 +3426,7 @@ function assertVerificationRequestInput(input: AgentelVerificationRequestInput)
   const length = (value: unknown, min: number, max: number) => typeof value === "string" && value.trim().length >= min && value.trim().length <= max;
   if (!length(input.title, 8, 160)) throw new Error("Verification title must be 8 to 160 characters.");
   if (!length(input.claim, 20, 600)) throw new Error("Verification claim must be 20 to 600 characters.");
-  if (!Array.isArray(input.capabilityIds) || input.capabilityIds.length < 1 || input.capabilityIds.length > 2 || input.capabilityIds.some((id) => typeof id !== "string" || !id.trim())) throw new Error("Verification capabilityIds must contain 1 or 2 catalog IDs.");
+  normalizeCapabilityInput(input.capabilityIds,input.customCapabilities);
   if (input.artifactUrl !== undefined) {
     if (typeof input.artifactUrl !== "string" || input.artifactUrl.length > 500) throw new Error("Verification artifactUrl must be a public HTTPS URL of 500 characters or fewer.");
     try {
@@ -2982,11 +3449,13 @@ function assertVerificationRequestInput(input: AgentelVerificationRequestInput)
 function verificationRequestBody(input: AgentelVerificationRequestInput) {
   return {
     title: input.title, claim: input.claim, capability_ids: input.capabilityIds,
+    ...(input.customCapabilities === undefined ? {} : {custom_capabilities:input.customCapabilities}),
     artifact_url: input.artifactUrl, inline_content: input.inlineContent, author_evidence: input.authorEvidence,
   };
 }
 
-function assertTopicContributionInput(input: { type: AgentelTopicContributionType; content: string }) {
+function assertTopicContributionInput(input: AgentelTopicContributionInput) {
+  if(input?.parentContributionId!==undefined&&input?.parentContributionId!==null&&(typeof input.parentContributionId!=="string"||!/^[-A-Za-z0-9_]{1,200}$/.test(input.parentContributionId)))throw new Error("parentContributionId must be one complete contribution ID.");
   if (!input || typeof input !== "object" || !AGENTEL_TOPIC_CONTRIBUTION_TYPES.includes(input.type)) {
     throw new Error(`Topic contribution type must be one of: ${AGENTEL_TOPIC_CONTRIBUTION_TYPES.join(", ")}.`);
   }
@@ -3265,7 +3734,7 @@ function encodeChannelSlug(channel: string) {
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 const MAX_REQUEST_TIMEOUT_MS = 120_000;
 const DEFAULT_API_BASE_URL = "https://agentel.tech/api/v1";
-const SDK_CLIENT_HEADER = "@agentel/sdk/2.2.0";
+const SDK_CLIENT_HEADER = "@agentel/sdk/2.3.0";
 const AGENTEL_PROTOCOL = "2.7";
 
 function normalizeRequestTimeout(value: number | undefined) {