totemlayer 0.1.21 → 0.1.25

package/bin/sdk/types.d.ts

@@ -0,0 +1,640 @@
+export type Metadata = Record<string, unknown>;
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Server-derived discovery links; no registry status or execution authority is implied. */
+export interface Erc8004DiscoveryLinks {
+    registrationPath: string;
+    identityPath: string;
+    grantsActionAuthority: false;
+}
+export interface Agent {
+    /** Authenticated connection-only listener marker; not an authority claim from a peer. */
+    listenerConnectionId?: string;
+    id: string;
+    address: string;
+    name: string;
+    description: string | null;
+    organization: {
+        id: string;
+        name: string;
+    };
+    verified: boolean;
+    /** Portable registry evidence; never a company verification badge or execution grant. */
+    erc8004?: Erc8004DiscoveryLinks;
+    environment: "SANDBOX" | "PRODUCTION";
+    capabilities: string[];
+    skills: string[];
+    tags: string[];
+    protocols: string[];
+    status: "ACTIVE" | "SUSPENDED" | "REVOKED" | "OFFLINE";
+    inputModes: string[];
+    outputModes: string[];
+    publicMetadata: Metadata;
+    communicationPolicy: {
+        mode: "public" | "verified_only" | "approved_organizations" | "allowlist" | "private";
+    };
+    createdAt: string;
+    updatedAt: string;
+    lastSeenAt: string | null;
+}
+export interface TextContent {
+    type: "text";
+    text: string;
+    /** Upload these IDs first; an attachment can be bound to one message only. */
+    attachments?: string[];
+}
+export interface Attachment {
+    id: string;
+    name: string;
+    mediaType: string;
+    size: number;
+    sha256: string;
+}
+export interface JsonContent {
+    type: "json";
+    data: JsonValue;
+}
+export type MessageContent = TextContent | JsonContent | import("./e2ee-wire.js").EncryptedContent;
+export type MessageState = "accepted" | "delivered" | "acknowledged" | "responded" | "failed" | "rejected" | "expired";
+export interface Message {
+    id: string;
+    sequence: string;
+    from: string;
+    to: string;
+    verified: boolean;
+    sandbox: boolean;
+    content: MessageContent;
+    attachments?: Attachment[];
+    conversationId: string;
+    taskId: string | null;
+    inReplyToId: string | null;
+    hopCount: number;
+    state: MessageState;
+    createdAt: string;
+    expiresAt: string;
+    deliveredAt: string | null;
+    readAt: string | null;
+    metadata: Metadata | null;
+    authorization: {
+        context: {
+            grantId: string;
+            action: string;
+            resource: string;
+        };
+        verified: false;
+    } | null;
+}
+export interface Conversation {
+    id: string;
+    participants: Array<{
+        id: string;
+        address: string;
+    }>;
+    status: string;
+    createdAt: string;
+    metadata: Metadata | null;
+}
+export type TaskState = "submitted" | "working" | "input_required" | "completed" | "failed" | "canceled" | "rejected";
+export interface Task {
+    id: string;
+    conversationId: string;
+    requesterId: string;
+    assigneeId: string;
+    state: TaskState;
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+    metadata: Metadata | null;
+    artifacts: JsonValue[];
+    repoClaims?: RepoClaim[];
+    events?: Array<{
+        id: string;
+        taskId: string;
+        state: TaskState;
+        sequence: string;
+        metadata: Metadata;
+        createdAt: string;
+    }>;
+}
+export type RepoClaimState = "planned" | "working" | "submitted" | "released";
+export interface RepoClaim {
+    id: string;
+    taskId: string;
+    agentId: string;
+    repository: string;
+    baseCommit: string;
+    branch: string;
+    paths: string[];
+    state: RepoClaimState;
+    headCommit: string | null;
+    pullRequestUrl: string | null;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RepositoryCoordination {
+    taskId: string;
+    repository: string;
+    baseCommit: string;
+    baseBranch: string | null;
+    claims: RepoClaim[];
+}
+export type MissionStatus = "active" | "paused" | "waiting_for_input" | "completed" | "failed" | "canceled";
+export interface MissionSummary {
+    id: string;
+    goal: string;
+    desiredOutput: string;
+    lifetime?: "task_scoped" | "ongoing";
+    status: MissionStatus;
+    role?: string;
+    coordinatorMemberId: string | null;
+    coordinatorAgentId?: string | null;
+    deadlineAt: string | null;
+    repository: {
+        url: string;
+        baseRevision: string;
+    } | null;
+    activeAgentLimit: number;
+    spendingLimitCents: number;
+    spentCents: number;
+    reservedCents?: number;
+}
+/** A bounded discovery sweep. Restart without a cursor after exhaustion to see changed eligibility. */
+export interface ListMissions extends Pagination {
+    status?: MissionStatus;
+}
+/** Context for the authenticated Company Brain or personal assistant. */
+export interface AssistantContext {
+    version: 1;
+    agent: {
+        id: string;
+        identityAgentId: string;
+        address: string;
+        name: string;
+        organizationId: string;
+        environment: "SANDBOX" | "PRODUCTION";
+        erc8004?: Erc8004DiscoveryLinks;
+    };
+    network: {
+        conversationCount: number;
+        unreadMessageCount: number;
+        conversations: Array<{
+            id: string;
+            status: string;
+            updatedAt: string;
+            participants: Array<{
+                id: string;
+                address: string;
+            }>;
+        }>;
+    };
+    missions: MissionSummary[];
+    /** Ongoing missions first, followed by recent finished work, bounded to 100. */
+    missionSnapshot?: {
+        total: number;
+        visible: number;
+        truncated: boolean;
+    };
+    invitations: Array<{
+        missionId: string;
+        goal: string;
+        role: string;
+        memberId: string;
+        consentUrl: string;
+    }>;
+    authorization: {
+        networkCredentialGrantsActions: false;
+        actionChecksRequireSeparateCredential: true;
+        missionPermissionsRequireHumanConsent: true;
+        missionPermissionsRecheckedAtDispatch: true;
+        checksUrl: "/checks";
+    };
+    /** Capability snapshot only; every check and execution revalidates authority. */
+    capabilities: {
+        actionChecks: {
+            supportedAdapters: Array<"NOOP_READ" | "LOOPBACK_ECHO">;
+            requiresVerifiedOrganization: true;
+            organizationVerified: boolean;
+            repositoryEffectsSupported: false;
+        };
+    };
+    links: {
+        network: "/communications";
+        trustNetwork: "/network";
+        missions: "/missions";
+    };
+}
+/** Advisory permission snapshot; dispatch always rechecks live authority. */
+export interface AssistantMissionPermissions {
+    version: 1;
+    agentId: string;
+    missionId: string;
+    memberId: string;
+    status: MissionStatus;
+    deadlineAt: string | null;
+    permissions: Array<{
+        id: string;
+        action: string;
+        resource: string;
+        environment: "SANDBOX" | "PRODUCTION";
+        createdAt: string;
+    }>;
+    authorization: {
+        advisory: true;
+        recheckedAtDispatch: true;
+        networkCredentialGrantsActions: false;
+        actionChecksRequireSeparateCredential: true;
+    };
+    links: {
+        mission: string;
+        checks: "/checks";
+    };
+}
+export interface MissionWorkItem {
+    id: string;
+    missionId: string;
+    ownerMemberId: string;
+    objective: string;
+    requiredOutput: string;
+    state: "queued" | "claimed" | "blocked" | "completed" | "failed" | "canceled";
+    dependsOnIds: string[];
+    deadlineAt: string | null;
+    timeoutSeconds: number | null;
+    attempts: number;
+    maxAttempts: number;
+    leaseExpired?: boolean;
+    metadata: Metadata;
+    repository?: {
+        url: string;
+        baseRevision: string;
+    } | null;
+    result?: Metadata | null;
+}
+export interface MissionArtifact {
+    id: string;
+    missionId: string;
+    kind: string;
+    title: string;
+    summary: string | null;
+    uri: string | null;
+    contentText?: string | null;
+    metadata: Metadata;
+    createdAt: string;
+}
+export interface MissionDetail extends Omit<MissionSummary, "activeAgentLimit" | "spendingLimitCents" | "spentCents" | "reservedCents"> {
+    ownerUserId?: string;
+    owner?: {
+        name: string;
+        organization: string;
+    };
+    organizationId?: string;
+    pendingApprovalKind?: string | null;
+    approvalDecisions?: string[];
+    permittedConnectorActions?: string[];
+    infrastructure?: {
+        provider: "local-static";
+        sourceDirectory: string;
+        executorAgentId: string;
+    } | null;
+    budget: {
+        spendingLimitCents: number;
+        spentCents: number;
+        reservedCents: number;
+        activeAgentLimit: number;
+        maxEvents: number;
+        eventCount: number;
+        maxDelegationDepth: number;
+        maxWorkItems: number;
+        workItemCount: number;
+    };
+    members: Array<{
+        id: string;
+        agentId: string;
+        role: string;
+        status: "invited" | "active" | "declined" | "removed";
+        ownerUserId: string;
+        historyFromSequence: string;
+        agent: {
+            id: string;
+            name: string;
+            address: string;
+            status: string;
+            organization: {
+                id: string;
+                name: string;
+            };
+            erc8004?: Erc8004DiscoveryLinks;
+            runtime: {
+                connected: boolean;
+                ready: boolean;
+                state: string;
+                lastSeenAt: string | null;
+            };
+        };
+    }>;
+    workItems: MissionWorkItem[];
+    artifacts: MissionArtifact[];
+    events: MissionEvent[];
+    coordination?: MissionCoordination;
+}
+export interface MissionSessionObservation {
+    status: "complete" | "truncated" | "unavailable";
+    baseRevision: string;
+    headCommit: string | null;
+    branch: string | null;
+    paths: string[];
+}
+export interface MissionSessionReport {
+    sessionId: string;
+    workItemId: string;
+    leaseToken: string;
+    sequence: number;
+    state: "running" | "completed" | "failed";
+    provider: "qwen-local" | "ollama-local" | "nim-local" | "codex" | "claude" | "command" | "http";
+    phase: "preparing" | "generating" | "checking" | "committing" | "settling" | "finished";
+    observation: MissionSessionObservation | null;
+}
+export interface SharedMissionSession {
+    id: string;
+    agentId: string;
+    memberId: string;
+    workItemId: string;
+    attempt: number;
+    provider: string;
+    stage: string;
+    phase: string;
+    state: string;
+    connected: boolean;
+    inactiveReason?: string | null;
+    repository: string | null;
+    observation: MissionSessionObservation | null;
+    lastSeenAt: string;
+    activities: Array<{
+        sequence: number;
+        phase: string;
+        state: string;
+        at: string;
+    }>;
+}
+export interface MissionOverlap {
+    id: string;
+    sessionIds: [string, string];
+    agentIds: [string, string];
+    paths: string[];
+    totalPaths?: number;
+}
+export interface MissionCoordination {
+    sessionsTruncated?: boolean;
+    overlapsTruncated?: boolean;
+    version: string;
+    briefing: string;
+    sessions: SharedMissionSession[];
+    overlaps: MissionOverlap[];
+}
+export interface MissionCoordinationUpdate {
+    version: string;
+    changed: boolean;
+    briefing: string | null;
+    overlaps: MissionOverlap[];
+    ownerClarifications?: Array<{
+        id: string;
+        sequence: string;
+        type: string;
+        payload: unknown;
+    }> | null;
+}
+export type MissionEventInput = {
+    version: 1;
+    workItemId?: string;
+    artifactIds?: string[];
+    recipientMemberIds?: string[];
+} & ({
+    type: "message";
+    payload: {
+        text: string;
+    };
+} | {
+    type: "proposal";
+    payload: {
+        title: string;
+        problem: string;
+        approach?: string;
+        candidates?: Array<{
+            title: string;
+            problem: string;
+            approach?: string;
+        }>;
+    };
+} | {
+    type: "review";
+    payload: {
+        summary: string;
+        verdict: "feasible" | "approved" | "changes_required" | "rejected";
+        findings?: string[];
+        candidateTitle?: string;
+    };
+} | {
+    type: "decision";
+    payload: {
+        title: string;
+        outcome: string;
+        rationale?: string;
+        selected?: boolean;
+        selectedCandidateTitle?: string;
+    };
+} | {
+    type: "assignment";
+    payload: {
+        objective: string;
+        requiredOutput?: string;
+    };
+} | {
+    type: "progress";
+    payload: {
+        summary: string;
+        percent?: number;
+    };
+} | {
+    type: "blocker";
+    payload: {
+        summary: string;
+        helpNeeded?: string;
+    };
+} | {
+    type: "question";
+    payload: {
+        question: string;
+    };
+} | {
+    type: "artifact";
+    payload: {
+        title: string;
+        summary?: string;
+    };
+} | {
+    type: "completion";
+    payload: {
+        summary: string;
+        result: "completed" | "failed";
+    };
+});
+export interface MissionEvent {
+    id: string;
+    missionId: string;
+    sequence: string;
+    version: 1 | null;
+    type: string;
+    payload: Metadata;
+    workItemId: string | null;
+    artifactIds: string[];
+    actor: {
+        kind: "human" | "agent" | "system";
+        id: string | null;
+        address?: string;
+    };
+    recipientMemberIds: string[];
+    createdAt: string;
+    deliveredAt?: string | null;
+    readAt?: string | null;
+}
+export interface Page<T> {
+    data: T[];
+    nextCursor?: string | null;
+}
+export interface Pagination {
+    cursor?: string;
+    limit?: number;
+}
+export interface SearchAgents extends Pagination {
+    q?: string;
+    organization?: string;
+    capability?: string;
+    skill?: string;
+    tag?: string;
+    protocol?: string;
+    verified?: boolean;
+    environment?: "SANDBOX" | "PRODUCTION";
+}
+export interface ListMessages extends Pagination {
+    unread?: boolean;
+    direction?: "inbound" | "outbound" | "all";
+    from?: string;
+    state?: MessageState;
+    conversationId?: string;
+    taskId?: string;
+}
+export interface ListTasks extends Pagination {
+    role?: "requester" | "assignee" | "all";
+    state?: TaskState;
+    conversationId?: string;
+}
+/** A sender is always derived from the API key. There is deliberately no `from`. */
+export type SendMessage = {
+    to: string;
+    conversationId?: string;
+    taskId?: string;
+    metadata?: Metadata;
+    ttlSeconds?: number;
+    authorization?: {
+        grantId: string;
+        action: string;
+        resource: string;
+    };
+} & ({
+    text: string;
+    content?: never;
+    message?: never;
+} | {
+    content: MessageContent;
+    text?: never;
+    message?: never;
+} | {
+    message: string;
+    text?: never;
+    content?: never;
+});
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
+export interface WriteOptions extends RequestOptions {
+    /** Reuse this key when retrying the same logical operation across restarts. */
+    idempotencyKey?: string;
+}
+export interface TotemOptions {
+    apiKey: string;
+    /** Server origin, for example http://127.0.0.1:3000 for local development. */
+    baseUrl?: string;
+    /** Optional identity assertion checked by connect(), never used as the sender. */
+    address?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    fetch?: typeof globalThis.fetch;
+}
+export interface IncomingMessage extends Message {
+    text: string;
+    /** Stable keys make replaying the same handler's replies safe. */
+    reply(text: string, options?: WriteOptions): Promise<Message>;
+    ack(): Promise<Message>;
+}
+export type MessageHandler = (message: IncomingMessage) => void | Promise<void>;
+export interface ListenOptions {
+    /** Customer-side policy. Screens message/file plaintext before invoking the handler. */
+    inspector?: import("./inspector.js").LocalInspector;
+    pollIntervalMs?: number;
+    /** Receives handler and transport failures; polling continues afterward. */
+    onError?: (error: Error) => void;
+}
+export interface Subscription {
+    /** Abort polling and wait for the currently running handler to finish. */
+    stop(): Promise<void>;
+    done: Promise<void>;
+}
+/** Human-origin commands are distinct from network messages and never impersonate an agent. */
+export interface Chat {
+    id: string;
+    agentId: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChatEvent {
+    id: string;
+    sequence: string;
+    actor: "human" | "agent" | "system";
+    kind: "message" | "update";
+    text: string;
+    createdAt: string;
+    runId?: string | null;
+}
+export interface ChatRun {
+    id: string;
+    commandEventId: string;
+    state: "queued" | "running" | "completed" | "failed" | "canceled";
+    error?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    leaseExpiresAt?: string | null;
+}
+export interface ChatCommand {
+    id: string;
+    chatId: string;
+    commandEventId: string;
+    text: string;
+    createdAt: string;
+}
+export interface ChatDetail {
+    chat: Chat;
+    events: ChatEvent[];
+    runs: ChatRun[];
+    nextCursor?: string;
+    hasMore?: boolean;
+    previousCursor?: string | null;
+}
+export interface RuntimeHeartbeat {
+    ready?: boolean;
+    state?: string;
+    connected: boolean;
+    lastSeenAt: string;
+}

package/bin/totem.mjs

@@ -237,9 +237,9 @@ function compactDigest(value) {
 function help() {
   writeBrand();
   writeHelpBody(`Start here
-  Install once          npm install --global totemlayer
+  Install once          npm install --global totemlayer@0.1.25
   Confirm installation totem --version
-  Run one-off           npx --yes totemlayer --help
+  Run one-off           npx --yes --package=totemlayer@0.1.25 totem --help
 
 Connect once and receive messages and approved Mission work
   Select Codex, Claude, a local model, or an owner-configured CLI/HTTP agent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.21",
+  "version": "0.1.25",
   "description": "Cross-platform CLI for TotemLayer agent identity and authorization",
   "type": "module",
   "bin": {

package/scripts/prepare.mjs

@@ -1,20 +1,9 @@
-import { execFileSync } from "node:child_process";
-import { mkdir, readdir, copyFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-
-// Build from the sibling source every time a distributable is packed.
-const sdk = fileURLToPath(new URL("../../sdk/", import.meta.url));
-const destination = new URL("../bin/sdk/", import.meta.url);
-execFileSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build", "--prefix", sdk], {
-  stdio: "inherit",
-});
-await mkdir(destination, { recursive: true });
-for (const name of await readdir(new URL("../../sdk/dist/", import.meta.url))) {
-  if (name.endsWith(".js"))
-    await copyFile(new URL(`../../sdk/dist/${name}`, import.meta.url), new URL(name, destination));
-}
-
-const workerCore = new URL("../bin/worker-core/", import.meta.url);
-await mkdir(workerCore, { recursive: true });
-for (const name of ["adapters.mjs", "errors.mjs"])
-  await copyFile(new URL(`../../agent-worker/${name}`, import.meta.url), new URL(name, workerCore));
+import { access } from "node:fs/promises";
+// This candidate rebases coordination on the immutable published 0.1.21 bundle.
+// Its bundled SDK is the release source; do not rebuild it from an older sibling checkout.
+for (const name of [
+  "totem.mjs", "mission-worker.mjs", "mission-coordination.mjs",
+  "sdk/index.js", "sdk/index.d.ts", "sdk/types.d.ts",
+  "network-retry.mjs", "runtime-diagnostics.mjs", "codex-chat-bridge.mjs",
+  "worker-core/adapters.mjs", "worker-core/errors.mjs",
+]) await access(new URL(`../bin/${name}`, import.meta.url));