@skrr-ai/cli 0.1.8

package/dist/lib/task-execution.d.ts

@@ -0,0 +1,90 @@
+import { type TaskRecord } from './tasks';
+/**
+ * Statuses at which an execution is OVER — nothing further will move the task
+ * without new input.
+ *
+ * `in_review` is one of them (OSK-2064). The required-output policy is
+ * default-ON, so the platform now PARKS a run that ended without an approved
+ * TASK_OUTPUT at `in_review` and releases the checkout: the run is finished and
+ * a human has to close the loop. It was in neither set, so `skrr tasks wait`
+ * (default `--until done`, default `--fail-on failed,blocked,cancelled`) polled
+ * a task that could never satisfy either condition and never returned — the
+ * default flip turned the most common CLI wait into an infinite hang.
+ */
+export declare const TERMINAL_STATUSES: Set<string>;
+/**
+ * Terminal statuses that are NOT a success, i.e. the wait ends non-zero.
+ * `in_review` belongs here for the same reason: a parked run did not produce
+ * the deliverable, and a caller waiting for `done` needs to be told so rather
+ * than told nothing. Overridable per command via `--fail-on`.
+ */
+export declare const DEFAULT_FAIL_STATUSES: Set<string>;
+/**
+ * The `--fail-on` flag default, derived from the set above so an oclif flag
+ * default string can never drift from it again (it did: every command hardcoded
+ * 'failed,blocked,cancelled', which silently shadowed `DEFAULT_FAIL_STATUSES`
+ * as the `parseStatusSet` fallback).
+ */
+export declare const DEFAULT_FAIL_STATUSES_FLAG: string;
+export declare const STARTABLE_STATUSES: Set<string>;
+export type TaskSnapshot = {
+    object: 'task_execution_snapshot';
+    rootId?: string;
+    taskCount: number;
+    counts: Record<string, number>;
+    activeCount: number;
+    recoveredCount: number;
+    terminalCount: number;
+    pendingCount: number;
+    failureCount: number;
+    tasks: TaskRecord[];
+    activeTasks: TaskRecord[];
+    recoveredTasks: TaskRecord[];
+    failureTasks: TaskRecord[];
+    generatedAt: string;
+};
+export type SpaceCapacity = {
+    object: 'space_task_capacity';
+    space: TaskRecord;
+    maxActiveTasks: number;
+    activeCount: number;
+    availableSlots: number;
+    activeTasks: TaskRecord[];
+    sampledTaskCount: number;
+};
+export declare function statusOf(task: TaskRecord | null | undefined): string;
+export declare function isTerminalTask(task: TaskRecord): boolean;
+/**
+ * Whether a task satisfies a `--until` target. `terminal` means any status in
+ * `TERMINAL_STATUSES` — read from the shared set rather than a per-command
+ * literal so the two definitions cannot diverge.
+ */
+export declare function satisfiesWaitTarget(task: TaskRecord, until: string): boolean;
+export declare function isActiveTask(task: TaskRecord): boolean;
+export declare function isRecoveredExecutionTask(task: TaskRecord): boolean;
+export declare function isStartableTask(task: TaskRecord): boolean;
+export declare function hasAgentAssignee(task: TaskRecord): boolean;
+export declare function parseStatusSet(value: string | undefined, fallback: Set<string>): Set<string>;
+export declare function hasFailureStatus(task: TaskRecord, failOn: Set<string>): boolean;
+export declare function summarizeTask(task: TaskRecord): Record<string, string>;
+export declare function recoveryReason(task: TaskRecord): string;
+export declare function fetchTaskSet({ rootId, spaceId, ids, descendants, childrenOnly, limit, }: {
+    rootId?: string;
+    spaceId?: string;
+    ids?: string[];
+    descendants?: boolean;
+    childrenOnly?: boolean;
+    limit?: number;
+}): Promise<TaskRecord[]>;
+export declare function fetchSpaceTasks(spaceId: string, limit?: number): Promise<TaskRecord[]>;
+export declare function getSpaceCapacity(spaceId: string, limit?: number): Promise<SpaceCapacity>;
+export declare function buildSnapshot(tasks: TaskRecord[], failOn?: Set<string>, rootId?: string): TaskSnapshot;
+export declare function taskSortKey(task: TaskRecord): string;
+export declare function workstreamKey(task: TaskRecord): string | null;
+export declare function dependencyKeys(task: TaskRecord): string[];
+export declare function blockingDependencies(task: TaskRecord, candidates: TaskRecord[]): TaskRecord[];
+export declare function formatTaskLine(task: TaskRecord): string;
+export declare function formatAgeSince(value: string): string;
+export declare function formatDurationMs(value: unknown): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function compactSnapshotSignature(snapshot: TaskSnapshot): string;

package/dist/lib/task-execution.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STARTABLE_STATUSES = exports.DEFAULT_FAIL_STATUSES_FLAG = exports.DEFAULT_FAIL_STATUSES = exports.TERMINAL_STATUSES = void 0;
+exports.statusOf = statusOf;
+exports.isTerminalTask = isTerminalTask;
+exports.satisfiesWaitTarget = satisfiesWaitTarget;
+exports.isActiveTask = isActiveTask;
+exports.isRecoveredExecutionTask = isRecoveredExecutionTask;
+exports.isStartableTask = isStartableTask;
+exports.hasAgentAssignee = hasAgentAssignee;
+exports.parseStatusSet = parseStatusSet;
+exports.hasFailureStatus = hasFailureStatus;
+exports.summarizeTask = summarizeTask;
+exports.recoveryReason = recoveryReason;
+exports.fetchTaskSet = fetchTaskSet;
+exports.fetchSpaceTasks = fetchSpaceTasks;
+exports.getSpaceCapacity = getSpaceCapacity;
+exports.buildSnapshot = buildSnapshot;
+exports.taskSortKey = taskSortKey;
+exports.workstreamKey = workstreamKey;
+exports.dependencyKeys = dependencyKeys;
+exports.blockingDependencies = blockingDependencies;
+exports.formatTaskLine = formatTaskLine;
+exports.formatAgeSince = formatAgeSince;
+exports.formatDurationMs = formatDurationMs;
+exports.sleep = sleep;
+exports.compactSnapshotSignature = compactSnapshotSignature;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const tasks_1 = require("./tasks");
+/**
+ * Statuses at which an execution is OVER — nothing further will move the task
+ * without new input.
+ *
+ * `in_review` is one of them (OSK-2064). The required-output policy is
+ * default-ON, so the platform now PARKS a run that ended without an approved
+ * TASK_OUTPUT at `in_review` and releases the checkout: the run is finished and
+ * a human has to close the loop. It was in neither set, so `skrr tasks wait`
+ * (default `--until done`, default `--fail-on failed,blocked,cancelled`) polled
+ * a task that could never satisfy either condition and never returned — the
+ * default flip turned the most common CLI wait into an infinite hang.
+ */
+exports.TERMINAL_STATUSES = new Set([
+    'done',
+    'failed',
+    'blocked',
+    'cancelled',
+    'hidden',
+    'in_review',
+]);
+/**
+ * Terminal statuses that are NOT a success, i.e. the wait ends non-zero.
+ * `in_review` belongs here for the same reason: a parked run did not produce
+ * the deliverable, and a caller waiting for `done` needs to be told so rather
+ * than told nothing. Overridable per command via `--fail-on`.
+ */
+exports.DEFAULT_FAIL_STATUSES = new Set(['failed', 'blocked', 'cancelled', 'in_review']);
+/**
+ * The `--fail-on` flag default, derived from the set above so an oclif flag
+ * default string can never drift from it again (it did: every command hardcoded
+ * 'failed,blocked,cancelled', which silently shadowed `DEFAULT_FAIL_STATUSES`
+ * as the `parseStatusSet` fallback).
+ */
+exports.DEFAULT_FAIL_STATUSES_FLAG = [...exports.DEFAULT_FAIL_STATUSES].join(',');
+exports.STARTABLE_STATUSES = new Set(['backlog', 'todo']);
+function statusOf(task) {
+    return String(task?.status ?? '');
+}
+function isTerminalTask(task) {
+    return exports.TERMINAL_STATUSES.has(statusOf(task));
+}
+/**
+ * Whether a task satisfies a `--until` target. `terminal` means any status in
+ * `TERMINAL_STATUSES` — read from the shared set rather than a per-command
+ * literal so the two definitions cannot diverge.
+ */
+function satisfiesWaitTarget(task, until) {
+    const status = statusOf(task);
+    return until === 'terminal' ? exports.TERMINAL_STATUSES.has(status) : status === until;
+}
+function isActiveTask(task) {
+    const status = statusOf(task);
+    return (status === 'in_progress' ||
+        isNonEmptyString(task.checkoutRunId) ||
+        isNonEmptyString(task.sessionId));
+}
+function isRecoveredExecutionTask(task) {
+    if (!isStartableTask(task))
+        return false;
+    const error = stringValue(task.executionError);
+    if (!error)
+        return false;
+    return (/\b(stuck|timeout|timed out|reaped|reset|lost|expired|usage|quota|rate limit|token)\b/i.test(error) ||
+        isNonEmptyString(task.startedAt) ||
+        isNonEmptyString(task.conversationId) ||
+        Number(task.executionAttempts) > 0);
+}
+function isStartableTask(task) {
+    return exports.STARTABLE_STATUSES.has(statusOf(task));
+}
+function hasAgentAssignee(task) {
+    return Array.isArray(task.assigneeAgentIds) && task.assigneeAgentIds.length > 0;
+}
+function parseStatusSet(value, fallback) {
+    if (!value || !value.trim())
+        return new Set(fallback);
+    return new Set(value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean));
+}
+function hasFailureStatus(task, failOn) {
+    return failOn.has(statusOf(task));
+}
+function summarizeTask(task) {
+    const startedAt = stringValue(task.startedAt ?? task.executionLockedAt);
+    return {
+        ref: (0, tasks_1.taskRef)(task) || '-',
+        id: (0, tasks_1.taskId)(task) || '-',
+        title: String(task.title ?? '-'),
+        status: statusOf(task) || '-',
+        run: stringValue(task.checkoutRunId) || '-',
+        session: stringValue(task.sessionId) || '-',
+        conversation: stringValue(task.conversationId) || '-',
+        age: startedAt ? formatAgeSince(startedAt) : '-',
+        attempts: String(task.executionAttempts ?? 0),
+        error: stringValue(task.executionError) || '-',
+        note: isRecoveredExecutionTask(task) ? recoveryReason(task) : '-',
+    };
+}
+function recoveryReason(task) {
+    const error = stringValue(task.executionError);
+    if (!error)
+        return 'recovered stale execution';
+    if (/stuck|reaped|reset/i.test(error))
+        return 'reaped stale execution';
+    if (/usage|quota|rate limit|token/i.test(error))
+        return 'execution limit/auth failure';
+    if (/timeout|timed out/i.test(error))
+        return 'execution timeout';
+    return 'previous execution failed to complete';
+}
+async function fetchTaskSet({ rootId, spaceId, ids, descendants = false, childrenOnly = false, limit = 500, }) {
+    if (rootId) {
+        const rootPromise = childrenOnly
+            ? Promise.resolve(null)
+            : data_provider_1.dataService.getTask(rootId, { enrich: false });
+        const relatedPromise = descendants
+            ? data_provider_1.dataService.getTaskDescendants(rootId, limit, true)
+            : data_provider_1.dataService.listTaskChildren(rootId, true);
+        const [root, related] = await Promise.all([rootPromise, relatedPromise]);
+        return [root, ...(0, tasks_1.listItems)(related)].filter(Boolean);
+    }
+    if (spaceId) {
+        return fetchSpaceTasks(spaceId, limit);
+    }
+    if (ids && ids.length > 0) {
+        return Promise.all(ids.map((id) => data_provider_1.dataService.getTask(id, { enrich: false })));
+    }
+    return [];
+}
+async function fetchSpaceTasks(spaceId, limit = 500) {
+    const pageSize = Math.min(Math.max(limit, 1), 500);
+    const items = [];
+    let cursor;
+    do {
+        const remaining = limit - items.length;
+        const response = await data_provider_1.dataService.listTasks({
+            spaceId,
+            limit: Math.min(pageSize, remaining),
+            cursor,
+            includeActionability: true,
+        });
+        items.push(...(0, tasks_1.listItems)(response));
+        const nextCursor = response?.next_cursor;
+        cursor = nextCursor || undefined;
+    } while (cursor && items.length < limit);
+    return items;
+}
+async function getSpaceCapacity(spaceId, limit = 1000) {
+    const [space, tasks] = await Promise.all([
+        data_provider_1.dataService.getSpace(spaceId),
+        fetchSpaceTasks(spaceId, limit),
+    ]);
+    const activeTasks = tasks.filter(isActiveTask);
+    const maxActiveTasks = normalizePositiveInt(space.autoExecuteMaxActiveTasks, 3);
+    const activeCount = activeTasks.length;
+    return {
+        object: 'space_task_capacity',
+        space,
+        maxActiveTasks,
+        activeCount,
+        availableSlots: Math.max(0, maxActiveTasks - activeCount),
+        activeTasks,
+        sampledTaskCount: tasks.length,
+    };
+}
+function buildSnapshot(tasks, failOn = exports.DEFAULT_FAIL_STATUSES, rootId) {
+    const counts = {};
+    for (const task of tasks) {
+        const status = statusOf(task) || 'unknown';
+        counts[status] = (counts[status] ?? 0) + 1;
+    }
+    const activeTasks = tasks.filter(isActiveTask);
+    const recoveredTasks = tasks.filter(isRecoveredExecutionTask);
+    const failureTasks = tasks.filter((task) => hasFailureStatus(task, failOn));
+    const terminalCount = tasks.filter(isTerminalTask).length;
+    return {
+        object: 'task_execution_snapshot',
+        rootId,
+        taskCount: tasks.length,
+        counts,
+        activeCount: activeTasks.length,
+        recoveredCount: recoveredTasks.length,
+        terminalCount,
+        pendingCount: Math.max(0, tasks.length - terminalCount),
+        failureCount: failureTasks.length,
+        tasks,
+        activeTasks,
+        recoveredTasks,
+        failureTasks,
+        generatedAt: new Date().toISOString(),
+    };
+}
+function taskSortKey(task) {
+    const order = Number.isFinite(Number(task.order)) ? Number(task.order) : 999999;
+    return `${String(order).padStart(8, '0')}:${String(task.createdAt ?? '')}:${(0, tasks_1.taskId)(task)}`;
+}
+function workstreamKey(task) {
+    const candidates = [
+        String(task.title ?? ''),
+        ...(Array.isArray(task.tags) ? task.tags.map((tag) => String(tag)) : []),
+    ];
+    for (const candidate of candidates) {
+        const match = candidate.match(/\bWS[-\s]?(\d+)[.-](\d+)\b/i);
+        if (match)
+            return `ws-${match[1]}-${match[2]}`;
+    }
+    return null;
+}
+function dependencyKeys(task) {
+    const text = stripHtml(String(task.description ?? ''));
+    const dependsMatch = text.match(/\bdepends(?:\s+on)?\s*:\s*([^\n\r]+)/i);
+    if (!dependsMatch)
+        return [];
+    const line = dependsMatch[1];
+    if (/^(none|—|-|n\/a)\b/i.test(line.trim()))
+        return [];
+    return Array.from(line.matchAll(/\bWS[-\s]?(\d+)[.-](\d+)\b/gi)).map((match) => `ws-${match[1]}-${match[2]}`);
+}
+function blockingDependencies(task, candidates) {
+    const byKey = new Map();
+    for (const candidate of candidates) {
+        const key = workstreamKey(candidate);
+        if (key)
+            byKey.set(key, candidate);
+    }
+    return dependencyKeys(task)
+        .map((key) => byKey.get(key))
+        .filter((dep) => !!dep && statusOf(dep) !== 'done');
+}
+function formatTaskLine(task) {
+    const ref = (0, tasks_1.taskRef)(task);
+    const title = String(task.title ?? '(no title)');
+    return `${ref ? `${ref} ` : ''}${title}`;
+}
+function formatAgeSince(value) {
+    const time = Date.parse(value);
+    if (!Number.isFinite(time))
+        return '-';
+    const seconds = Math.max(0, Math.floor((Date.now() - time) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h${minutes % 60 ? `${minutes % 60}m` : ''}`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function formatDurationMs(value) {
+    const ms = Number(value);
+    if (!Number.isFinite(ms) || ms < 0)
+        return '-';
+    if (ms < 1000)
+        return `${Math.floor(ms)}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${seconds % 60 ? `${seconds % 60}s` : ''}`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h${minutes % 60 ? `${minutes % 60}m` : ''}`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function compactSnapshotSignature(snapshot) {
+    return snapshot.tasks
+        .map((task) => `${(0, tasks_1.taskId)(task)}:${statusOf(task)}:${task.sessionId ?? ''}:${task.checkoutRunId ?? ''}:${task.executionError ?? ''}:${task.startedAt ?? ''}`)
+        .sort()
+        .join('|');
+}
+function stripHtml(value) {
+    return value
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&amp;/g, '&')
+        .replace(/[ \t]+/g, ' ');
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function normalizePositiveInt(value, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    return Math.floor(n);
+}

package/dist/lib/task-extras.d.ts

@@ -0,0 +1,78 @@
+import { withQuery } from './triggers';
+type Query = Parameters<typeof withQuery>[1];
+type Json = Record<string, unknown>;
+export declare const taskWorkflowApi: {
+    get: (id: string) => Promise<Json>;
+    start: (id: string) => Promise<Json>;
+    cancel: (id: string) => Promise<Json>;
+    approveMerge: (id: string) => Promise<Json>;
+    retryStage: (id: string, body: Json) => Promise<Json>;
+    e2eComplete: (id: string, body: Json) => Promise<Json>;
+};
+export declare const taskLookupApi: {
+    agentCalendar: (query?: Query) => Promise<Json>;
+    bySourceMessage: (query: Query) => Promise<Json>;
+    /** Batch form of the above — one round trip for a whole rail of messages. */
+    bySourceMessages: (body: Json) => Promise<Json>;
+    pendingFollowUps: (query?: Query) => Promise<Json>;
+    runCommunications: (id: string, runId: string, query?: Query) => Promise<Json>;
+    /**
+     * Queue a follow-up task from a finished one. Lives here rather than in the
+     * command so the endpoint is visible to the parity check — a command owns
+     * flags, the lib owns URLs.
+     */
+    followUp: (id: string, body: Json) => Promise<Json>;
+    cancelFollowUp: (id: string) => Promise<Json>;
+    /**
+     * Atomic completion: moves the task AND writes the TASK_OUTPUT comment in one
+     * request, so a crash between the two cannot leave a done task with no record
+     * of what it produced.
+     */
+    complete: (id: string, body: Json) => Promise<Json>;
+    treePosition: (id: string, body: Json) => Promise<Json>;
+    createAndStart: (body: Json) => Promise<Json>;
+};
+/**
+ * The completion URL as a STRING.
+ *
+ * `skrr tasks complete` cannot go through `request.post`: it sends an
+ * `X-Idempotency-Key` header so a completion that lands but loses its response
+ * is not applied twice on outbox replay, and that needs `apiFetch`. Exporting
+ * the path keeps URL ownership in the lib anyway — the alternative was the
+ * command building `/api/tasks/${id}/complete` inline, which is invisible to the
+ * parity check.
+ */
+export declare function taskCompletePath(taskId: string): string;
+export declare const taskChatApi: {
+    transcriptSources: (id: string, query?: Query) => Promise<Json>;
+    reindexTranscript: (id: string) => Promise<Json>;
+    chat: (id: string, query?: Query) => Promise<Json>;
+    markRead: (id: string, body: Json) => Promise<Json>;
+    /**
+     * Start a fresh conversation epoch. The OLD transcript stays in Task history —
+     * rotating is how you get a clean slate without destroying the record.
+     */
+    rotate: (id: string, body?: Json) => Promise<Json>;
+    transferPreview: (id: string, query?: Query) => Promise<Json>;
+    exchanges: (id: string, query?: Query) => Promise<Json>;
+    sendExchangeMessage: (id: string, body: Json) => Promise<Json>;
+    closeInput: (id: string, exchangeId: string, body?: Json) => Promise<Json>;
+    cancelExchange: (id: string, exchangeId: string, body?: Json) => Promise<Json>;
+    interruptExchange: (id: string, exchangeId: string, body?: Json) => Promise<Json>;
+    reopen: (id: string, body?: Json) => Promise<Json>;
+    /**
+     * Re-derive the task's attention projection. A repair verb, not a routine one:
+     * it exists because a crash between a terminal and its projection can leave a
+     * task showing "waiting for user" when nothing is.
+     */
+    repairAttention: (id: string) => Promise<Json>;
+    executionRuns: (id: string, query?: Query) => Promise<Json>;
+    /**
+     * The TASK-HISTORY projection: every source that ever fed this task, in one
+     * continuous view. Distinct from `lib/task-transcript.ts`, which renders ONE
+     * run's conversation — that is what the agent said on an attempt, this is the
+     * whole work relationship.
+     */
+    taskHistory: (id: string, query?: Query) => Promise<Json>;
+};
+export {};

package/dist/lib/task-extras.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskChatApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
+exports.taskCompletePath = taskCompletePath;
+/**
+ * task-extras.ts — the `/api/tasks` endpoints that have no `dataService.*`
+ * wrapper, gathered so every one of them is reachable from `skrr`.
+ *
+ * Three clusters, and they are unrelated except in having been CLI-less:
+ *
+ *   WORKFLOW    the staged pipeline a task can run (start → stages → merge).
+ *               Distinct from a cascade: a cascade fans out subtasks, a workflow
+ *               walks named stages with an approval gate at the merge.
+ *   LOOKUP      finding tasks by something other than their id — the calendar
+ *               view, and the group-chat message a task was created from.
+ *   CHAT        the multi-turn discussion plane: read marks, epoch rotation,
+ *               exchange lifecycle, and the human-input handshake.
+ */
+const data_provider_1 = require("@skrr-ai/data-provider");
+const triggers_1 = require("./triggers");
+const MOUNT = '/api/tasks';
+const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
+exports.taskWorkflowApi = {
+    get: (id) => data_provider_1.request.get(`${base(id)}/workflow`),
+    start: (id) => data_provider_1.request.post(`${base(id)}/workflow/start`, {}),
+    cancel: (id) => data_provider_1.request.post(`${base(id)}/workflow/cancel`, {}),
+    approveMerge: (id) => data_provider_1.request.post(`${base(id)}/workflow/approve-merge`, {}),
+    retryStage: (id, body) => data_provider_1.request.post(`${base(id)}/workflow/retry-stage`, body),
+    e2eComplete: (id, body) => data_provider_1.request.post(`${base(id)}/workflow/e2e-complete`, body),
+};
+exports.taskLookupApi = {
+    agentCalendar: (query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${MOUNT}/agent-calendar`, query)),
+    bySourceMessage: (query) => data_provider_1.request.get((0, triggers_1.withQuery)(`${MOUNT}/by-source-message`, query)),
+    /** Batch form of the above — one round trip for a whole rail of messages. */
+    bySourceMessages: (body) => data_provider_1.request.post(`${MOUNT}/by-source-messages`, body),
+    pendingFollowUps: (query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${MOUNT}/pending-follow-ups`, query)),
+    runCommunications: (id, runId, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/runs/${encodeURIComponent(runId)}/communications`, query)),
+    /**
+     * Queue a follow-up task from a finished one. Lives here rather than in the
+     * command so the endpoint is visible to the parity check — a command owns
+     * flags, the lib owns URLs.
+     */
+    followUp: (id, body) => data_provider_1.request.post(`${base(id)}/follow-up`, body),
+    cancelFollowUp: (id) => data_provider_1.request.post(`${base(id)}/follow-up/cancel`, {}),
+    /**
+     * Atomic completion: moves the task AND writes the TASK_OUTPUT comment in one
+     * request, so a crash between the two cannot leave a done task with no record
+     * of what it produced.
+     */
+    complete: (id, body) => data_provider_1.request.post(`${base(id)}/complete`, body),
+    treePosition: (id, body) => data_provider_1.request.patch(`${base(id)}/tree-position`, body),
+    createAndStart: (body) => data_provider_1.request.post(`${MOUNT}/create-and-start`, body),
+};
+/**
+ * The completion URL as a STRING.
+ *
+ * `skrr tasks complete` cannot go through `request.post`: it sends an
+ * `X-Idempotency-Key` header so a completion that lands but loses its response
+ * is not applied twice on outbox replay, and that needs `apiFetch`. Exporting
+ * the path keeps URL ownership in the lib anyway — the alternative was the
+ * command building `/api/tasks/${id}/complete` inline, which is invisible to the
+ * parity check.
+ */
+function taskCompletePath(taskId) {
+    return `${base(taskId)}/complete`;
+}
+exports.taskChatApi = {
+    transcriptSources: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/transcript/sources`, query)),
+    reindexTranscript: (id) => data_provider_1.request.post(`${base(id)}/transcript/reindex`, {}),
+    chat: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/chat`, query)),
+    markRead: (id, body) => data_provider_1.request.post(`${base(id)}/chat/read`, body),
+    /**
+     * Start a fresh conversation epoch. The OLD transcript stays in Task history —
+     * rotating is how you get a clean slate without destroying the record.
+     */
+    rotate: (id, body = {}) => data_provider_1.request.post(`${base(id)}/chat/rotate`, body),
+    transferPreview: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/chat/transfer-preview`, query)),
+    exchanges: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/exchanges`, query)),
+    sendExchangeMessage: (id, body) => data_provider_1.request.post(`${base(id)}/exchanges/messages`, body),
+    closeInput: (id, exchangeId, body = {}) => data_provider_1.request.post(`${base(id)}/exchanges/${encodeURIComponent(exchangeId)}/close-input`, body),
+    cancelExchange: (id, exchangeId, body = {}) => data_provider_1.request.post(`${base(id)}/exchanges/${encodeURIComponent(exchangeId)}/cancel`, body),
+    interruptExchange: (id, exchangeId, body = {}) => data_provider_1.request.post(`${base(id)}/exchanges/${encodeURIComponent(exchangeId)}/interrupt`, body),
+    // human-input lives in `skrr tasks input show|answer|dismiss`, which reaches it
+    // through dataService. Deliberately not duplicated here.
+    reopen: (id, body = {}) => data_provider_1.request.post(`${base(id)}/reopen`, body),
+    /**
+     * Re-derive the task's attention projection. A repair verb, not a routine one:
+     * it exists because a crash between a terminal and its projection can leave a
+     * task showing "waiting for user" when nothing is.
+     */
+    repairAttention: (id) => data_provider_1.request.post(`${base(id)}/attention/repair`, {}),
+    executionRuns: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/execution-runs`, query)),
+    /**
+     * The TASK-HISTORY projection: every source that ever fed this task, in one
+     * continuous view. Distinct from `lib/task-transcript.ts`, which renders ONE
+     * run's conversation — that is what the agent said on an attempt, this is the
+     * whole work relationship.
+     */
+    taskHistory: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/transcript`, query)),
+};

package/dist/lib/task-instruction-offer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Best-effort contextual activation after a human successfully uses a task
+ * command. It must never change the task command's exit status.
+ */
+export declare function maybeOfferTaskManagementInstructions(log: (message: string) => void): Promise<void>;