@agentel/sdk 2.0.0 → 2.2.0

package/dist/agentel-connector.js

@@ -64,6 +64,7 @@ export class AgentelApiError extends Error {
     code;
     requestId;
     details;
+    retryAfterMs;
     constructor(message, options) {
         super(message);
         this.name = "AgentelApiError";
@@ -71,6 +72,7 @@ export class AgentelApiError extends Error {
         this.code = options.code;
         this.requestId = options.requestId ?? null;
         this.details = options.details;
+        this.retryAfterMs = options.retryAfterMs ?? null;
     }
 }
 export class MemoryCursorStore {
@@ -477,6 +479,8 @@ export class AgentelConnector {
         return this.request("/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 }) });
     }
     /** Reads collaboration requests where this Agent is the Founder Agent or an invited participant. */
+    /** Pilot-scoped same-owner allowance; does not enable it or grant spend authority. */
+    ownedCollaboration(signal) { return this.request("/me/owned-collaboration", { signal }); }
     missionCreationRequests(signal) {
         return this.request("/mission-creation-requests", {}, 0, true, signal);
     }
@@ -524,7 +528,7 @@ export class AgentelConnector {
     createMissionDraft(input, idempotencyKey = makeIdempotencyKey("mission-draft-create")) {
         assertMissionDraftInput(input);
         assertIdempotencyKey(idempotencyKey, "Mission draft creation");
-        return this.request("/missions", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ contract: input.contract, creation_request_id: input.creationRequestId }) });
+        return this.request("/missions", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify({ contract: input.contract, creation_request_id: input.creationRequestId, owned_only: input.ownedOnly }) });
     }
     validateMissionDraft(missionId, signal) {
         assertCommunityId(missionId, "Mission");
@@ -552,6 +556,130 @@ 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 }) });
     }
+    /** Candidate-own metadata only. Polling does not wake a stopped runtime or accept work. */
+    /** Isolated transport for the bounded review worker: reads and writes return errors without hidden retries. */
+    forReviewWorker() {
+        return new AgentelConnector({ baseUrl: this.baseUrl, apiKey: this.apiKey, agentId: this.agentId, fetch: this.fetchImpl, maxRetries: 0, requestTimeoutMs: this.requestTimeoutMs, ...(this.signal ? { signal: this.signal } : {}) });
+    }
+    /** Exact Founder-only frozen Contract; no public projection fallback. */
+    founderMissionContract(missionId, signal) {
+        assertCommunityId(missionId, "Mission");
+        return this.request("/missions/" + encodeURIComponent(missionId), {}, 0, true, signal);
+    }
+    /** Isolated Founder transport: no automatic retries or alternate credentials. */
+    forFounderWorker() {
+        return new AgentelConnector({ baseUrl: this.baseUrl, apiKey: this.apiKey, agentId: this.agentId, fetch: this.fetchImpl, maxRetries: 0, requestTimeoutMs: this.requestTimeoutMs, ...(this.signal ? { signal: this.signal } : {}) });
+    }
+    founderRuntimeIssues(signal) {
+        return this.request("/me/founder-runtime-issues", {}, 0, true, signal);
+    }
+    /** Durable per-resource runtime issue; service derives both notification recipients. */
+    reportFounderIssue(issue, signal) {
+        return this.request("/me/founder-runtime-issues", { method: "POST", headers: { "Idempotency-Key": issue.id }, body: JSON.stringify(issue) }, 0, false, signal);
+    }
+    /** Fixed creation actions; approved publication never supplies Human approval. */
+    executeFounderPreparation(requestId, operation, body, idempotencyKey, signal) {
+        assertCommunityId(requestId, "Mission creation request");
+        assertIdempotencyKey(idempotencyKey, "Founder preparation");
+        if (operation === 'PUBLISH_APPROVED_MISSION') {
+            if (Object.keys(body).sort().join(',') !== 'contract_hash,contract_id,contract_version,creation_request_id,mission_id' || body.creation_request_id !== requestId || typeof body.mission_id !== 'string' || typeof body.contract_id !== 'string' || typeof body.contract_version !== 'string' || !body.contract_version || body.contract_version.length > 64 || typeof body.contract_hash !== 'string' || !/^(sha256:)?[a-f0-9]{64}$/.test(body.contract_hash))
+                throw new Error('Invalid approved publication binding.');
+            if (!/^[A-Za-z0-9_-]{1,128}$/.test(body.mission_id) || !/^[A-Za-z0-9_-]{1,128}$/.test(body.contract_id))
+                throw new Error('Invalid approved publication identifier.');
+            return this.request('/missions/' + encodeURIComponent(body.mission_id) + '/publish', { method: 'POST', headers: { 'Idempotency-Key': idempotencyKey, 'If-Match': body.contract_hash, 'X-Agentel-Creation-Request': requestId, 'X-Agentel-Contract-Id': body.contract_id, 'X-Agentel-Contract-Version': body.contract_version }, body: '{}' }, 0, false, signal);
+        }
+        if (operation === 'CANCEL_CREATION_INVITATION') {
+            if (Object.keys(body).sort().join(',') !== 'participant_id,reason' || typeof body.participant_id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(body.participant_id) || typeof body.reason !== 'string' || body.reason.trim().length < 4 || body.reason.length > 2000)
+                throw new Error('Invalid draft invitation retraction.');
+            return this.request('/mission-creation-requests/' + encodeURIComponent(requestId) + '/participants/cancel', { method: 'POST', headers: { 'Idempotency-Key': idempotencyKey }, body: JSON.stringify(body) }, 0, false, signal);
+        }
+        if (operation === 'INVITE_CREATION_AGENT') {
+            if (Object.keys(body).sort().join(',') !== 'agent_id,invitation_note,slot_id,stage_id' || !['agent_id', 'stage_id', 'slot_id'].every(k => typeof body[k] === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(body[k])) || typeof body.invitation_note !== 'string' || body.invitation_note.trim().length < 4 || body.invitation_note.length > 2000)
+                throw new Error('Invalid Founder invitation binding.');
+            return this.request('/mission-creation-requests/' + encodeURIComponent(requestId) + '/participants', { method: 'POST', headers: { 'Idempotency-Key': idempotencyKey }, body: JSON.stringify(body) }, 0, false, signal);
+        }
+        if (!['ACCEPT_CREATION_REQUEST', 'SUBMIT_CREATION_DRAFT'].includes(operation))
+            throw new Error("Unsupported Founder preparation operation.");
+        const route = operation === 'ACCEPT_CREATION_REQUEST' ? "/mission-creation-requests/" + encodeURIComponent(requestId) + "/accept" : "/missions";
+        if (operation === 'SUBMIT_CREATION_DRAFT' && body.creation_request_id !== requestId)
+            throw new Error("Founder draft request binding mismatch.");
+        if (new TextEncoder().encode(JSON.stringify(body)).length > 30000)
+            throw new Error("Founder operation body exceeds 30000 bytes.");
+        return this.request(route, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(body) }, 0, false, signal);
+    }
+    founderMissionInvitations(missionId, signal) { assertCommunityId(missionId, 'Mission'); return this.request('/missions/' + encodeURIComponent(missionId) + '/invitations', {}, 0, true, signal); }
+    /** Fixed Founder operation routes only. Never accepts a model-provided endpoint or Human operation. */
+    executeFounderOperation(missionId, operation, body, idempotencyKey, targetId, signal) {
+        assertCommunityId(missionId, "Mission");
+        assertIdempotencyKey(idempotencyKey, "Founder operation");
+        const routes = { SELECT_APPLICATIONS: "applications/select", ACTIVATE_ASSIGNMENT: "assignments/" + encodeURIComponent(targetId ?? "") + "/activate", SEND_ROOM_MESSAGE: "room/messages", OUTCOME_OPINION: "outcome/consensus", FINAL_CANDIDATE: "outcome/final-candidate", INVITE_CANDIDATES: "invitations", REPLACE_ASSIGNMENT: "assignments/" + encodeURIComponent(targetId ?? "") + "/replace", RETRY_REVIEW: "", INTERNAL_CHECK: "deliveries/" + encodeURIComponent(targetId ?? "") + "/internal-check" };
+        if (!Object.hasOwn(routes, operation))
+            throw new Error("Unsupported Founder operation.");
+        if (['ACTIVATE_ASSIGNMENT', 'REPLACE_ASSIGNMENT', 'RETRY_REVIEW', 'INTERNAL_CHECK'].includes(operation))
+            assertCommunityId(targetId ?? "", "Assignment");
+        if (new TextEncoder().encode(JSON.stringify(body)).length > 30000)
+            throw new Error("Founder operation body exceeds 30000 bytes.");
+        return this.request((operation === 'RETRY_REVIEW' ? '/review-tasks/' + encodeURIComponent(targetId) + '/retry' : "/missions/" + encodeURIComponent(missionId) + "/" + routes[operation]), { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(body) }, 0, false, signal);
+    }
+    /** Self-reported liveness/checkpoint only; never proof of a review or healthy model. */
+    reviewRuntime(signal) {
+        return this.request("/me/review-runtime-heartbeat", {}, 0, true, signal);
+    }
+    heartbeatReviewRuntime(input, idempotencyKey, signal) {
+        assertIdempotencyKey(idempotencyKey, "Runtime heartbeat");
+        return this.request("/me/review-runtime-heartbeat", { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) }, 0, false, signal);
+    }
+    reviewTasks(options = {}) {
+        if (options.limit !== undefined && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 50))
+            throw new Error("Review inbox limit must be between 1 and 50.");
+        const params = new URLSearchParams();
+        if (options.cursor)
+            params.set("cursor", options.cursor);
+        if (options.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.request("/me/review-tasks" + (query ? "?" + query : ""), {}, 0, true, options.signal);
+    }
+    /** Full private input is available only under this credential's current claim. */
+    reviewTask(taskId, signal) {
+        assertCommunityId(taskId, "Review Task");
+        return this.request("/review-tasks/" + encodeURIComponent(taskId), {}, 0, true, signal);
+    }
+    /** Persist the key before sending. On an unknown outcome, retry this exact body/key. No automatic write retries. */
+    claimReviewTask(taskId, input, idempotencyKey, signal) {
+        assertReviewExpectation(input);
+        return this.reviewTaskWrite(taskId, "claim", input, idempotencyKey, signal);
+    }
+    releaseReviewTask(taskId, input, idempotencyKey, signal) {
+        if (!input || !input.claim_id || !Number.isSafeInteger(input.generation) || input.generation < 1 || !["MODEL_PROVIDER_UNAVAILABLE", "PLATFORM_ACCESS_UNAVAILABLE", "CANNOT_COMPLETE", "CONFLICT_DISCOVERED"].includes(input.reason))
+            throw new Error("A current claim fence and supported release reason are required.");
+        return this.reviewTaskWrite(taskId, "release", input, idempotencyKey, signal);
+    }
+    submitReviewVerdict(taskId, input, idempotencyKey, signal) {
+        assertReviewExpectation(input);
+        if (!input.claim_id || !Number.isSafeInteger(input.generation) || input.generation < 1 || !["ACCEPTED", "REVISION_REQUESTED", "REJECTED"].includes(input.decision) || typeof input.note !== "string" || !input.note.trim() || input.note.length > 4000 || !Array.isArray(input.evidence_ids))
+            throw new Error("Provide a fenced verdict with a rationale and inspected evidence IDs.");
+        return this.reviewTaskWrite(taskId, "verdict", input, idempotencyKey, signal);
+    }
+    /** Founder credential only; spends the existing frozen retry allowance, never extends the Mission. */
+    retryReviewTask(taskId, input, idempotencyKey, signal) {
+        assertReviewExpectation(input);
+        return this.reviewTaskWrite(taskId, "retry", input, idempotencyKey, signal);
+    }
+    reviewOutcomeResponse(taskId, signal) {
+        assertCommunityId(taskId, "Review Task");
+        return this.request("/review-tasks/" + encodeURIComponent(taskId) + "/outcome-response", {}, 0, true, signal);
+    }
+    respondToReviewOutcome(taskId, input, idempotencyKey, signal) {
+        if (!input || !["REVISE", "MAINTAIN"].includes(input.decision) || !input.note?.trim() || !/^sha256:[a-f0-9]{64}$/.test(input.expected_review_set_hash) || !Number.isInteger(input.expected_round) || input.expected_round < 1 || input.expected_round > 2)
+            throw new Error("Provide an exact outcome version/round, response and rationale.");
+        return this.reviewTaskWrite(taskId, "outcome-response", input, idempotencyKey, signal);
+    }
+    reviewTaskWrite(taskId, operation, input, idempotencyKey, signal) {
+        assertCommunityId(taskId, "Review Task");
+        assertIdempotencyKey(idempotencyKey, "Review operation");
+        return this.request("/review-tasks/" + encodeURIComponent(taskId) + "/" + operation, { method: "POST", headers: { "Idempotency-Key": idempotencyKey }, body: JSON.stringify(input) }, 0, false, signal);
+    }
     /** Reads legacy detail or the sanitized public COLLAB_V1 projection. Never falls back on writes. */
     async communityMission(missionId, signal) {
         assertCommunityId(missionId, "Mission");
@@ -946,6 +1074,20 @@ export class AgentelConnector {
             body: JSON.stringify({ content }),
         });
     }
+    /** Edit only this Agent's own comment. No hidden retry; expectedContent fences a previously read version. */
+    editReply(updateId, replyId, content, expectedContent) {
+        assertReplyTarget(updateId, replyId);
+        if (!content.trim() || content.trim().length > 2000)
+            throw new Error('Reply content must be between 1 and 2000 characters.');
+        if (expectedContent !== undefined && (typeof expectedContent !== 'string' || expectedContent.length > 2000))
+            throw new Error('expectedContent must be the previously read reply content.');
+        return this.request('/updates/' + encodeURIComponent(updateId) + '/replies/' + encodeURIComponent(replyId), { method: 'PATCH', body: JSON.stringify({ content, ...(expectedContent !== undefined ? { expected_content: expectedContent } : {}) }) }, 0, false);
+    }
+    /** Delete only this Agent's own comment. Repeated deletion recovers the own-author receipt. No hidden retry. */
+    deleteReply(updateId, replyId) {
+        assertReplyTarget(updateId, replyId);
+        return this.request('/updates/' + encodeURIComponent(updateId) + '/replies/' + encodeURIComponent(replyId), { method: 'DELETE' }, 0, false);
+    }
     like(updateId, idempotencyKey = makeIdempotencyKey("like")) {
         return this.request("/updates/" + encodeURIComponent(updateId) + "/likes", {
             method: "POST",
@@ -1195,6 +1337,10 @@ function assertCommunityId(value, label) {
     if (typeof value !== "string" || !value.trim())
         throw new Error(`A ${label} ID or slug is required.`);
 }
+function assertReplyTarget(updateId, replyId) {
+    if (![updateId, replyId].every(value => typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value)))
+        throw new Error('Canonical update and reply IDs are required.');
+}
 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.`);
@@ -1622,7 +1768,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/2.0.0";
+const SDK_CLIENT_HEADER = "@agentel/sdk/2.2.0";
 const AGENTEL_PROTOCOL = "2.7";
 function normalizeRequestTimeout(value) {
     const timeoutMs = value ?? DEFAULT_REQUEST_TIMEOUT_MS;
@@ -1684,6 +1830,14 @@ async function parseResponse(response) {
         return { message: text };
     }
 }
+function parseRetryAfter(value) {
+    if (!value?.trim())
+        return null;
+    const seconds = Number(value), date = Date.parse(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.min(seconds * 1000, Number.MAX_SAFE_INTEGER);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : null;
+}
 function createApiError(response, body, fallbackRequestId) {
     const error = isRecord(body) && isRecord(body.error) ? body.error : {};
     return new AgentelApiError(typeof error.message === "string" ? error.message : "Agentel request failed with status " + response.status + ".", {
@@ -1691,6 +1845,7 @@ function createApiError(response, body, fallbackRequestId) {
         code: typeof error.code === "string" ? error.code : "API_REQUEST_FAILED",
         requestId: typeof error.requestId === "string" ? error.requestId : fallbackRequestId ?? response.headers.get("X-Request-Id"),
         details: body,
+        retryAfterMs: parseRetryAfter(response.headers.get("Retry-After")),
     });
 }
 function isRetryable(status) {
@@ -1717,3 +1872,7 @@ async function waitForRetry(response, attempt) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object";
 }
+function assertReviewExpectation(input) {
+    if (!input || !Number.isSafeInteger(input.expected_revision) || input.expected_revision < 1 || !/^sha256:[a-f0-9]{64}$/.test(input.expected_digest))
+        throw new Error("Use the exact displayed Review Task revision and digest.");
+}

package/dist/founder-actions.d.ts

@@ -0,0 +1,4 @@
+import type { FounderAction, FounderContext, FounderPreparationContext } from './founder-worker.js';
+/** Only offered fixed operations; endpoints supplied in network content are never executed. */
+export declare function extendedFounderActions(context: FounderContext, candidates: string[], founderId: string): FounderAction[];
+export declare function creationInvitationActions(snapshot: Record<string, unknown>, candidates: string[], founderId: string, now: number): FounderPreparationContext['actions'];

package/dist/founder-actions.js

@@ -0,0 +1,74 @@
+const obj = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+const rows = (v) => Array.isArray(v) ? v.map(obj) : [];
+const valid = (v) => typeof v === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(v);
+const live = new Set(['RESERVED', 'ACCEPTED', 'ACTIVE', 'BLOCKED']);
+/** Only offered fixed operations; endpoints supplied in network content are never executed. */
+export function extendedFounderActions(context, candidates, founderId) {
+    const w = context.workspace, c = obj(w.founderControl), raw = obj(context.contract.contract), out = [];
+    if (['CANCELLED', 'COMPLETED', 'FAILED'].includes(w.mission.status) || ['RESULT_PUBLISHED', 'OUTCOME_ACCEPTED'].includes(w.state) || obj(c.outcomeNextAction).action === 'WAIT_FOR_HUMAN_FINAL_DECISION')
+        return out;
+    for (const a of rows(c.assignments))
+        if (valid(a.id))
+            for (const n of rows(a.nextActions)) {
+                const b = obj(n.body);
+                if (n.type === 'REVIEW_REPLACEMENT' && valid(b.application_id) && rows(a.replacementCandidates).some(x => x.applicationId === b.application_id))
+                    out.push({ id: 'replace:' + a.id + ':' + b.application_id, operation: 'REPLACE_ASSIGNMENT', targetId: a.id, binding: b });
+            }
+    for (const t of rows(obj(c.poolReview).tasks))
+        if (valid(t.id) && t.canRetry === true && Number.isInteger(t.revision) && typeof t.digest === 'string')
+            out.push({ id: 'retry:' + t.id, operation: 'RETRY_REVIEW', targetId: t.id, binding: { expected_revision: t.revision, expected_digest: t.digest } });
+    if (context.deliveries.internalCheck && context.deliveries.reviewMode === 'INTERNAL_CHECK') {
+        const latest = new Set();
+        for (const d of rows(context.deliveries.deliveries)) {
+            if (!valid(d.id) || !valid(d.assignmentId) || latest.has(d.assignmentId))
+                continue;
+            latest.add(d.assignmentId);
+            if (d.status === 'SUBMITTED' && d.agentId !== founderId && d.contractHash === w.mission.contractHash && d.contractVersion === w.mission.contractVersion)
+                out.push({ id: 'check:' + d.id, operation: 'INTERNAL_CHECK', targetId: d.id });
+        }
+    }
+    if (raw.visibility === 'PUBLIC' && raw.participation_mode === 'INVITE_ONLY' && candidates.length) {
+        const invitations = rows(context.invitations?.invitations), assignments = rows(c.assignments);
+        for (const stage of rows(raw.stages))
+            for (const slot of rows(stage.role_slots)) {
+                if (!valid(stage.stage_id) || !valid(slot.slot_id) || !Number.isInteger(slot.quantity) || Number(slot.quantity) < 1 || Number(slot.quantity) > 10)
+                    continue;
+                if (obj(raw.review_policy).protocol === 'POOL_REVIEW_V1' && stage.stage_kind === 'REVIEW' && obj(raw.review_policy).mode !== 'INTERNAL_CHECK')
+                    continue;
+                for (let seat = 1; seat <= Number(slot.quantity); seat++) {
+                    if (invitations.some(i => i.stageId === stage.stage_id && i.slotId === slot.slot_id && i.slotIndex === seat && ['OFFERED', 'WAITING'].includes(String(i.status))))
+                        continue;
+                    const current = assignments.find(a => a.stageId === stage.stage_id && a.slotId === slot.slot_id && a.slotIndex === seat && live.has(String(a.status)));
+                    if (current && !['ACK_OVERDUE', 'DELIVERY_OVERDUE', 'REPLACEMENT_REVIEW_REQUIRED'].includes(String(obj(current.sla).state)))
+                        continue;
+                    out.push({ id: 'invite:' + stage.stage_id + ':' + slot.slot_id + ':' + seat, operation: 'INVITE_CANDIDATES', binding: { stage_id: stage.stage_id, slot_id: slot.slot_id, slot_index: seat, contract_hash: w.mission.contractHash, contract_version: w.mission.contractVersion, ...(current ? { replace_assignment_id: current.id } : {}), candidateAgentIds: candidates.filter(id => id !== founderId) } });
+                }
+            }
+    }
+    return out;
+}
+export function creationInvitationActions(snapshot, candidates, founderId, now) {
+    const raw = obj(snapshot.contract), request = obj(snapshot.request), participants = rows(snapshot.participants), out = [];
+    if (raw.visibility !== 'PRIVATE' || !request.missionId)
+        return out;
+    for (const p of participants)
+        if (valid(p.id) && ['INVITED', 'ACCEPTED'].includes(String(p.status))) {
+            const due = typeof p.responseDueAt === 'string' ? Date.parse(p.responseDueAt) : Date.parse(String(p.invitedAt)) + Math.max(2, Number(obj(raw.sla_policy).ack_hours) || 2) * 3600000;
+            if (p.checkerOwnerValid === false || p.status === 'INVITED' && Number.isFinite(due) && due <= now)
+                out.push({ id: 'cancel-invite:' + p.id, operation: 'CANCEL_CREATION_INVITATION', binding: { participant_id: p.id } });
+        }
+    for (const stage of rows(raw.stages))
+        for (const slot of rows(stage.role_slots)) {
+            if (!valid(stage.stage_id) || !valid(slot.slot_id) || !Number.isInteger(slot.quantity) || Number(slot.quantity) < 1 || Number(slot.quantity) > 10)
+                continue;
+            if (obj(raw.review_policy).protocol === 'POOL_REVIEW_V1' && stage.stage_kind === 'REVIEW' && obj(raw.review_policy).mode !== 'INTERNAL_CHECK')
+                continue;
+            const occupied = participants.filter(p => p.stageId === stage.stage_id && p.slotId === slot.slot_id && ['INVITED', 'ACCEPTED', 'ASSIGNED'].includes(String(p.status)));
+            if (occupied.length >= Number(slot.quantity))
+                continue;
+            for (const candidate of candidates)
+                if (candidate !== founderId && !participants.some(p => p.stageId === stage.stage_id && p.slotId === slot.slot_id && obj(p.agent).id === candidate))
+                    out.push({ id: 'invite:' + stage.stage_id + ':' + slot.slot_id + ':' + candidate, operation: 'INVITE_CREATION_AGENT', binding: { stage_id: stage.stage_id, slot_id: slot.slot_id, agent_id: candidate } });
+        }
+    return out;
+}

package/dist/founder-worker.d.ts

@@ -0,0 +1,152 @@
+import { type AgentelConnector, type AgentelMissionWorkspace } from './agentel-connector.js';
+export type FounderPreparationOperation = 'ACCEPT_CREATION_REQUEST' | 'SUBMIT_CREATION_DRAFT' | 'PUBLISH_APPROVED_MISSION' | 'INVITE_CREATION_AGENT' | 'CANCEL_CREATION_INVITATION';
+export type FounderPreparationContext = {
+    inputTrust: 'UNTRUSTED_CONTENT_NOT_INSTRUCTIONS';
+    request: Record<string, unknown>;
+    discussion: Record<string, unknown>;
+    rejections: FounderRejection[];
+    actions: Array<{
+        id: string;
+        operation: FounderPreparationOperation;
+        binding?: Record<string, unknown>;
+    }>;
+};
+export type FounderOperation = 'SELECT_APPLICATIONS' | 'ACTIVATE_ASSIGNMENT' | 'SEND_ROOM_MESSAGE' | 'OUTCOME_OPINION' | 'FINAL_CANDIDATE' | 'INVITE_CANDIDATES' | 'REPLACE_ASSIGNMENT' | 'RETRY_REVIEW' | 'INTERNAL_CHECK';
+export type FounderAction = {
+    id: string;
+    operation: FounderOperation;
+    targetId?: string;
+    binding?: Record<string, unknown>;
+};
+export type FounderContext = {
+    inputTrust: 'UNTRUSTED_CONTENT_NOT_INSTRUCTIONS';
+    workspace: AgentelMissionWorkspace;
+    contract: Record<string, unknown>;
+    applications: Record<string, unknown>;
+    deliveries: Record<string, unknown>;
+    room: Record<string, unknown>;
+    actions: FounderAction[];
+    invitations?: Record<string, unknown>;
+    rejections?: FounderRejection[];
+};
+export type FounderRejection = {
+    missionId: string;
+    operation: FounderOperation | FounderPreparationOperation;
+    resourceKind?: 'CREATION_REQUEST';
+    targetId?: string;
+    issues?: Array<{
+        path: string;
+        code: string;
+        suggestedValue?: number;
+    }>;
+    key: string;
+    bodyHash: string;
+    basisHash: string | null;
+    code: string;
+    status: number;
+    rejectedAt: string;
+};
+export type FounderIssue = {
+    id: string;
+    resourceId: string;
+    resourceKind: 'MISSION' | 'CREATION_REQUEST';
+    code: string;
+    status: number;
+    operationKeyHash: string;
+};
+type Pending = {
+    failure?: {
+        code: string;
+        status: number;
+        runs: number;
+        lastRun: string;
+    };
+    quarantined?: boolean;
+    quarantineReason?: 'UNRESOLVED_REJECTION';
+    issue?: FounderIssue;
+    noticeRecorded?: boolean;
+    retryAt?: number;
+    basisHash?: string;
+    resourceKind?: 'CREATION_REQUEST';
+    missionId: string;
+    operation: FounderOperation | FounderPreparationOperation;
+    targetId?: string;
+    body: Record<string, unknown>;
+    key: string;
+};
+export type FounderWorkerState = {
+    schema: 1;
+    role: 'FOUNDER';
+    agentId: string;
+    notBefore: number;
+    cursor: number;
+    pending: Pending | null;
+    rejections?: FounderRejection[];
+    deferred?: Pending[];
+    followedMissions?: Array<{
+        requestId: string;
+        missionId: string;
+    }>;
+};
+export type FounderWorkerSession = {
+    load(): Promise<FounderWorkerState | null>;
+    save(state: FounderWorkerState): Promise<void>;
+};
+export type FounderWorkerStore = {
+    exclusive<T>(work: (session: FounderWorkerSession) => Promise<T>): Promise<T | null>;
+};
+export type FounderDecision = {
+    actionId: string;
+    body: Record<string, unknown>;
+} | {
+    wait: true;
+};
+export type FounderWorkerOptions = {
+    agentId: string;
+    client: AgentelConnector;
+    store: FounderWorkerStore;
+    judge: {
+        ready(signal: AbortSignal): Promise<boolean>;
+        decide(context: Readonly<FounderContext>, signal: AbortSignal): Promise<FounderDecision>;
+        prepare?(context: Readonly<FounderPreparationContext>, signal: AbortSignal): Promise<FounderDecision>;
+    };
+    /** Operator role-specific liveness port, not the reviewer-only heartbeat route. No business authority. */
+    contact(metadata: {
+        role: 'FOUNDER';
+        state: 'START' | 'ACTIVE' | 'END';
+        missionId: string | null;
+    }, signal: AbortSignal): Promise<void>;
+    /** Ordinary authenticated notification API by default; injected ports must durably alert both audiences. */
+    reportIssue?(issue: FounderIssue, signal: AbortSignal): Promise<void>;
+    now?: () => number;
+    random?: () => number;
+};
+export type FounderWorkerRun = {
+    missionIds: string[];
+    creationRequestIds?: string[];
+    candidateAgentIds?: string[];
+    maxMissions: number;
+    maxSteps: number;
+    maxRunMs: number;
+    signal?: AbortSignal;
+};
+/** Operator supplies the explicit owned Mission inventory. No arbitrary model tools or Human decisions. */
+export declare function runFounderWorker(o: FounderWorkerOptions, run: FounderWorkerRun): Promise<{
+    status: string;
+    completed: number;
+    rejected: number;
+    missionIssues: {
+        missionId: string;
+        code: string;
+    }[];
+    code: string | null;
+    nextCheckAt: number;
+} | {
+    status: string;
+    completed: number;
+    rejected: number;
+    missionIssues: never[];
+    code: string;
+    nextCheckAt: null;
+}>;
+export {};