@love-moon/conductor-sdk 0.2.42 → 0.3.0

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+export { ProjectsApi, type Project, type CreateProjectInput, type ListProjectsOptions, type ResolveProjectInput, } from './projects.js';
+export { IssuesApi, type Issue, type ListIssuesInput, type CreateIssueInput, type UpdateIssueInput, type UpdateIssueStatusOptions, } from './issues.js';
+export { TasksApi, type Task, type Message, type ListTasksInput, type SendTaskMessageOptions, type ListTaskMessagesOptions, } from './tasks.js';
+export { ProjectNotResolvedError, buildAuditMetadata, isBackendApiError, type ApiClient, type SdkClientOptions, } from './shared.js';

package/dist/api/index.js

@@ -0,0 +1,4 @@
+export { ProjectsApi, } from './projects.js';
+export { IssuesApi, } from './issues.js';
+export { TasksApi, } from './tasks.js';
+export { ProjectNotResolvedError, buildAuditMetadata, isBackendApiError, } from './shared.js';

package/dist/api/issues.d.ts

@@ -0,0 +1,57 @@
+import { ApiClient, SdkClientOptions } from './shared.js';
+export interface Issue {
+    id: string;
+    projectId: string;
+    title: string;
+    description?: string | null;
+    status: string;
+    priority?: string | null;
+    position?: number | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    /** Unmodified server payload, used by callers that need fields we haven't typed. */
+    raw: Record<string, unknown>;
+}
+export interface ListIssuesInput {
+    projectId: string;
+    status?: string | string[];
+    limit?: number;
+}
+export interface CreateIssueInput {
+    projectId: string;
+    title: string;
+    description?: string;
+    priority?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    clientRequestId?: string;
+}
+export interface UpdateIssueInput {
+    title?: string;
+    description?: string;
+    priority?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateIssueStatusOptions {
+    evidence?: string;
+    /**
+     * Extra metadata merged into the patch; caller's `audit.*` fields win over
+     * SDK defaults (see shared.ts). Useful for the CLI to thread its
+     * `audit: { actor: "cli", ... }` namespace through without needing a custom
+     * call path.
+     */
+    metadata?: Record<string, unknown>;
+}
+export declare class IssuesApi {
+    private readonly client;
+    private readonly options;
+    constructor(client: ApiClient, options?: SdkClientOptions);
+    listIssues(input: ListIssuesInput): Promise<Issue[]>;
+    getIssue(issueId: string): Promise<Issue>;
+    createIssue(input: CreateIssueInput): Promise<Issue>;
+    updateIssue(issueId: string, patch: UpdateIssueInput): Promise<Issue>;
+    updateIssueStatus(issueId: string, status: string, options?: UpdateIssueStatusOptions): Promise<Issue>;
+    deleteIssue(issueId: string): Promise<void>;
+}

package/dist/api/issues.js

@@ -0,0 +1,177 @@
+import { buildAuditMetadata } from './shared.js';
+const normalizeIssue = (payload) => {
+    const id = payload.id ? String(payload.id) : '';
+    if (!id) {
+        throw new Error('Issue payload missing id');
+    }
+    return {
+        id,
+        projectId: String(payload.projectId ?? payload.project_id ?? ''),
+        title: String(payload.title ?? ''),
+        description: payload.description ?? null,
+        status: String(payload.status ?? ''),
+        priority: payload.priority ?? null,
+        position: typeof payload.position === 'number' ? payload.position : null,
+        metadata: payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+            ? payload.metadata
+            : null,
+        createdAt: payload.createdAt ?? payload.created_at ?? null,
+        updatedAt: payload.updatedAt ?? payload.updated_at ?? null,
+        raw: payload,
+    };
+};
+const extractIssue = (payload) => {
+    // The PATCH /issues/[issueId] route returns `{ issue, activeTask, ... }`.
+    // Other routes return the issue itself. Normalize both shapes here so
+    // facade callers always get the issue back regardless of source endpoint.
+    if (payload && typeof payload === 'object' && payload.issue && typeof payload.issue === 'object') {
+        return payload.issue;
+    }
+    return payload;
+};
+const mergeMetadataAtPath = (target, pathParts, value) => {
+    if (pathParts.length === 0) {
+        return target;
+    }
+    const [head, ...rest] = pathParts;
+    const next = { ...target };
+    if (rest.length === 0) {
+        next[head] = value;
+        return next;
+    }
+    const existing = target[head];
+    const child = existing && typeof existing === 'object' && !Array.isArray(existing)
+        ? existing
+        : {};
+    next[head] = mergeMetadataAtPath(child, rest, value);
+    return next;
+};
+export class IssuesApi {
+    client;
+    options;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    async listIssues(input) {
+        if (!input.projectId) {
+            throw new Error('projectId is required');
+        }
+        // The server `/api/issues` route accepts a single `status` query string;
+        // it doesn't (yet) parse comma-separated lists, so we filter on the
+        // client side for the multi-status case to match RFC 0025 §3 wording.
+        const statusFilter = Array.isArray(input.status)
+            ? input.status.map((value) => String(value).trim()).filter(Boolean)
+            : input.status
+                ? [String(input.status).trim()].filter(Boolean)
+                : [];
+        const issues = await this.client.listIssues({
+            projectId: input.projectId,
+            status: statusFilter.length === 1 ? statusFilter[0] : undefined,
+        });
+        let normalized = issues.map((entry) => normalizeIssue(entry));
+        if (statusFilter.length > 1) {
+            const statusSet = new Set(statusFilter);
+            normalized = normalized.filter((issue) => statusSet.has(issue.status));
+        }
+        if (typeof input.limit === 'number' && Number.isFinite(input.limit)) {
+            normalized = normalized.slice(0, Math.max(0, Math.floor(input.limit)));
+        }
+        return normalized;
+    }
+    async getIssue(issueId) {
+        const trimmed = String(issueId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('issueId is required');
+        }
+        const payload = await this.client.getIssue(trimmed);
+        return normalizeIssue(extractIssue(payload));
+    }
+    async createIssue(input) {
+        if (!input.projectId) {
+            throw new Error('projectId is required');
+        }
+        if (!input.title) {
+            throw new Error('title is required');
+        }
+        const userMetadata = input.clientRequestId
+            ? { clientRequestId: input.clientRequestId, ...(input.metadata ?? {}) }
+            : input.metadata;
+        const metadata = buildAuditMetadata(userMetadata, this.options);
+        const params = {
+            projectId: input.projectId,
+            title: input.title,
+            metadata,
+        };
+        if (input.description !== undefined) {
+            params.description = input.description;
+        }
+        if (input.priority !== undefined) {
+            params.priority = input.priority;
+        }
+        if (input.status !== undefined) {
+            params.status = input.status;
+        }
+        const payload = await this.client.createIssue(params);
+        return normalizeIssue(extractIssue(payload));
+    }
+    async updateIssue(issueId, patch) {
+        const trimmed = String(issueId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('issueId is required');
+        }
+        const params = {};
+        if (patch.title !== undefined) {
+            params.title = patch.title;
+        }
+        if (patch.description !== undefined) {
+            params.description = patch.description;
+        }
+        if (patch.priority !== undefined) {
+            params.priority = patch.priority;
+        }
+        if (patch.status !== undefined) {
+            params.status = patch.status;
+        }
+        // We always include audit metadata on writes. If the caller passes a
+        // `metadata` patch, we merge our audit keys with theirs (caller wins).
+        params.metadata = buildAuditMetadata(patch.metadata, this.options);
+        const payload = await this.client.patchIssue(trimmed, params);
+        return normalizeIssue(extractIssue(payload));
+    }
+    async updateIssueStatus(issueId, status, options = {}) {
+        const callerMetadata = options.metadata && typeof options.metadata === 'object' && !Array.isArray(options.metadata)
+            ? { ...options.metadata }
+            : null;
+        if (!options.evidence) {
+            return this.updateIssue(issueId, {
+                status,
+                ...(callerMetadata ? { metadata: callerMetadata } : {}),
+            });
+        }
+        // Pull the existing metadata so we can merge `qa.evidence` without
+        // clobbering unrelated keys. The PATCH body fully replaces metadata, so
+        // we have to round-trip the current state (matches RFC 0025 §3 wording
+        // for `done --evidence`).
+        const existing = await this.getIssue(issueId);
+        const existingMetadata = existing.metadata && typeof existing.metadata === 'object'
+            ? existing.metadata
+            : {};
+        // Merge order: existing DB metadata < caller's patch metadata < qa.evidence.
+        // The `audit` key under `callerMetadata` is preserved when present so the
+        // CLI's `actor:"cli"` namespace flows through to `updateIssue` (and from
+        // there to `buildAuditMetadata`, where caller wins).
+        const baseMetadata = callerMetadata
+            ? { ...existingMetadata, ...callerMetadata }
+            : { ...existingMetadata };
+        const merged = mergeMetadataAtPath(baseMetadata, ['qa', 'evidence'], options.evidence);
+        return this.updateIssue(issueId, { status, metadata: merged });
+    }
+    async deleteIssue(issueId) {
+        const trimmed = String(issueId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('issueId is required');
+        }
+        await this.client.deleteIssue(trimmed);
+    }
+}

package/dist/api/projects.d.ts

@@ -0,0 +1,71 @@
+import { ApiClient, SdkClientOptions } from './shared.js';
+/**
+ * Project record as returned by the REST API. We deliberately don't subclass
+ * `ProjectSummary` here because the REST surface returns more fields (notably
+ * `hidden`, `isDefault`, `metadata`) than the WS-flavored summary, and we
+ * want CLI / AI consumers to see the full picture.
+ */
+export interface Project {
+    id: string;
+    name?: string | null;
+    daemonHost?: string | null;
+    workspacePath?: string | null;
+    repoRoot?: string | null;
+    worktreeBranch?: string | null;
+    lastCommit?: string | null;
+    fileCount?: number | null;
+    isDefault: boolean;
+    hidden: boolean;
+    hiddenAt?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    /**
+     * The unmodified server payload, kept for callers that need fields the
+     * typed surface hasn't promoted yet (e.g. `gitRemoteUrl`, `mergeOptOut`).
+     */
+    raw: Record<string, unknown>;
+}
+export interface ResolveProjectInput {
+    id?: string;
+    name?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Daemon host to use when resolving by `cwd`. Required for the path-match
+     * fallback (the server keys workspace bindings on `(daemonHost, path)`).
+     * Defaults to `env.CONDUCTOR_DAEMON_NAME` if unset.
+     */
+    daemonHost?: string;
+}
+export interface CreateProjectInput {
+    name?: string;
+    workspacePath?: string;
+    daemonHost?: string;
+    isDefault?: boolean;
+    clientRequestId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ListProjectsOptions {
+    includeHidden?: boolean;
+}
+export interface ProjectWriteOptions {
+    /**
+     * Extra metadata merged into the request (caller-supplied audit fields
+     * under `metadata.audit` win over the SDK defaults, see shared.ts).
+     */
+    metadata?: Record<string, unknown>;
+}
+export declare class ProjectsApi {
+    private readonly client;
+    private readonly options;
+    constructor(client: ApiClient, options?: SdkClientOptions);
+    listProjects(options?: ListProjectsOptions): Promise<Project[]>;
+    getProject(idOrName: string): Promise<Project>;
+    createProject(input: CreateProjectInput): Promise<Project>;
+    setDefaultProject(idOrName: string, options?: ProjectWriteOptions): Promise<Project>;
+    setProjectHidden(idOrName: string, hidden: boolean, options?: ProjectWriteOptions): Promise<Project>;
+    resolveProject(input?: ResolveProjectInput): Promise<Project>;
+    private findUniqueByName;
+    private resolveById;
+}

package/dist/api/projects.js

@@ -0,0 +1,247 @@
+import { BackendApiError } from '../backend/index.js';
+import { ProjectNotResolvedError, buildAuditMetadata, } from './shared.js';
+const stripTrailingSlash = (value) => value.replace(/\/+$/, '');
+/**
+ * Heuristic for "this string looks like a project id, not a name".
+ *
+ * The server uses cuid-like ids (e.g. `clxk1y0fz0000abc123`) and UUIDs. Names
+ * are arbitrary strings, but in practice users name their projects with
+ * spaces, slashes, accents, etc. — i.e. they almost never match the
+ * `^[a-zA-Z0-9_-]{12,}$` shape we treat as an id below. This lets the SDK
+ * skip a redundant `getProject(id)` round-trip when the caller (CLI) has
+ * already resolved to an id (review L-NEW-1). On a miss we fall back to the
+ * full resolve, so the only downside of a false positive is one extra
+ * 404 → re-list round trip.
+ */
+const looksLikeProjectId = (value) => {
+    if (!value || typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    if (trimmed.length < 12)
+        return false;
+    return /^[A-Za-z0-9_-]+$/.test(trimmed);
+};
+/**
+ * Local longest-prefix match used by `resolveProject` step 4 when no daemon
+ * host is available to delegate to the server-side matcher. We treat each
+ * project's `workspacePath` as a prefix and pick the longest one that's a
+ * proper directory ancestor of `cwd`. Mirrors the server's
+ * match-path/route.ts logic for the simple single-daemon case.
+ */
+const matchProjectByLocalPrefix = (projects, cwd) => {
+    const target = stripTrailingSlash(cwd.trim());
+    if (!target)
+        return null;
+    let best = null;
+    for (const project of projects) {
+        const path = project.workspacePath;
+        if (typeof path !== 'string' || !path.trim())
+            continue;
+        const normalized = stripTrailingSlash(path.trim());
+        if (target === normalized || target.startsWith(`${normalized}/`)) {
+            if (!best || normalized.length > best.length) {
+                best = { project, length: normalized.length };
+            }
+        }
+    }
+    return best?.project ?? null;
+};
+const normalizeProject = (payload) => {
+    const id = payload.id ? String(payload.id) : '';
+    if (!id) {
+        throw new Error('Project payload missing id');
+    }
+    const hiddenAt = payload.hiddenAt ?? payload.hidden_at ?? null;
+    return {
+        id,
+        name: payload.name ?? null,
+        daemonHost: payload.daemonHost ?? payload.daemon_host ?? null,
+        workspacePath: payload.workspacePath ?? payload.workspace_path ?? null,
+        repoRoot: payload.repoRoot ?? payload.repo_root ?? null,
+        worktreeBranch: payload.worktreeBranch ?? payload.worktree_branch ?? null,
+        lastCommit: payload.lastCommit ?? payload.last_commit ?? null,
+        fileCount: payload.fileCount ?? payload.file_count ?? null,
+        isDefault: Boolean(payload.isDefault ?? payload.is_default ?? false),
+        hidden: Boolean(payload.hidden ?? Boolean(hiddenAt)),
+        hiddenAt: hiddenAt ?? null,
+        metadata: payload.metadata && typeof payload.metadata === 'object' && !Array.isArray(payload.metadata)
+            ? payload.metadata
+            : null,
+        createdAt: payload.createdAt ?? payload.created_at ?? null,
+        updatedAt: payload.updatedAt ?? payload.updated_at ?? null,
+        raw: payload,
+    };
+};
+export class ProjectsApi {
+    client;
+    options;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    async listProjects(options = {}) {
+        const summaries = await this.client.listProjects();
+        // `BackendApiClient.listProjects` already pulls /projects, but it loses
+        // the `hidden` and `isDefault` fields when collapsing to ProjectSummary.
+        // Promote each summary's `asObject()` payload back to a Project so we
+        // surface those fields. Hidden projects are filtered out here unless
+        // `includeHidden: true` is passed (RFC 0025 §3).
+        const promoted = summaries.map((summary) => normalizeProject(
+        // ProjectSummary `asObject()` always exists in the backend module.
+        summary.asObject ? summary.asObject() : summary));
+        if (options.includeHidden) {
+            return promoted;
+        }
+        return promoted.filter((project) => !project.hidden);
+    }
+    async getProject(idOrName) {
+        const trimmed = String(idOrName ?? '').trim();
+        if (!trimmed) {
+            throw new Error('idOrName is required');
+        }
+        // First try by id; if 404, fall back to a unique name match against the
+        // project list. Splitting these two paths keeps the happy-path single
+        // round-trip and only pulls the full list on miss.
+        try {
+            const payload = await this.client.getProject(trimmed);
+            return normalizeProject(payload);
+        }
+        catch (error) {
+            if (!(error instanceof BackendApiError) || error.statusCode !== 404) {
+                throw error;
+            }
+        }
+        return this.findUniqueByName(trimmed);
+    }
+    async createProject(input) {
+        const metadata = buildAuditMetadata(
+        // `clientRequestId` is stamped onto metadata per RFC 0025 §5 idempotency
+        // spec; the server treats it as the idempotency key.
+        input.clientRequestId
+            ? { clientRequestId: input.clientRequestId, ...(input.metadata ?? {}) }
+            : input.metadata, this.options);
+        const params = {};
+        if (input.name) {
+            params.name = input.name;
+        }
+        if (input.isDefault) {
+            params.isDefault = true;
+            params.is_default = true;
+        }
+        else {
+            // Non-default projects need a binding. The server validates with the
+            // daemon synchronously when `daemonHost + workspacePath` are present,
+            // which is the path AI / CLI will use most of the time.
+            if (input.workspacePath) {
+                params.workspacePath = input.workspacePath;
+            }
+            if (input.daemonHost) {
+                params.daemonHost = input.daemonHost;
+            }
+        }
+        params.metadata = metadata;
+        const summary = await this.client.createProject(params);
+        return normalizeProject(summary.asObject ? summary.asObject() : summary);
+    }
+    async setDefaultProject(idOrName, options = {}) {
+        // Short-circuit the pre-flight `getProject` when the caller already has
+        // a project id (review L-NEW-1). On a miss the server returns 404 and
+        // the caller can retry via `getProject(idOrName)` themselves, but the
+        // common CLI path passes the id directly.
+        const targetId = looksLikeProjectId(idOrName) ? idOrName.trim() : (await this.resolveById(idOrName)).id;
+        const metadata = buildAuditMetadata(options.metadata, this.options);
+        const payload = await this.client.setDefaultProject(targetId, { metadata });
+        return normalizeProject(payload);
+    }
+    async setProjectHidden(idOrName, hidden, options = {}) {
+        const targetId = looksLikeProjectId(idOrName) ? idOrName.trim() : (await this.resolveById(idOrName)).id;
+        const metadata = buildAuditMetadata(options.metadata, this.options);
+        const payload = await this.client.patchProjectByQuery(targetId, { hidden, metadata });
+        return normalizeProject(payload);
+    }
+    async resolveProject(input = {}) {
+        const env = input.env ?? this.options.env ?? process.env;
+        // 1. explicit id wins
+        if (input.id && input.id.trim()) {
+            try {
+                const payload = await this.client.getProject(input.id.trim());
+                return normalizeProject(payload);
+            }
+            catch (error) {
+                if (error instanceof BackendApiError && error.statusCode === 404) {
+                    throw new ProjectNotResolvedError(`Project not found: id=${input.id}`, 'not_found');
+                }
+                throw error;
+            }
+        }
+        // 2. explicit name
+        if (input.name && input.name.trim()) {
+            return this.findUniqueByName(input.name.trim());
+        }
+        // 3. env override
+        const envId = env.CONDUCTOR_PROJECT_ID;
+        if (typeof envId === 'string' && envId.trim()) {
+            try {
+                const payload = await this.client.getProject(envId.trim());
+                return normalizeProject(payload);
+            }
+            catch (error) {
+                if (error instanceof BackendApiError && error.statusCode === 404) {
+                    throw new ProjectNotResolvedError(`Project not found from CONDUCTOR_PROJECT_ID=${envId}`, 'not_found');
+                }
+                throw error;
+            }
+        }
+        // 4. cwd path match. We try two routes:
+        //    a. If a daemon host is known, delegate to the server-side matcher
+        //       (it understands binding-pending / repoRoot / multi-daemon rules).
+        //    b. Otherwise, do a local longest-prefix match against the project
+        //       list. This keeps the CLI usable when the user hasn't set
+        //       CONDUCTOR_DAEMON_NAME — review finding M1: never silently skip
+        //       cwd resolution just because a daemon hint is missing.
+        const projects = await this.listProjects({ includeHidden: true });
+        if (input.cwd && input.cwd.trim()) {
+            const daemonHost = input.daemonHost ?? env.CONDUCTOR_DAEMON_NAME ?? env.CONDUCTOR_AGENT_NAME;
+            if (daemonHost && daemonHost.trim()) {
+                const result = await this.client.matchProjectByPath({
+                    daemon_host: daemonHost.trim(),
+                    path: input.cwd,
+                });
+                if (result.project) {
+                    return normalizeProject(result.project.asObject());
+                }
+            }
+            else {
+                const localMatch = matchProjectByLocalPrefix(projects, input.cwd);
+                if (localMatch) {
+                    return localMatch;
+                }
+            }
+        }
+        // 5. default project — derived from the list we already fetched in (4).
+        //    Every healthy account has at most one default; we return it when
+        //    found.
+        const defaults = projects.filter((project) => project.isDefault);
+        if (defaults.length === 1) {
+            return defaults[0];
+        }
+        if (defaults.length > 1) {
+            throw new ProjectNotResolvedError('Multiple default projects exist; specify --project explicitly', 'multiple_matches');
+        }
+        throw new ProjectNotResolvedError('No project specified and no default project found. Pass --project <id|name>, set CONDUCTOR_PROJECT_ID, cd into a project directory, or configure a default project.', 'no_signal');
+    }
+    async findUniqueByName(name) {
+        const projects = await this.listProjects({ includeHidden: true });
+        const matches = projects.filter((project) => project.name === name);
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length === 0) {
+            throw new ProjectNotResolvedError(`No project found with name "${name}"`, 'not_found');
+        }
+        throw new ProjectNotResolvedError(`Multiple projects found with name "${name}" (${matches.length}); pass --project <id> to disambiguate`, 'multiple_matches');
+    }
+    async resolveById(idOrName) {
+        return this.getProject(idOrName);
+    }
+}

package/dist/api/shared.d.ts

@@ -0,0 +1,45 @@
+import { BackendApiClient, BackendApiError } from '../backend/index.js';
+export type ApiClient = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'getProject' | 'updateProject' | 'patchProjectByQuery' | 'setDefaultProject' | 'matchProjectByPath' | 'listIssues' | 'getIssue' | 'createIssue' | 'patchIssue' | 'deleteIssue' | 'listTasks' | 'getTask' | 'listTaskMessages' | 'postTaskMessage'>;
+export interface SdkClientOptions {
+    /**
+     * Optional override for the SDK version stamped onto audit metadata. Falls
+     * back to the package.json version. Tests may want to pin this so output is
+     * stable.
+     */
+    sdkVersion?: string;
+    /**
+     * Optional environment provider for `CONDUCTOR_INVOKED_BY` lookup. Defaults
+     * to `process.env`. Useful for tests that want to inject env without
+     * mutating globals.
+     */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * 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 declare const buildAuditMetadata: (userMetadata: Record<string, unknown> | undefined, options?: SdkClientOptions) => Record<string, unknown>;
+export declare class ProjectNotResolvedError extends Error {
+    readonly reason: 'not_found' | 'multiple_matches' | 'no_default' | 'no_signal';
+    constructor(message: string, reason: 'not_found' | 'multiple_matches' | 'no_default' | 'no_signal');
+}
+/**
+ * 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 declare const isBackendApiError: (value: unknown) => value is BackendApiError;

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,6 +1,10 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.2.42",
+  "version": "0.3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovemoon-ai/conductor.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +12,8 @@
     "dist"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -27,5 +32,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "f79f36f"
+  "gitCommitId": "b9f33cd"
 }