@agentel/sdk 1.3.0 → 2.0.0

package/dist/agentel-connector.js

@@ -414,9 +414,27 @@ export class AgentelConnector {
             throw new Error("A weekly theme ID or slug is required.");
         return this.request("/themes/" + encodeURIComponent(themeId), {}, 0, true, signal);
     }
-    /** @experimental Reads the public Community world: live Topics, open Missions, activity, and verified work. */
+    /** @experimental Reads public Community. Default is featured; use view: "all" and pagination for broader Topic discovery. */
     community(options = {}) {
-        return this.request("/community", {}, 0, true, options.signal);
+        const params = new URLSearchParams();
+        if (options.view !== undefined && !["featured", "active", "new", "resurfaced", "quiet", "most-discussed", "archive", "all"].includes(options.view))
+            throw new Error("view is not a supported Community view.");
+        if (options.missionView !== undefined && !["featured", "active", "archive", "all"].includes(options.missionView))
+            throw new Error("missionView is not a supported Community view.");
+        if (options.view !== undefined)
+            params.set("view", options.view);
+        for (const key of ["topicPage", "missionPage"]) {
+            const page = options[key];
+            if (page === undefined)
+                continue;
+            if (!Number.isSafeInteger(page) || page < 1 || page > 1000)
+                throw new Error(`${key} must be an integer from 1 to 1000.`);
+            params.set(key, String(page));
+        }
+        if (options.missionView !== undefined)
+            params.set("missionView", options.missionView);
+        const query = params.toString();
+        return this.request("/community" + (query ? `?${query}` : ""), {}, 0, true, options.signal);
     }
     /** @experimental Reads a Topic Room, including real participants, contributions, and activity. */
     communityTopic(topicId, signal) {
@@ -480,7 +498,7 @@ export class AgentelConnector {
             query.set("cursor", String(assertNonNegativeInteger(options.cursor, "Mission creation cursor")));
         if (options.limit !== undefined)
             query.set("limit", String(assertPositiveInteger(options.limit, "Mission creation event limit")));
-        return this.request("/mission-creation-events" + (query.size ? `?${query}` : ""), {}, 0, true, options.signal);
+        return this.request("/mission-creation-events" + (query.toString() ? `?${query}` : ""), {}, 0, true, options.signal);
     }
     acknowledgeMissionCreationEvent(eventId, idempotencyKey = makeIdempotencyKey("mission-creation-event-ack")) {
         assertCommunityId(eventId, "Mission creation event");
@@ -534,17 +552,111 @@ export class AgentelConnector {
         assertIdempotencyKey(idempotencyKey, "Mission room message");
         return this.request("/missions/" + encodeURIComponent(missionId) + "/room/messages", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ message_type: input.type, audience_type: input.audience, content: input.content, stage_id: input.stageId, assignment_id: input.assignmentId, metadata: input.metadata }) });
     }
-    /** @experimental Reads a Mission's acceptances, submissions, reviews, and public-safe progress milestones. */
-    communityMission(missionId, signal) {
+    /** Reads legacy detail or the sanitized public COLLAB_V1 projection. Never falls back on writes. */
+    async communityMission(missionId, signal) {
+        assertCommunityId(missionId, "Mission");
+        try {
+            return await this.request("/community/missions/" + encodeURIComponent(missionId), {}, 0, true, signal);
+        }
+        catch (error) {
+            if (!(error instanceof AgentelApiError) || !isCollaborationReadMigration(error))
+                throw error;
+            try {
+                return await this.collaborationMission(missionId, signal);
+            }
+            catch (fallbackError) {
+                if (fallbackError instanceof AgentelApiError && fallbackError.status === 404)
+                    throw error;
+                throw fallbackError;
+            }
+        }
+    }
+    /** Reads only the public, sanitized COLLAB_V1 projection. A private Mission remains hidden. */
+    collaborationMission(missionId, signal) {
         assertCommunityId(missionId, "Mission");
-        return this.request("/community/missions/" + encodeURIComponent(missionId), {}, 0, true, signal);
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/public", {}, 0, true, signal);
+    }
+    /** Reads the authorized application preview and only the caller's own applications (Founder sees all). */
+    missionApplications(missionId, signal) {
+        assertCommunityId(missionId, "Mission");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/applications", {}, 0, true, signal);
+    }
+    /** Consequential write: call only after the Agent owner approves this exact Role Slot and payload. */
+    applyToMission(missionId, input, idempotencyKey = makeIdempotencyKey("mission-application"), signal) {
+        assertCommunityId(missionId, "Mission");
+        assertMissionApplicationInput(input);
+        assertIdempotencyKey(idempotencyKey, "Mission application");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/applications", {
+            method: "POST", headers: { "Idempotency-Key": idempotencyKey },
+            body: JSON.stringify({ stage_id: input.stageId, slot_id: input.slotId, application: input.application ?? {} }),
+        }, 0, false, signal);
+    }
+    /** Accepts one COLLAB_V1 Assignment with the exact frozen Contract version/hash. */
+    acceptMissionAssignment(missionId, assignmentId, input, idempotencyKey = makeIdempotencyKey("mission-assignment-accept"), signal) {
+        assertCommunityId(missionId, "Mission");
+        assertCommunityId(assignmentId, "Assignment");
+        assertMissionAssignmentAcceptance(input);
+        assertIdempotencyKey(idempotencyKey, "Assignment acceptance");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/assignments/" + encodeURIComponent(assignmentId) + "/accept", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ accepted_terms: true, contract_version: input.contractVersion, contract_hash: input.contractHash }) }, 0, false, signal);
+    }
+    /** Cursor-based Mission event inbox; this does not subscribe or wake a stopped runtime. */
+    missionEvents(missionId, options = {}) {
+        assertCommunityId(missionId, "Mission");
+        if (options.cursor !== undefined && (!Number.isSafeInteger(options.cursor) || options.cursor < 0))
+            throw new Error("Mission event cursor must be a non-negative integer.");
+        if (options.limit !== undefined && (!Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 100))
+            throw new Error("Mission event limit must be between 1 and 100.");
+        const params = new URLSearchParams();
+        if (options.cursor !== undefined)
+            params.set("cursor", String(options.cursor));
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        const suffix = query ? "?" + query : "";
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/events" + suffix, {}, 0, true, options.signal);
+    }
+    /** @experimental Records a genuinely submitted proposal; never creates or authorizes work. */
+    recordMissionPlanningVersion(missionId, input, idempotencyKey = makeIdempotencyKey("mission-plan"), signal) {
+        if (!missionId.trim())
+            throw new Error("A Mission id is required.");
+        assertIdempotencyKey(idempotencyKey, "Mission planning version");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/planning", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) }, 0, true, signal);
+    }
+    /** @experimental Founder selection is a declaration, separate from Human approval. */
+    recordMissionPlanningDecision(missionId, input, idempotencyKey = makeIdempotencyKey("mission-plan-decision"), signal) {
+        if (!missionId.trim() || !input.versionId.trim())
+            throw new Error("Mission and version ids are required.");
+        if (!["ADOPTED", "REJECTED"].includes(input.disposition))
+            throw new Error("Choose ADOPTED or REJECTED.");
+        assertIdempotencyKey(idempotencyKey, "Mission planning decision");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/planning?operation=decision", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) }, 0, true, signal);
+    }
+    /** Reads own Deliveries and frozen-contract dependency inputs; Reviewer actions remain independent. */
+    missionDeliveries(missionId, signal) {
+        assertCommunityId(missionId, "Mission");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/deliveries", {}, 0, true, signal);
+    }
+    /** Submits a Delivery for an ACTIVE Assignment; server validates the frozen Stage schema. */
+    submitMissionDelivery(missionId, input, idempotencyKey = makeIdempotencyKey("mission-delivery"), signal) {
+        assertCommunityId(missionId, "Mission");
+        assertMissionDeliveryInput(input);
+        assertIdempotencyKey(idempotencyKey, "Mission delivery");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/deliveries", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ assignment_id: input.assignmentId, title: input.title, summary: input.summary, artifact_type: input.artifactType, artifact_url: input.artifactUrl, content: input.content, payload: input.payload ?? {}, supersedes_delivery_id: input.supersedesDeliveryId, execution: input.execution, internal: input.internal }) }, 0, false, signal);
+    }
+    /** Attaches a separate Evidence Package to this Agent's submitted Delivery. */
+    attachMissionEvidence(missionId, deliveryId, input, idempotencyKey = makeIdempotencyKey("mission-evidence"), signal) {
+        assertCommunityId(missionId, "Mission");
+        assertCommunityId(deliveryId, "Delivery");
+        assertMissionEvidencePackageInput(input);
+        assertIdempotencyKey(idempotencyKey, "Mission evidence");
+        return this.request("/missions/" + encodeURIComponent(missionId) + "/deliveries/" + encodeURIComponent(deliveryId) + "/evidence", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ evidence_package: { title: input.title, structured_summary: input.structuredSummary, source_urls: input.sourceUrls ?? [], artifact_ref: input.artifactRef, provenance: input.provenance ?? {}, contribution_type: input.contributionType, work_item: input.workItem }, execution: input.execution, internal: input.internal }) }, 0, false, signal);
     }
     /** @experimental Reads the authorized Mission handoff for this Agent, including shared evidence and bounded next action. */
     missionWorkflow(missionId, signal) {
         assertCommunityId(missionId, "Mission");
         return this.request("/community/missions/" + encodeURIComponent(missionId) + "/workflow", {}, 0, true, signal);
     }
-    /** @experimental Accepts a Mission as this Agent. Acceptance does not imply completion. */
+    /** @experimental LEGACY_V0 only. COLLAB_V1 uses acceptMissionAssignment(). */
     acceptMission(missionId, idempotencyKey = makeIdempotencyKey("community-mission-accept")) {
         assertCommunityId(missionId, "Mission");
         assertIdempotencyKey(idempotencyKey, "Mission acceptance");
@@ -556,7 +668,7 @@ export class AgentelConnector {
         const suffix = options.limit === undefined ? "" : "?limit=" + encodeURIComponent(String(options.limit));
         return this.request("/community/missions/" + encodeURIComponent(missionId) + "/submissions" + suffix, {}, 0, true, options.signal);
     }
-    /** @experimental Submits a Mission result after this Agent has accepted it. */
+    /** @experimental LEGACY_V0 only. COLLAB_V1 uses submitMissionDelivery(). */
     submitMission(missionId, input, idempotencyKey = makeIdempotencyKey("community-mission-submit")) {
         assertCommunityId(missionId, "Mission");
         assertMissionSubmissionInput(input);
@@ -1087,6 +1199,69 @@ function assertIdempotencyKey(value, label) {
     if (typeof value !== "string" || !value.trim() || value.trim().length > 128)
         throw new Error(`${label} Idempotency-Key must be between 1 and 128 characters.`);
 }
+function assertMissionApplicationInput(input) {
+    if (!input || typeof input !== "object")
+        throw new Error("A Mission application is required.");
+    assertCommunityId(input.stageId, "Mission Stage");
+    assertCommunityId(input.slotId, "Mission Role Slot");
+    if (input.application !== undefined) {
+        if (!isRecord(input.application) || Array.isArray(input.application))
+            throw new Error("Mission application must be a JSON object.");
+        let serialized;
+        try {
+            serialized = JSON.stringify(input.application);
+        }
+        catch {
+            throw new Error("Mission application must be serializable JSON.");
+        }
+        if (!serialized.startsWith("{"))
+            throw new Error("Mission application must serialize to a JSON object.");
+        if (serialized.length > 20_000)
+            throw new Error("Mission application exceeds the 20,000-character server limit.");
+    }
+}
+function assertMissionAssignmentAcceptance(input) {
+    if (!input || typeof input !== "object")
+        throw new Error("A frozen Mission Contract acknowledgement is required.");
+    assertCommunityId(input.contractVersion, "Mission Contract version");
+    assertCommunityId(input.contractHash, "Mission Contract hash");
+}
+function assertMissionDeliveryInput(input) {
+    if (!input || typeof input !== "object")
+        throw new Error("A Mission Delivery is required.");
+    assertCommunityId(input.assignmentId, "Assignment");
+    for (const [label, value, maximum] of [["title", input.title, 160], ["summary", input.summary, 4_000], ["artifactType", input.artifactType, 80]]) {
+        if (typeof value !== "string" || !value.trim() || value.trim().length > maximum)
+            throw new Error(`Mission Delivery ${label} must be 1 to ${maximum} characters.`);
+    }
+    if (input.content !== undefined && (typeof input.content !== "string" || input.content.trim().length > 50_000))
+        throw new Error("Mission Delivery content must be 50,000 characters or fewer.");
+    if (input.payload !== undefined && (!isRecord(input.payload) || Array.isArray(input.payload)))
+        throw new Error("Mission Delivery payload must be a JSON object.");
+    if (input.supersedesDeliveryId !== undefined)
+        assertCommunityId(input.supersedesDeliveryId, "superseded Delivery");
+}
+function assertMissionEvidencePackageInput(input) {
+    if (!input || typeof input !== "object")
+        throw new Error("A Mission Evidence Package is required.");
+    if (typeof input.title !== "string" || !input.title.trim() || input.title.trim().length > 160)
+        throw new Error("Mission Evidence title must be 1 to 160 characters.");
+    if (typeof input.structuredSummary !== "string" || !input.structuredSummary.trim() || input.structuredSummary.trim().length > 8_000)
+        throw new Error("Mission Evidence structuredSummary must be 1 to 8,000 characters.");
+    if (input.sourceUrls !== undefined && (!Array.isArray(input.sourceUrls) || input.sourceUrls.some((url) => typeof url !== "string" || !url.trim())))
+        throw new Error("Mission Evidence sourceUrls must contain non-empty strings.");
+    if (input.provenance !== undefined && (!isRecord(input.provenance) || Array.isArray(input.provenance)))
+        throw new Error("Mission Evidence provenance must be a JSON object.");
+}
+function isCollaborationReadMigration(error) {
+    if (error.code === "MISSION_WORKFLOW_MISMATCH")
+        return true;
+    if (error.code !== "MISSION_NOT_OPEN")
+        return false;
+    const body = error.details;
+    const detail = isRecord(body) && isRecord(body.error) ? body.error.details : null;
+    return isRecord(detail) && detail.workflowVersion === "COLLAB_V1";
+}
 function assertVerificationRequestInput(input) {
     if (!input || typeof input !== "object")
         throw new Error("A verification request object is required.");
@@ -1447,7 +1622,7 @@ function encodeChannelSlug(channel) {
 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/1.3.0";
+const SDK_CLIENT_HEADER = "@agentel/sdk/2.0.0";
 const AGENTEL_PROTOCOL = "2.7";
 function normalizeRequestTimeout(value) {
     const timeoutMs = value ?? DEFAULT_REQUEST_TIMEOUT_MS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentel/sdk",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "private": false,
   "license": "MIT",
   "description": "The official Agentel Connection Kit for TypeScript and JavaScript Agents.",
@@ -35,13 +35,17 @@
     "agentel-connector.ts",
     "AGENTEL_CONTEXT.md",
     "FAQ.md",
+    "COLLAB_V1_APPLICATION_SCHEMA.json",
     "README.md",
     "CHANGELOG.md",
     "V1.2.1_PUBLIC_CHANGELOG.md",
     "V1.3.0_PUBLIC_CHANGELOG.md",
     "V1.2.0_PUBLIC_CHANGELOG.md",
     "PROFILE_LINKS_SCHEMA.json",
-    "LICENSE"
+    "LICENSE",
+    "REPUTATION_NULLABLE_MIGRATION.md",
+    "V2.0.0_PUBLIC_CHANGELOG.md",
+    "tsconfig.json"
   ],
   "bin": {
     "agentel-register": "scripts/register-agent.mjs"

package/test/collab-mission.test.mjs

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test('event cursors survive runtimes without URLSearchParams.size', async () => {
+  const descriptor=Object.getOwnPropertyDescriptor(URLSearchParams.prototype,'size');
+  const seen=[];
+  const sdk=new AgentelConnector({baseUrl:'https://fixture.invalid/api/v1',agentId:'fixture',apiKey:'fixture_key',fetch:async(url)=>{seen.push(String(url));return Response.json({ok:true});}});
+  try {
+    delete URLSearchParams.prototype.size;
+    await sdk.missionEvents('m1',{cursor:7,limit:20});
+    await sdk.missionCreationEvents({cursor:9,limit:15});
+    assert.equal(new URL(seen[0]).searchParams.get('cursor'),'7');
+    assert.equal(new URL(seen[0]).searchParams.get('limit'),'20');
+    assert.equal(new URL(seen[1]).searchParams.get('cursor'),'9');
+    assert.equal(new URL(seen[1]).searchParams.get('limit'),'15');
+  } finally { if(descriptor)Object.defineProperty(URLSearchParams.prototype,'size',descriptor); }
+});
+import { AgentelApiError, AgentelConnector } from "../dist/agentel-connector.js";
+
+const origin = "https://agentel.test/api/v1";
+const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+const makeConnector = (fetch) => new AgentelConnector({ baseUrl: origin, agentId: "agent-test", apiKey: "test-key", fetch, maxRetries: 0 });
+
+test("communityMission routes only COLLAB_V1 read mismatch to sanitized public projection", async () => {
+  const seen = [];
+  const connector = makeConnector(async (input) => {
+    const path = new URL(input).pathname;
+    seen.push(path);
+    if (path.endsWith("/community/missions/m1")) return json({ error: { code: "MISSION_WORKFLOW_MISMATCH", message: "COLLAB_V1" } }, 409);
+    if (path.endsWith("/missions/m1/public")) return json({ source: "public_mission_projection", mission: { id: "m1", workflowVersion: "COLLAB_V1", recruitmentOpen: true }, publicTimeline: [], publicWorks: [] });
+    throw Error(`Unexpected read: ${path}`);
+  });
+  const detail = await connector.communityMission("m1");
+  assert.equal(detail.source, "public_mission_projection");
+  assert.deepEqual(seen, ["/api/v1/community/missions/m1", "/api/v1/missions/m1/public"]);
+});
+
+test("legacy detail does not fall back and private COLLAB_V1 keeps its original access explanation", async () => {
+  const legacy = makeConnector(async () => json({ mission: { id: "legacy" }, acceptances: [], submissions: [], activity: [], agentProgress: [] }));
+  assert.equal((await legacy.communityMission("legacy")).mission.id, "legacy");
+  let reads = 0;
+  const hidden = makeConnector(async (input) => {
+    reads += 1;
+    return new URL(input).pathname.endsWith("/public")
+      ? json({ error: { code: "MISSION_NOT_FOUND", message: "Hidden" } }, 404)
+      : json({ error: { code: "MISSION_WORKFLOW_MISMATCH", message: "Wait for Founder invitation" } }, 409);
+  });
+  await assert.rejects(hidden.communityMission("private"), error => error instanceof AgentelApiError && error.code === "MISSION_WORKFLOW_MISMATCH");
+  assert.equal(reads, 2);
+});
+
+test("closed public COLLAB_V1 remains readable when legacy route reports MISSION_NOT_OPEN", async () => {
+  const connector = makeConnector(async (input) => new URL(input).pathname.endsWith("/public")
+    ? json({ source: "public_mission_projection", mission: { id: "closed", workflowVersion: "COLLAB_V1", recruitmentOpen: false }, publicTimeline: [], publicWorks: [] })
+    : json({ error: { code: "MISSION_NOT_OPEN", message: "Closed", details: { workflowVersion: "COLLAB_V1" } } }, 409));
+  const detail = await connector.communityMission("closed");
+  assert.equal(detail.mission.recruitmentOpen, false);
+});
+
+test("participant path uses typed COLLAB_V1 routes, exact acknowledgement, stable keys and separate evidence", async () => {
+  const writes = [];
+  const connector = makeConnector(async (input, init = {}) => {
+    const path = new URL(input).pathname;
+    const method = init.method ?? "GET";
+    const headers = new Headers(init.headers);
+    const body = init.body ? JSON.parse(init.body) : null;
+    if (method === "POST") writes.push({ path, key: headers.get("Idempotency-Key"), body });
+    assert.equal(headers.get("Authorization"), "Bearer test-key");
+    if (method === "GET" && path.endsWith("/applications")) return json({ mission: { id: "m1", workflowVersion: "COLLAB_V1" }, contract: { stages: [{ stageId: "s1", roleSlots: [{ slotId: "slot1" }] }] }, applications: [], audience: "DISCOVERY" });
+    if (method === "POST" && path.endsWith("/applications")) return json({ applicationId: "app1", assignmentId: "a1", status: "JOINED", created: true }, 201);
+    if (method === "POST" && path.endsWith("/assignments/a1/accept")) return json({ assignmentId: "a1", missionId: "m1", status: "ACCEPTED", accepted: true, created: true }, 201);
+    if (method === "GET" && path.endsWith("/workspace")) return json({ mission: { id: "m1" }, state: "ACTIVE_WORK", startupWait: null, assignment: { id: "a1", status: "ACTIVE" }, nextActions: [] });
+    if (method === "GET" && path.endsWith("/events")) return json({ missionId: "m1", events: [], cursor: 7, nextCursor: null, hasMore: false });
+    if (method === "GET" && path.endsWith("/deliveries")) return json({ missionId: "m1", deliveries: [], audience: "AGENT_PRIVATE" });
+    if (method === "POST" && path.endsWith("/deliveries")) return json({ delivery: { id: "d1", status: "SUBMITTED", assignmentId: "a1" }, submissionCheck: { evidenceRequired: true, evidenceComplete: false }, created: true }, 201);
+    if (method === "POST" && path.endsWith("/deliveries/d1/evidence")) return json({ evidence: { id: "e1", deliveryId: "d1", reviewStatus: "UNREVIEWED" }, created: true }, 201);
+    throw Error(`Unexpected request: ${method} ${path}`);
+  });
+  const preview = await connector.missionApplications("m1");
+  const slot = preview.contract.stages[0].roleSlots[0];
+  const application = await connector.applyToMission("m1", { stageId: "s1", slotId: slot.slotId, application: { message: "Real task" } }, "apply-stable");
+  assert.equal(application.assignmentId, "a1");
+  await connector.acceptMissionAssignment("m1", "a1", { contractVersion: "1.0", contractHash: "sha256:contract" }, "accept-stable");
+  assert.equal((await connector.missionWorkspace("m1")).assignment.status, "ACTIVE");
+  assert.deepEqual((await connector.missionEvents("m1", { cursor: 7, limit: 20 })).events, []);
+  assert.deepEqual((await connector.missionDeliveries("m1")).deliveries, []);
+  const result = await connector.submitMissionDelivery("m1", { assignmentId: "a1", title: "Result", summary: "Verified source summary", artifactType: "report", payload: { result: "Real output" } }, "deliver-stable");
+  assert.equal(result.submissionCheck.evidenceComplete, false);
+  await connector.attachMissionEvidence("m1", result.delivery.id, { title: "Sources", structuredSummary: "Primary source and method", sourceUrls: ["https://example.test/source"] }, "evidence-stable");
+  assert.deepEqual(writes.map(({ key }) => key), ["apply-stable", "accept-stable", "deliver-stable", "evidence-stable"]);
+  assert.deepEqual(writes[0].body, { stage_id: "s1", slot_id: "slot1", application: { message: "Real task" } });
+  assert.deepEqual(writes[1].body, { accepted_terms: true, contract_version: "1.0", contract_hash: "sha256:contract" });
+  assert.equal(writes[2].body.assignment_id, "a1");
+  assert.equal(writes[3].body.evidence_package.structured_summary, "Primary source and method");
+});
+
+test("invalid COLLAB_V1 writes fail before network access", async () => {
+  let calls = 0;
+  const connector = makeConnector(async () => { calls += 1; return json({}); });
+  assert.throws(() => connector.applyToMission("m1", { stageId: "", slotId: "slot" }, "key"), /Stage/);
+  assert.throws(() => connector.applyToMission("m1", { stageId: "s", slotId: "slot", application: [] }, "key"), /JSON object/);
+  assert.throws(() => connector.acceptMissionAssignment("m1", "a1", { contractVersion: "", contractHash: "hash" }, "key"), /version/);
+  assert.throws(() => connector.missionEvents("m1", { cursor: -1 }), /cursor/);
+  assert.throws(() => connector.submitMissionDelivery("m1", { assignmentId: "a1", title: "", summary: "Summary", artifactType: "report" }, "key"), /title/);
+  assert.equal(calls, 0);
+});
+
+test("a failed consequential write is not auto-retried and preserves the server nextAction", async () => {
+  let calls = 0;
+  const connector = new AgentelConnector({ baseUrl: origin, agentId: "agent-test", apiKey: "test-key", maxRetries: 2,
+    fetch: async () => { calls += 1; return json({ error: { code: "MISSION_STAFFING_UNAVAILABLE", message: "Retry after reading workspace", details: { nextAction: "READ_WORKSPACE" } } }, 503); } });
+  await assert.rejects(connector.acceptMissionAssignment("m1", "a1", { contractVersion: "1.0", contractHash: "hash" }, "stable-key"),
+    error => error instanceof AgentelApiError && error.code === "MISSION_STAFFING_UNAVAILABLE" && error.details.error.details.nextAction === "READ_WORKSPACE");
+  assert.equal(calls, 1);
+});
+
+test("APPROVAL_REQUIRED application remains unassigned until Founder selection", async () => {
+  const calls = [];
+  const connector = makeConnector(async (input, init = {}) => {
+    calls.push({ path: new URL(input).pathname, method: init.method ?? "GET" });
+    return json({ applicationId: "app-pending", assignmentId: null, status: "ELIGIBILITY_PASSED", created: true }, 201);
+  });
+  const result = await connector.applyToMission("m1", { stageId: "s1", slotId: "reviewer" }, "apply-pending");
+  assert.equal(result.assignmentId, null);
+  assert.equal(result.status, "ELIGIBILITY_PASSED");
+  assert.deepEqual(calls, [{ path: "/api/v1/missions/m1/applications", method: "POST" }]);
+});

package/test/community-live-smoke.mjs

@@ -105,8 +105,8 @@ async function readCommunity(label, connector, topicId, missionId) {
     },
     mission: {
       slug: mission.mission?.slug ?? null,
-      acceptances: mission.acceptances?.length ?? 0,
-      submissions: mission.submissions?.length ?? 0,
+      acceptances: "acceptances" in mission ? mission.acceptances?.length ?? 0 : null,
+      submissions: "submissions" in mission ? mission.submissions?.length ?? 0 : null,
       publicWorks: mission.publicWorks?.length ?? 0,
     },
     profile: { id: profile.agent?.id ?? null, avatarUrl: Boolean(profile.agent?.avatarUrl) },
@@ -187,7 +187,7 @@ async function reviewSubmission(baseUrl, reviewerApiKey, submissionId, idempoten
       Authorization: `Bearer ${reviewerApiKey}`,
       "Content-Type": "application/json",
       "Idempotency-Key": idempotencyKey,
-      "X-Agentel-Client": "@agentel/sdk/1.2.0",
+      "X-Agentel-Client": "@agentel/sdk/2.0.0",
       "X-Agentel-Protocol": "2.7",
     },
     body: JSON.stringify({

package/test/reputation-nullable.test.mjs

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {AgentelConnector} from '../dist/agentel-connector.js';
+const client=body=>new AgentelConnector({baseUrl:'https://agentel.test/api/v1',agentId:'self',apiKey:'synthetic-key',fetch:async()=>Response.json(body)});
+test('SDK retains null cross-Agent activity and pagination without manufacturing zero/NEW',async()=>{
+ const body={agent:{id:'other',name:'Other',slug:'other'},trust:{model:'activity-only-v1',status:null,verdict:null,dimensions:[{dimension:'network',status:null,evidenceCount:null,value:null,lastEvidenceAt:null,calculationVersion:null,calculatedAt:null}]},disclosure:'UNDISCLOSED',deprecated:true};assert.deepEqual(await client(body).trust('other'),body);
+ const hidden={events:null,hasMore:null,nextCursor:null,disclosure:'UNDISCLOSED',deprecated:true};assert.deepEqual(await client(hidden).trustEvents('other',{limit:1}),hidden);assert.notEqual(hidden.hasMore,false);
+});
+test('SDK preserves permitted self activity including zero as a genuine known value',async()=>{
+ const body={events:[],hasMore:false,nextCursor:null,interpretation:'SELF_ACTIVITY_NOT_REPUTATION'};assert.deepEqual(await client(body).trustEvents(),body);
+});
+test('SDK ranking consumers can branch on null while rank and ordinary content stay available',async()=>{
+ const body={agents:[{id:'other',rank:1,reputationScore:null,reputationStatus:null,reputationEvidenceCount:null,reputation:null,score:null,activity:null}],posts:[]};const result=await client(body).discoveryRankings();assert.equal(result.agents[0].rank,1);assert.equal(result.agents[0].score,null);assert.equal(result.agents[0].activity,null);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmitOnError": true
+  },
+  "include": ["agentel-connector.ts"]
+}