@awebai/oats 0.29.4 → 0.30.1

package/capabilities/oats-jira/skills/jira-tasks/SKILL.md

@@ -1,179 +0,0 @@
----
-name: jira-tasks
-description: >-
-  Jira task tracking and agent roster protocol for OATS agents. Use when you
-  are an agent instance working an epic, story, or task in Jira: reading your
-  assignment, finding your work queue, joining or leaving an epic's Agent
-  Roster, posting progress or handoff comments, transitioning ticket status,
-  or creating stories/tasks under an epic. Also use when asked about "the
-  board", "the roster", "your ticket", "epic status", or task tracking
-  between agents. Uses the acli CLI (Atlassian CLI) from bash.
----
-
-# Agent task tracking (Jira)
-
-Jira is your deployment's **tasks layer** — the shared record for task
-tracking and the agent roster. Agents do not know about projects — you know
-**repos and epics**. The hierarchy:
-
-- **Epic** — the unit of work that kicks off, runs, and completes. May touch
-  one repo or several. Its description carries the **Agent Roster** — the
-  source of truth for who is on the epic and their role. Bugs/support run as
-  a standing epic.
-- **Story** — a **group of related tasks** covering one part of the epic's
-  work (often one repo's slice, one feature area). Not every task needs a
-  story.
-- **Task** — a small bounded item, the thing an agent actually works. Lives
-  **either directly under the epic** (standalone item) **or under a story**
-  (part of a grouped slice). Everything traces up to an epic.
-
-## Site and project (from your deployment, never hardcoded)
-
-Your Jira **site** and **project key** come from the tasks payload OATS merged
-for this instance: the soul's `soul.yaml` `tasks: { site, project }`, the
-deployment's `oats-local.yaml` `settings.oats.jira.{site,project}`, or a
-spawn's `--provider oats.jira key=value`. Find them, in order:
-
-1. Your `TASK.md` briefing — the spawn hook writes a
-   `Tasks: Jira — project <KEY> on <site>` line.
-2. `./instance.json` in your instance home — `providers["oats.jira"]` is the
-   merged payload this instance received.
-3. Ask your human.
-
-Below, `<PROJECT>` means that project key. If site or project are unset,
-STOP and ask your human to set them — do not guess.
-
-**First use**: run `acli jira auth status` — if unauthorized, STOP and tell
-the human to run `acli jira auth login --web`. Never attempt login yourself.
-
-## Identity rules (non-negotiable)
-
-- **The human assignee is always the owning engineer** (never change
-  assignee to yourself; agents are not Jira users). Do not touch assignee
-  unless told.
-- **You are identified by label and description**, not the assignee field:
-  - Label `agent-<your-instance-alias>` on any story/task you work.
-  - An `Agent:` line in the description (see templates).
-- **Never set or modify sprints.** Never delete tickets. Comment, don't
-  rewrite, other agents' descriptions (exception: coordinators maintain the
-  roster table).
-
-## Your work queue
-
-```bash
-acli jira workitem search --jql "project = <PROJECT> AND labels = agent-<alias> AND statusCategory != Done ORDER BY rank" --json
-acli jira workitem view <PROJECT>-1234 --json          # read one ticket (description, labels, status)
-acli jira workitem search --jql "project = <PROJECT> AND parent = <PROJECT>-<epic> AND statusCategory != Done" --json   # epic's direct children (stories + standalone tasks)
-acli jira workitem search --jql "project = <PROJECT> AND parent = <PROJECT>-<story> AND statusCategory != Done" --json  # a story's tasks
-```
-
-An epic's full open work = its direct children **plus** the tasks under each
-of its stories — walk one level down from stories when you need the complete
-picture.
-
-Record your epic and ticket keys in your instance memory (e.g. `STATE.md`
-`# Context`).
-
-## The Agent Roster (epics)
-
-The epic description contains a `## Agent Roster` markdown table — current
-truth for who is on the epic:
-
-```
-## Agent Roster
-
-| Agent (instance) | Soul / class | Repo | Role on epic | Status | Since |
-|---|---|---|---|---|---|
-| coordinator-digest | coordinator (newsletter) | newsletter-service | runs the epic | active | 2026-07-07 |
-| developer-digest-api | developer (newsletter) | newsletter-service | implements API | active | 2026-07-07 |
-```
-
-Protocol:
-- **Joining**: the coordinator (or the spawning agent) adds your row to the
-  table (`acli jira workitem edit <epic> --description ...` with the full
-  updated description — read it first, edit only the roster table) AND posts
-  a comment: `[roster] <alias> joined — role: <role>, repo: <repo>`.
-- **Leaving/retiring**: set the row's Status to `retired` (keep the row — it
-  is history) and comment `[roster] <alias> retired — <one-line outcome>`.
-- Only edit the roster table; never rewrite the rest of the epic description.
-- Comments are the event log; the table is current state. On conflict, fix
-  the table and note it in a comment.
-
-## Working a ticket
-
-1. Read your ticket and its epic (description + roster) before starting.
-2. **Milestones** → comment on your ticket, prefixed `[<alias>]`. Mirror the
-   entry you record in your instance memory — same events, two audiences.
-3. **Status transitions** — move your ticket as you work:
-   `acli jira workitem transition <PROJECT>-1234 --status "In Progress"`.
-   Discover valid statuses with `--help` or by trying; if a transition is
-   rejected, comment instead and let the coordinator move it.
-4. **Done** = your latest commit is review-clean and the branch is handed
-   off. Comment the outcome (branch, PR link, verification), then transition.
-5. **Handoff/blocked** → comment
-   `[<alias>] handoff → <next-alias>: <what+where>` or
-   `[<alias>] blocked: <what is needed, from whom>`.
-
-Tasks ≠ messaging: status and outcomes live here in Jira; conversation lives
-in your deployment's messaging layer. Mail nudges; Jira records.
-
-## Creating tickets (coordinators; developers file follow-ups as Tasks)
-
-House rules: summary ≤ 12 words, describe the requirement not the solution,
-bugs always include reproduction steps, keep descriptions to a few bullets.
-
-**Choosing the level:**
-- Small bounded item, no siblings needed → **Task directly under the epic**.
-- A part of the epic's work that breaks into several related tasks → **Story
-  under the epic, tasks under the story**. The story is the group, not the
-  work item — agents are assigned to its tasks (a story worked wholly by one
-  agent may carry that agent's label too).
-- Never create a story for a single task, and never nest stories.
-
-```bash
-acli jira workitem create --project <PROJECT> --type Task --summary "<summary>" \
-  --parent <PROJECT>-<epic-or-story> --label "agent-<alias>" --description "<see template>"
-acli jira workitem create --project <PROJECT> --type Story --summary "<summary>" \
-  --parent <PROJECT>-<epic> --description "<see template>"
-```
-
-### Story/Task description template
-
-```
-<What & why — 2-4 bullets. Acceptance criteria as a checklist.>
-
----
-Agent: <instance-alias>          (who works this — matches the agent-<alias> label; stories list it only when one agent works the whole story)
-Soul: <soul-name> · Repo: <repo>
-Parent: <PROJECT>-<epic-or-story-key> · Epic: <PROJECT>-<epic-key>
-```
-
-### Epic description template
-
-```
-<Intent — what this epic delivers and why. Walls — what is explicitly out.>
-
-Repos touched: <repo>, <repo>
-Human gates: <security/authz/migration/contract items needing sign-off, or "none">
-
-## Agent Roster
-
-| Agent (instance) | Soul / class | Repo | Role on epic | Status | Since |
-|---|---|---|---|---|---|
-```
-
-### Comment conventions (machine-greppable prefixes)
-
-- `[roster] <alias> joined|retired — …`
-- `[<alias>] milestone: …` · `[<alias>] handoff → <alias>: …` ·
-  `[<alias>] blocked: …` · `[<alias>] done: branch <name>, <verification>`
-
-## Verify-before-trusting
-
-Jira workflows differ per site. On first real use in a deployment: check the
-project's issue types (`Epic/Story/Task/Bug`), whether `--parent` links
-stories/tasks to epics, whether a **Task can take a Story as parent** (some
-Jira configs only allow that via the Sub-task type — if so, use Sub-tasks
-under stories and treat them as tasks), and the exact status names. If
-reality differs, note it in a comment on your ticket and tell your
-coordinator so your deployment's conventions get recorded.

package/capabilities/oats-linear/bin/oats-linear-hook.mjs

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-/** OATS spawn briefing for the Linear tasks integration. Makes no API calls. */
-const output = (value) => {
-  process.stdout.write(JSON.stringify(value) + "\n");
-  process.exit(0);
-};
-
-const event = process.env.OATS_EVENT || process.argv[2];
-if (event !== "spawn") output({ warning: `oats-linear: unknown event "${event}" (expected spawn)` });
-
-let settings = {};
-try { settings = JSON.parse(process.env.OATS_SETTINGS || "{}"); }
-catch { output({ warning: "oats-linear: the tasks settings payload (OATS_SETTINGS) is not valid JSON" }); }
-
-const instance = process.env.OATS_INSTANCE || "unknown-instance";
-const team = settings.team;
-const project = settings.project;
-const label = `agent-${instance}`;
-// Where team lives under the workspace model (0.26): the soul's tasks payload or this machine's settings.
-const TEAM_HOMES = "tasks: { team } in the soul's soul.yaml, or settings.oats.linear.team in the deployment's oats-local.yaml";
-const target = team
-  ? `team ${team}${project ? `, default project ${project}` : ""}`
-  : `team unset — ask your human to set ${TEAM_HOMES}`;
-const warnings = [];
-if (!team) warnings.push(`settings.team is unset (set ${TEAM_HOMES})`);
-if (!process.env.LINEAR_API_KEY) warnings.push("LINEAR_API_KEY is not in the spawn environment");
-
-output({
-  meta: { label, ...(team ? { team } : {}), ...(project ? { project } : {}) },
-  brief: `Tasks: Linear — ${target}. Your agent identity is label "${label}"; keep the human assignee unchanged. Load the linear-tasks skill before touching issues.`,
-  ...(warnings.length ? {
-    warning: `oats-linear: ${warnings.join("; ")} — see the linear-tasks skill`,
-  } : {}),
-});

package/capabilities/oats-linear/bin/oats-linear.mjs

@@ -1,344 +0,0 @@
-#!/usr/bin/env node
-/**
- * JSON-first Linear task operations for OATS.
- *
- * Uses Linear's official GraphQL API directly. No third-party Linear CLI or
- * SDK is required; authentication is a personal key in LINEAR_API_KEY.
- */
-import { readFileSync } from "node:fs";
-
-const API_URL = process.env.LINEAR_API_URL || "https://api.linear.app/graphql";
-const argv = process.argv.slice(2);
-const command = argv.shift();
-
-function die(message, details) {
-  process.stderr.write(JSON.stringify({ error: String(message), ...(details ? { details } : {}) }, null, 2) + "\n");
-  process.exit(1);
-}
-function print(value) { process.stdout.write(JSON.stringify(value, null, 2) + "\n"); }
-function parseArgs(values) {
-  const options = new Map();
-  const positional = [];
-  for (let i = 0; i < values.length; i++) {
-    const value = values[i];
-    if (!value.startsWith("--")) { positional.push(value); continue; }
-    const name = value.slice(2);
-    const next = values[i + 1];
-    const parsed = next !== undefined && !next.startsWith("--") ? values[++i] : true;
-    const previous = options.get(name) || [];
-    previous.push(parsed);
-    options.set(name, previous);
-  }
-  return {
-    positional,
-    has: (name) => options.has(name),
-    one: (name) => options.get(name)?.at(-1),
-    many: (name) => options.get(name) || [],
-  };
-}
-const args = parseArgs(argv);
-
-async function graphql(query, variables = {}) {
-  const key = process.env.LINEAR_API_KEY;
-  if (!key) die("LINEAR_API_KEY is not set", "Create a personal API key in Linear Settings → Security & access → API keys, export it, then run `oats linear auth`.");
-  let response;
-  try {
-    response = await fetch(API_URL, {
-      method: "POST",
-      headers: {
-        "Authorization": key,
-        "Content-Type": "application/json",
-        "User-Agent": "oats-linear/0.1",
-      },
-      body: JSON.stringify({ query, variables }),
-      signal: AbortSignal.timeout(30000),
-    });
-  } catch (error) {
-    die(`Linear API request failed: ${error.message || error}`);
-  }
-  const text = await response.text();
-  let payload;
-  try { payload = JSON.parse(text); }
-  catch { die(`Linear API returned HTTP ${response.status} with non-JSON content`, text.slice(0, 500)); }
-  if (!response.ok || payload.errors?.length) {
-    const errors = (payload.errors || []).map((error) => ({
-      message: error.extensions?.userPresentableMessage || error.message,
-      code: error.extensions?.code,
-      path: error.path,
-    }));
-    const hint = response.status === 401 ? "Check LINEAR_API_KEY and run `oats linear auth`." : undefined;
-    die(`Linear API request failed (HTTP ${response.status})`, { errors, ...(hint ? { hint } : {}) });
-  }
-  return payload.data;
-}
-
-const PAGE_INFO = "pageInfo { hasNextPage endCursor }";
-const ISSUE_FIELDS = `
-  id identifier title description url priority priorityLabel
-  team { id key name }
-  state { id name type }
-  project { id name slugId }
-  parent { id identifier title }
-  assignee { id name email }
-  labels(first: 100) { nodes { id name } }
-`;
-
-async function teamByKey(key) {
-  if (!key || key === true) die("--team <KEY> is required");
-  const data = await graphql(`
-    query OatsLinearTeam($key: String!) {
-      teams(first: 2, filter: { key: { eqIgnoreCase: $key } }) { nodes { id key name } }
-    }
-  `, { key });
-  if (data.teams.nodes.length === 0) die(`Linear team "${key}" was not found`, "Run `oats linear teams` and use its key.");
-  if (data.teams.nodes.length > 1) die(`Linear team key "${key}" is ambiguous`);
-  return data.teams.nodes[0];
-}
-
-async function statesForTeam(team) {
-  const data = await graphql(`
-    query OatsLinearStates($id: String!) {
-      team(id: $id) { states(first: 100) { nodes { id name type position } } }
-    }
-  `, { id: team.id });
-  return data.team.states.nodes.sort((a, b) => a.position - b.position);
-}
-async function stateByName(team, name) {
-  const states = await statesForTeam(team);
-  const matches = states.filter((state) => state.id === name || state.name.toLowerCase() === String(name).toLowerCase());
-  if (matches.length !== 1) die(`Workflow state "${name}" was not found for team ${team.key}`, { available: states.map((state) => `${state.name} (${state.type})`) });
-  return matches[0];
-}
-
-async function labelsForTeam(team) {
-  const data = await graphql(`
-    query OatsLinearLabels($teamId: ID!) {
-      issueLabels(first: 250, filter: { or: [
-        { team: { null: true } },
-        { team: { id: { eq: $teamId } } }
-      ] }) {
-        nodes { id name color isGroup team { id key } }
-      }
-    }
-  `, { teamId: team.id });
-  return data.issueLabels.nodes;
-}
-async function findLabel(team, name) {
-  const labels = await labelsForTeam(team);
-  const matches = labels.filter((label) => !label.isGroup && label.name.toLowerCase() === String(name).toLowerCase());
-  const scoped = matches.find((label) => label.team?.id === team.id);
-  return scoped || matches.find((label) => !label.team);
-}
-async function ensureAgentLabel(team, alias) {
-  const name = `agent-${alias}`;
-  const existing = await findLabel(team, name);
-  if (existing) return existing;
-  const data = await graphql(`
-    mutation OatsLinearCreateLabel($input: IssueLabelCreateInput!) {
-      issueLabelCreate(input: $input) { success issueLabel { id name color team { id key } } }
-    }
-  `, { input: { name, teamId: team.id, color: "#5E6AD2", description: "OATS agent instance identity" } });
-  if (!data.issueLabelCreate.success) die(`Linear did not create label "${name}"`);
-  return data.issueLabelCreate.issueLabel;
-}
-async function labelByName(team, name) {
-  const label = await findLabel(team, name);
-  if (!label) die(`Label "${name}" was not found for team ${team.key}`, "Create it in Linear first. Agent labels are created automatically by --agent.");
-  return label;
-}
-
-async function projectsForTeam(team) {
-  const data = await graphql(`
-    query OatsLinearProjects($teamId: ID!) {
-      projects(first: 250, filter: { accessibleTeams: { some: { id: { eq: $teamId } } } }) {
-        nodes { id name slugId status { id name type } teams(first: 20) { nodes { id key name } } }
-      }
-    }
-  `, { teamId: team.id });
-  return data.projects.nodes;
-}
-async function projectByRef(team, ref) {
-  const projects = await projectsForTeam(team);
-  const needle = String(ref).toLowerCase();
-  const matches = projects.filter((project) =>
-    project.id === ref || project.slugId.toLowerCase() === needle || project.name.toLowerCase() === needle);
-  if (matches.length !== 1) die(`Project "${ref}" ${matches.length ? "is ambiguous" : "was not found"} for team ${team.key}`, { available: projects.map((project) => ({ name: project.name, slug: project.slugId })) });
-  return matches[0];
-}
-
-async function issueById(id) {
-  if (!id || id === true) die("an issue identifier such as ENG-123 is required");
-  const data = await graphql(`
-    query OatsLinearIssue($id: String!) { issue(id: $id) { ${ISSUE_FIELDS} } }
-  `, { id });
-  return data.issue;
-}
-
-function textOption(name) {
-  const inline = args.one(name);
-  const file = args.one(`${name}-file`);
-  if (inline !== undefined && file !== undefined) die(`use only one of --${name} or --${name}-file`);
-  if (file !== undefined) {
-    if (file === true) die(`--${name}-file needs a path`);
-    try { return readFileSync(file, "utf8").trim(); }
-    catch (error) { die(`cannot read --${name}-file ${file}: ${error.message}`); }
-  }
-  return inline;
-}
-function assertTerminalAllowed(state) {
-  if (["completed", "canceled", "duplicate"].includes(state.type) && !args.has("allow-terminal")) {
-    die(`refusing terminal state "${state.name}" without --allow-terminal`, "Agents should hand work to review, not close or cancel it. Use --allow-terminal only with explicit human authorization.");
-  }
-}
-
-async function auth() {
-  const data = await graphql(`
-    query OatsLinearAuth { viewer { id name email } organization { id name urlKey } }
-  `);
-  print({ authenticated: true, endpoint: API_URL, viewer: data.viewer, workspace: data.organization });
-}
-async function teams() {
-  const data = await graphql(`
-    query OatsLinearTeams { teams(first: 100) { nodes { id key name } } }
-  `);
-  print(data.teams.nodes);
-}
-async function states() {
-  const team = await teamByKey(args.one("team"));
-  print(await statesForTeam(team));
-}
-async function projects() {
-  const team = await teamByKey(args.one("team"));
-  print(await projectsForTeam(team));
-}
-async function labels() {
-  const team = await teamByKey(args.one("team"));
-  print(await labelsForTeam(team));
-}
-
-async function listIssues() {
-  const team = await teamByKey(args.one("team"));
-  const requestedLimit = Number(args.one("limit") || 100);
-  if (!Number.isInteger(requestedLimit) || requestedLimit < 1 || requestedLimit > 250) die("--limit must be an integer from 1 to 250");
-  const filter = { team: { id: { eq: team.id } } };
-  if (!args.has("all")) filter.state = { type: { nin: ["completed", "canceled", "duplicate"] } };
-  if (args.one("agent")) filter.labels = { some: { name: { eqIgnoreCase: `agent-${args.one("agent")}` } } };
-  if (args.one("project")) {
-    const project = await projectByRef(team, args.one("project"));
-    filter.project = { id: { eq: project.id } };
-  }
-  const data = await graphql(`
-    query OatsLinearIssues($first: Int!, $filter: IssueFilter) {
-      issues(first: $first, filter: $filter) { nodes { ${ISSUE_FIELDS} } ${PAGE_INFO} }
-    }
-  `, { first: requestedLimit, filter });
-  print({ issues: data.issues.nodes, pageInfo: data.issues.pageInfo });
-}
-async function createIssue() {
-  const team = await teamByKey(args.one("team"));
-  const title = args.one("title");
-  if (!title || title === true) die("--title <text> is required");
-  let description = textOption("description");
-  const input = { teamId: team.id, title };
-  if (description !== undefined) input.description = description;
-  if (args.one("project")) input.projectId = (await projectByRef(team, args.one("project"))).id;
-  if (args.one("parent")) input.parentId = args.one("parent");
-  if (args.one("state")) {
-    const state = await stateByName(team, args.one("state"));
-    assertTerminalAllowed(state);
-    input.stateId = state.id;
-  }
-  const issueLabels = [];
-  if (args.one("agent")) {
-    const alias = args.one("agent");
-    issueLabels.push(await ensureAgentLabel(team, alias));
-    if (!/^Agent:/mi.test(description || "")) {
-      description = `${description ? `${description.trim()}\n\n` : ""}---\nAgent: ${alias}`;
-      input.description = description;
-    }
-  }
-  for (const name of args.many("label")) issueLabels.push(await labelByName(team, name));
-  if (issueLabels.length) input.labelIds = [...new Set(issueLabels.map((label) => label.id))];
-  const data = await graphql(`
-    mutation OatsLinearIssueCreate($input: IssueCreateInput!) {
-      issueCreate(input: $input) { success issue { ${ISSUE_FIELDS} } }
-    }
-  `, { input });
-  if (!data.issueCreate.success || !data.issueCreate.issue) die("Linear did not create the issue");
-  print(data.issueCreate.issue);
-}
-async function updateIssue(id) {
-  const current = await issueById(id);
-  const team = current.team;
-  const input = {};
-  if (args.has("title")) input.title = args.one("title");
-  const description = textOption("description");
-  if (description !== undefined) input.description = description;
-  if (args.one("state")) {
-    const state = await stateByName(team, args.one("state"));
-    assertTerminalAllowed(state);
-    input.stateId = state.id;
-  }
-  const added = [];
-  if (args.one("agent")) added.push((await ensureAgentLabel(team, args.one("agent"))).id);
-  for (const name of args.many("add-label")) added.push((await labelByName(team, name)).id);
-  const removed = [];
-  for (const name of args.many("remove-label")) removed.push((await labelByName(team, name)).id);
-  if (added.length) input.addedLabelIds = [...new Set(added)];
-  if (removed.length) input.removedLabelIds = [...new Set(removed)];
-  if (Object.keys(input).length === 0) die("no update supplied", "Use --title, --description[-file], --state, --agent, --add-label, or --remove-label.");
-  const data = await graphql(`
-    mutation OatsLinearIssueUpdate($id: String!, $input: IssueUpdateInput!) {
-      issueUpdate(id: $id, input: $input) { success issue { ${ISSUE_FIELDS} } }
-    }
-  `, { id, input });
-  if (!data.issueUpdate.success || !data.issueUpdate.issue) die(`Linear did not update ${id}`);
-  print(data.issueUpdate.issue);
-}
-async function commentIssue(id) {
-  const body = textOption("body");
-  if (!body || body === true) die("--body <markdown> or --body-file <path> is required");
-  const data = await graphql(`
-    mutation OatsLinearComment($input: CommentCreateInput!) {
-      commentCreate(input: $input) { success comment { id body createdAt url user { id name } } }
-    }
-  `, { input: { issueId: id, body } });
-  if (!data.commentCreate.success) die(`Linear did not comment on ${id}`);
-  print(data.commentCreate.comment);
-}
-
-function usage() {
-  process.stderr.write(`oats linear commands (all output JSON):
-  auth
-  teams
-  states --team <KEY>
-  projects --team <KEY>
-  labels --team <KEY>
-  issue list --team <KEY> [--agent <alias>] [--project <name|slug>] [--all] [--limit 100]
-  issue get <KEY-123>
-  issue create --team <KEY> --title <text> [--description <md>|--description-file <path>]
-      [--project <name|slug>] [--parent <KEY-123>] [--state <name>] [--agent <alias>]
-      [--label <name> ...]
-  issue update <KEY-123> [--title <text>] [--description <md>|--description-file <path>]
-      [--state <name>] [--agent <alias>] [--add-label <name> ...] [--remove-label <name> ...]
-      [--allow-terminal]
-  issue comment <KEY-123> (--body <md>|--body-file <path>)
-`);
-  process.exit(1);
-}
-
-if (command === "auth") await auth();
-else if (command === "teams") await teams();
-else if (command === "states") await states();
-else if (command === "projects") await projects();
-else if (command === "labels") await labels();
-else if (command === "issue") {
-  const subcommand = args.positional[0];
-  const id = args.positional[1];
-  if (subcommand === "list") await listIssues();
-  else if (subcommand === "get") print(await issueById(id));
-  else if (subcommand === "create") await createIssue();
-  else if (subcommand === "update") await updateIssue(id);
-  else if (subcommand === "comment") await commentIssue(id);
-  else usage();
-} else usage();

package/capabilities/oats-linear/injects/linear.md

@@ -1,8 +0,0 @@
-## Tasks: Linear
-
-Your tasks layer is **Linear**, operated through the JSON-first `oats linear`
-commands. You are identified by the label `agent-<your-instance-name>`, not
-by changing the human assignee. Load the **linear-tasks** skill before reading
-your queue, creating or updating issues/sub-issues, changing status, or posting
-handoffs. Tasks only: status and outcomes live in Linear; conversation lives
-in your deployment's messaging layer.

package/capabilities/oats-linear/oats.json

@@ -1,24 +0,0 @@
-{
-  "capability": "oats.linear",
-  "command": "linear",
-  "version": "1.0.1",
-  "compatibility": { "oats": ">=0.26.0" },
-  "layer": "tasks",
-  "description": "Tasks layer via Linear: JSON-first GraphQL commands, project/issue/sub-issue workflow, label-based agent identity.",
-  "requires": [],
-  "skills": [
-    "skills"
-  ],
-  "commands": {
-    "auth": "bin/oats-linear.mjs auth",
-    "teams": "bin/oats-linear.mjs teams",
-    "states": "bin/oats-linear.mjs states",
-    "projects": "bin/oats-linear.mjs projects",
-    "labels": "bin/oats-linear.mjs labels",
-    "issue": "bin/oats-linear.mjs issue"
-  },
-  "inject": "injects/linear.md",
-  "hooks": {
-    "spawn": "bin/oats-linear-hook.mjs spawn"
-  }
-}