@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/core/TaskDurableStatusMutationService.d.ts

@@ -0,0 +1,74 @@
+import type { TaskItem } from './Taskforce.js';
+export declare const DURABLE_TASK_TARGET_STATUSES: readonly ["task", "on-hold", "in-progress", "review", "done", "cancelled"];
+export type DurableTaskTargetStatus = typeof DURABLE_TASK_TARGET_STATUSES[number];
+export type DurableTaskStatusAssigneeIntent = {
+    kind: 'preserve';
+} | {
+    kind: 'set';
+    value: string | null;
+} | {
+    kind: 'claim-if-unassigned';
+    value: string;
+};
+export type DurableTaskStatusMutationPayload = {
+    status: DurableTaskTargetStatus;
+    assigneeIntent: DurableTaskStatusAssigneeIntent;
+    canceledReason: string | null;
+    metadataPatch: Partial<TaskItem>;
+};
+export declare class DurableTaskStatusMutationError extends Error {
+    readonly code: 'TASK_NOT_FOUND' | 'TASK_STATUS_INVALID_PAYLOAD' | 'TASK_STATUS_ARCHIVED';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_NOT_FOUND' | 'TASK_STATUS_INVALID_PAYLOAD' | 'TASK_STATUS_ARCHIVED', statusCode: number);
+}
+export interface DurableTaskStatusMutationCore {
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        skipTaskEvents?: boolean;
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        taskEventId?: string;
+        taskEventAction?: string;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowV3OwnedLifecycleWrite?: boolean;
+    }): TaskItem | null;
+    addTaskStatusEventsForDurableSync(event: {
+        taskId: string;
+        workspaceId: string;
+        action: string;
+        actor: string;
+        eventId: string;
+        createdAt: string;
+        details: {
+            changes: Record<string, {
+                from: unknown;
+                to: unknown;
+            }>;
+        };
+        task: TaskItem;
+        previousWorkstreamId: string | null;
+        allowAuthoritativeReplacement?: boolean;
+    }): void;
+}
+export interface DurableTaskStatusMutationResult {
+    task: TaskItem;
+    metadataOwned: boolean;
+    assigneeOwned: boolean;
+    statusChanged: boolean;
+    noOp: boolean;
+}
+export declare function validateDurableTaskStatusMutationPayload(value: unknown): DurableTaskStatusMutationPayload;
+export declare function applyTaskStatusMutationForDurableSync(input: {
+    core: DurableTaskStatusMutationCore;
+    workspaceId: string;
+    taskId: string;
+    targetStatus: DurableTaskTargetStatus;
+    metadataPatch?: unknown;
+    assigneeIntent: DurableTaskStatusAssigneeIntent;
+    canceledReason?: string | null;
+    updatedAt: string;
+    actorRef: string;
+    taskEventId: string;
+}): DurableTaskStatusMutationResult;

package/dist/core/TaskDurableStatusMutationService.js

@@ -0,0 +1,247 @@
+import { DurableTaskMetadataMutationError, validateDurableTaskMetadataPatch, } from './TaskDurableSyncMutationService.js';
+export const DURABLE_TASK_TARGET_STATUSES = [
+    'task',
+    'on-hold',
+    'in-progress',
+    'review',
+    'done',
+    'cancelled',
+];
+export class DurableTaskStatusMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskStatusMutationError';
+    }
+}
+const MAX_CANCELED_REASON_LENGTH = 2000;
+function invalid(message) {
+    throw new DurableTaskStatusMutationError(message, 'TASK_STATUS_INVALID_PAYLOAD', 400);
+}
+function normalizeTargetStatus(value) {
+    if (typeof value !== 'string' || !DURABLE_TASK_TARGET_STATUSES.includes(value)) {
+        return invalid(`Task status must be one of: ${DURABLE_TASK_TARGET_STATUSES.join(', ')}.`);
+    }
+    return value;
+}
+function normalizeCanceledReason(value, targetStatus) {
+    if (value !== null && typeof value !== 'string') {
+        return invalid('Task cancellation reason must be a string or null.');
+    }
+    const reason = typeof value === 'string' ? value.trim() : null;
+    if (reason !== null && (reason.length === 0 || reason.length > MAX_CANCELED_REASON_LENGTH)) {
+        return invalid(`Task cancellation reason must contain 1-${MAX_CANCELED_REASON_LENGTH} characters.`);
+    }
+    if (targetStatus !== 'cancelled' && reason !== null) {
+        return invalid('Task cancellation reason must be null unless status is cancelled.');
+    }
+    return reason;
+}
+function normalizeMetadataPatch(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)
+        return {};
+    let patch;
+    try {
+        patch = validateDurableTaskMetadataPatch(value);
+    }
+    catch (error) {
+        if (error instanceof DurableTaskMetadataMutationError)
+            return invalid(error.message);
+        throw error;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'assignee')) {
+        return invalid('Task status metadataPatch cannot contain assignee; use assigneeIntent.');
+    }
+    return patch;
+}
+function normalizeAssigneeIntent(value, targetStatus) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return invalid('Task status assigneeIntent must be an object.');
+    }
+    const record = value;
+    if (record.kind === 'preserve') {
+        if (Object.keys(record).length !== 1)
+            return invalid('Preserve assignee intent must contain exactly kind.');
+        return { kind: 'preserve' };
+    }
+    if (record.kind === 'set') {
+        if (Object.keys(record).sort().join(',') !== 'kind,value') {
+            return invalid('Set assignee intent must contain exactly kind and value.');
+        }
+        if (record.value !== null && typeof record.value !== 'string') {
+            return invalid('Set assignee intent value must be a string or null.');
+        }
+        const normalized = typeof record.value === 'string' ? record.value.trim() : '';
+        const assignee = normalized || null;
+        return { kind: 'set', value: assignee };
+    }
+    if (record.kind === 'claim-if-unassigned') {
+        if (Object.keys(record).sort().join(',') !== 'kind,value') {
+            return invalid('Claim-if-unassigned intent must contain exactly kind and value.');
+        }
+        if (targetStatus !== 'in-progress') {
+            return invalid('Claim-if-unassigned is valid only when status is in-progress.');
+        }
+        if (typeof record.value !== 'string' || !record.value.trim()) {
+            return invalid('Claim-if-unassigned value must be a nonblank string.');
+        }
+        return { kind: 'claim-if-unassigned', value: record.value.trim() };
+    }
+    return invalid('Task status assigneeIntent kind is invalid.');
+}
+export function validateDurableTaskStatusMutationPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return invalid('Task status payload must be an object.');
+    }
+    const record = value;
+    if (Object.keys(record).sort().join(',') !== 'assigneeIntent,canceledReason,metadataPatch,status') {
+        return invalid('Task status payload must contain exactly status, assigneeIntent, canceledReason, and metadataPatch.');
+    }
+    const status = normalizeTargetStatus(record.status);
+    return {
+        status,
+        assigneeIntent: normalizeAssigneeIntent(record.assigneeIntent, status),
+        canceledReason: normalizeCanceledReason(record.canceledReason, status),
+        metadataPatch: normalizeMetadataPatch(record.metadataPatch),
+    };
+}
+function normalizeComparable(value) {
+    if (value === undefined)
+        return null;
+    if (Array.isArray(value))
+        return value.map(normalizeComparable);
+    if (value && typeof value === 'object') {
+        return Object.keys(value).sort().reduce((result, key) => {
+            result[key] = normalizeComparable(value[key]);
+            return result;
+        }, {});
+    }
+    return value;
+}
+function valuesEqual(left, right) {
+    return JSON.stringify(normalizeComparable(left)) === JSON.stringify(normalizeComparable(right));
+}
+function isUnassigned(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === '' || normalized === 'unassigned';
+}
+function assigneesEqual(left, right) {
+    const normalize = (value) => isUnassigned(value) ? 'unassigned' : String(value).trim();
+    return normalize(left) === normalize(right);
+}
+export function applyTaskStatusMutationForDurableSync(input) {
+    const payload = validateDurableTaskStatusMutationPayload({
+        status: input.targetStatus,
+        assigneeIntent: input.assigneeIntent,
+        canceledReason: input.canceledReason ?? null,
+        metadataPatch: input.metadataPatch ?? {},
+    });
+    const targetStatus = payload.status;
+    const canceledReason = payload.canceledReason;
+    const metadataPatch = payload.metadataPatch;
+    const assigneeIntent = payload.assigneeIntent;
+    const current = input.core.getTask(input.taskId, input.workspaceId);
+    if (!current)
+        throw new DurableTaskStatusMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    if (current.isArchived) {
+        throw new DurableTaskStatusMutationError('Archived tasks cannot receive a durable status update.', 'TASK_STATUS_ARCHIVED', 409);
+    }
+    const updates = {
+        ...metadataPatch,
+        status: targetStatus,
+        canceledReason,
+    };
+    if (assigneeIntent.kind === 'set') {
+        updates.assignee = assigneeIntent.value;
+    }
+    else if (assigneeIntent.kind === 'claim-if-unassigned' && isUnassigned(current.assignee)) {
+        updates.assignee = assigneeIntent.value;
+    }
+    const trackedFields = Object.keys(updates);
+    const predictedNoOp = trackedFields.every((field) => field === 'assignee'
+        ? assigneesEqual(current.assignee, updates.assignee)
+        : valuesEqual(current[field], updates[field]));
+    const metadataFields = Object.keys(metadataPatch);
+    if (predictedNoOp) {
+        return {
+            task: current,
+            metadataOwned: metadataFields.length > 0,
+            assigneeOwned: assigneeIntent.kind === 'set',
+            statusChanged: false,
+            noOp: true,
+        };
+    }
+    const mutated = input.core.updateTask(input.taskId, updates, input.workspaceId, {
+        persistBackup: false,
+        emitRealtime: false,
+        skipTaskEvents: true,
+        syncUpdatedAt: input.updatedAt,
+        actorRef: input.actorRef,
+        taskEventId: input.taskEventId,
+        taskEventAction: 'task-status-changed',
+        allowV3OwnedMetadataWrite: true,
+        allowV3OwnedLifecycleWrite: true,
+    });
+    if (!mutated)
+        throw new DurableTaskStatusMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    let updated = mutated;
+    const metadataChanged = metadataFields.some((field) => !valuesEqual(current[field], updated[field]));
+    const assigneeChanged = !assigneesEqual(current.assignee, updated.assignee);
+    // An explicit set establishes durable provenance even when the canonical
+    // value is already equal. A conditional claim owns the field only when it
+    // actually claimed an unassigned task.
+    const assigneeOwned = assigneeIntent.kind === 'set' || assigneeChanged;
+    const statusChanged = current.status !== updated.status;
+    const canceledReasonChanged = !valuesEqual(current.canceledReason, updated.canceledReason);
+    const completedAtChanged = !valuesEqual(current.completedAt, updated.completedAt);
+    const noOp = !statusChanged && !canceledReasonChanged && !completedAtChanged && !metadataChanged && !assigneeChanged;
+    if (noOp) {
+        const restored = input.core.updateTask(input.taskId, {}, input.workspaceId, {
+            persistBackup: false,
+            emitRealtime: false,
+            skipTaskEvents: true,
+            syncUpdatedAt: current.updatedAt,
+            actorRef: input.actorRef,
+            allowV3OwnedMetadataWrite: true,
+            allowV3OwnedLifecycleWrite: true,
+        });
+        if (!restored)
+            throw new DurableTaskStatusMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+        updated = restored;
+    }
+    else {
+        const changeFields = Array.from(new Set([
+            ...trackedFields,
+            'completedAt',
+        ]));
+        const changes = Object.fromEntries(changeFields
+            .filter((field) => !valuesEqual(current?.[field], updated?.[field]))
+            .map((field) => [field, {
+                from: current[field] ?? null,
+                to: updated[field] ?? null,
+            }]));
+        input.core.addTaskStatusEventsForDurableSync({
+            taskId: input.taskId,
+            workspaceId: input.workspaceId,
+            action: 'task-status-changed',
+            actor: input.actorRef,
+            eventId: input.taskEventId,
+            createdAt: input.updatedAt,
+            details: { changes },
+            task: updated,
+            previousWorkstreamId: current.workstreamId || null,
+            allowAuthoritativeReplacement: true,
+        });
+        updated = input.core.getTask(input.taskId, input.workspaceId) || updated;
+    }
+    return {
+        task: updated,
+        metadataOwned: metadataFields.length > 0,
+        assigneeOwned,
+        statusChanged,
+        noOp,
+    };
+}

package/dist/core/TaskDurableSyncMutationService.d.ts

@@ -0,0 +1,34 @@
+import type { TaskItem } from './Taskforce.js';
+export declare const DURABLE_TASK_METADATA_FIELDS: Set<keyof TaskItem>;
+export declare function selectDurableTaskMetadataPatch(value: Record<string, unknown>): Partial<TaskItem>;
+export declare class DurableTaskMetadataMutationError extends Error {
+    readonly code: 'DURABLE_TASK_PATCH_INVALID' | 'TASK_NOT_FOUND';
+    readonly statusCode: number;
+    constructor(message: string, code: 'DURABLE_TASK_PATCH_INVALID' | 'TASK_NOT_FOUND', statusCode: number);
+}
+export interface DurableTaskMetadataMutationCore {
+    updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        skipTaskEvents?: boolean;
+        taskEventId?: string;
+        taskEventAction?: string;
+        allowAuthoritativeTaskEventReplacement?: boolean;
+        saveSource?: 'manual' | 'autosave';
+        syncUpdatedAt?: string;
+        actorRef?: string;
+        emitRealtime?: boolean;
+        allowV3OwnedMetadataWrite?: boolean;
+    }): TaskItem | null;
+}
+export declare function validateDurableTaskMetadataPatch(value: unknown): Partial<TaskItem>;
+export declare function applyTaskMetadataUpdateForDurableSync(input: {
+    core: DurableTaskMetadataMutationCore;
+    workspaceId: string;
+    taskId: string;
+    patch: Partial<TaskItem>;
+    updatedAt: string;
+    actorRef: string;
+    activityEventId: string;
+    saveSource?: 'manual' | 'autosave';
+    activityAction?: 'task-updated' | 'task-schedule-changed';
+}): TaskItem;

package/dist/core/TaskDurableSyncMutationService.js

@@ -0,0 +1,70 @@
+export const DURABLE_TASK_METADATA_FIELDS = new Set([
+    'title',
+    'description',
+    'priority',
+    'complexity',
+    'type',
+    'category',
+    'createdBy',
+    'assignee',
+    'scheduledDate',
+    'dueDate',
+    'scheduledWeekKey',
+    'orderInDay',
+    'workstreamId',
+    'taxonomies',
+]);
+export function selectDurableTaskMetadataPatch(value) {
+    const patch = {};
+    for (const field of DURABLE_TASK_METADATA_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(value, field)) {
+            patch[field] = value[field];
+        }
+    }
+    return patch;
+}
+export class DurableTaskMetadataMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskMetadataMutationError';
+    }
+}
+export function validateDurableTaskMetadataPatch(value) {
+    const patch = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+    if (!patch) {
+        throw new DurableTaskMetadataMutationError('Task metadata patch must be an object.', 'DURABLE_TASK_PATCH_INVALID', 400);
+    }
+    const keys = Object.keys(patch);
+    if (keys.length === 0) {
+        throw new DurableTaskMetadataMutationError('Task metadata patch cannot be empty.', 'DURABLE_TASK_PATCH_INVALID', 400);
+    }
+    const unsupported = keys.filter((key) => !DURABLE_TASK_METADATA_FIELDS.has(key));
+    if (unsupported.length > 0) {
+        throw new DurableTaskMetadataMutationError(`Task metadata patch contains unsupported fields: ${unsupported.sort().join(', ')}.`, 'DURABLE_TASK_PATCH_INVALID', 400);
+    }
+    return { ...patch };
+}
+export function applyTaskMetadataUpdateForDurableSync(input) {
+    const patch = validateDurableTaskMetadataPatch(input.patch);
+    const updated = input.core.updateTask(input.taskId, patch, input.workspaceId, {
+        persistBackup: false,
+        taskEventId: input.activityEventId,
+        taskEventAction: input.activityAction || 'task-updated',
+        saveSource: input.saveSource,
+        allowAuthoritativeTaskEventReplacement: true,
+        syncUpdatedAt: input.updatedAt,
+        actorRef: input.actorRef,
+        emitRealtime: false,
+        allowV3OwnedMetadataWrite: true,
+    });
+    if (!updated) {
+        throw new DurableTaskMetadataMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    }
+    return updated;
+}

package/dist/core/TaskDurableWorkflowMutationService.d.ts

@@ -0,0 +1,48 @@
+import type { TaskItem } from './Taskforce.js';
+export type DurableTaskWorkflowMutationKind = 'complete' | 'reopen';
+export declare class DurableTaskWorkflowMutationError extends Error {
+    readonly code: 'TASK_NOT_FOUND' | 'TASK_WORKFLOW_INVALID_PAYLOAD' | 'TASK_COMPLETE_STATE_CONFLICT' | 'TASK_REOPEN_CANCELLED' | 'TASK_REOPEN_INVALID_STATE';
+    readonly statusCode: number;
+    constructor(message: string, code: 'TASK_NOT_FOUND' | 'TASK_WORKFLOW_INVALID_PAYLOAD' | 'TASK_COMPLETE_STATE_CONFLICT' | 'TASK_REOPEN_CANCELLED' | 'TASK_REOPEN_INVALID_STATE', statusCode: number);
+}
+export interface DurableTaskWorkflowMutationCore {
+    lockTaskLifecycleMutationDomain(workspaceId?: string, updatedAt?: string): void;
+    getTask(id: string, workspaceId?: string): TaskItem | null;
+    updateTask(id: string, updates: Partial<TaskItem>, workspaceId?: string, options?: {
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowV3OwnedLifecycleWrite?: boolean;
+        actorRef?: string;
+        taskEventId?: string;
+    }): TaskItem | null;
+    reopenTask(id: string, workspaceId?: string, options?: {
+        actorRef?: string;
+        assignee?: string | null;
+        persistBackup?: boolean;
+        emitRealtime?: boolean;
+        syncUpdatedAt?: string;
+        allowV3OwnedMetadataWrite?: boolean;
+        allowV3OwnedLifecycleWrite?: boolean;
+        taskEventId?: string;
+    }): {
+        task: TaskItem;
+        claimed: boolean;
+        statusChanged: boolean;
+    };
+}
+export declare function applyTaskWorkflowMutationForDurableSync(input: {
+    core: DurableTaskWorkflowMutationCore;
+    workspaceId: string;
+    taskId: string;
+    mutationKind: DurableTaskWorkflowMutationKind;
+    assignee?: string | null;
+    updatedAt: string;
+    actorRef: string;
+    taskEventId?: string;
+}): {
+    task: TaskItem;
+    assigneeClaimed: boolean;
+    noOp: boolean;
+};

package/dist/core/TaskDurableWorkflowMutationService.js

@@ -0,0 +1,59 @@
+export class DurableTaskWorkflowMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskWorkflowMutationError';
+    }
+}
+export function applyTaskWorkflowMutationForDurableSync(input) {
+    input.core.lockTaskLifecycleMutationDomain(input.workspaceId, input.updatedAt);
+    const current = input.core.getTask(input.taskId, input.workspaceId);
+    if (!current)
+        throw new DurableTaskWorkflowMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+    const status = String(current.status || '').trim().toLowerCase();
+    if (input.mutationKind === 'complete') {
+        if (current.isArchived || status === 'cancelled' || status === 'done') {
+            throw new DurableTaskWorkflowMutationError('Only an active, non-terminal task can be completed.', 'TASK_COMPLETE_STATE_CONFLICT', 409);
+        }
+        const completed = input.core.updateTask(input.taskId, {
+            status: 'done',
+            canceledReason: null,
+        }, input.workspaceId, {
+            persistBackup: false,
+            emitRealtime: false,
+            syncUpdatedAt: input.updatedAt,
+            actorRef: input.actorRef,
+            taskEventId: input.taskEventId,
+            allowV3OwnedLifecycleWrite: true,
+        });
+        if (!completed)
+            throw new DurableTaskWorkflowMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+        return { task: completed, assigneeClaimed: false, noOp: false };
+    }
+    if (status === 'cancelled') {
+        throw new DurableTaskWorkflowMutationError('Cancelled tasks cannot be reopened.', 'TASK_REOPEN_CANCELLED', 409);
+    }
+    const alreadyInProgress = status === 'in-progress' && !current.isArchived;
+    if (!alreadyInProgress && status !== 'done' && status !== 'review') {
+        throw new DurableTaskWorkflowMutationError('Only done, review, or already active in-progress tasks can be reopened.', 'TASK_REOPEN_INVALID_STATE', 409);
+    }
+    const reopened = input.core.reopenTask(input.taskId, input.workspaceId, {
+        actorRef: input.actorRef,
+        assignee: input.assignee ?? null,
+        persistBackup: false,
+        emitRealtime: false,
+        syncUpdatedAt: input.updatedAt,
+        allowV3OwnedMetadataWrite: true,
+        allowV3OwnedLifecycleWrite: true,
+        taskEventId: input.taskEventId,
+    });
+    const requestedAssignee = typeof input.assignee === 'string' ? input.assignee.trim() : null;
+    const assigneeClaimed = reopened.claimed
+        && requestedAssignee !== null
+        && requestedAssignee !== 'unassigned'
+        && reopened.task.assignee === requestedAssignee;
+    return { task: reopened.task, assigneeClaimed, noOp: !reopened.statusChanged && !reopened.claimed };
+}

package/dist/core/TaskLifecycleCommandService.d.ts

@@ -0,0 +1,101 @@
+export type TaskLifecycleStatus = 'task' | 'in-progress' | 'review' | 'on-hold' | 'done' | 'cancelled' | string;
+export interface TaskLifecycleTask {
+    id: string;
+    title?: string;
+    referenceLabel?: string | null;
+    status: TaskLifecycleStatus;
+    assignee?: string | null;
+    isArchived?: boolean;
+}
+export type TaskLifecycleAssigneeIntent = {
+    kind: 'preserve';
+} | {
+    kind: 'claim-if-unassigned';
+    value: string;
+} | {
+    kind: 'set';
+    value: string | null;
+};
+export type TaskLifecycleMutationKind = 'archive' | 'unarchive' | 'reopen';
+export interface TaskLifecycleReviewerResolution {
+    assignee: string;
+    source: string;
+    warning?: string;
+}
+export interface TaskLifecycleCommandServiceDependencies {
+    formatTaskIdentifier(task: TaskLifecycleTask): string;
+    resolveAssigneeLabel(assignee: string): string;
+    setStatus(input: {
+        task: TaskLifecycleTask;
+        updates: Record<string, unknown>;
+        forceDurable?: boolean;
+        assigneeIntent?: TaskLifecycleAssigneeIntent;
+    }): TaskLifecycleTask;
+    mutateLifecycle(input: {
+        taskId: string;
+        mutationKind: TaskLifecycleMutationKind;
+        payload: Record<string, unknown>;
+        legacyArchiveArgs?: {
+            isCancellation: boolean;
+            reason: string | undefined;
+        };
+    }): TaskLifecycleTask | null;
+    resolveReviewer(task: TaskLifecycleTask): TaskLifecycleReviewerResolution;
+}
+export declare class TaskLifecycleCommandError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: string, statusCode?: number, details?: Record<string, unknown>);
+}
+export type StartTaskCommandResult = {
+    task: TaskLifecycleTask;
+    started: true;
+    claimed: boolean;
+    statusChanged: boolean;
+    previousAssignee: string;
+    previousStatus: string;
+};
+export type FinishTaskCommandResult = {
+    task: TaskLifecycleTask;
+    completion: {
+        outcome: 'done' | 'review';
+        archived: boolean;
+        reviewerResolution?: TaskLifecycleReviewerResolution;
+        comment?: string;
+    };
+};
+export type ReopenTaskCommandResult = {
+    task: TaskLifecycleTask;
+    reopened: boolean;
+    claimed: boolean;
+    statusChanged: boolean;
+    previousStatus: string;
+    previousArchived: boolean;
+    previousAssignee: string;
+};
+export declare function createTaskLifecycleCommandService(deps: TaskLifecycleCommandServiceDependencies): {
+    start(task: TaskLifecycleTask, input: {
+        activeAiProfileId: unknown;
+    }): StartTaskCommandResult;
+    finish(task: TaskLifecycleTask, input: {
+        outcome: unknown;
+        comment?: unknown;
+    }): FinishTaskCommandResult;
+    reopen(task: TaskLifecycleTask, input: {
+        activeAiProfileId: string | null | undefined;
+    }): ReopenTaskCommandResult;
+    archive(task: TaskLifecycleTask, input: {
+        status: unknown;
+        reason?: string;
+    }): {
+        task: TaskLifecycleTask;
+        archived: true;
+        status: string;
+        cancelled: boolean;
+    };
+    unarchive(task: TaskLifecycleTask): {
+        task: TaskLifecycleTask;
+        unarchived: true;
+    };
+};