@love-moon/conductor-sdk 0.2.42 → 0.3.1

package/dist/api/shared.js

@@ -0,0 +1,78 @@
+import { createRequire } from 'node:module';
+import { BackendApiError } from '../backend/index.js';
+// Loaded eagerly so we don't pay a require() on every audit metadata stamp.
+// Falls back to a stable string when the package.json isn't reachable (eg.
+// bundled scenarios). The version is only ever embedded into outbound
+// metadata, so a fallback is fine.
+let cachedSdkVersion = null;
+const readSdkVersion = () => {
+    if (cachedSdkVersion !== null) {
+        return cachedSdkVersion;
+    }
+    try {
+        const localRequire = createRequire(import.meta.url);
+        const pkg = localRequire('../../package.json');
+        cachedSdkVersion =
+            pkg && typeof pkg.version === 'string' ? pkg.version : 'unknown';
+    }
+    catch {
+        cachedSdkVersion = 'unknown';
+    }
+    return cachedSdkVersion;
+};
+/**
+ * Build the metadata payload every SDK write attaches to the request.
+ *
+ * Audit fields are namespaced under `metadata.audit` (RFC 0025 §5.2 + review
+ * findings M3/H1). This avoids two failure modes the original top-level shape
+ * had:
+ *   1. A caller passing `--metadata-json '{"actor":"system"}'` could spoof the
+ *      audit actor by colliding with our top-level key.
+ *   2. Server-side strippers had to know the full audit-key list to filter.
+ *
+ * Merge order:
+ *   - Non-audit user keys are passed through verbatim.
+ *   - Audit defaults (`actor:"sdk"`, `sdkVersion`, `invokedBy`) are layered
+ *     UNDER the caller's `audit` (so the CLI's `actor:"cli"` wins).
+ *   - The caller's top-level `audit` key, if any, takes precedence over the
+ *     SDK defaults but never replaces all of them — `cliVersion`, etc., are
+ *     additive.
+ */
+export const buildAuditMetadata = (userMetadata, options = {}) => {
+    const env = options.env ?? process.env;
+    const invokedByRaw = env.CONDUCTOR_INVOKED_BY;
+    const invokedBy = typeof invokedByRaw === 'string' && invokedByRaw.trim()
+        ? invokedByRaw.trim()
+        : null;
+    const sdkAudit = {
+        actor: 'sdk',
+        sdkVersion: options.sdkVersion ?? readSdkVersion(),
+        invokedBy,
+    };
+    const safeUserMetadata = userMetadata && typeof userMetadata === 'object' && !Array.isArray(userMetadata)
+        ? { ...userMetadata }
+        : {};
+    const callerAuditRaw = safeUserMetadata.audit;
+    delete safeUserMetadata.audit;
+    const callerAudit = callerAuditRaw && typeof callerAuditRaw === 'object' && !Array.isArray(callerAuditRaw)
+        ? callerAuditRaw
+        : {};
+    // Caller-supplied audit fields win over SDK defaults so a CLI invocation
+    // tagging `actor:"cli"` ends up authoritative.
+    const audit = { ...sdkAudit, ...callerAudit };
+    return { ...safeUserMetadata, audit };
+};
+export class ProjectNotResolvedError extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = 'ProjectNotResolvedError';
+    }
+}
+/**
+ * Best-effort mapping for HTTP-shaped failures so the CLI exit-code matrix
+ * (RFC 0025 §4) has a stable signal. Callers can choose to inspect
+ * `BackendApiError.statusCode` directly instead.
+ */
+export const isBackendApiError = (value) => value instanceof BackendApiError;

package/dist/api/tasks.d.ts

@@ -0,0 +1,46 @@
+import { ApiClient, SdkClientOptions } from './shared.js';
+export interface Task {
+    id: string;
+    projectId: string | null;
+    issueId?: string | null;
+    title: string;
+    status: string;
+    backendType?: string | null;
+    sessionId?: string | null;
+    sessionFilePath?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    raw: Record<string, unknown>;
+}
+export interface Message {
+    id: string;
+    taskId?: string | null;
+    role: string;
+    content: string;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | null;
+    raw: Record<string, unknown>;
+}
+export interface ListTasksInput {
+    projectId?: string;
+    issueId?: string;
+    status?: string | string[];
+}
+export interface SendTaskMessageOptions {
+    role?: string;
+    metadata?: Record<string, unknown>;
+    clientRequestId?: string;
+}
+export interface ListTaskMessagesOptions {
+    limit?: number;
+    before?: string;
+}
+export declare class TasksApi {
+    private readonly client;
+    private readonly options;
+    constructor(client: ApiClient, options?: SdkClientOptions);
+    listTasks(input?: ListTasksInput): Promise<Task[]>;
+    getTask(taskId: string): Promise<Task>;
+    sendTaskMessage(taskId: string, content: string, options?: SendTaskMessageOptions): Promise<Message>;
+    listTaskMessages(taskId: string, options?: ListTaskMessagesOptions): Promise<Message[]>;
+}

package/dist/api/tasks.js

@@ -0,0 +1,118 @@
+import { buildAuditMetadata } from './shared.js';
+const normalizeTask = (payload) => {
+    const id = payload.id ? String(payload.id) : '';
+    if (!id) {
+        throw new Error('Task payload missing id');
+    }
+    return {
+        id,
+        projectId: payload.projectId !== undefined
+            ? payload.projectId === null
+                ? null
+                : String(payload.projectId)
+            : payload.project_id !== undefined
+                ? payload.project_id === null
+                    ? null
+                    : String(payload.project_id)
+                : null,
+        issueId: payload.issueId ?? payload.issue_id ?? null,
+        title: String(payload.title ?? ''),
+        status: String(payload.status ?? ''),
+        backendType: payload.backendType ?? payload.backend_type ?? null,
+        sessionId: payload.sessionId ?? payload.session_id ?? null,
+        sessionFilePath: payload.sessionFilePath ?? payload.session_file_path ?? null,
+        createdAt: payload.createdAt ?? payload.created_at ?? null,
+        updatedAt: payload.updatedAt ?? payload.updated_at ?? null,
+        raw: payload,
+    };
+};
+const normalizeMessage = (payload) => {
+    const id = payload.id ? String(payload.id) : payload.message_id ? String(payload.message_id) : '';
+    if (!id) {
+        throw new Error('Message payload missing id');
+    }
+    return {
+        id,
+        taskId: payload.taskId ?? payload.task_id ?? null,
+        role: String(payload.role ?? ''),
+        content: typeof payload.content === 'string' ? payload.content : '',
+        metadata: payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+            ? payload.metadata
+            : null,
+        createdAt: payload.createdAt ?? payload.created_at ?? null,
+        raw: payload,
+    };
+};
+export class TasksApi {
+    client;
+    options;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    async listTasks(input = {}) {
+        // The server `/api/tasks` only filters on `project_id`; status / issue
+        // filtering happens client-side here so we can support both string and
+        // array `status` shapes from the facade input.
+        const tasks = await this.client.listTasks({
+            projectId: input.projectId,
+        });
+        let normalized = tasks.map((entry) => normalizeTask(typeof entry.asObject === 'function' ? entry.asObject() : entry));
+        if (input.issueId) {
+            normalized = normalized.filter((task) => task.issueId === input.issueId);
+        }
+        const statusFilter = Array.isArray(input.status)
+            ? input.status.map((value) => String(value).trim()).filter(Boolean)
+            : input.status
+                ? [String(input.status).trim()].filter(Boolean)
+                : [];
+        if (statusFilter.length > 0) {
+            const statusSet = new Set(statusFilter);
+            normalized = normalized.filter((task) => statusSet.has(task.status));
+        }
+        return normalized;
+    }
+    async getTask(taskId) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        const summary = await this.client.getTask(trimmed);
+        return normalizeTask(typeof summary.asObject === 'function'
+            ? summary.asObject()
+            : summary);
+    }
+    async sendTaskMessage(taskId, content, options = {}) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        if (typeof content !== 'string' || content.length === 0) {
+            throw new Error('content is required');
+        }
+        const userMetadata = options.clientRequestId
+            ? { clientRequestId: options.clientRequestId, ...(options.metadata ?? {}) }
+            : options.metadata;
+        const metadata = buildAuditMetadata(userMetadata, this.options);
+        const body = {
+            content,
+            metadata,
+        };
+        if (options.role) {
+            body.role = options.role;
+        }
+        const payload = await this.client.postTaskMessage(trimmed, body);
+        return normalizeMessage(payload);
+    }
+    async listTaskMessages(taskId, options = {}) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        const messages = await this.client.listTaskMessages(trimmed, {
+            limit: options.limit,
+            before: options.before,
+        });
+        return messages.map((entry) => normalizeMessage(entry));
+    }
+}

package/dist/backend/client.d.ts

@@ -95,6 +95,7 @@ export declare class BackendApiClient {
         agentHost?: string;
         metadata?: Record<string, unknown>;
     }): Promise<TaskSummary>;
+    getTask(taskId: string): Promise<TaskSummary>;
     updateTask(taskId: string, params: {
         projectId?: string;
         title?: string;
@@ -176,6 +177,41 @@ export declare class BackendApiClient {
         lastCommit?: string;
         fileCount?: number;
     }): Promise<ProjectSummary>;
+    /**
+     * PATCH /projects?projectId=... — used for fields the per-id PATCH endpoint
+     * doesn't accept (today: `hidden`). The two PATCH endpoints intentionally
+     * have different surfaces; see web/src/app/api/projects/route.ts vs
+     * web/src/app/api/projects/[projectId]/route.ts.
+     */
+    patchProjectByQuery(projectId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
+    /**
+     * POST /projects/default — switches the user's default project to
+     * `projectId`. Returns the serialized Project (with `is_default: true`).
+     * Extra body fields (e.g., `metadata`) are merged into the request so the
+     * facade can pass audit info through.
+     */
+    setDefaultProject(projectId: string, extraBody?: Record<string, unknown>): Promise<Record<string, any>>;
+    listIssues(params?: {
+        projectId?: string;
+        projectIds?: string[];
+        status?: string;
+    }): Promise<Record<string, any>[]>;
+    getIssue(issueId: string): Promise<Record<string, any>>;
+    createIssue(params: Record<string, unknown>): Promise<Record<string, any>>;
+    patchIssue(issueId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
+    deleteIssue(issueId: string): Promise<void>;
+    listTaskMessages(taskId: string, params?: {
+        limit?: number;
+        before?: string;
+    }): Promise<Record<string, any>[]>;
+    /**
+     * POST /tasks/[taskId]/messages — direct REST call. Note: `BackendApiClient`
+     * has a higher-level `commitSdkMessage` that goes through the agent-events
+     * pipeline (durable outbox + WS scope), but the CLI/AI Agent flow is a
+     * one-shot HTTP write with no agent host context, so we use the REST
+     * endpoint directly here. (RFC 0025 §2 picks the simpler path.)
+     */
+    postTaskMessage(taskId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
     private request;
     private buildUrl;
     private sendRequest;

package/dist/backend/client.js

@@ -157,6 +157,11 @@ export class BackendApiClient {
         const payload = await this.parseJson(response);
         return TaskSummary.fromJSON(payload);
     }
+    async getTask(taskId) {
+        const response = await this.request('GET', `/tasks/${taskId}`);
+        const payload = await this.parseJson(response);
+        return TaskSummary.fromJSON(payload);
+    }
     async updateTask(taskId, params) {
         const response = await this.request('PATCH', `/tasks/${taskId}`, {
             body: JSON.stringify(params),
@@ -305,6 +310,102 @@ export class BackendApiClient {
         const payload = await this.parseJson(response);
         return ProjectSummary.fromJSON(payload);
     }
+    /**
+     * PATCH /projects?projectId=... — used for fields the per-id PATCH endpoint
+     * doesn't accept (today: `hidden`). The two PATCH endpoints intentionally
+     * have different surfaces; see web/src/app/api/projects/route.ts vs
+     * web/src/app/api/projects/[projectId]/route.ts.
+     */
+    async patchProjectByQuery(projectId, params) {
+        const query = new URLSearchParams();
+        query.set('projectId', projectId);
+        const response = await this.request('PATCH', '/projects', {
+            query,
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    /**
+     * POST /projects/default — switches the user's default project to
+     * `projectId`. Returns the serialized Project (with `is_default: true`).
+     * Extra body fields (e.g., `metadata`) are merged into the request so the
+     * facade can pass audit info through.
+     */
+    async setDefaultProject(projectId, extraBody = {}) {
+        const response = await this.request('POST', '/projects/default', {
+            body: JSON.stringify({ projectId, ...extraBody }),
+        });
+        return this.parseJson(response);
+    }
+    async listIssues(params = {}) {
+        const query = new URLSearchParams();
+        if (params.projectId) {
+            query.set('project_id', params.projectId);
+        }
+        if (params.projectIds && params.projectIds.length > 0) {
+            query.set('project_ids', params.projectIds.join(','));
+        }
+        if (params.status) {
+            query.set('status', params.status);
+        }
+        const response = await this.request('GET', '/issues', { query });
+        const payload = await this.parseJson(response);
+        if (!Array.isArray(payload)) {
+            throw new BackendApiError('Invalid issues response: expected list', response.status, payload);
+        }
+        return payload;
+    }
+    async getIssue(issueId) {
+        const response = await this.request('GET', `/issues/${issueId}`);
+        return this.parseJson(response);
+    }
+    async createIssue(params) {
+        const response = await this.request('POST', '/issues', {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    async patchIssue(issueId, params) {
+        const response = await this.request('PATCH', `/issues/${issueId}`, {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    async deleteIssue(issueId) {
+        await this.request('DELETE', `/issues/${issueId}`);
+    }
+    async listTaskMessages(taskId, params = {}) {
+        const query = new URLSearchParams();
+        query.set('pagination', '1');
+        if (typeof params.limit === 'number' && Number.isFinite(params.limit)) {
+            query.set('limit', String(params.limit));
+        }
+        if (params.before) {
+            query.set('before_id', params.before);
+        }
+        const response = await this.request('GET', `/tasks/${taskId}/messages`, { query });
+        const payload = await this.parseJson(response);
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        if (payload && typeof payload === 'object' && Array.isArray(payload.messages)) {
+            return payload.messages;
+        }
+        throw new BackendApiError('Invalid messages response', response.status, payload);
+    }
+    /**
+     * POST /tasks/[taskId]/messages — direct REST call. Note: `BackendApiClient`
+     * has a higher-level `commitSdkMessage` that goes through the agent-events
+     * pipeline (durable outbox + WS scope), but the CLI/AI Agent flow is a
+     * one-shot HTTP write with no agent host context, so we use the REST
+     * endpoint directly here. (RFC 0025 §2 picks the simpler path.)
+     */
+    async postTaskMessage(taskId, params) {
+        const response = await this.request('POST', `/tasks/${taskId}/messages`, {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
     async request(method, pathname, opts = {}) {
         const url = this.buildUrl(pathname, opts.query);
         const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;

package/dist/client.d.ts

@@ -4,7 +4,7 @@ import { MessageRouter } from './message/index.js';
 import { DownstreamCursorStore, DurableUpstreamOutboxStore } from './outbox/index.js';
 import { SessionDiskStore, SessionManager } from './session/index.js';
 import { ConductorWebSocketClient, WebSocketConnectedEvent, WebSocketDisconnectEvent, WebSocketPongEvent } from './ws/index.js';
-type BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'createTask' | 'updateTask' | 'commitSdkMessage' | 'commitTaskStatusUpdate' | 'commitAgentCommandAck' | 'commitTaskStopAck' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
+type BackendApiLike = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'listTasks' | 'getTask' | 'createTask' | 'updateTask' | 'commitSdkMessage' | 'commitTaskStatusUpdate' | 'commitAgentCommandAck' | 'commitTaskStopAck' | 'matchProjectByPath' | 'getProject' | 'updateProject'>;
 type RealtimeClientLike = Pick<ConductorWebSocketClient, 'registerHandler' | 'connect' | 'disconnect' | 'sendJson'> & Partial<Pick<ConductorWebSocketClient, 'forceReconnect'>>;
 export interface ConductorClientConnectOptions {
     config?: ConductorConfig;
@@ -126,6 +126,7 @@ export declare class ConductorClient {
     createProject(name: string, metadata?: Record<string, unknown>): Promise<Record<string, any>>;
     createProject(payload: Record<string, any>): Promise<Record<string, any>>;
     listTasks(payload?: Record<string, any>): Promise<Record<string, any>>;
+    getTask(taskId: string): Promise<Record<string, any>>;
     getLocalProjectRecord(payload?: Record<string, any>): Promise<Record<string, any>>;
     getLocalTaskRecord(payload?: Record<string, any>): Promise<Record<string, any>>;
     bindTaskSession(taskId: string, payload?: Record<string, any>): Promise<Record<string, any>>;

package/dist/client.js

@@ -376,6 +376,24 @@ export class ConductorClient {
             })),
         };
     }
+    async getTask(taskId) {
+        const normalizedTaskId = String(taskId || '').trim();
+        if (!normalizedTaskId) {
+            throw new Error('task_id is required');
+        }
+        const task = await this.backendApi.getTask(normalizedTaskId);
+        return {
+            id: task.id,
+            project_id: task.projectId,
+            title: task.title,
+            status: task.status,
+            backend_type: task.backendType ?? null,
+            session_id: task.sessionId ?? null,
+            session_file_path: task.sessionFilePath ?? null,
+            created_at: task.createdAt ?? null,
+            updated_at: task.updatedAt ?? null,
+        };
+    }
     async getLocalProjectRecord(payload = {}) {
         const projectPath = typeof payload.project_path === 'string' && payload.project_path
             ? payload.project_path

package/dist/context/project_context.d.ts

@@ -7,6 +7,13 @@ export interface WorkspaceSnapshot {
     repoRoot?: string;
     worktreeBranch?: string;
     lastCommit?: string;
+    /**
+     * Normalized origin remote URL (lower-cased, trailing `.git` stripped).
+     * Only populated when the workspace is a git repository AND has an
+     * `origin` remote configured. Used by the web UI to merge same-name
+     * projects across daemons that point to the same upstream repo.
+     */
+    gitRemoteUrl?: string;
     fileCount?: number;
 }
 export declare class ProjectContext {
@@ -20,6 +27,25 @@ export declare class ProjectContext {
     private gitRoot;
     private gitBranch;
     private gitHead;
+    private gitRemoteUrl;
     private gitFileCount;
     private gitListFiles;
 }
+/**
+ * Normalize a git remote URL so that variations of the same upstream
+ * compare equal. Examples:
+ *   git@github.com:foo/bar.git              -> github.com/foo/bar
+ *   https://github.com/foo/bar/             -> github.com/foo/bar
+ *   ssh://git@github.com/foo/bar            -> github.com/foo/bar
+ *   https://gitea.local:3000/foo/bar.git    -> gitea.local:3000/foo/bar
+ *   https://user:pass@gitlab.com/foo/bar    -> gitlab.com/foo/bar
+ *
+ * Two normalization paths:
+ *  1. URL form (anything with `://`): parsed via WHATWG URL so host, port,
+ *     and path are preserved correctly while user-info is dropped.
+ *  2. scp form (`user@host:path`): handled with a small regex; the colon
+ *     after host becomes a `/` so it lines up with the URL form. IPv6 hosts
+ *     should use the `ssh://` URL form; git's scp-like syntax does not
+ *     reliably represent bracketed IPv6 hosts.
+ */
+export declare function normalizeGitRemoteUrl(raw: string | null | undefined): string | null;

package/dist/context/project_context.js

@@ -26,6 +26,7 @@ export class ProjectContext {
             repoRoot: guess.repoRoot,
             worktreeBranch: this.gitBranch(guess.repoRoot) ?? undefined,
             lastCommit: this.gitHead(guess.repoRoot) ?? undefined,
+            gitRemoteUrl: this.gitRemoteUrl(guess.repoRoot) ?? undefined,
             fileCount: this.gitFileCount(guess.repoRoot) ?? undefined,
         };
     }
@@ -91,6 +92,15 @@ export class ProjectContext {
             return null;
         }
     }
+    gitRemoteUrl(repoRoot) {
+        try {
+            const url = runGit(['config', '--get', 'remote.origin.url'], repoRoot).trim();
+            return normalizeGitRemoteUrl(url);
+        }
+        catch {
+            return null;
+        }
+    }
     gitFileCount(repoRoot) {
         try {
             return this.gitListFiles(repoRoot).length;
@@ -122,6 +132,60 @@ function runGit(args, cwd) {
     }
     return result.stdout;
 }
+/**
+ * Normalize a git remote URL so that variations of the same upstream
+ * compare equal. Examples:
+ *   git@github.com:foo/bar.git              -> github.com/foo/bar
+ *   https://github.com/foo/bar/             -> github.com/foo/bar
+ *   ssh://git@github.com/foo/bar            -> github.com/foo/bar
+ *   https://gitea.local:3000/foo/bar.git    -> gitea.local:3000/foo/bar
+ *   https://user:pass@gitlab.com/foo/bar    -> gitlab.com/foo/bar
+ *
+ * Two normalization paths:
+ *  1. URL form (anything with `://`): parsed via WHATWG URL so host, port,
+ *     and path are preserved correctly while user-info is dropped.
+ *  2. scp form (`user@host:path`): handled with a small regex; the colon
+ *     after host becomes a `/` so it lines up with the URL form. IPv6 hosts
+ *     should use the `ssh://` URL form; git's scp-like syntax does not
+ *     reliably represent bracketed IPv6 hosts.
+ */
+export function normalizeGitRemoteUrl(raw) {
+    if (!raw)
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    // URL form: ssh://, https://, http://, git://, ftp://, file://, etc.
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+        let parsed;
+        try {
+            parsed = new URL(trimmed);
+        }
+        catch {
+            return null;
+        }
+        // `host` keeps the explicit port when present (e.g. `gitea.local:3000`).
+        // `pathname` preserves the leading slash so `${host}${pathname}` reads
+        // naturally; we drop trailing `/` and trailing `.git` afterwards.
+        const path = parsed.pathname.replace(/\/+$/, '');
+        const combined = `${parsed.host}${path}`.replace(/\.git$/i, '');
+        return combined.toLowerCase() || null;
+    }
+    // scp form: `[user@]host:path`. The host segment must not contain `/`
+    // (otherwise the first `/` would have shown up before the `:` and we'd
+    // be looking at a relative-path URL, which git doesn't support as a
+    // remote URL anyway).
+    const scpMatch = trimmed.match(/^(?:[^@/:]+@)?([^/:]+):(?!\/)(.*)$/);
+    if (scpMatch) {
+        const host = scpMatch[1];
+        const path = scpMatch[2].replace(/\/+$/, '').replace(/\.git$/i, '');
+        return `${host}/${path}`.toLowerCase() || null;
+    }
+    // Anything else (e.g. plain path) — give up so we don't fabricate a
+    // misleading "normalized" form that could accidentally collide with a
+    // real upstream URL.
+    return null;
+}
 function* walkFiles(root) {
     const entries = fs.readdirSync(root, { withFileTypes: true });
     for (const entry of entries) {

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export * from './client.js';
 export * from './context/index.js';
 export * from './limits/index.js';
 export * from './outbox/index.js';
+export * from './api/index.js';

package/dist/index.js

@@ -7,3 +7,4 @@ export * from './client.js';
 export * from './context/index.js';
 export * from './limits/index.js';
 export * from './outbox/index.js';
+export * from './api/index.js';

package/dist/ws/client.js

@@ -87,13 +87,27 @@ export class ConductorWebSocketClient {
         await this.terminateConnection(conn);
     }
     async sendJson(payload) {
+        // Once disconnect() has flipped `stop`, sending is a no-op. Callers
+        // commonly queue sends via fire-and-forget helpers (`.catch(() => {})`),
+        // but late rejections that slip through were being promoted to
+        // unhandledRejection / uncaughtException and crashed the daemon during
+        // restart. Treat a send-after-disconnect as a silent no-op instead.
+        if (this.stop) {
+            return;
+        }
         await this.ensureConnection();
+        if (this.stop) {
+            return;
+        }
         await this.sendWithReconnect(JSON.stringify(payload));
     }
     async ensureConnection() {
         if (this.conn && !this.isConnectionClosed(this.conn)) {
             return;
         }
+        if (this.stop) {
+            return;
+        }
         await this.openConnection(true);
     }
     async openConnection(force = false) {
@@ -261,10 +275,19 @@ export class ConductorWebSocketClient {
         let attemptedReconnect = false;
         // Loop at most twice: initial send, then one reconnect + retry
         while (true) {
+            if (this.stop) {
+                // `disconnect()` has been called; swallow the send to avoid raising
+                // "WebSocket not connected" from an already-silenced client. Any
+                // send queued before disconnect() finishes is best-effort.
+                return;
+            }
             const conn = this.conn;
             if (!conn || this.isConnectionClosed(conn)) {
                 await this.openConnection(true);
             }
+            if (this.stop) {
+                return;
+            }
             if (!this.conn || this.isConnectionClosed(this.conn)) {
                 throw new Error('WebSocket not connected');
             }

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.42",
+  "version": "0.3.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovemoon-ai/conductor.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -27,5 +33,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "f79f36f"
+  "gitCommitId": "03b4582"
 }