@lumoai/cli 1.0.0

package/dist/cli/src/commands/milestone-list.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMilestoneList = formatMilestoneList;
+exports.milestoneList = milestoneList;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+function formatDate(iso) {
+    if (!iso)
+        return '-';
+    return iso.slice(0, 10);
+}
+/**
+ * Render milestones as fixed-width rows:
+ *   <STATUS>  <target-date or ->  <name>
+ *
+ * Sorted server-side by targetDate asc nulls last, createdAt asc.
+ */
+function formatMilestoneList(rows) {
+    if (rows.length === 0)
+        return 'No milestones.';
+    const statusW = Math.max(...rows.map(r => r.status.length));
+    const dateW = Math.max(...rows.map(r => formatDate(r.targetDate).length));
+    return rows
+        .map(r => `${r.status.padEnd(statusW)}  ${formatDate(r.targetDate).padEnd(dateW)}  ${r.name}`)
+        .join('\n');
+}
+async function milestoneList(options) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let projectId;
+    try {
+        projectId = await (0, resolve_1.resolveProjectId)(base, creds.token, options.project);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${msg}`);
+        return 1;
+    }
+    const res = await fetch(`${base}/api/projects/${projectId}/milestones`, {
+        headers: { Authorization: `Bearer ${creds.token}` },
+    });
+    if (!res.ok) {
+        console.error(`Error: milestone list failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    process.stdout.write(formatMilestoneList(data.milestones) + '\n');
+}

package/dist/cli/src/commands/milestone-show.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMilestoneShow = formatMilestoneShow;
+exports.milestoneShow = milestoneShow;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const format_1 = require("../lib/format");
+function fmtDate(iso) {
+    return iso ? iso.slice(0, 10) : '-';
+}
+function formatMilestoneShow(m, tasks) {
+    const total = m.taskCounts.TODO +
+        m.taskCounts.IN_PROGRESS +
+        m.taskCounts.IN_REVIEW +
+        m.taskCounts.DONE;
+    const lines = [
+        `Milestone:    ${m.name}`,
+        `Status:       ${m.status}`,
+        `Start:        ${fmtDate(m.startDate)}`,
+        `Target:       ${fmtDate(m.targetDate)}`,
+        `Project:      ${m.projectName}`,
+        `Description:`,
+        `  ${m.description && m.description.length > 0 ? m.description : '-'}`,
+        ``,
+        `Tasks:        ${total} total (TODO ${m.taskCounts.TODO} / IN_PROGRESS ${m.taskCounts.IN_PROGRESS} / IN_REVIEW ${m.taskCounts.IN_REVIEW} / DONE ${m.taskCounts.DONE})`,
+    ];
+    if (tasks.length > 0) {
+        lines.push('', (0, format_1.formatTaskListTable)(tasks));
+    }
+    return lines.join('\n');
+}
+async function milestoneShow(identifier, opts) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let milestoneId;
+    try {
+        const resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, identifier, opts.project);
+        milestoneId = resolved.id;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Fetch the milestone (with taskCounts) and the task list in parallel.
+    let milestoneRes;
+    let tasksRes;
+    try {
+        ;
+        [milestoneRes, tasksRes] = await Promise.all([
+            fetch(`${base}/api/milestones/${milestoneId}`, {
+                headers: { Authorization: `Bearer ${creds.token}` },
+            }),
+            fetch(`${base}/api/milestones/${milestoneId}/tasks`, {
+                headers: { Authorization: `Bearer ${creds.token}` },
+            }),
+        ]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (milestoneRes.status === 401 || tasksRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!milestoneRes.ok) {
+        console.error(`Error: milestone show failed (HTTP ${milestoneRes.status})`);
+        return 1;
+    }
+    if (!tasksRes.ok) {
+        console.error(`Error: milestone tasks failed (HTTP ${tasksRes.status})`);
+        return 1;
+    }
+    const { milestone } = (await milestoneRes.json());
+    const { tasks } = (await tasksRes.json());
+    // Look up project display name. If the caller passed `--project <ref>`
+    // we already know it; otherwise hit /api/projects once.
+    let projectName = opts.project ?? '';
+    if (!projectName) {
+        const pr = await fetch(`${base}/api/projects`, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+        if (pr.ok) {
+            const { projects } = (await pr.json());
+            projectName = projects.find(p => p.id === milestone.projectId)?.name ?? '';
+        }
+    }
+    process.stdout.write(formatMilestoneShow({
+        id: milestone.id,
+        name: milestone.name,
+        status: milestone.status,
+        startDate: milestone.startDate,
+        targetDate: milestone.targetDate,
+        description: milestone.description,
+        projectName,
+        taskCounts: milestone.taskCounts,
+    }, tasks) + '\n');
+}

package/dist/cli/src/commands/milestone-update.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMilestoneStatus = normalizeMilestoneStatus;
+exports.buildMilestoneUpdatePayload = buildMilestoneUpdatePayload;
+exports.formatMilestoneUpdateSummary = formatMilestoneUpdateSummary;
+exports.milestoneUpdate = milestoneUpdate;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+const ALLOWED_STATUSES = [
+    'PLANNED',
+    'ACTIVE',
+    'COMPLETED',
+    'CANCELLED',
+];
+function normalizeMilestoneStatus(value) {
+    if (!value)
+        return null;
+    const upper = value.toUpperCase().replace(/-/g, '_');
+    return ALLOWED_STATUSES.includes(upper)
+        ? upper
+        : null;
+}
+function buildMilestoneUpdatePayload(opts) {
+    const payload = {};
+    const flagsGiven = [];
+    if (opts.name !== undefined) {
+        payload.name = opts.name;
+        flagsGiven.push('--name');
+    }
+    if (opts.description !== undefined) {
+        payload.description = opts.description === '' ? null : opts.description;
+        flagsGiven.push('--description');
+    }
+    if (opts.status !== undefined) {
+        payload.status = opts.status;
+        flagsGiven.push('--status');
+    }
+    if (opts.start !== undefined) {
+        payload.startDate = opts.start === '' ? null : opts.start;
+        flagsGiven.push('--start');
+    }
+    if (opts.target !== undefined) {
+        payload.targetDate = opts.target === '' ? null : opts.target;
+        flagsGiven.push('--target');
+    }
+    return { payload, flagsGiven };
+}
+function fmtDate(v) {
+    if (v === null)
+        return '∅';
+    if (v === undefined)
+        return '-';
+    return v.slice(0, 10);
+}
+function formatMilestoneUpdateSummary(before, after) {
+    const changes = [];
+    if (after.name !== undefined && after.name !== before.name) {
+        changes.push(`name "${before.name}" → "${after.name}"`);
+    }
+    if (after.description !== undefined) {
+        changes.push(after.description === null ? 'description → ∅' : 'description updated');
+    }
+    if (after.status !== undefined && after.status !== before.status) {
+        changes.push(`status ${before.status} → ${after.status}`);
+    }
+    if (after.startDate !== undefined) {
+        changes.push(`start → ${fmtDate(after.startDate)}`);
+    }
+    if (after.targetDate !== undefined) {
+        changes.push(`target → ${fmtDate(after.targetDate)}`);
+    }
+    return `Updated milestone "${before.name}": ${changes.join(', ')}`;
+}
+async function milestoneUpdate(identifier, opts) {
+    // Validate status flag eagerly.
+    let normalizedStatus;
+    if (opts.status !== undefined) {
+        const n = normalizeMilestoneStatus(opts.status);
+        if (!n) {
+            console.error(`Error: invalid status "${opts.status}". Allowed: planned, active, completed, cancelled`);
+            return 1;
+        }
+        normalizedStatus = n;
+    }
+    const { payload, flagsGiven } = buildMilestoneUpdatePayload({
+        ...opts,
+        ...(normalizedStatus !== undefined && { status: normalizedStatus }),
+    });
+    if (flagsGiven.length === 0) {
+        console.error('Error: provide at least one field to update (--name, --description, --status, --start, --target)');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    let milestoneId;
+    try {
+        const resolved = await (0, resolve_1.resolveMilestoneId)(base, creds.token, identifier, opts.project);
+        milestoneId = resolved.id;
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Fetch current values so we can render a delta summary. Wrap network in
+    // try/catch + check 401 explicitly to match milestone-create / task-create.
+    let beforeRes;
+    try {
+        beforeRes = await fetch(`${base}/api/milestones/${milestoneId}`, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (beforeRes.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!beforeRes.ok) {
+        console.error(`Error: milestone fetch failed (HTTP ${beforeRes.status})`);
+        return 1;
+    }
+    const { milestone: before } = (await beforeRes.json());
+    let res;
+    try {
+        res = await fetch(`${base}/api/milestones/${milestoneId}`, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        let errMsg = `milestone update failed (HTTP ${res.status})`;
+        try {
+            const errBody = (await res.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // body wasn't JSON; keep the status-only message
+        }
+        console.error(`Error: ${errMsg}`);
+        return 1;
+    }
+    process.stdout.write(formatMilestoneUpdateSummary(before, payload) + '\n');
+}

package/dist/cli/src/commands/project-list.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProjectList = formatProjectList;
+exports.projectList = projectList;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+/**
+ * Render projects as `slug-style-name  Display Name` lines. The slug form
+ * matches what `lumo task create --project <ref>` accepts (slugify(name)),
+ * so users can copy a slug straight into the create flag.
+ *
+ * Slug source of truth: `cli/src/lib/resolve.ts` (mirrors server's
+ * `lib/utils/slugify.ts`). Keep that single copy in sync with the server.
+ */
+function formatProjectList(projects) {
+    if (projects.length === 0)
+        return 'No projects.';
+    const rows = projects
+        .filter(p => !p.isIdea)
+        .map(p => ({ slug: (0, resolve_1.slugify)(p.name), name: p.name }));
+    if (rows.length === 0)
+        return 'No projects.';
+    const w = Math.max(...rows.map(r => r.slug.length));
+    return rows.map(r => `${r.slug.padEnd(w)}  ${r.name}`).join('\n');
+}
+async function projectList() {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/projects`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: project list failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    process.stdout.write(formatProjectList(data.projects) + '\n');
+}

package/dist/cli/src/commands/session-attach.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionAttach = sessionAttach;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+/**
+ * `lumo session attach <identifier>` — bind the currently-running
+ * Claude Code session to a task.
+ *
+ * Required environment: `CLAUDE_CODE_SESSION_ID` (set automatically by
+ * Claude Code). Must be invoked from inside a Claude Code session — there
+ * is no longer a global "current task" pointer for terminals outside CC.
+ *
+ * The binding lives entirely on the server (`Session.taskId`); subsequent
+ * hooks read it back via the session row. The CLI keeps no local sentinel.
+ */
+async function sessionAttach(identifier) {
+    if (!identifier) {
+        console.error('Error: missing <identifier>. Usage: lumo session attach <LUM-42>');
+        return 1;
+    }
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    if (!sessionId) {
+        console.error('Error: $CLAUDE_CODE_SESSION_ID is not set.\n' +
+            '`lumo session attach` must be run inside a Claude Code session.');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${creds.token}`,
+            },
+            body: JSON.stringify({ taskIdentifier: identifier }),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (res.status === 404) {
+        let message = 'Not found';
+        try {
+            const body = (await res.json());
+            if (body.error)
+                message = body.error;
+        }
+        catch {
+            // fall through
+        }
+        console.error(`Error: ${message}`);
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: bind-task failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const result = (await res.json());
+    console.log(`Attached session ${sessionId} to ${result.taskIdentifier} "${result.taskTitle}"`);
+    console.log(`Re-tagged ${result.retaggedEventCount} previously-untagged event${result.retaggedEventCount === 1 ? '' : 's'} in this session.`);
+    if (result.memorySection !== '') {
+        console.log('');
+        console.log(result.memorySection);
+    }
+}

package/dist/cli/src/commands/session-detach.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionDetach = sessionDetach;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+/**
+ * `lumo session detach` — clear the task binding on the current Claude Code
+ * session. Idempotent: re-detaching an already-unbound session reports
+ * "already unbound" instead of erroring.
+ *
+ * Past HookEvent rows keep their original taskId — only future events on
+ * this session will be unbound. Re-attach later with `session attach
+ * <LUM-N>` to point the session at a different task.
+ */
+async function sessionDetach() {
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    if (!sessionId) {
+        console.error('Error: $CLAUDE_CODE_SESSION_ID is not set.\n' +
+            '`lumo session detach` must be run inside a Claude Code session.');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (res.status === 404) {
+        process.stdout.write(`Session ${sessionId} has no server-side state yet — nothing to detach.\n`);
+        return;
+    }
+    if (!res.ok) {
+        console.error(`Error: session detach failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    if (data.alreadyUnbound) {
+        process.stdout.write(`Session ${sessionId} was already unbound.\n`);
+        return;
+    }
+    process.stdout.write(`Detached session ${sessionId} from ${data.previousTaskIdentifier} "${data.previousTaskTitle}".\n`);
+}

package/dist/cli/src/commands/session-status.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionStatus = sessionStatus;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+async function sessionStatus() {
+    const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
+    if (!sessionId) {
+        console.error('Error: $CLAUDE_CODE_SESSION_ID is not set.\n' +
+            '`lumo session status` must be run inside a Claude Code session.');
+        return 1;
+    }
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { Authorization: `Bearer ${creds.token}` },
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    if (res.status === 404) {
+        // Session row only materializes after the first hook event or an
+        // explicit `session attach`. Until then there's nothing to report.
+        process.stdout.write(`Session ${sessionId} has no server-side state yet (no task bound, no hook events).\n` +
+            `Run \`lumo session attach <LUM-N>\` to bind it.\n`);
+        return;
+    }
+    if (!res.ok) {
+        console.error(`Error: session status failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const data = (await res.json());
+    if (data.taskIdentifier && data.taskTitle) {
+        process.stdout.write(`Session ${sessionId}\n` +
+            `  Bound to:  ${data.taskIdentifier} "${data.taskTitle}"\n` +
+            `  Events:    ${data.eventCount}\n`);
+    }
+    else {
+        process.stdout.write(`Session ${sessionId}\n` +
+            `  Bound to:  (no task)\n` +
+            `  Events:    ${data.eventCount}\n`);
+    }
+}

package/dist/cli/src/commands/sprint-add.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sprintAdd = sprintAdd;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const resolve_1 = require("../lib/resolve");
+async function sprintAdd(identifier, taskIdentifier, opts) {
+    const creds = (0, config_1.readCredentials)();
+    if (!creds) {
+        console.error('Error: not logged in. Run `lumo auth login` first.');
+        return 1;
+    }
+    const envUrl = process.env.LUMO_API_URL?.trim();
+    const apiUrl = envUrl && envUrl.length > 0 ? envUrl : creds.apiUrl;
+    const base = (0, api_1.trimTrailingSlash)(apiUrl);
+    const workspaceSlug = creds.workspaceSlug ?? '';
+    let resolved;
+    try {
+        resolved = await (0, resolve_1.resolveSprintId)(base, creds.token, identifier, opts.team, workspaceSlug);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Resolve task → id via /api/tasks/by-identifier/<LUM-N>
+    const tr = await fetch(`${base}/api/tasks/by-identifier/${encodeURIComponent(taskIdentifier)}`, { headers: { Authorization: `Bearer ${creds.token}` } });
+    if (!tr.ok) {
+        console.error(`Error: task ${taskIdentifier} not found (HTTP ${tr.status})`);
+        return 1;
+    }
+    const { task } = (await tr.json());
+    let res;
+    try {
+        res = await fetch(`${base}/api/sprints/${resolved.id}/tasks`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ taskId: task.id }),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (!res.ok) {
+        let errMsg = `sprint add failed (HTTP ${res.status})`;
+        try {
+            const errBody = (await res.json());
+            if (errBody.error)
+                errMsg = errBody.error;
+        }
+        catch {
+            // ignore
+        }
+        console.error(`Error: ${errMsg}`);
+        return 1;
+    }
+    process.stdout.write(`Added ${taskIdentifier} to sprint #${resolved.number}\n`);
+}