@clipboard-health/groundcrew 4.20.1 → 4.21.0

package/README.md

@@ -93,6 +93,9 @@ crew init [--global | --local] [--force] [--dry-run]     # create a crew.config.
           [--project-dir <dir>] [--repo <repo>]...
           [--runner <auto|safehouse|sdx|none>] [--model <claude|codex>]
 crew doctor                                              # check setup
+crew task list [--source <name>]                         # list tasks across sources
+crew task get <TASK> [--source <name>] [--prompt]        # inspect one task or its prompt
+crew task create "Title" --source <name> --agent <name>  # create a source task
 crew status [<TASK>]                                   # inspect current state or one task
 crew run [--watch]                                       # one-shot or --watch forever
 crew start <TASK>                                      # provision + launch one task now

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AA+QA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAwCvD"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAqRA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAwCvD"}

package/dist/cli.js

@@ -8,6 +8,7 @@ import { resumeWorkspaceCli } from "./commands/resumeWorkspace.js";
 import { setupWorkspaceCli } from "./commands/setupWorkspace.js";
 import { sourceCli } from "./commands/source.js";
 import { statusCli } from "./commands/status.js";
+import { taskCli } from "./commands/task.js";
 import { createDefaultUpgradeCliOptions, upgradeCli } from "./commands/upgrade.js";
 import { errorMessage, parseDryRunPositionals, readEnvironmentVariable, readTaskArgument, setVerbose, writeError, writeOutput, } from "./lib/util.js";
 const REMOVED_SANDBOX_COMMAND_MESSAGE = [
@@ -134,6 +135,11 @@ const SUBCOMMANDS = {
         usage: "<list|verify> [...]",
         invoke: sourceCli,
     },
+    task: {
+        summary: "List, get, and create tasks across configured sources",
+        usage: "<list|get|create> [...]",
+        invoke: taskCli,
+    },
     status: {
         summary: "Print read-only groundcrew state, or one task's local/Linear status",
         usage: "[<task>]",

package/dist/commands/task.d.ts

@@ -0,0 +1,2 @@
+export declare function taskCli(argv: string[]): Promise<void>;
+//# sourceMappingURL=task.d.ts.map

package/dist/commands/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/commands/task.ts"],"names":[],"mappings":"AAmmBA,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAe3D"}

package/dist/commands/task.js

@@ -0,0 +1,488 @@
+import { buildSources, sourcesFromConfig } from "../lib/buildSources.js";
+import { loadConfig } from "../lib/config.js";
+import { naturalIdFromCanonical, } from "../lib/taskSource.js";
+import { writeOutput } from "../lib/util.js";
+const TASK_USAGE = `Usage: crew task <subcommand>
+
+Subcommands:
+  list [options]                  List tasks across configured sources
+  get <task-id> [options]         Get one task
+  create "Short title" [options]  Create one task`;
+const LIST_USAGE = `Usage: crew task list [options]
+
+Options:
+  --source <name>      Limit to one source.
+  --status <status>    Filter by status. Repeatable.
+  --agent <name>       Filter by agent/model.
+  --repo <owner/repo>  Filter by repository.
+  --blocked            Show only blocked tasks.
+  --unblocked          Show only unblocked tasks.
+  --json               Print normalized task JSON.
+  --limit <n>          Limit output.`;
+const GET_USAGE = `Usage: crew task get <task-id> [options]
+
+Options:
+  --source <name>  Resolve a source-native ID against a specific source.
+  --json           Print normalized task JSON.
+  --prompt         Print only the task description/prompt.`;
+const CREATE_USAGE = `Usage: crew task create "Short title" --source <source> --agent <agent> [options]`;
+const CANONICAL_STATUSES = [
+    "todo",
+    "in-progress",
+    "in-review",
+    "done",
+    "other",
+];
+const CANONICAL_STATUS_SET = new Set(CANONICAL_STATUSES);
+function isCanonicalStatus(value) {
+    return CANONICAL_STATUS_SET.has(value);
+}
+function readOptionValue(argv, index, option, usage) {
+    const value = argv[index + 1];
+    if (value === undefined) {
+        throw new Error(`crew task: ${option} requires a value\n${usage}`);
+    }
+    return value;
+}
+const CREATE_VALUE_HANDLERS = {
+    "--source": (state, value) => {
+        state.sourceName = value;
+    },
+    "--agent": (state, value) => {
+        state.agent = value;
+    },
+    "--repo": (state, value) => {
+        state.repository = value;
+    },
+    "--id": (state, value) => {
+        state.id = value;
+    },
+    "--priority": (state, value) => {
+        state.priority = value;
+    },
+    "--project": (state, value) => {
+        state.projects.push(value);
+    },
+    "--context": (state, value) => {
+        state.contexts.push(value);
+    },
+    "--dep": (state, value) => {
+        state.dependencies.push(value);
+    },
+    "--due": (state, value) => {
+        state.due = value;
+    },
+    "--rec": (state, value) => {
+        state.recurrence = value;
+    },
+    "--prompt-file": (state, value) => {
+        state.promptFile = value;
+    },
+    "--description": (state, value) => {
+        state.description = value;
+    },
+};
+function parseLimit(raw) {
+    const limit = Number.parseInt(raw, 10);
+    if (!Number.isInteger(limit) || limit < 1 || String(limit) !== raw) {
+        throw new Error("crew task list: --limit must be a positive integer");
+    }
+    return limit;
+}
+function parseListOptions(argv) {
+    const options = {
+        statuses: [],
+        blocked: false,
+        unblocked: false,
+        json: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        /* v8 ignore next 3 @preserve -- index is bounded by argv.length; guard exists for noUncheckedIndexedAccess */
+        if (argument === undefined) {
+            continue;
+        }
+        if (argument === "--source") {
+            options.sourceName = readOptionValue(argv, index, argument, LIST_USAGE);
+            index += 1;
+            continue;
+        }
+        if (argument === "--status") {
+            const status = readOptionValue(argv, index, argument, LIST_USAGE);
+            if (!isCanonicalStatus(status)) {
+                throw new Error(`crew task list: unknown status "${status}" (expected ${CANONICAL_STATUSES.join(", ")})`);
+            }
+            options.statuses.push(status);
+            index += 1;
+            continue;
+        }
+        if (argument === "--agent") {
+            options.agent = readOptionValue(argv, index, argument, LIST_USAGE);
+            index += 1;
+            continue;
+        }
+        if (argument === "--repo") {
+            options.repository = readOptionValue(argv, index, argument, LIST_USAGE);
+            index += 1;
+            continue;
+        }
+        if (argument === "--blocked") {
+            options.blocked = true;
+            continue;
+        }
+        if (argument === "--unblocked") {
+            options.unblocked = true;
+            continue;
+        }
+        if (argument === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (argument === "--limit") {
+            options.limit = parseLimit(readOptionValue(argv, index, argument, LIST_USAGE));
+            index += 1;
+            continue;
+        }
+        throw new Error(`crew task list: unknown argument: ${argument}\n${LIST_USAGE}`);
+    }
+    if (options.blocked && options.unblocked) {
+        throw new Error("crew task list: --blocked and --unblocked are mutually exclusive");
+    }
+    return options;
+}
+function parseGetOptions(argv) {
+    const positionals = [];
+    let sourceName;
+    let json = false;
+    let prompt = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        /* v8 ignore next 3 @preserve -- index is bounded by argv.length; guard exists for noUncheckedIndexedAccess */
+        if (argument === undefined) {
+            continue;
+        }
+        if (argument === "--source") {
+            sourceName = readOptionValue(argv, index, argument, GET_USAGE);
+            index += 1;
+            continue;
+        }
+        if (argument === "--json") {
+            json = true;
+            continue;
+        }
+        if (argument === "--prompt") {
+            prompt = true;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            throw new Error(`crew task get: unknown option: ${argument}\n${GET_USAGE}`);
+        }
+        positionals.push(argument);
+    }
+    const [taskId, ...extras] = positionals;
+    if (taskId === undefined || extras.length > 0) {
+        throw new Error(GET_USAGE);
+    }
+    if (json && prompt) {
+        throw new Error("crew task get: --json and --prompt are mutually exclusive");
+    }
+    return { taskId, ...(sourceName === undefined ? {} : { sourceName }), json, prompt };
+}
+function parseCreateOptions(argv) {
+    const state = {
+        positionals: [],
+        projects: [],
+        contexts: [],
+        dependencies: [],
+        edit: false,
+        json: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        /* v8 ignore next 3 @preserve -- index is bounded by argv.length; guard exists for noUncheckedIndexedAccess */
+        if (argument === undefined) {
+            continue;
+        }
+        const valueHandler = CREATE_VALUE_HANDLERS[argument];
+        if (valueHandler !== undefined) {
+            valueHandler(state, readOptionValue(argv, index, argument, CREATE_USAGE));
+            index += 1;
+            continue;
+        }
+        if (argument === "--edit") {
+            state.edit = true;
+            continue;
+        }
+        if (argument === "--json") {
+            state.json = true;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            throw new Error(`crew task create: unknown option: ${argument}\n${CREATE_USAGE}`);
+        }
+        state.positionals.push(argument);
+    }
+    const [title, ...extras] = state.positionals;
+    if (title === undefined || extras.length > 0) {
+        throw new Error(`${CREATE_USAGE}\nQuote multi-word titles as one argument.`);
+    }
+    if (state.sourceName === undefined) {
+        throw new Error("crew task create: --source is required");
+    }
+    if (state.agent === undefined) {
+        throw new Error("crew task create: --agent is required");
+    }
+    const input = {
+        title,
+        agent: state.agent,
+        projects: state.projects,
+        contexts: state.contexts,
+        dependencies: state.dependencies,
+        edit: state.edit,
+        ...(state.repository === undefined ? {} : { repository: state.repository }),
+        ...(state.id === undefined ? {} : { id: state.id }),
+        ...(state.priority === undefined ? {} : { priority: state.priority }),
+        ...(state.due === undefined ? {} : { due: state.due }),
+        ...(state.recurrence === undefined ? {} : { recurrence: state.recurrence }),
+        ...(state.promptFile === undefined ? {} : { promptFile: state.promptFile }),
+        ...(state.description === undefined ? {} : { description: state.description }),
+    };
+    return { title, sourceName: state.sourceName, input, json: state.json };
+}
+async function loadTaskSources() {
+    const config = await loadConfig();
+    return await buildSources(sourcesFromConfig(config), { globalConfig: config });
+}
+function findSource(sources, sourceName) {
+    const source = sources.find((candidate) => candidate.name === sourceName);
+    if (source === undefined) {
+        throw new Error(`crew task: no source named "${sourceName}"`);
+    }
+    return source;
+}
+function taskIsBlocked(task) {
+    return task.hasMoreBlockers || task.blockers.some((blocker) => blocker.status !== "done");
+}
+function filterTasks(tasks, options) {
+    let filtered = [...tasks];
+    if (options.statuses.length > 0) {
+        filtered = filtered.filter((task) => options.statuses.includes(task.status));
+    }
+    if (options.agent !== undefined) {
+        filtered = filtered.filter((task) => task.model === options.agent);
+    }
+    if (options.repository !== undefined) {
+        filtered = filtered.filter((task) => task.repository === options.repository);
+    }
+    if (options.blocked) {
+        filtered = filtered.filter(taskIsBlocked);
+    }
+    if (options.unblocked) {
+        filtered = filtered.filter((task) => !taskIsBlocked(task));
+    }
+    if (options.limit !== undefined) {
+        filtered = filtered.slice(0, options.limit);
+    }
+    return filtered;
+}
+function printableTask(task) {
+    return {
+        id: task.id,
+        source: task.source,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+        repository: task.repository,
+        model: task.model,
+        assignee: task.assignee,
+        updatedAt: task.updatedAt,
+        blockers: task.blockers,
+        hasMoreBlockers: task.hasMoreBlockers,
+        ...(task.url === undefined ? {} : { url: task.url }),
+        ...(task.priority === undefined ? {} : { priority: task.priority }),
+    };
+}
+function writeJson(tasks) {
+    writeOutput(JSON.stringify(tasks.map(printableTask), null, 2));
+}
+function writeTaskJson(task) {
+    writeOutput(JSON.stringify(printableTask(task), null, 2));
+}
+function writeTaskTable(tasks) {
+    if (tasks.length === 0) {
+        writeOutput("(no tasks)");
+        return;
+    }
+    const rows = tasks.map((task) => ({
+        id: task.id,
+        status: task.status,
+        agent: task.model ?? "-",
+        repository: task.repository ?? "-",
+        blocked: taskIsBlocked(task) ? "yes" : "no",
+        title: task.title,
+    }));
+    const idWidth = Math.max(2, ...rows.map((row) => row.id.length));
+    const statusWidth = Math.max(6, ...rows.map((row) => row.status.length));
+    const agentWidth = Math.max(5, ...rows.map((row) => row.agent.length));
+    const repositoryWidth = Math.max(4, ...rows.map((row) => row.repository.length));
+    writeOutput([
+        "ID".padEnd(idWidth),
+        "STATUS".padEnd(statusWidth),
+        "AGENT".padEnd(agentWidth),
+        "REPO".padEnd(repositoryWidth),
+        "BLOCKED",
+        "TITLE",
+    ].join("  "));
+    for (const row of rows) {
+        writeOutput([
+            row.id.padEnd(idWidth),
+            row.status.padEnd(statusWidth),
+            row.agent.padEnd(agentWidth),
+            row.repository.padEnd(repositoryWidth),
+            row.blocked.padEnd(7),
+            row.title,
+        ].join("  "));
+    }
+}
+function canonicalParts(taskId) {
+    const colonIndex = taskId.indexOf(":");
+    if (colonIndex === -1) {
+        return undefined;
+    }
+    const sourceName = taskId.slice(0, colonIndex);
+    const naturalId = taskId.slice(colonIndex + 1);
+    if (sourceName.length === 0 || naturalId.length === 0) {
+        throw new Error(`crew task get: invalid canonical task id "${taskId}"`);
+    }
+    return { sourceName, naturalId };
+}
+async function taskFromSource(source, naturalId) {
+    return await source.getTask(naturalId);
+}
+async function resolveTask(sources, taskId, sourceName) {
+    const canonical = canonicalParts(taskId);
+    if (canonical !== undefined) {
+        if (sourceName !== undefined && sourceName !== canonical.sourceName) {
+            throw new Error(`crew task get: canonical id "${taskId}" already names source "${canonical.sourceName}"`);
+        }
+        const source = findSource(sources, canonical.sourceName);
+        const task = await taskFromSource(source, canonical.naturalId);
+        if (task === null) {
+            throw new Error(`Task ${taskId} not found in source "${source.name}".`);
+        }
+        return task;
+    }
+    if (sourceName !== undefined) {
+        const source = findSource(sources, sourceName);
+        const task = await taskFromSource(source, taskId);
+        if (task === null) {
+            throw new Error(`Task ${taskId} not found in source "${source.name}".`);
+        }
+        return task;
+    }
+    const results = await Promise.allSettled(sources.map(async (source) => await taskFromSource(source, taskId)));
+    const matches = [];
+    const rejections = [];
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            if (result.value !== null) {
+                matches.push(result.value);
+            }
+            continue;
+        }
+        rejections.push(result.reason);
+    }
+    if (matches.length === 0) {
+        if (rejections.length > 0) {
+            throw rejections[0];
+        }
+        throw new Error(`Task ${taskId} not found across configured sources.`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`Task id "${taskId}" matched multiple sources: ${matches.map((task) => task.id).join(", ")}. Re-run with a canonical id or --source <name>.`);
+    }
+    const [match] = matches;
+    /* v8 ignore next 3 @preserve -- matches.length was checked above; guard exists for noUncheckedIndexedAccess */
+    if (match === undefined) {
+        throw new Error(`Task ${taskId} not found across configured sources.`);
+    }
+    return match;
+}
+function writeTaskDetails(task) {
+    writeOutput(task.id);
+    writeOutput(`title: ${task.title}`);
+    writeOutput(`status: ${task.status}`);
+    writeOutput(`source: ${task.source}`);
+    if (task.repository !== undefined) {
+        writeOutput(`repo: ${task.repository}`);
+    }
+    if (task.model !== undefined) {
+        writeOutput(`agent: ${task.model}`);
+    }
+    if (task.url !== undefined) {
+        writeOutput(`url: ${task.url}`);
+    }
+    if (task.blockers.length > 0) {
+        writeOutput(`blockers: ${task.blockers.map((blocker) => `${naturalIdFromCanonical(blocker.id)}(${blocker.status})`).join(", ")}`);
+    }
+    if (task.description.trim().length > 0) {
+        writeOutput("");
+        writeOutput(task.description);
+    }
+}
+async function taskListCli(argv) {
+    const options = parseListOptions(argv);
+    const sources = await loadTaskSources();
+    const selectedSources = options.sourceName === undefined ? sources : [findSource(sources, options.sourceName)];
+    const sourceTasks = await Promise.all(selectedSources.map(async (source) => await source.listTasks()));
+    const tasks = filterTasks(sourceTasks.flat(), options);
+    if (options.json) {
+        writeJson(tasks);
+        return;
+    }
+    writeTaskTable(tasks);
+}
+async function taskGetCli(argv) {
+    const options = parseGetOptions(argv);
+    const sources = await loadTaskSources();
+    const task = await resolveTask(sources, options.taskId, options.sourceName);
+    if (options.prompt) {
+        writeOutput(task.description);
+        return;
+    }
+    if (options.json) {
+        writeTaskJson(task);
+        return;
+    }
+    writeTaskDetails(task);
+}
+async function taskCreateCli(argv) {
+    const options = parseCreateOptions(argv);
+    const sources = await loadTaskSources();
+    const source = findSource(sources, options.sourceName);
+    if (source.createTask === undefined) {
+        throw new Error(`crew task create: source "${source.name}" does not support task creation`);
+    }
+    const created = await source.createTask(options.input);
+    if (options.json) {
+        writeTaskJson(created);
+        return;
+    }
+    writeOutput(created.id);
+}
+export async function taskCli(argv) {
+    const [verb, ...rest] = argv;
+    if (verb === "list") {
+        await taskListCli(rest);
+        return;
+    }
+    if (verb === "get") {
+        await taskGetCli(rest);
+        return;
+    }
+    if (verb === "create") {
+        await taskCreateCli(rest);
+        return;
+    }
+    throw new Error(TASK_USAGE);
+}

package/dist/lib/adapters/linear/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/linear/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAIL,KAAK,KAAK,IAAI,cAAc,EAG5B,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAIL,KAAK,KAAK,IAAI,WAAW,EAE1B,MAAM,YAAY,CAAC;AACpB,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,YAAY,EAAE,MAAM,CAAC;CACtB;AAmDD,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,iBAA+C,GAC3D,cAAc,CA4BhB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,cAAc,GACtB,UAAU,CAiGZ"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/linear/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAIL,KAAK,KAAK,IAAI,cAAc,EAG5B,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,EAIL,KAAK,KAAK,IAAI,WAAW,EAE1B,MAAM,YAAY,CAAC;AACpB,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,YAAY,EAAE,MAAM,CAAC;CACtB;AA2DD,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,iBAA+C,GAC3D,cAAc,CA4BhB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,cAAc,GACtB,UAAU,CAwHZ"}

package/dist/lib/adapters/linear/factory.js

@@ -51,6 +51,11 @@ function toCanonicalParentSkip(skip, sourceName) {
         childCount: skip.childCount,
     };
 }
+function isLinearNotFoundError(error, naturalId) {
+    return (error instanceof Error &&
+        error.message.startsWith(`Task ${naturalId.toUpperCase()} `) &&
+        error.message.includes("not found"));
+}
 export function toCanonicalIssue(linearIssue, sourceName, statusNames = DEFAULT_LINEAR_STATUS_NAMES) {
     const sourceRef = {
         uuid: linearIssue.uuid,
@@ -106,51 +111,73 @@ export function createLinearTaskSource(config, context) {
         return cachedIssueStatusUpdater;
     }
     let lastParentSkips = [];
+    async function listTasks() {
+        const state = await getBoardSource().fetch();
+        lastParentSkips = state.parentSkips.map((skip) => toCanonicalParentSkip(skip, sourceName));
+        return state.issues.map((linearIssue) => toCanonicalIssue(linearIssue, sourceName, statusNames));
+    }
+    async function getTask(naturalId) {
+        let resolved;
+        try {
+            resolved = await fetchResolvedIssue({
+                client: getClient(),
+                config: globalConfig,
+                task: naturalId,
+            });
+        }
+        catch (error) {
+            if (isLinearNotFoundError(error, naturalId)) {
+                return null;
+            }
+            throw error;
+        }
+        const sourceRef = {
+            uuid: resolved.uuid,
+            statusId: resolved.statusId,
+            teamId: resolved.teamId,
+            stateType: resolved.stateType,
+            nativeStatus: resolved.status,
+        };
+        return {
+            id: toCanonicalId(sourceName, naturalId),
+            source: sourceName,
+            title: resolved.title,
+            description: resolved.description,
+            status: canonicalStatusFromLinearState({
+                nativeStatus: resolved.status,
+                stateType: resolved.stateType,
+                statusNames,
+            }),
+            repository: resolved.repository,
+            model: resolved.model,
+            assignee: resolved.assignee,
+            updatedAt: resolved.updatedAt,
+            blockers: resolved.blockers.map((b) => toCanonicalBlocker(b, sourceName, statusNames)),
+            hasMoreBlockers: resolved.hasMoreBlockers,
+            url: resolved.url,
+            ...(resolved.priority === 0 ? {} : { priority: resolved.priority }),
+            sourceRef,
+        };
+    }
     return {
         name: sourceName,
         async verify() {
             await getBoardSource().verify();
         },
+        async listTasks() {
+            return await listTasks();
+        },
+        async getTask(naturalId) {
+            return await getTask(naturalId);
+        },
         async fetch() {
-            const state = await getBoardSource().fetch();
-            lastParentSkips = state.parentSkips.map((skip) => toCanonicalParentSkip(skip, sourceName));
-            return state.issues.map((linearIssue) => toCanonicalIssue(linearIssue, sourceName, statusNames));
+            return await listTasks();
         },
         async fetchParentSkips() {
             return lastParentSkips;
         },
         async resolveOne(naturalId) {
-            const resolved = await fetchResolvedIssue({
-                client: getClient(),
-                config: globalConfig,
-                task: naturalId,
-            });
-            const sourceRef = {
-                uuid: resolved.uuid,
-                statusId: resolved.statusId,
-                teamId: resolved.teamId,
-                stateType: resolved.stateType,
-                nativeStatus: resolved.status,
-            };
-            return {
-                id: toCanonicalId(sourceName, naturalId),
-                source: sourceName,
-                title: resolved.title,
-                description: resolved.description,
-                status: canonicalStatusFromLinearState({
-                    nativeStatus: resolved.status,
-                    stateType: resolved.stateType,
-                    statusNames,
-                }),
-                repository: resolved.repository,
-                model: resolved.model,
-                assignee: "Unassigned",
-                updatedAt: new Date().toISOString(),
-                blockers: [],
-                hasMoreBlockers: false,
-                url: resolved.url,
-                sourceRef,
-            };
+            return (await getTask(naturalId)) ?? undefined;
         },
         async markInProgress(issue) {
             // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- by the Linear adapter's contract, every Issue it produces carries a LinearSourceRef in sourceRef

package/dist/lib/adapters/linear/fetch.d.ts

@@ -116,7 +116,12 @@ interface ResolvedIssue {
     stateType: string;
     status: string;
     statusId: string;
+    assignee: string;
+    updatedAt: string;
+    blockers: Blocker[];
+    hasMoreBlockers: boolean;
     url: string;
+    priority: number;
 }
 export interface RawLinearIssue {
     uuid: string;
@@ -130,6 +135,8 @@ export interface RawLinearIssue {
     stateName: string;
     stateType: string;
     stateId: string;
+    assignee: string;
+    updatedAt: string;
     blockers: Blocker[];
     hasMoreBlockers: boolean;
     /**
@@ -141,6 +148,8 @@ export interface RawLinearIssue {
     hasChildren: boolean;
     /** Linear `Issue.url` — direct web link to the task. */
     url: string;
+    /** Linear priority: 1=Urgent, 2=High, 3=Medium, 4=Low, 0=No priority. */
+    priority: number;
 }
 export declare function fetchBlockersForTask(arguments_: {
     client: LinearClient;