@love-moon/conductor-sdk 0.7.6 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @love-moon/conductor-sdk
 
+## 0.8.0
+
+### Minor Changes
+
+- 959dd1d: Add project-configured worker and reviewer task groups, task-group discovery in
+  the SDK and `conductor task group`, and a lightweight daemon protocol for
+  refreshing the project agent registry.
+- fe76139: Add `conductor task create` for creating app tasks with title, prompt, backend,
+  project resolution, and optional parent task-card grouping. App tasks now
+  require an online compatible daemon, and grouping results are exposed to
+  callers so partial success is visible without retrying task creation.
+
+## 0.7.7
+
+### Patch Changes
+
+- 400f3a7: Report a terminal task status when a stop request finds no active process, so a
+  task whose Fire already died converges instead of sitting in `killing` forever.
+
+  Drop queued terminal status events before an in-place restart reuses a working
+  directory. The durable upstream outbox lives inside that directory, so an
+  undelivered `KILLED` from the previous run was flushed on startup and killed the
+  task that had just finished resuming.
+
 ## 0.7.6
 
 ### Patch Changes

package/dist/api/index.d.ts

@@ -1,4 +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, type ScheduledMessage, type ScheduledMessageSchedule, type CreateScheduledMessageInput, } from './tasks.js';
+export { TasksApi, type Task, type TaskGroupingResult, type TaskGroup, type TaskGroupMember, type Message, type ListTasksInput, type CreateTaskInput, type SendTaskMessageOptions, type ListTaskMessagesOptions, type ScheduledMessage, type ScheduledMessageSchedule, type CreateScheduledMessageInput, } from './tasks.js';
 export { ProjectNotResolvedError, buildAuditMetadata, isBackendApiError, type ApiClient, type SdkClientOptions, } from './shared.js';

package/dist/api/shared.d.ts

@@ -1,5 +1,5 @@
 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' | 'postTaskInsert' | 'listScheduledMessages' | 'createScheduledMessage' | 'deleteScheduledMessage'>;
+export type ApiClient = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'getProject' | 'updateProject' | 'patchProjectByQuery' | 'setDefaultProject' | 'matchProjectByPath' | 'listIssues' | 'getIssue' | 'createIssue' | 'patchIssue' | 'deleteIssue' | 'listTasks' | 'createTask' | 'createAppTask' | 'getTask' | 'getTaskGroup' | 'listTaskMessages' | 'postTaskMessage' | 'postTaskInsert' | 'listScheduledMessages' | 'createScheduledMessage' | 'deleteScheduledMessage'>;
 export interface SdkClientOptions {
     /**
      * Optional override for the SDK version stamped onto audit metadata. Falls

package/dist/api/tasks.d.ts

@@ -10,8 +10,14 @@ export interface Task {
     sessionFilePath?: string | null;
     createdAt?: string | null;
     updatedAt?: string | null;
+    grouping?: TaskGroupingResult | null;
     raw: Record<string, unknown>;
 }
+export interface TaskGroupingResult {
+    parentTaskId: string;
+    grouped: boolean;
+    warning?: string | null;
+}
 export interface Message {
     id: string;
     taskId?: string | null;
@@ -21,6 +27,21 @@ export interface Message {
     createdAt?: string | null;
     raw: Record<string, unknown>;
 }
+/** RFC 0033 — one member of a multi-agent task group. */
+export interface TaskGroupMember {
+    taskId: string;
+    role: string | null;
+    agent: string | null;
+    title: string | null;
+    status: string | null;
+    backendType: string | null;
+    isSelf: boolean;
+}
+/** RFC 0033 — the group a task belongs to (groupId null when standalone). */
+export interface TaskGroup {
+    groupId: string | null;
+    members: TaskGroupMember[];
+}
 export type ScheduledMessageSchedule = {
     mode: 'delay';
     amount: number;
@@ -71,6 +92,14 @@ export interface ListTasksInput {
     issueId?: string;
     status?: string | string[];
 }
+export interface CreateTaskInput {
+    projectId: string;
+    title: string;
+    backendType?: string;
+    initialContent?: string;
+    parentTaskId?: string;
+    metadata?: Record<string, unknown>;
+}
 export interface SendTaskMessageOptions {
     role?: string;
     metadata?: Record<string, unknown>;
@@ -99,6 +128,14 @@ export declare class TasksApi {
     constructor(client: ApiClient, options?: SdkClientOptions);
     listTasks(input?: ListTasksInput): Promise<Task[]>;
     getTask(taskId: string): Promise<Task>;
+    createTask(input: CreateTaskInput): Promise<Task>;
+    /**
+     * RFC 0033 — resolve the multi-agent group a task belongs to. Returns the
+     * group id (null if the task is standalone) and every sibling task with its
+     * role/agent. Agents use this to discover the task(s) they read from / send
+     * feedback to.
+     */
+    getTaskGroup(taskId: string): Promise<TaskGroup>;
     sendTaskMessage(taskId: string, content: string, options?: SendTaskMessageOptions): Promise<Message>;
     /**
      * Insert a mid-turn message into a running task. The message is delivered and

package/dist/api/tasks.js

@@ -4,6 +4,21 @@ const normalizeTask = (payload) => {
     if (!id) {
         throw new Error('Task payload missing id');
     }
+    const groupingPayload = payload.grouping && typeof payload.grouping === 'object' && !Array.isArray(payload.grouping)
+        ? payload.grouping
+        : null;
+    const groupingParentTaskId = groupingPayload
+        ? groupingPayload.parentTaskId ?? groupingPayload.parent_task_id
+        : null;
+    const grouping = groupingParentTaskId && typeof groupingPayload?.grouped === 'boolean'
+        ? {
+            parentTaskId: String(groupingParentTaskId),
+            grouped: groupingPayload.grouped,
+            warning: typeof groupingPayload.warning === 'string'
+                ? groupingPayload.warning
+                : null,
+        }
+        : null;
     return {
         id,
         projectId: payload.projectId !== undefined
@@ -23,9 +38,27 @@ const normalizeTask = (payload) => {
         sessionFilePath: payload.sessionFilePath ?? payload.session_file_path ?? null,
         createdAt: payload.createdAt ?? payload.created_at ?? null,
         updatedAt: payload.updatedAt ?? payload.updated_at ?? null,
+        grouping,
         raw: payload,
     };
 };
+const asStringOrNull = (value) => typeof value === 'string' && value.trim() ? value.trim() : null;
+const normalizeTaskGroup = (payload) => {
+    const rawMembers = Array.isArray(payload?.members) ? payload.members : [];
+    const members = rawMembers.map((m) => ({
+        taskId: String(m?.task_id ?? m?.taskId ?? ''),
+        role: asStringOrNull(m?.role),
+        agent: asStringOrNull(m?.agent),
+        title: asStringOrNull(m?.title),
+        status: asStringOrNull(m?.status),
+        backendType: asStringOrNull(m?.backend_type ?? m?.backendType),
+        isSelf: Boolean(m?.is_self ?? m?.isSelf),
+    }));
+    return {
+        groupId: asStringOrNull(payload?.group_id ?? payload?.groupId),
+        members,
+    };
+};
 const normalizeMessage = (payload) => {
     const id = payload.id ? String(payload.id) : payload.message_id ? String(payload.message_id) : '';
     if (!id) {
@@ -129,6 +162,49 @@ export class TasksApi {
             ? summary.asObject()
             : summary);
     }
+    async createTask(input) {
+        const projectId = String(input?.projectId ?? '').trim();
+        const title = String(input?.title ?? '').trim();
+        if (!projectId) {
+            throw new Error('projectId is required');
+        }
+        if (!title) {
+            throw new Error('title is required');
+        }
+        const params = {
+            projectId,
+            title,
+            taskType: 'ai_task',
+            metadata: buildAuditMetadata(input.metadata, this.options),
+        };
+        if (input.backendType !== undefined) {
+            params.backendType = input.backendType;
+        }
+        if (input.initialContent !== undefined) {
+            params.initialContent = input.initialContent;
+        }
+        if (input.parentTaskId !== undefined) {
+            params.parentTaskId = input.parentTaskId;
+        }
+        const payload = await this.client.createAppTask(params);
+        return normalizeTask(typeof payload.asObject === 'function'
+            ? payload.asObject()
+            : payload);
+    }
+    /**
+     * RFC 0033 — resolve the multi-agent group a task belongs to. Returns the
+     * group id (null if the task is standalone) and every sibling task with its
+     * role/agent. Agents use this to discover the task(s) they read from / send
+     * feedback to.
+     */
+    async getTaskGroup(taskId) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        const payload = await this.client.getTaskGroup(trimmed);
+        return normalizeTaskGroup(payload);
+    }
     async sendTaskMessage(taskId, content, options = {}) {
         const trimmed = String(taskId ?? '').trim();
         if (!trimmed) {

package/dist/backend/client.d.ts

@@ -4,6 +4,20 @@ export interface BackendClientOptions {
     fetchImpl?: FetchFn;
     timeoutMs?: number;
 }
+export interface BackendCreateTaskParams {
+    id?: string;
+    projectId: string;
+    title: string;
+    taskType?: string;
+    status?: string;
+    backendType?: string;
+    sessionId?: string | null;
+    sessionFilePath?: string | null;
+    initialContent?: string;
+    agentHost?: string;
+    parentTaskId?: string;
+    metadata?: Record<string, unknown>;
+}
 export type AgentCommitEvent = {
     eventType: 'sdk_message';
     taskId: string;
@@ -48,6 +62,11 @@ export declare class ProjectSummary {
     static fromJSON(payload: Record<string, any>): ProjectSummary;
     asObject(): Record<string, unknown>;
 }
+export interface TaskGroupingSummary {
+    parentTaskId: string;
+    grouped: boolean;
+    warning?: string | null;
+}
 export declare class TaskSummary {
     readonly id: string;
     readonly projectId: string | null;
@@ -58,7 +77,8 @@ export declare class TaskSummary {
     readonly sessionFilePath?: string | null | undefined;
     readonly createdAt?: string | null | undefined;
     readonly updatedAt?: string | null | undefined;
-    constructor(id: string, projectId: string | null, title: string, status: string, backendType?: string | null | undefined, sessionId?: string | null | undefined, sessionFilePath?: string | null | undefined, createdAt?: string | null | undefined, updatedAt?: string | null | undefined);
+    readonly grouping?: (TaskGroupingSummary | null) | undefined;
+    constructor(id: string, projectId: string | null, title: string, status: string, backendType?: string | null | undefined, sessionId?: string | null | undefined, sessionFilePath?: string | null | undefined, createdAt?: string | null | undefined, updatedAt?: string | null | undefined, grouping?: (TaskGroupingSummary | null) | undefined);
     static fromJSON(payload: Record<string, any>): TaskSummary;
 }
 export declare class BackendApiClient {
@@ -85,19 +105,19 @@ export declare class BackendApiClient {
         projectId?: string;
         status?: string;
     }): Promise<TaskSummary[]>;
-    createTask(params: {
-        id?: string;
-        projectId: string;
-        title: string;
-        status?: string;
-        backendType?: string;
-        sessionId?: string | null;
-        sessionFilePath?: string | null;
-        initialContent?: string;
-        agentHost?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<TaskSummary>;
+    createTask(params: BackendCreateTaskParams): Promise<TaskSummary>;
+    /**
+     * Create an app-managed task through the frontend pipeline. This route
+     * assigns daemon ownership and delivers initialContent; it is intentionally
+     * separate from the legacy agent/fire POST /tasks endpoint.
+     */
+    createAppTask(params: BackendCreateTaskParams): Promise<TaskSummary>;
     getTask(taskId: string): Promise<TaskSummary>;
+    /**
+     * GET /tasks/[taskId]/group — RFC 0033 task-group discovery. Returns the raw
+     * payload `{ group_id, members }`; the higher layer normalizes it.
+     */
+    getTaskGroup(taskId: string): Promise<Record<string, any>>;
     updateTask(taskId: string, params: {
         projectId?: string;
         title?: string;

package/dist/backend/client.js

@@ -62,7 +62,8 @@ export class TaskSummary {
     sessionFilePath;
     createdAt;
     updatedAt;
-    constructor(id, projectId, title, status, backendType, sessionId, sessionFilePath, createdAt, updatedAt) {
+    grouping;
+    constructor(id, projectId, title, status, backendType, sessionId, sessionFilePath, createdAt, updatedAt, grouping) {
         this.id = id;
         this.projectId = projectId;
         this.title = title;
@@ -72,6 +73,7 @@ export class TaskSummary {
         this.sessionFilePath = sessionFilePath;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
+        this.grouping = grouping;
     }
     static fromJSON(payload) {
         const id = payload.id ? String(payload.id) : '';
@@ -83,7 +85,22 @@ export class TaskSummary {
         if (!title || !status) {
             throw new Error('Task payload missing required fields');
         }
-        return new TaskSummary(id, payload.project_id ? String(payload.project_id) : null, title, status, payload.backend_type ?? payload.backendType ?? null, payload.session_id ?? payload.sessionId ?? null, payload.session_file_path ?? payload.sessionFilePath ?? null, payload.created_at ?? null, payload.updated_at ?? null);
+        const groupingPayload = payload.grouping && typeof payload.grouping === 'object' && !Array.isArray(payload.grouping)
+            ? payload.grouping
+            : null;
+        const groupingParentTaskId = groupingPayload
+            ? groupingPayload.parent_task_id ?? groupingPayload.parentTaskId
+            : null;
+        const grouping = groupingParentTaskId && typeof groupingPayload?.grouped === 'boolean'
+            ? {
+                parentTaskId: String(groupingParentTaskId),
+                grouped: groupingPayload.grouped,
+                warning: typeof groupingPayload.warning === 'string'
+                    ? groupingPayload.warning
+                    : null,
+            }
+            : null;
+        return new TaskSummary(id, payload.project_id ? String(payload.project_id) : null, title, status, payload.backend_type ?? payload.backendType ?? null, payload.session_id ?? payload.sessionId ?? null, payload.session_file_path ?? payload.sessionFilePath ?? null, payload.created_at ?? null, payload.updated_at ?? null, grouping);
     }
 }
 export class BackendApiClient {
@@ -160,11 +177,35 @@ export class BackendApiClient {
         const payload = await this.parseJson(response);
         return TaskSummary.fromJSON(payload);
     }
+    /**
+     * Create an app-managed task through the frontend pipeline. This route
+     * assigns daemon ownership and delivers initialContent; it is intentionally
+     * separate from the legacy agent/fire POST /tasks endpoint.
+     */
+    async createAppTask(params) {
+        const response = await this.request('POST', '/api/tasks', {
+            body: JSON.stringify(params),
+        });
+        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);
     }
+    /**
+     * GET /tasks/[taskId]/group — RFC 0033 task-group discovery. Returns the raw
+     * payload `{ group_id, members }`; the higher layer normalizes it.
+     */
+    async getTaskGroup(taskId) {
+        const response = await this.request('GET', `/tasks/${taskId}/group`);
+        const payload = await this.parseJson(response);
+        if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+            return payload;
+        }
+        throw new BackendApiError('Invalid task group response', response.status, payload);
+    }
     async updateTask(taskId, params) {
         const response = await this.request('PATCH', `/tasks/${taskId}`, {
             body: JSON.stringify(params),

package/dist/outbox/store.d.ts

@@ -21,6 +21,30 @@ export declare class DurableUpstreamOutboxStore {
         payload: Record<string, unknown>;
     }): DurableUpstreamEvent;
     remove(stableId: string): void;
+    /**
+     * Discard queued terminal `task_status_update` events (KILLED / COMPLETED).
+     *
+     * This outbox lives INSIDE the fire's working directory, and an in-place
+     * restart deliberately re-uses that same directory (the daemon sets
+     * `CONDUCTOR_RESUME_CWD` so `--resume` finds the original project). That
+     * means a terminal status the PREVIOUS run failed to deliver — e.g. its
+     * websocket dropped while it was being stopped — is still sitting on disk
+     * when the NEXT run starts, and the startup flush delivers it against the
+     * task that was just brought back to life. The server marks the task
+     * `killed`, then answers the newly-attached fire with
+     * `stop_task(task_already_killed)` and shoots it down seconds after it
+     * finished resuming.
+     *
+     * A terminal status from a superseded run is definitionally obsolete: the
+     * task has since been restarted, so "that run ended" is no longer news the
+     * server can act on correctly. Drop those and keep everything else —
+     * `sdk_message` entries are real conversation content that must still be
+     * delivered, and `task_stop_ack` / `agent_command_ack` are idempotent
+     * bookkeeping whose delivery actually clears stale server-side outbox rows.
+     *
+     * Returns the dropped entries so callers can log exactly what was discarded.
+     */
+    dropPendingTerminalStatusEvents(): DurableUpstreamEvent[];
     markRetry(stableId: string, delayMs: number): DurableUpstreamEvent | null;
     listReady(nowMs?: number): DurableUpstreamEvent[];
     nextRetryDelay(nowMs?: number): number | null;

package/dist/outbox/store.js

@@ -19,6 +19,16 @@ const sleepSync = (ms) => {
         }
     }
 };
+// Terminal statuses as published by `conductor daemon` (see cli/src/daemon.js,
+// which sends the upper-case wire form). Compared case-insensitively so a
+// future lower-case producer does not silently bypass the check.
+const TERMINAL_TASK_STATUSES = new Set(['killed', 'completed']);
+const isTerminalStatusEvent = (entry) => {
+    if (entry.eventType !== 'task_status_update')
+        return false;
+    const status = entry.payload?.status;
+    return typeof status === 'string' && TERMINAL_TASK_STATUSES.has(status.trim().toLowerCase());
+};
 const sanitizeScopeId = (scopeId) => scopeId
     .trim()
     .replace(/[^a-zA-Z0-9._-]+/g, '_')
@@ -66,6 +76,40 @@ export class DurableUpstreamOutboxStore {
             this.saveUnlocked(entries);
         });
     }
+    /**
+     * Discard queued terminal `task_status_update` events (KILLED / COMPLETED).
+     *
+     * This outbox lives INSIDE the fire's working directory, and an in-place
+     * restart deliberately re-uses that same directory (the daemon sets
+     * `CONDUCTOR_RESUME_CWD` so `--resume` finds the original project). That
+     * means a terminal status the PREVIOUS run failed to deliver — e.g. its
+     * websocket dropped while it was being stopped — is still sitting on disk
+     * when the NEXT run starts, and the startup flush delivers it against the
+     * task that was just brought back to life. The server marks the task
+     * `killed`, then answers the newly-attached fire with
+     * `stop_task(task_already_killed)` and shoots it down seconds after it
+     * finished resuming.
+     *
+     * A terminal status from a superseded run is definitionally obsolete: the
+     * task has since been restarted, so "that run ended" is no longer news the
+     * server can act on correctly. Drop those and keep everything else —
+     * `sdk_message` entries are real conversation content that must still be
+     * delivered, and `task_stop_ack` / `agent_command_ack` are idempotent
+     * bookkeeping whose delivery actually clears stale server-side outbox rows.
+     *
+     * Returns the dropped entries so callers can log exactly what was discarded.
+     */
+    dropPendingTerminalStatusEvents() {
+        return this.withLock(() => {
+            const entries = this.loadUnlocked();
+            const dropped = entries.filter(isTerminalStatusEvent);
+            if (dropped.length === 0) {
+                return [];
+            }
+            this.saveUnlocked(entries.filter((entry) => !isTerminalStatusEvent(entry)));
+            return dropped;
+        });
+    }
     markRetry(stableId, delayMs) {
         return this.withLock(() => {
             const entries = this.loadUnlocked();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -33,5 +33,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "c939df2"
+  "gitCommitId": "04d4f62"
 }