@skrr-ai/cli 0.1.42 → 0.1.44

package/dist/lib/task-asset-upload.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTaskForUpload = readTaskForUpload;
+exports.uploadTaskAssetFile = uploadTaskAssetFile;
+exports.attachTaskAssetFiles = attachTaskAssetFiles;
+exports.taskAssetMarkdownRef = taskAssetMarkdownRef;
+exports.sha256OfFile = sha256OfFile;
+exports.postFileToStorage = postFileToStorage;
+/**
+ * One Task-asset upload path for every CLI surface — `tasks attachments
+ * upload` and the `--attach` flag on updates/result/complete/comments all
+ * funnel here so the routing rules live in exactly one place (OSK-9863).
+ *
+ *   ≤25MB or image → buffered multipart (canonicalization needs the bytes)
+ *   larger non-image → intent → presigned POST to S3 → complete (OSK-9867)
+ *
+ * Session routing follows the CREDENTIAL, resolved here once per file so a
+ * narrowed agent session lands on `task-attachments*` and a human (or a
+ * delegated session holding a wide credential) lands on `/api/tasks/:id/*`.
+ *
+ * Retry safety is server-side: the sha256 IS the asset identity, so a second
+ * upload of the same bytes returns the existing ready row instead of
+ * duplicating it.
+ *
+ * The digest this module REPORTS is always the server's. The server
+ * canonicalizes images (EXIF strip, orientation, re-encode) before storing
+ * them, so the bytes on disk and the bytes stored are routinely different; an
+ * evidence reference that named the local hash would pin a version of the
+ * file that was never stored (OSK-10120). The local hash is computed only
+ * where the protocol needs it — declaring a direct upload, which storage then
+ * enforces — and never leaves this module as a claim about the asset.
+ */
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const path = __importStar(require("node:path"));
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../base-command");
+const file_mime_1 = require("./file-mime");
+const api_fetch_1 = require("./api-fetch");
+const session_task_endpoints_1 = require("./session-task-endpoints");
+function mb(bytes) {
+    return `${Math.floor(bytes / (1024 * 1024))} MB`;
+}
+const SHA256_HEX = /^[0-9a-f]{64}$/i;
+function storedDigest(asset) {
+    const value = asset.contentSha256;
+    return typeof value === 'string' && SHA256_HEX.test(value) ? value.toLowerCase() : undefined;
+}
+/**
+ * Read the Task an upload targets, through the same credential the upload
+ * will use. In a session the task comes from the claim, so the read is the
+ * bound task and `taskId` is only reconciled against it — a scoped credential
+ * refuses to act on any other task before a byte leaves the machine.
+ */
+async function readTaskForUpload(taskId) {
+    const readPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('read');
+    if (readPath) {
+        const bound = await (0, api_fetch_1.apiFetch)(readPath);
+        if (!(0, session_task_endpoints_1.requestMatchesBoundTask)(bound, taskId)) {
+            throw new Error(`This session is bound to task ${String(bound.identifier ?? bound.id ?? '?')} — a scoped credential cannot attach files to ${taskId}.`);
+        }
+        return bound;
+    }
+    return (await data_provider_1.dataService.getTask(taskId, { enrich: false }));
+}
+/**
+ * Upload `filePath` as a Task asset. In a session the task comes from the
+ * claim — `taskId` is only reconciled against the binding, never sent.
+ * Throws a plain Error; callers decide how to surface it.
+ */
+async function uploadTaskAssetFile(opts) {
+    const { taskId, filePath, role } = opts;
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+        throw new Error(`Not a regular file: ${filePath}`);
+    }
+    const size = stat.size;
+    const filename = path.basename(filePath);
+    const mimeType = (0, file_mime_1.mimeTypeForFilename)(filename);
+    const isImage = mimeType.startsWith('image/');
+    if (isImage && size > data_provider_1.TASK_ATTACHMENT_MAX_BYTES) {
+        throw new Error(`${filename} is too large for an image (max ${mb(data_provider_1.TASK_ATTACHMENT_MAX_BYTES)})`);
+    }
+    if (size > data_provider_1.TASK_DIRECT_UPLOAD_MAX_BYTES) {
+        throw new Error(`${filename} exceeds the direct-upload limit (${mb(data_provider_1.TASK_DIRECT_UPLOAD_MAX_BYTES)})`);
+    }
+    const direct = !isImage && size > data_provider_1.TASK_ATTACHMENT_MAX_BYTES;
+    const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachment');
+    let result;
+    try {
+        if (sessionPath) {
+            await readTaskForUpload(taskId);
+            result = direct
+                ? await sessionDirectUpload({ filePath, size, filename, mimeType, role })
+                : await sessionBufferedUpload({ filePath, filename, mimeType, role });
+        }
+        else {
+            result = direct
+                ? await genericDirectUpload({ taskId, filePath, size, filename, mimeType, role })
+                : await genericBufferedUpload({ taskId, filePath, filename, mimeType, role });
+        }
+    }
+    catch (err) {
+        throw withServerReason(err, filename);
+    }
+    return {
+        id: String(result.id ?? result._id),
+        digest: storedDigest(result),
+        filename,
+        mimeType,
+        deduplicated: result.deduplicated === true,
+    };
+}
+/**
+ * Put the server's own reason on a refused upload.
+ *
+ * The transports keep response bodies out of `message` (a body can carry a
+ * stack trace), so a refusal read `HTTP 403 Forbidden — POST …` — and `--attach`
+ * prints only the message. Task media refusals are written to be acted on: 422
+ * an image whose bytes cannot be decoded, 415 a type the bytes contradict, 413
+ * the storage quota, 403 an agent asking for a Run input. The reason and its
+ * code replace the transport line; status and body stay on the error, so
+ * `handleApiError` still reads them. An error with no stated reason is left
+ * exactly as it was.
+ */
+function withServerReason(err, filename) {
+    if (!(err instanceof Error))
+        return err;
+    const { code, message } = (0, base_command_1.apiRefusal)(err);
+    if (!message)
+        return err;
+    err.message = `${filename}: ${message}${code ? ` (${code})` : ''}`;
+    return err;
+}
+/**
+ * Upload every `--attach` file and return the reference objects an Update or
+ * Result appends to `evidenceRefs`. Serial: half a dozen files is the
+ * realistic case and parallel uploads would race the session rate limiter.
+ */
+async function attachTaskAssetFiles(opts) {
+    const refs = [];
+    for (const filePath of opts.files) {
+        const asset = await uploadTaskAssetFile({
+            taskId: opts.taskId,
+            filePath,
+            role: opts.role,
+        });
+        refs.push({
+            kind: 'task_attachment',
+            id: asset.id,
+            ...(asset.digest ? { digest: `sha256:${asset.digest}` } : {}),
+        });
+    }
+    return refs;
+}
+/**
+ * The markdown image a comment body carries for an asset. The alt text is the
+ * filename, so its brackets are escaped: `shot [final].png` would otherwise
+ * close the alt early and break the reference.
+ */
+function taskAssetMarkdownRef(asset) {
+    const alt = asset.filename.replace(/[\\[\]]/g, (ch) => `\\${ch}`);
+    return `![${alt}](task-asset:${asset.id})`;
+}
+/**
+ * The buffered path holds the file in memory by design: it is capped at the
+ * buffered limit, and the server needs the whole body to canonicalize it.
+ */
+function fileFormData(filePath, filename, mimeType, role) {
+    const fd = new FormData();
+    fd.append('file', new node_buffer_1.Blob([fs.readFileSync(filePath)], { type: mimeType }), filename);
+    if (role)
+        fd.append('role', role);
+    return fd;
+}
+async function genericBufferedUpload(p) {
+    return data_provider_1.dataService.uploadTaskAttachment({
+        taskId: p.taskId,
+        formData: fileFormData(p.filePath, p.filename, p.mimeType, p.role),
+    });
+}
+async function sessionBufferedUpload(p) {
+    return (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachment')), {
+        method: 'POST',
+        body: fileFormData(p.filePath, p.filename, p.mimeType, p.role),
+    });
+}
+async function genericDirectUpload(p) {
+    const intent = await data_provider_1.dataService.createTaskAttachmentUploadIntent({
+        taskId: p.taskId,
+        filename: p.filename,
+        mimeType: p.mimeType,
+        sizeBytes: p.size,
+        sha256: await sha256OfFile(p.filePath),
+        role: p.role,
+    });
+    if (!intent.uploadUrl)
+        return intent.attachment;
+    await postFileToStorage({
+        uploadUrl: intent.uploadUrl,
+        uploadFields: intent.uploadFields ?? {},
+        filePath: p.filePath,
+        size: p.size,
+        filename: p.filename,
+        mimeType: p.mimeType,
+    });
+    return data_provider_1.dataService.completeTaskAttachmentUpload({
+        taskId: p.taskId,
+        attachmentId: intent.attachment.id,
+    });
+}
+async function sessionDirectUpload(p) {
+    const intent = await (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachmentIntent')), {
+        method: 'POST',
+        body: {
+            filename: p.filename,
+            mimeType: p.mimeType,
+            sizeBytes: p.size,
+            sha256: await sha256OfFile(p.filePath),
+            ...(p.role ? { role: p.role } : {}),
+        },
+    });
+    if (!intent.uploadUrl)
+        return intent.attachment;
+    await postFileToStorage({
+        uploadUrl: intent.uploadUrl,
+        uploadFields: intent.uploadFields ?? {},
+        filePath: p.filePath,
+        size: p.size,
+        filename: p.filename,
+        mimeType: p.mimeType,
+    });
+    return (0, api_fetch_1.apiFetch)((await (0, session_task_endpoints_1.sessionScopedTaskPath)('attachmentComplete')), {
+        method: 'POST',
+        body: { attachmentId: intent.attachment.id },
+    });
+}
+/** sha256 of a file, read as a stream: a 250MB recording never sits in memory. */
+async function sha256OfFile(filePath) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    for await (const chunk of fs.createReadStream(filePath)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
+}
+/** A form-data header value: no CR/LF, and quotes percent-encoded. */
+function quotedHeaderValue(value) {
+    return value.replace(/[\r\n]/g, ' ').replace(/"/g, '%22');
+}
+/**
+ * POST the file to the presigned URL as multipart/form-data, streamed from
+ * disk.
+ *
+ * Built by hand rather than with `FormData` + `fetch` for two reasons, both
+ * about large files. `FormData` needs a `Blob`, which here means the whole
+ * file in memory — the double buffering this replaced read up to 250MB and
+ * then copied it again. And storage refuses a POST without a Content-Length
+ * (it does not take chunked uploads), which a streamed `fetch` body cannot
+ * promise; the exact length is known here, because every part except the file
+ * is a small in-memory string and the file's size came from `stat`.
+ *
+ * `file` goes LAST — S3 presigned POST evaluates fields in order and ignores
+ * anything after it. The fields carry `x-amz-checksum-sha256`, so storage
+ * itself rejects bytes that do not match the digest the intent declared,
+ * including a file that changed between hashing and upload.
+ */
+async function postFileToStorage(p) {
+    const boundary = `----skrr-upload-${(0, node_crypto_1.randomBytes)(16).toString('hex')}`;
+    const fieldParts = Object.entries(p.uploadFields).map(([name, value]) => `--${boundary}\r\nContent-Disposition: form-data; name="${quotedHeaderValue(name)}"\r\n\r\n${value}\r\n`);
+    const head = Buffer.from(fieldParts.join('') +
+        `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${quotedHeaderValue(p.filename)}"\r\nContent-Type: ${quotedHeaderValue(p.mimeType)}\r\n\r\n`, 'utf8');
+    const tail = Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8');
+    const url = new URL(p.uploadUrl);
+    const transport = url.protocol === 'http:' ? http : https;
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        const req = transport.request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': String(head.length + p.size + tail.length),
+            },
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                if (body.length < 4096)
+                    body += chunk;
+            });
+            res.on('error', fail);
+            res.on('end', () => {
+                const status = res.statusCode ?? 0;
+                if (status >= 200 && status < 300) {
+                    if (!settled) {
+                        settled = true;
+                        resolve();
+                    }
+                    return;
+                }
+                // S3 names the refusal in XML (`<Code>BadDigest</Code>`,
+                // `EntityTooLarge`, `AccessDenied` once the POST policy expired).
+                // The code is the only part a person can act on.
+                const code = /<Code>([^<]+)<\/Code>/.exec(body)?.[1];
+                fail(new Error(`Storage rejected the upload (${status}${code ? ` ${code}` : ''})`));
+            });
+        });
+        req.on('error', fail);
+        req.write(head);
+        let sent = 0;
+        const stream = fs.createReadStream(p.filePath);
+        stream.on('data', (chunk) => {
+            sent += chunk.length;
+        });
+        stream.on('error', (err) => {
+            req.destroy(err);
+            fail(err);
+        });
+        stream.on('end', () => {
+            if (sent !== p.size) {
+                const err = new Error(`${p.filename} changed while it was being uploaded`);
+                req.destroy(err);
+                fail(err);
+                return;
+            }
+            req.end(tail);
+        });
+        stream.pipe(req, { end: false });
+    });
+}

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

@@ -1,4 +1,19 @@
 import type { TaskClosureEvaluation } from '@skrr-ai/data-provider';
+/**
+ * Is this Task SETTLED — closed in a way that refuses a new Result until it is
+ * reopened (`TASK_REOPEN_REQUIRED`)?
+ *
+ * Read the same way the server reads it: the immutable `statusType` when the row
+ * carries a known one, the legacy status id otherwise, and the `settled` band
+ * from the shared vocabulary rather than a column name. A command asks this
+ * BEFORE doing something the refusal would strand — uploading `--attach` files
+ * for a Result the server is about to refuse — and never instead of the
+ * server's own check, which stays the authority.
+ */
+export declare function taskIsSettled(task: {
+    statusType?: unknown;
+    status?: unknown;
+} | null | undefined): boolean;
 /**
  * Render "where does this Task actually stand" for every surface that should
  * say it.

package/dist/lib/task-closure.js

@@ -1,9 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.closureSnapshotLines = exports.describeAssessor = void 0;
+exports.taskIsSettled = taskIsSettled;
 exports.closureReport = closureReport;
 exports.reopenRequiredLines = reopenRequiredLines;
 const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * Is this Task SETTLED — closed in a way that refuses a new Result until it is
+ * reopened (`TASK_REOPEN_REQUIRED`)?
+ *
+ * Read the same way the server reads it: the immutable `statusType` when the row
+ * carries a known one, the legacy status id otherwise, and the `settled` band
+ * from the shared vocabulary rather than a column name. A command asks this
+ * BEFORE doing something the refusal would strand — uploading `--attach` files
+ * for a Result the server is about to refuse — and never instead of the
+ * server's own check, which stays the authority.
+ */
+function taskIsSettled(task) {
+    if (!task)
+        return false;
+    const type = (0, data_provider_1.isTaskWorkflowStateType)(task.statusType)
+        ? task.statusType
+        : data_provider_1.LEGACY_STATUS_TYPE_BY_ID[String(task.status ?? '')];
+    return Boolean(type) && data_provider_1.TASK_WORKFLOW_TYPE_BANDS.settled.includes(type);
+}
 function isUnavailable(closure) {
     return Boolean(closure && closure.unavailable);
 }

package/dist/lib/task-view-render.d.ts

@@ -13,12 +13,15 @@
  * go.
  */
 export interface TaskViewFilters {
+    quickFilter?: string;
     statuses?: string[];
+    statusTypes?: string[];
     priorities?: string[];
     assignees?: string[];
     labels?: string[];
     goalIds?: string[];
     projectIds?: string[];
+    cycleIds?: string[];
     search?: string;
 }
 export interface TaskViewLike {
@@ -69,3 +72,14 @@ export declare function immutableViewPatchKeys(body: Record<string, unknown>): s
  * than listing six empty ones.
  */
 export declare function describeTaskView(view: TaskViewLike): string[];
+/**
+ * One line saying what a view SELECTS, for a table cell.
+ *
+ * `views list` had a SELECTION column whose value was the word `criteria` for
+ * every view that was not a pinned task list — a kind label sitting where the
+ * reader looks for an answer (dogfood OSK-4646). Values that fit are named
+ * (statuses, priorities, the quick filter, the search); ids are counted, since
+ * a row of UUIDs answers nothing at a glance and `views show` prints them in
+ * full.
+ */
+export declare function summarizeTaskViewSelection(view: TaskViewLike): string;

package/dist/lib/task-view-render.js

@@ -18,6 +18,12 @@ exports.EDITABLE_VIEW_PATCH_FIELDS = void 0;
 exports.unshareableViewWarning = unshareableViewWarning;
 exports.immutableViewPatchKeys = immutableViewPatchKeys;
 exports.describeTaskView = describeTaskView;
+exports.summarizeTaskViewSelection = summarizeTaskViewSelection;
+/** `all` is the quick filter that filters nothing; any other one narrows. */
+function narrowingQuickFilter(filters) {
+    const quick = filters.quickFilter;
+    return quick && quick !== 'all' ? quick : undefined;
+}
 /**
  * OSK-4859 — a view created with no active workspace comes back with no
  * `workspaceId`, and the server then refuses to share it
@@ -97,13 +103,20 @@ function describeTaskView(view) {
         add('pinned tasks', `${pinned.length}: ${pinned.join(', ')}`);
     }
     const f = view.filters ?? {};
+    // Every selection field the create schema accepts. `--quick-filter` was a
+    // create flag this renderer never printed, so a saved quick filter was
+    // exactly the kind of selection that "did not take" invisibly.
+    const quick = narrowingQuickFilter(f);
     const filterRows = [
+        ['quick filter', quick ? [quick] : undefined],
         ['statuses', f.statuses],
+        ['status types', f.statusTypes],
         ['priorities', f.priorities],
         ['assignees', f.assignees],
         ['labels', f.labels],
         ['goals', f.goalIds],
         ['projects', f.projectIds],
+        ['cycles', f.cycleIds],
     ];
     let anyFilter = false;
     for (const [label, values] of filterRows) {
@@ -123,3 +136,45 @@ function describeTaskView(view) {
     add('sort', describeShape(view.sort));
     return lines;
 }
+const counted = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+/**
+ * One line saying what a view SELECTS, for a table cell.
+ *
+ * `views list` had a SELECTION column whose value was the word `criteria` for
+ * every view that was not a pinned task list — a kind label sitting where the
+ * reader looks for an answer (dogfood OSK-4646). Values that fit are named
+ * (statuses, priorities, the quick filter, the search); ids are counted, since
+ * a row of UUIDs answers nothing at a glance and `views show` prints them in
+ * full.
+ */
+function summarizeTaskViewSelection(view) {
+    const parts = [];
+    const pinned = view.taskIds ?? [];
+    if (pinned.length)
+        parts.push(counted(pinned.length, 'pinned task'));
+    const spaces = view.spaceIds ?? [];
+    parts.push(spaces.length ? counted(spaces.length, 'space') : 'all spaces');
+    const f = view.filters ?? {};
+    const quick = narrowingQuickFilter(f);
+    if (quick)
+        parts.push(quick);
+    if (f.statuses?.length)
+        parts.push(`status ${f.statuses.join('/')}`);
+    if (f.statusTypes?.length)
+        parts.push(`status type ${f.statusTypes.join('/')}`);
+    if (f.priorities?.length)
+        parts.push(`priority ${f.priorities.join('/')}`);
+    if (f.assignees?.length)
+        parts.push(counted(f.assignees.length, 'assignee'));
+    if (f.labels?.length)
+        parts.push(counted(f.labels.length, 'label'));
+    if (f.goalIds?.length)
+        parts.push(counted(f.goalIds.length, 'goal'));
+    if (f.projectIds?.length)
+        parts.push(counted(f.projectIds.length, 'project'));
+    if (f.cycleIds?.length)
+        parts.push(counted(f.cycleIds.length, 'cycle'));
+    if (f.search)
+        parts.push(`"${f.search}"`);
+    return parts.join(', ');
+}

package/dist/lib/tasks.d.ts

@@ -1,4 +1,30 @@
 import type { ParsedDeliverableCoordinate, ParsedExpectationSpec } from '@skrr-ai/data-provider';
+/**
+ * `--goal` on `tasks update`. `none`, `null` and `clear` detach the goal: PATCH
+ * sends `goalId: null`. Anything else names a goal. `clear` is accepted because
+ * this same command documents it for `--expect`, so it is the spelling a user
+ * reaches for — and it used to be stored as a goal id (OSK-10207).
+ * Undefined means the flag was not passed.
+ */
+export declare function resolveTaskGoalFlag(value: string | undefined): string | null | undefined;
+export declare const TASK_GOAL_NOT_FOUND = "TASK_GOAL_NOT_FOUND";
+/**
+ * The refusal for a goal id that names no goal, in CLI terms.
+ *
+ * The server's sentence carries the API's remedy — "detach the goal with
+ * goalId: null" on update, "leave goalId out" on create — and a CLI user can
+ * type neither. So the goal id THIS command sent is named, with the flag that
+ * gets past the refusal: `--goal none` on update (see `resolveTaskGoalFlag`),
+ * leaving the goal out on create, where no goal is simply the default
+ * (OSK-10219). `goalSource: 'json'` is a create whose id came from
+ * `--from-json` rather than `--goal`.
+ */
+export declare function describeTaskGoalNotFound({ goalId, command, bin, goalSource, }: {
+    goalId: string;
+    command: 'create' | 'update';
+    bin?: string;
+    goalSource?: 'flag' | 'json';
+}): string;
 export declare const TASK_PRIORITIES: readonly ["low", "medium", "high", "critical"];
 /**
  * The kinds `tasks events append --kind` will accept.

package/dist/lib/tasks.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECOGNIZED_TASK_VERDICTS = exports.DELIVERABLE_LIFECYCLE_VALUES = exports.EXPECT_FLAG_HELP = exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = void 0;
+exports.RECOGNIZED_TASK_VERDICTS = exports.DELIVERABLE_LIFECYCLE_VALUES = exports.EXPECT_FLAG_HELP = exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = exports.TASK_GOAL_NOT_FOUND = void 0;
+exports.resolveTaskGoalFlag = resolveTaskGoalFlag;
+exports.describeTaskGoalNotFound = describeTaskGoalNotFound;
 exports.releasePinRepairGuard = releasePinRepairGuard;
 exports.taskUpdateMutationGuard = taskUpdateMutationGuard;
 exports.executionIsolationFromWorktreeFlag = executionIsolationFromWorktreeFlag;
@@ -36,6 +38,41 @@ exports.verdictIsRecognized = verdictIsRecognized;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const prompt_1 = require("./prompt");
 const projects_1 = require("./projects");
+/**
+ * `--goal` on `tasks update`. `none`, `null` and `clear` detach the goal: PATCH
+ * sends `goalId: null`. Anything else names a goal. `clear` is accepted because
+ * this same command documents it for `--expect`, so it is the spelling a user
+ * reaches for — and it used to be stored as a goal id (OSK-10207).
+ * Undefined means the flag was not passed.
+ */
+function resolveTaskGoalFlag(value) {
+    if (value === undefined)
+        return undefined;
+    const v = value.trim();
+    if (!v || ['none', 'null', 'clear'].includes(v.toLowerCase()))
+        return null;
+    return v;
+}
+exports.TASK_GOAL_NOT_FOUND = 'TASK_GOAL_NOT_FOUND';
+/**
+ * The refusal for a goal id that names no goal, in CLI terms.
+ *
+ * The server's sentence carries the API's remedy — "detach the goal with
+ * goalId: null" on update, "leave goalId out" on create — and a CLI user can
+ * type neither. So the goal id THIS command sent is named, with the flag that
+ * gets past the refusal: `--goal none` on update (see `resolveTaskGoalFlag`),
+ * leaving the goal out on create, where no goal is simply the default
+ * (OSK-10219). `goalSource: 'json'` is a create whose id came from
+ * `--from-json` rather than `--goal`.
+ */
+function describeTaskGoalNotFound({ goalId, command, bin = 'skrr', goalSource = 'flag', }) {
+    const find = `Pass an existing goal id (\`${bin} goals list\` shows them)`;
+    if (command === 'update') {
+        return `No goal "${goalId}" exists. ${find}, or detach the task from its goal with \`--goal none\`.`;
+    }
+    const omit = goalSource === 'json' ? 'remove goalId from the --from-json body' : 'leave out --goal';
+    return `No goal "${goalId}" exists, so no task was created. ${find}, or ${omit} to create it without a goal.`;
+}
 exports.TASK_PRIORITIES = ['low', 'medium', 'high', 'critical'];
 const DESCRIPTION_FORMATS = ['html', 'markdown', 'plain'];
 /**

package/dist/lib/views/vocabulary.d.ts

@@ -5,4 +5,4 @@
  * a re-export, not a second CLI vocabulary: adding a saved-view capability is
  * one data-provider registration followed by renderer work on each surface.
  */
-export { SPACE_RENDERABLE_VIEW_TYPES, TASK_RENDERABLE_VIEW_TYPES, VIEW_GROUP_BY_REGISTRY, VIEW_GROUP_BY_VALUES, VIEW_QUICK_FILTER_REGISTRY, VIEW_QUICK_FILTERS, VIEW_SORT_DIRECTIONS, VIEW_SORT_KEY_REGISTRY, VIEW_SORT_KEYS, VIEW_TYPE_REGISTRY, VIEW_TYPES, viewTypesForSurface, } from '@skrr-ai/data-provider';
+export { SPACE_RENDERABLE_VIEW_TYPES, TASK_VIEW_DEFAULT_GROUP_BY, TASK_VIEW_DEFAULT_TYPE, TASK_RENDERABLE_VIEW_TYPES, VIEW_GROUP_BY_REGISTRY, VIEW_GROUP_BY_VALUES, VIEW_QUICK_FILTER_REGISTRY, VIEW_QUICK_FILTERS, VIEW_SORT_DIRECTIONS, VIEW_SORT_KEY_REGISTRY, VIEW_SORT_KEYS, VIEW_TYPE_REGISTRY, VIEW_TYPES, viewTypesForSurface, } from '@skrr-ai/data-provider';

package/dist/lib/views/vocabulary.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.viewTypesForSurface = exports.VIEW_TYPES = exports.VIEW_TYPE_REGISTRY = exports.VIEW_SORT_KEYS = exports.VIEW_SORT_KEY_REGISTRY = exports.VIEW_SORT_DIRECTIONS = exports.VIEW_QUICK_FILTERS = exports.VIEW_QUICK_FILTER_REGISTRY = exports.VIEW_GROUP_BY_VALUES = exports.VIEW_GROUP_BY_REGISTRY = exports.TASK_RENDERABLE_VIEW_TYPES = exports.SPACE_RENDERABLE_VIEW_TYPES = void 0;
+exports.viewTypesForSurface = exports.VIEW_TYPES = exports.VIEW_TYPE_REGISTRY = exports.VIEW_SORT_KEYS = exports.VIEW_SORT_KEY_REGISTRY = exports.VIEW_SORT_DIRECTIONS = exports.VIEW_QUICK_FILTERS = exports.VIEW_QUICK_FILTER_REGISTRY = exports.VIEW_GROUP_BY_VALUES = exports.VIEW_GROUP_BY_REGISTRY = exports.TASK_RENDERABLE_VIEW_TYPES = exports.TASK_VIEW_DEFAULT_TYPE = exports.TASK_VIEW_DEFAULT_GROUP_BY = exports.SPACE_RENDERABLE_VIEW_TYPES = void 0;
 /**
  * CLI parity re-export for persisted task views.
  *
@@ -10,6 +10,8 @@ exports.viewTypesForSurface = exports.VIEW_TYPES = exports.VIEW_TYPE_REGISTRY =
  */
 var data_provider_1 = require("@skrr-ai/data-provider");
 Object.defineProperty(exports, "SPACE_RENDERABLE_VIEW_TYPES", { enumerable: true, get: function () { return data_provider_1.SPACE_RENDERABLE_VIEW_TYPES; } });
+Object.defineProperty(exports, "TASK_VIEW_DEFAULT_GROUP_BY", { enumerable: true, get: function () { return data_provider_1.TASK_VIEW_DEFAULT_GROUP_BY; } });
+Object.defineProperty(exports, "TASK_VIEW_DEFAULT_TYPE", { enumerable: true, get: function () { return data_provider_1.TASK_VIEW_DEFAULT_TYPE; } });
 Object.defineProperty(exports, "TASK_RENDERABLE_VIEW_TYPES", { enumerable: true, get: function () { return data_provider_1.TASK_RENDERABLE_VIEW_TYPES; } });
 Object.defineProperty(exports, "VIEW_GROUP_BY_REGISTRY", { enumerable: true, get: function () { return data_provider_1.VIEW_GROUP_BY_REGISTRY; } });
 Object.defineProperty(exports, "VIEW_GROUP_BY_VALUES", { enumerable: true, get: function () { return data_provider_1.VIEW_GROUP_BY_VALUES; } });