@swarm-agent/sdk 0.1.49 → 0.1.51

package/dist/client.js

@@ -1,3 +1,4 @@
+import { SwarmAgentsNamespace } from './agents.js';
 import { SwarmAppsNamespace } from './apps.js';
 import { SwarmChatNamespace } from './chat.js';
 import { SwarmPermissionsNamespace } from './permissions.js';
@@ -11,10 +12,14 @@ import { SwarmWorkersNamespace } from './workers.js';
 import { SwarmDeliverablesNamespace } from './deliverables.js';
 import { SwarmDeployNamespace } from './deploy/index.js';
 import { SwarmNotificationsNamespace } from './notifications.js';
+import { SwarmSignalsNamespace } from './signals.js';
+import { SwarmBoxNamespace } from './box.js';
 import { SwarmProjectsNamespace } from './projects.js';
+import { SwarmRemoteNamespace } from './remote.js';
 import { SwarmSessionsNamespace } from './sessions.js';
 import { SwarmSystemNamespace } from './system.js';
 import { SwarmStorageNamespace } from './storage/index.js';
+import { resolveSwarmConnection } from './local-connection.js';
 import { SwarmTransport } from './transport.js';
 import { SwarmWorkspacesNamespace } from './workspaces.js';
 export class SwarmClient {
@@ -51,19 +56,23 @@ export class SwarmClient {
     notifications;
     /** Convenient alias for notifications namespace: inbox */
     inbox;
+    /** Machine signal feed: blocked agents, failures, refused keys, reported events. */
+    signals;
+    /** Machine state for monitors: sandbox, blocked sessions, failing workers, usage. */
+    box;
     storage;
+    /** Owner administration of the relay connection (private transport only) */
+    remote;
+    /** Sealed agents and the client tools your application answers */
+    agents;
     /** Convenient alias for cloud storage connections: cloud */
     cloud;
     constructor(config = {}) {
         const env = typeof process !== 'undefined' && process?.env ? process.env : {};
-        const baseUrl = config.baseUrl ||
-            env.SWARM_API_URL ||
-            env.SWARM_DESKTOP_URL ||
-            'http://127.0.0.1:18080';
-        const socketPath = config.socketPath || env.SWARM_SOCKET_PATH;
+        const { baseUrl, socketPath } = resolveSwarmConnection(config, { env });
         const token = config.token || env.SWARM_AUTH_TOKEN || env.SWARM_DEPLOY_TOKEN;
         const resolved = {
-            baseUrl: baseUrl.replace(/\/+$/, ''),
+            baseUrl,
             token,
             socketPath,
             defaultHeaders: config.defaultHeaders ?? {},
@@ -92,8 +101,12 @@ export class SwarmClient {
         this.deploy = new SwarmDeployNamespace(this.transport);
         this.notifications = new SwarmNotificationsNamespace(this.transport);
         this.inbox = this.notifications;
+        this.signals = new SwarmSignalsNamespace(this.transport);
+        this.box = new SwarmBoxNamespace(this.transport);
+        this.agents = new SwarmAgentsNamespace(this.transport);
         this.storage = new SwarmStorageNamespace(this.transport);
         this.cloud = this.storage;
+        this.remote = new SwarmRemoteNamespace(this.transport);
     }
     /**
      * Updates the bearer authentication token for all subsequent client requests.

package/dist/copy-tags.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Swarm agents wrap copyable snippets (commands, config, file payloads) in
+ * `<copy label="...">…</copy>` tags. Swarm's own desktop and terminal UIs render
+ * them as copy buttons; everywhere else they are noise. `copyTagsToMarkdown`
+ * turns each tag into a plain Markdown code block (with its label, if any, as a
+ * bold line above it), so any Markdown renderer shows it correctly.
+ *
+ * Rules (same parsing as Swarm's own renderers):
+ * - Tags inside fenced code blocks (``` or ~~~) are left untouched.
+ * - The label comes from `label`, `title` or `name`.
+ * - A tag that is never closed becomes a code block running to the end.
+ * - Text without copy tags is returned unchanged.
+ *
+ * Pass `{ streaming: true }` for text that is still arriving: a half-written tag
+ * at the very end is hidden, so converting the growing text only ever appends.
+ *
+ * The SDK applies it by default to assistant text from `chat.run`,
+ * `chat.listMessages` and `chat.stream` (`onText`, `onComplete`); pass
+ * `rawCopyTags: true` there to get the original text. Lower-level reads
+ * (`sessions.get`, `realtime.watchSession`) return the stored text unchanged.
+ */
+export declare function copyTagsToMarkdown(text: string, options?: {
+    streaming?: boolean;
+}): string;
+/** True when `text` contains at least one `<copy>` tag outside fenced code. */
+export declare function hasCopyTags(text: string): boolean;

package/dist/copy-tags.js

@@ -0,0 +1,133 @@
+/**
+ * Swarm agents wrap copyable snippets (commands, config, file payloads) in
+ * `<copy label="...">…</copy>` tags. Swarm's own desktop and terminal UIs render
+ * them as copy buttons; everywhere else they are noise. `copyTagsToMarkdown`
+ * turns each tag into a plain Markdown code block (with its label, if any, as a
+ * bold line above it), so any Markdown renderer shows it correctly.
+ *
+ * Rules (same parsing as Swarm's own renderers):
+ * - Tags inside fenced code blocks (``` or ~~~) are left untouched.
+ * - The label comes from `label`, `title` or `name`.
+ * - A tag that is never closed becomes a code block running to the end.
+ * - Text without copy tags is returned unchanged.
+ *
+ * Pass `{ streaming: true }` for text that is still arriving: a half-written tag
+ * at the very end is hidden, so converting the growing text only ever appends.
+ *
+ * The SDK applies it by default to assistant text from `chat.run`,
+ * `chat.listMessages` and `chat.stream` (`onText`, `onComplete`); pass
+ * `rawCopyTags: true` there to get the original text. Lower-level reads
+ * (`sessions.get`, `realtime.watchSession`) return the stored text unchanged.
+ */
+export function copyTagsToMarkdown(text, options = {}) {
+    if (typeof text !== 'string' || !text)
+        return text;
+    const streaming = options.streaming === true;
+    if (!(streaming ? /</.test(text) : /<copy[\s>]/i.test(text)))
+        return text;
+    const source = text.replace(/\r\n?/g, '\n');
+    const protectedRanges = fencedRanges(source);
+    let out = '';
+    let cursor = 0;
+    while (cursor < source.length) {
+        const open = nextOpenTag(source, cursor, protectedRanges);
+        if (!open) {
+            out += source.slice(cursor);
+            break;
+        }
+        out += source.slice(cursor, open.start);
+        const afterOpen = source.slice(open.end);
+        const closeIndex = afterOpen.toLowerCase().indexOf('</copy>');
+        if (closeIndex < 0) {
+            let body = afterOpen;
+            if (streaming)
+                body = body.replace(PARTIAL_CLOSE_TAIL, '');
+            return out + renderBlock(out, tagLabel(open.tag), body.replace(/^\n+/, ''), false, streaming);
+        }
+        // Streaming keeps trailing newlines it may already have delivered.
+        const body = afterOpen.slice(0, closeIndex).replace(streaming ? /^\n+/ : /^\n+|\n+$/g, '');
+        out += renderBlock(out, tagLabel(open.tag), body, true, streaming);
+        cursor = open.end + closeIndex + '</copy>'.length;
+        if (cursor < source.length && source[cursor] !== '\n')
+            out += '\n';
+    }
+    if (streaming && !inside(out.length - 1, fencedRanges(out)))
+        out = out.replace(PARTIAL_OPEN_TAIL, '');
+    return out;
+}
+/** True when `text` contains at least one `<copy>` tag outside fenced code. */
+export function hasCopyTags(text) {
+    if (typeof text !== 'string' || !/<copy[\s>]/i.test(text))
+        return false;
+    const source = text.replace(/\r\n?/g, '\n');
+    return nextOpenTag(source, 0, fencedRanges(source)) !== undefined;
+}
+const OPEN_TAG = /<copy(?:\s+[^>]*)?>/gi;
+const LABEL_ATTR = /\b(?:label|title|name)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i;
+// Streaming only: a tag cut off at the very end (`<`, `<co`, `<copy label="x`).
+const PARTIAL_OPEN_TAIL = /<(?:c(?:o(?:p(?:y(?:\s[^<>]*)?)?)?)?)?$/i;
+const PARTIAL_CLOSE_TAIL = /<\/?(?:c(?:o(?:p(?:y)?)?)?)?$/i;
+function renderBlock(before, label, body, closed, streaming) {
+    let longest = 0;
+    for (const run of body.match(/`+/g) ?? [])
+        longest = Math.max(longest, run.length);
+    // Streaming uses a 4-backtick fence so a payload that later shows a ``` line does
+    // not force re-fencing text that was already delivered.
+    const fence = '`'.repeat(Math.max(streaming ? 4 : 3, longest + 1));
+    const lead = before === '' || before.endsWith('\n') ? '' : '\n';
+    const title = label ? `**${label}**\n` : '';
+    // An open (still streaming) block gets no trailing newline, so later text only appends.
+    return closed
+        ? `${lead}${title}${fence}\n${body}${body && !body.endsWith('\n') ? '\n' : ''}${fence}`
+        : `${lead}${title}${fence}\n${body}`;
+}
+function tagLabel(tag) {
+    const match = LABEL_ATTR.exec(tag);
+    if (!match)
+        return '';
+    return (match[1] ?? match[2] ?? match[3] ?? '').trim();
+}
+function inside(index, ranges) {
+    return ranges.some((range) => index >= range.start && index < range.end);
+}
+function nextOpenTag(text, from, ranges) {
+    OPEN_TAG.lastIndex = from;
+    for (let match = OPEN_TAG.exec(text); match; match = OPEN_TAG.exec(text)) {
+        const start = match.index;
+        const range = ranges.find((r) => start >= r.start && start < r.end);
+        if (range) {
+            OPEN_TAG.lastIndex = Math.max(range.end, start + match[0].length);
+            continue;
+        }
+        return { start, end: start + match[0].length, tag: match[0] };
+    }
+    return undefined;
+}
+function fencedRanges(text) {
+    const ranges = [];
+    let fence;
+    let lineStart = 0;
+    while (lineStart < text.length) {
+        const newline = text.indexOf('\n', lineStart);
+        const lineEnd = newline < 0 ? text.length : newline;
+        const next = newline < 0 ? text.length : newline + 1;
+        const line = text.slice(lineStart, lineEnd).trim();
+        const marker = line[0];
+        if (marker === '`' || marker === '~') {
+            let count = 0;
+            while (line[count] === marker)
+                count++;
+            const info = line.slice(count).trim();
+            if (!fence && count >= 3)
+                fence = { marker, count, start: lineStart };
+            else if (fence && marker === fence.marker && count >= fence.count && info === '') {
+                ranges.push({ start: fence.start, end: next });
+                fence = undefined;
+            }
+        }
+        lineStart = next;
+    }
+    if (fence)
+        ranges.push({ start: fence.start, end: text.length });
+    return ranges;
+}

package/dist/errors.d.ts

@@ -34,3 +34,19 @@ export declare class SwarmValidationError extends SwarmError {
     readonly details?: unknown;
     constructor(message: string, details?: unknown);
 }
+/**
+ * `chat_reconnecting`: the connection to this conversation is being restored; retry shortly.
+ * `chat_disconnected`: the connection is down and will not come back on its own; call `connect()`.
+ * `chat_not_subscribed`: the conversation is not open in this client; `subscribe()` to it first.
+ */
+export type SwarmChatNotReadyCode = 'chat_reconnecting' | 'chat_disconnected' | 'chat_not_subscribed';
+/**
+ * A browser chat send refused before anything reached Swarm. The message is plain enough
+ * to show people; apps branch on `code` (or `retryable`) instead of matching text.
+ */
+export declare class SwarmChatNotReadyError extends SwarmError {
+    readonly code: SwarmChatNotReadyCode;
+    /** True when retrying the same send shortly is expected to work without app action. */
+    readonly retryable: boolean;
+    constructor(code: SwarmChatNotReadyCode);
+}

package/dist/errors.js

@@ -66,3 +66,24 @@ export class SwarmValidationError extends SwarmError {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
+const chatNotReadyMessages = {
+    chat_reconnecting: 'Not sent: reconnecting to Swarm, try again in a moment',
+    chat_disconnected: 'Not sent: disconnected from Swarm, reconnect and try again',
+    chat_not_subscribed: 'Not sent: this conversation is not open yet, open it and try again',
+};
+/**
+ * A browser chat send refused before anything reached Swarm. The message is plain enough
+ * to show people; apps branch on `code` (or `retryable`) instead of matching text.
+ */
+export class SwarmChatNotReadyError extends SwarmError {
+    code;
+    /** True when retrying the same send shortly is expected to work without app action. */
+    retryable;
+    constructor(code) {
+        super(chatNotReadyMessages[code]);
+        this.name = 'SwarmChatNotReadyError';
+        this.code = code;
+        this.retryable = code === 'chat_reconnecting';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './client.js';
+export * from './local-connection.js';
 export * from './auth.js';
 export * from './automations.js';
 export * from './workers.js';
@@ -6,12 +7,17 @@ export * from './worker-control.js';
 export * from './deliverables.js';
 export * from './deploy/index.js';
 export * from './notifications.js';
+export * from './signals.js';
+export * from './box.js';
 export * from './sessions.js';
 export * from './projects.js';
 export * from './permissions.js';
 export * from './chat.js';
+export * from './copy-tags.js';
 export * from './workspaces.js';
 export * from './system.js';
+export * from './remote.js';
+export * from './agents.js';
 export * from './transport.js';
 export * from './errors.js';
 export * from './types.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './client.js';
+export * from './local-connection.js';
 export * from './auth.js';
 export * from './automations.js';
 export * from './workers.js';
@@ -6,12 +7,17 @@ export * from './worker-control.js';
 export * from './deliverables.js';
 export * from './deploy/index.js';
 export * from './notifications.js';
+export * from './signals.js';
+export * from './box.js';
 export * from './sessions.js';
 export * from './projects.js';
 export * from './permissions.js';
 export * from './chat.js';
+export * from './copy-tags.js';
 export * from './workspaces.js';
 export * from './system.js';
+export * from './remote.js';
+export * from './agents.js';
 export * from './transport.js';
 export * from './errors.js';
 export * from './types.js';

package/dist/local-connection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * How a client with no explicit address finds this machine's Swarm.
+ *
+ * Order: an explicit `socketPath`/`baseUrl`, then `SWARM_SOCKET_PATH`, then
+ * `SWARM_API_URL`/`SWARM_DESKTOP_URL`, then (Node only) the owner socket of a
+ * system install when it exists and this process may connect to it, then the
+ * daemon's default loopback API at http://127.0.0.1:7781.
+ *
+ * Browsers never touch the filesystem: the probe uses Node's synchronous
+ * `process.getBuiltinModule`, which no bundler resolves and no browser has.
+ */
+/** Owner socket of a Linux system install (`/var/lib/swarmd` data root, main lane). */
+export declare const SWARM_OWNER_SOCKET_PATH = "/var/lib/swarmd/local-transport/api.sock";
+/** The daemon's default loopback API address. */
+export declare const SWARM_DEFAULT_API_URL = "http://127.0.0.1:7781";
+export interface SwarmConnectionInput {
+    baseUrl?: string;
+    socketPath?: string;
+}
+export interface SwarmConnectionOptions {
+    /** Environment to read; defaults to `process.env` in Node, `{}` elsewhere. */
+    env?: Record<string, string | undefined>;
+    /** Owner socket to probe; defaults to {@link SWARM_OWNER_SOCKET_PATH}. */
+    ownerSocketPath?: string;
+    /** Returns true when `path` is a socket this process may connect to. */
+    isUsableSocket?: (path: string) => boolean;
+}
+export interface SwarmConnection {
+    baseUrl: string;
+    socketPath?: string;
+}
+/**
+ * True when `path` exists, is a Unix socket and is readable and writable by
+ * this process. Any error (missing, no permission on a parent directory, not
+ * Node) means "not usable"; it never throws.
+ */
+export declare function isUsableSwarmSocket(path: string): boolean;
+/** Resolves where a client with the given explicit settings connects. */
+export declare function resolveSwarmConnection(input?: SwarmConnectionInput, options?: SwarmConnectionOptions): SwarmConnection;

package/dist/local-connection.js

@@ -0,0 +1,56 @@
+/**
+ * How a client with no explicit address finds this machine's Swarm.
+ *
+ * Order: an explicit `socketPath`/`baseUrl`, then `SWARM_SOCKET_PATH`, then
+ * `SWARM_API_URL`/`SWARM_DESKTOP_URL`, then (Node only) the owner socket of a
+ * system install when it exists and this process may connect to it, then the
+ * daemon's default loopback API at http://127.0.0.1:7781.
+ *
+ * Browsers never touch the filesystem: the probe uses Node's synchronous
+ * `process.getBuiltinModule`, which no bundler resolves and no browser has.
+ */
+/** Owner socket of a Linux system install (`/var/lib/swarmd` data root, main lane). */
+export const SWARM_OWNER_SOCKET_PATH = '/var/lib/swarmd/local-transport/api.sock';
+/** The daemon's default loopback API address. */
+export const SWARM_DEFAULT_API_URL = 'http://127.0.0.1:7781';
+function processEnv() {
+    return typeof process !== 'undefined' && process?.env ? process.env : {};
+}
+/**
+ * True when `path` exists, is a Unix socket and is readable and writable by
+ * this process. Any error (missing, no permission on a parent directory, not
+ * Node) means "not usable"; it never throws.
+ */
+export function isUsableSwarmSocket(path) {
+    if (typeof process === 'undefined' || typeof process?.getBuiltinModule !== 'function')
+        return false;
+    try {
+        const fs = process.getBuiltinModule('node:fs');
+        if (!fs?.statSync(path)?.isSocket())
+            return false;
+        fs.accessSync(path, fs.constants.R_OK | fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolves where a client with the given explicit settings connects. */
+export function resolveSwarmConnection(input = {}, options = {}) {
+    const env = options.env ?? processEnv();
+    const explicitUrl = input.baseUrl || env.SWARM_API_URL || env.SWARM_DESKTOP_URL;
+    const baseUrl = (explicitUrl || SWARM_DEFAULT_API_URL).replace(/\/+$/, '');
+    if (input.socketPath)
+        return { baseUrl, socketPath: input.socketPath };
+    if (input.baseUrl)
+        return { baseUrl };
+    if (env.SWARM_SOCKET_PATH)
+        return { baseUrl, socketPath: env.SWARM_SOCKET_PATH };
+    if (explicitUrl)
+        return { baseUrl };
+    const ownerSocket = options.ownerSocketPath ?? SWARM_OWNER_SOCKET_PATH;
+    const usable = options.isUsableSocket ?? isUsableSwarmSocket;
+    if (usable(ownerSocket))
+        return { baseUrl, socketPath: ownerSocket };
+    return { baseUrl };
+}

package/dist/permission-ui.d.ts

@@ -27,6 +27,7 @@ export interface PermissionRequestView {
     arguments: Record<string, unknown> | null;
     rawArguments: string;
     parseError?: string;
+    /** Plain-text heading: the request's own title, else a fallback (bash command, first ask-user question, tool + action). Never HTML. */
     title?: string;
     context?: string;
     structured: boolean;

package/dist/permission-ui.js

@@ -15,6 +15,11 @@ export function isAskUserPermission(permission) {
 }
 /** Parse untrusted request arguments for text rendering. Never render these fields as HTML. */
 export function describePermission(permission) {
+    const view = describePermissionRequest(permission);
+    view.title = view.title || permissionFallbackTitle(view);
+    return view;
+}
+function describePermissionRequest(permission) {
     const id = permissionId(permission?.id);
     const sessionId = permissionId(permission?.session_id, 'sessionId');
     const raw = permission.tool_arguments ?? permission.tool_call_arguments ?? '';
@@ -165,3 +170,35 @@ export function confirmPermissionResolution(result, sessionId, id, action, optio
     }
     return result;
 }
+const TITLE_MAX = 160;
+/** One plain-text line: control characters and runs of whitespace collapse, long text is cut. */
+function titleLine(value) {
+    const line = value.replace(/[\u0000-\u001f\u007f\s]+/g, ' ').trim();
+    return line.length > TITLE_MAX ? `${line.slice(0, TITLE_MAX - 1).trimEnd()}…` : line;
+}
+function humanize(value) {
+    const words = value.trim().split('.').at(-1).replace(/[_-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').trim().toLowerCase();
+    return words ? words[0].toUpperCase() + words.slice(1) : '';
+}
+/**
+ * Plain-text fallback title when the request carries none: bash shows its command,
+ * ask-user its first question, any other tool its humanized name plus action/subject.
+ * Built only from untrusted strings; render it as text, never as HTML.
+ */
+function permissionFallbackTitle(view) {
+    const args = view.arguments ?? {};
+    const tool = text(view.toolName).toLowerCase().split('.').at(-1) ?? '';
+    if ((tool === 'bash' || tool === 'shell') && text(args.command))
+        return titleLine(text(args.command));
+    if (view.kind === 'ask-user') {
+        const first = view.questions[0]?.question
+            || (Array.isArray(args.questions) && object(args.questions[0]) ? text(args.questions[0].question) : '')
+            || text(args.question);
+        if (first)
+            return titleLine(first);
+    }
+    const name = humanize(text(view.toolName)) || 'Tool request';
+    const action = text(args.action) ? humanize(text(args.action)).toLowerCase() : '';
+    const subject = [args.title, args.name, args.path, args.file_path, args.url, args.query].map(text).find(Boolean) ?? '';
+    return titleLine(`${name}${action ? `: ${action}` : ''}${subject ? ` (${subject})` : ''}`);
+}

package/dist/permissions.d.ts

@@ -74,6 +74,10 @@ export declare class SwarmPermissionsNamespace {
      * Retrieves the current account-wide permission policy, including bash profile and persistent rules.
      */
     getPolicy(): Promise<PermissionPolicy>;
+    /**
+     * Whether permissionless mode (bypass permissions) is on.
+     */
+    bypass(): Promise<boolean>;
     /**
      * Toggles permissionless mode (bypass permissions).
      * When enabled, tool executions run autonomously without pausing for manual approvals.

package/dist/permissions.js

@@ -13,6 +13,13 @@ export class SwarmPermissionsNamespace {
         const res = await this.transport.request('/v1/permissions');
         return res.data.policy;
     }
+    /**
+     * Whether permissionless mode (bypass permissions) is on.
+     */
+    async bypass() {
+        const res = await this.transport.request('/v1/permissions');
+        return res.data.bypass_permissions === true;
+    }
     /**
      * Toggles permissionless mode (bypass permissions).
      * When enabled, tool executions run autonomously without pausing for manual approvals.

package/dist/projects.d.ts

@@ -1,5 +1,5 @@
 import type { SwarmTransport } from './transport.js';
-import type { ApproveProjectTaskResult, ClearProjectContextResult, CompleteProjectTaskResult, CreateProjectParams, CreateProjectTaskParams, CreateProjectTaskResult, DeleteProjectMediaResult, DeleteProjectResult, DeleteProjectTaskResult, DeployProjectTaskProgramResult, GetProjectTaskProgramResult, GetProjectTaskResult, IntegrateProjectTaskResult, ListProjectsParams, PreviewProjectTaskParams, ProjectRecord, ProjectTaskApprovalGuards, ProjectTaskMediaRef, ProjectTaskModelPreviewResult, ProjectTaskPreviewResult, ProjectTaskRecord, RedeployProjectTaskJobResult, RefineProjectTaskParams, RefineProjectTaskResult, RejectProjectTaskResult, ReopenProjectTaskResult, RequestOptions, SessionRecord, SyncStreamParams, SyncStreamResult, SynthesizeProjectContextParams, UpdateProjectParams, UpdateProjectTaskParams } from './types.js';
+import type { ApproveProjectTaskResult, ClearProjectContextResult, CompleteProjectTaskResult, CreateProjectParams, CreateProjectTaskParams, CreateProjectTaskResult, DeleteProjectMediaResult, DeleteProjectResult, DeleteProjectTaskResult, DeployProjectTaskProgramResult, GetProjectTaskProgramResult, GetProjectTaskResult, IntegrateProjectTaskOptions, IntegrateProjectTaskResult, IntegrateProjectTaskSelection, ListProjectsParams, PreviewProjectTaskParams, ProjectRecord, ProjectTaskApprovalGuards, ProjectTaskMediaRef, ProjectTaskModelPreviewResult, ProjectTaskPreviewResult, ProjectTaskRecord, RedeployProjectTaskJobResult, RefineProjectTaskParams, RefineProjectTaskResult, RejectProjectTaskResult, ReopenProjectTaskResult, RequestOptions, SessionRecord, SyncStreamParams, SyncStreamResult, UpdateProjectParams, UpdateProjectTaskParams } from './types.js';
 export declare class SwarmProjectsNamespace {
     private readonly transport;
     constructor(transport: SwarmTransport);
@@ -38,9 +38,18 @@ export declare class SwarmProjectsNamespace {
     listConversations(projectId: string, params?: {
         limit?: number;
     }, reqOptions?: RequestOptions): Promise<SessionRecord[]>;
+    /** Rename a project conversation (a conversation ID is its session ID); see sessions.rename. */
+    renameConversation(conversationId: string, title: string, options?: {
+        clientRequestId?: string;
+    }): Promise<{
+        ok: boolean;
+        session_id: string;
+        title: string;
+    }>;
     /** Create an independent project conversation without archiving existing conversations.
      * Models/context resolve on the daemon. Project conversations never bind a workspace.
-     * Reuse clientRequestId when retrying an uncertain creation result.
+     * Reuse clientRequestId when retrying an uncertain creation result. Without a title the
+     * conversation is named from its first message; rename it with renameConversation.
      */
     createConversation(projectId: string, options?: {
         title?: string;
@@ -56,10 +65,6 @@ export declare class SwarmProjectsNamespace {
      * Deletes a project by ID.
      */
     delete(projectId: string, options?: RequestOptions): Promise<DeleteProjectResult>;
-    /**
-     * Synthesizes Markdown project context from project name and linked workspaces.
-     */
-    synthesizeContext(params: SynthesizeProjectContextParams, options?: RequestOptions): Promise<string>;
     /**
      * Clears orchestrator context for a project, archiving old session and provisioning replacement.
      */
@@ -136,8 +141,14 @@ export declare class SwarmProjectsNamespace {
     refineTask(projectId: string, taskId: string, params: RefineProjectTaskParams, options?: RequestOptions): Promise<RefineProjectTaskResult>;
     /**
      * Integrates task commits into the parent workspace repository.
+     *
+     * The daemon only integrates an exact selection: the task's current session and its
+     * captured source/target branches. With no options the SDK fetches the task
+     * (`getTask`, which runs a fresh delivery assessment) and builds that selection from
+     * it; pass `options.selection` to override individual fields. A stale selection is
+     * refused by the daemon with a conflict error rather than integrating the wrong lane.
      */
-    integrateTask(projectId: string, taskId: string, options?: RequestOptions): Promise<IntegrateProjectTaskResult>;
+    integrateTask(projectId: string, taskId: string, options?: IntegrateProjectTaskOptions): Promise<IntegrateProjectTaskResult>;
     /**
      * Deploys a task program for staged multi-agent execution.
      */
@@ -180,3 +191,10 @@ export declare class SwarmProjectsNamespace {
         timeoutMs?: number;
     }): AsyncIterableIterator<TEvent>;
 }
+/**
+ * Builds the integrate selection the daemon checks from a fresh task record.
+ * Branch precedence: the detail GET's delivery assessment (the daemon's own view of
+ * the captured lane), then the task's recorded worktree/base branch, then the active
+ * attempt's. The daemon still verifies every field against the owned session.
+ */
+export declare function integrationSelectionFromTask(task: ProjectTaskRecord): Partial<IntegrateProjectTaskSelection>;