@calltelemetry/openclaw-linear 0.6.0 → 0.7.0

package/README.md

@@ -39,8 +39,9 @@ An OpenClaw plugin that connects Linear to AI agents. Issues get triaged automat
 | **Real-time progress** | Agent activity (thinking, acting, responding) streams to Linear's UI |
 | **Unified `code_run`** | One tool, three backends (Codex, Claude Code, Gemini), configurable per agent |
 | **Issue management** | Agents use `linearis` CLI to update status, close issues, add comments |
-| **Customizable prompts** | `prompts.yaml` -- edit worker, audit, and rework prompts without rebuilding |
-| **Discord notifications** | Dispatch lifecycle events posted to a Discord channel |
+| **Project planner** | Interactive interview builds out Linear issue hierarchies with dependency DAGs |
+| **Customizable prompts** | `prompts.yaml` -- edit worker, audit, planner, and rework prompts without rebuilding |
+| **Multi-channel notifications** | Dispatch events fan out to Discord, Slack, Telegram, Signal, or any OpenClaw channel |
 | **Artifact logging** | Every dispatch writes structured logs to `.claw/` in the worktree |
 
 ---
@@ -74,6 +75,12 @@ sequenceDiagram
     Plugin->>Agents: QA agent
     Agents-->>Plugin: Response
     Plugin-->>Linear: Branded comment
+
+    You->>Linear: Comment "@ctclaw plan this project"
+    Linear->>Plugin: Webhook (Comment)
+    Plugin->>Agents: Planner agent
+    Agents-->>Linear: Creates epics + issues + dependency DAG
+    Agents-->>Linear: Interview question
 ```
 
 ---
@@ -122,6 +129,23 @@ stateDiagram-v2
 
 All transitions use compare-and-swap (CAS) to prevent races. `dispatch-state.json` is the canonical source of truth.
 
+### Project Planner Pipeline
+
+When `@ctclaw plan this project` is commented on a root issue, the plugin enters planning mode:
+
+```mermaid
+flowchart TD
+    A["Comment: 'plan this project'"] --> B["INITIATE<br/>Register session, post welcome"]
+    B --> C["INTERVIEW<br/>Agent asks questions,<br/>creates issues + DAG"]
+    C -->|user responds| C
+    C -->|"'finalize plan'"| D["AUDIT<br/>DAG validation, completeness checks"]
+    D -->|Pass| E["APPROVED<br/>Project ready for dispatch"]
+    D -->|Fail| C
+    C -->|"'abandon'"| F["ABANDONED"]
+```
+
+During planning mode, the planner creates epics, sub-issues, and dependency relationships (`blocks`/`blocked_by`) via 5 dedicated tools. Issue dispatch is blocked for projects in planning mode.
+
 ### Webhook Event Router
 
 ```mermaid
@@ -129,7 +153,7 @@ flowchart TD
     A["POST /linear/webhook"] --> B{"Event Type"}
     B --> C["AgentSessionEvent.created → Dispatch pipeline"]
     B --> D["AgentSessionEvent.prompted → Resume session"]
-    B --> E["Comment.create → @mention routing"]
+    B --> E["Comment.create → @mention routing<br/>or planning mode"]
     B --> F["Issue.create → Auto-triage"]
     B --> G["Issue.update → Dispatch if assigned"]
     B --> H["AppUserNotification → Direct response"]
@@ -180,7 +204,9 @@ openclaw-linear/
     |   |-- dispatch-service.ts    Background monitor: stale detection, recovery, cleanup
     |   |-- active-session.ts      In-memory session registry (issueId -> session)
     |   |-- tier-assess.ts         Issue complexity assessment (junior/medior/senior)
-    |   +-- artifacts.ts           .claw/ directory: manifest, logs, verdicts, summaries
+    |   |-- artifacts.ts           .claw/ directory: manifest, logs, verdicts, summaries
+    |   |-- planner.ts             Project planner orchestration (interview, audit)
+    |   +-- planning-state.ts      File-backed planning state (mirrors dispatch-state)
     |
     |-- agent/                 Agent execution & monitoring
     |   |-- agent.ts               Embedded runner + subprocess fallback, retry on watchdog kill
@@ -193,7 +219,8 @@ openclaw-linear/
     |   |-- claude-tool.ts         Claude Code CLI runner (JSONL -> Linear activities)
     |   |-- codex-tool.ts          Codex CLI runner (JSONL -> Linear activities)
     |   |-- gemini-tool.ts         Gemini CLI runner (JSONL -> Linear activities)
-    |   +-- orchestration-tools.ts spawn_agent / ask_agent for multi-agent delegation
+    |   |-- orchestration-tools.ts spawn_agent / ask_agent for multi-agent delegation
+    |   +-- planner-tools.ts       5 planning tools (create/link/update issues, audit DAG)
     |
     |-- api/                   Linear API & auth
     |   |-- linear-api.ts          GraphQL client, token resolution, auto-refresh
@@ -203,7 +230,7 @@ openclaw-linear/
     +-- infra/                 Infrastructure utilities
         |-- cli.ts                 CLI subcommands (auth, status, worktrees, prompts)
         |-- codex-worktree.ts      Git worktree create/remove/status/PR helpers
-        +-- notify.ts              Discord notifier (+ noop fallback)
+        +-- notify.ts              Multi-channel notifier (Discord, Slack, Telegram, Signal)
 ```
 
 ---
@@ -401,6 +428,9 @@ Once set up, the plugin responds to Linear events automatically:
 | Assign an issue to the agent | Worker-audit pipeline runs with watchdog protection |
 | Trigger an agent session | Agent responds directly in the session |
 | Comment `@qa check the tests` | QA agent responds with its expertise |
+| Comment `@ctclaw plan this project` | Planner agent enters interview mode, builds issue DAG |
+| Reply during planning mode | Planner creates/updates issues and asks next question |
+| Comment "finalize plan" | DAG audit runs: cycles, orphans, missing estimates/priorities |
 | Ask "close this issue" | Agent runs `linearis issues update API-123 --status Done` |
 | Ask "use gemini to review" | Agent calls `code_run` with `backend: "gemini"` |
 
@@ -435,7 +465,7 @@ Set in `openclaw.json` under the plugin entry:
 | `codexTimeoutMs` | number | `600000` | Legacy timeout for coding CLIs (ms) |
 | `worktreeBaseDir` | string | `"~/.openclaw/worktrees"` | Base directory for worktrees |
 | `dispatchStatePath` | string | `"~/.openclaw/linear-dispatch-state.json"` | Dispatch state file |
-| `flowDiscordChannel` | string | -- | Discord channel ID for notifications |
+| `notifications` | object | -- | [Notification targets and event toggles](#notifications) |
 | `promptsPath` | string | -- | Override path for `prompts.yaml` |
 | `maxReworkAttempts` | number | `2` | Max audit failures before escalation |
 | `inactivitySec` | number | `120` | Kill sessions with no I/O for this long |
@@ -511,17 +541,78 @@ openclaw openclaw-linear prompts validate   # Validate structure and template va
 
 ## Notifications
 
-Configure `flowDiscordChannel` in plugin config with a Discord channel ID. Events:
+Dispatch lifecycle events fan out to any combination of OpenClaw channels -- Discord, Slack, Telegram, Signal, or any channel the runtime supports.
 
-| Event | Message |
-|---|---|
-| Dispatch | `**API-123** dispatched -- Fix auth bug` |
-| Worker started | `**API-123** worker started (attempt 0)` |
-| Audit in progress | `**API-123** audit in progress` |
-| Audit passed | `**API-123** passed audit. PR ready.` |
-| Audit failed | `**API-123** failed audit (attempt 1). Gaps: ...` |
-| Escalation | `**API-123** needs human review -- audit failed 3x` |
-| Watchdog kill | `**API-123** killed by watchdog (no I/O for 120s). Retrying.` |
+### Configuration
+
+Add a `notifications` object to your plugin config:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "openclaw-linear": {
+        "config": {
+          "notifications": {
+            "targets": [
+              { "channel": "discord", "target": "1471743433566715974" },
+              { "channel": "slack", "target": "C0123456789", "accountId": "my-acct" },
+              { "channel": "telegram", "target": "-1003884997363" }
+            ],
+            "events": {
+              "auditing": false
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**`targets`** -- Array of notification destinations. Each target specifies:
+
+| Field | Required | Description |
+|---|---|---|
+| `channel` | Yes | OpenClaw channel name: `discord`, `slack`, `telegram`, `signal`, etc. |
+| `target` | Yes | Channel/group/user ID to send to |
+| `accountId` | No | Account ID for multi-account setups (Slack) |
+
+**`events`** -- Per-event-type toggles. All events are enabled by default. Set to `false` to suppress.
+
+### Events
+
+| Event | Kind | Example Message |
+|---|---|---|
+| Dispatch | `dispatch` | `API-123 dispatched -- Fix auth bug` |
+| Worker started | `working` | `API-123 worker started (attempt 0)` |
+| Audit in progress | `auditing` | `API-123 audit in progress` |
+| Audit passed | `audit_pass` | `API-123 passed audit. PR ready.` |
+| Audit failed | `audit_fail` | `API-123 failed audit (attempt 1). Gaps: no tests, missing validation` |
+| Escalation | `escalation` | `API-123 needs human review -- audit failed 3x` |
+| Stale detection | `stuck` | `API-123 stuck -- stale 2h` |
+| Watchdog kill | `watchdog_kill` | `API-123 killed by watchdog (no I/O for 120s). Retrying (attempt 0).` |
+
+### Delivery
+
+Messages route through OpenClaw's native runtime channel API:
+
+- **Discord** -- `runtime.channel.discord.sendMessageDiscord()`
+- **Slack** -- `runtime.channel.slack.sendMessageSlack()` (passes `accountId` for multi-workspace)
+- **Telegram** -- `runtime.channel.telegram.sendMessageTelegram()` (silent mode)
+- **Signal** -- `runtime.channel.signal.sendMessageSignal()`
+- **Other** -- Falls back to `openclaw message send` CLI
+
+Failures are isolated per target -- one channel going down doesn't block the others.
+
+### Notify CLI
+
+```bash
+openclaw openclaw-linear notify status                  # Show configured targets and suppressed events
+openclaw openclaw-linear notify test                    # Send test notification to all targets
+openclaw openclaw-linear notify test --channel discord  # Test only discord targets
+openclaw openclaw-linear notify setup                   # Interactive target setup
+```
 
 ---
 
@@ -649,6 +740,13 @@ openclaw openclaw-linear worktrees --prune <path>  # Remove a worktree
 openclaw openclaw-linear prompts show      # Print current prompts
 openclaw openclaw-linear prompts path      # Print resolved prompts file path
 openclaw openclaw-linear prompts validate  # Validate prompt structure
+openclaw openclaw-linear notify status     # Show notification targets and event toggles
+openclaw openclaw-linear notify test       # Send test notification to all targets
+openclaw openclaw-linear notify test --channel slack  # Test specific channel only
+openclaw openclaw-linear notify setup      # Interactive notification target setup
+openclaw openclaw-linear doctor            # Run comprehensive health checks
+openclaw openclaw-linear doctor --fix      # Auto-fix safe issues
+openclaw openclaw-linear doctor --json     # Output results as JSON
 ```
 
 ---

package/index.ts

@@ -9,7 +9,9 @@ import { LinearAgentApi, resolveLinearToken } from "./src/api/linear-api.js";
 import { createDispatchService } from "./src/pipeline/dispatch-service.js";
 import { readDispatchState, lookupSessionMapping, getActiveDispatch } from "./src/pipeline/dispatch-state.js";
 import { triggerAudit, processVerdict, type HookContext } from "./src/pipeline/pipeline.js";
-import { createDiscordNotifier, createNoopNotifier, type NotifyFn } from "./src/infra/notify.js";
+import { createNotifierFromConfig, type NotifyFn } from "./src/infra/notify.js";
+import { readPlanningState, setPlanningCache } from "./src/pipeline/planning-state.js";
+import { createPlannerTools } from "./src/tools/planner-tools.js";
 
 export default function register(api: OpenClawPluginApi) {
   const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
@@ -36,6 +38,9 @@ export default function register(api: OpenClawPluginApi) {
     return createLinearTools(api, ctx);
   });
 
+  // Register planner tools (context injected at runtime via setActivePlannerContext)
+  api.registerTool(() => createPlannerTools());
+
   // Register Linear webhook handler on a dedicated route
   api.registerHttpRoute({
     path: "/linear/webhook",
@@ -63,31 +68,22 @@ export default function register(api: OpenClawPluginApi) {
   // Register dispatch monitor service (stale detection, session hydration, cleanup)
   api.registerService(createDispatchService(api));
 
+  // Hydrate planning state on startup
+  readPlanningState(pluginConfig?.planningStatePath as string | undefined).then((state) => {
+    for (const session of Object.values(state.sessions)) {
+      if (session.status === "interviewing" || session.status === "plan_review") {
+        setPlanningCache(session);
+        api.logger.info(`Planning: restored session for ${session.projectName} (${session.rootIdentifier})`);
+      }
+    }
+  }).catch((err) => api.logger.warn(`Planning state hydration failed: ${err}`));
+
   // ---------------------------------------------------------------------------
   // Dispatch pipeline v2: notifier + agent_end lifecycle hook
   // ---------------------------------------------------------------------------
 
-  // Instantiate notifier (Discord if configured, otherwise noop)
-  const discordBotToken = (() => {
-    try {
-      const config = JSON.parse(
-        require("node:fs").readFileSync(
-          require("node:path").join(process.env.HOME ?? "/home/claw", ".openclaw", "openclaw.json"),
-          "utf8",
-        ),
-      );
-      return config?.channels?.discord?.token as string | undefined;
-    } catch { return undefined; }
-  })();
-  const flowDiscordChannel = pluginConfig?.flowDiscordChannel as string | undefined;
-
-  const notify: NotifyFn = (discordBotToken && flowDiscordChannel)
-    ? createDiscordNotifier(discordBotToken, flowDiscordChannel)
-    : createNoopNotifier();
-
-  if (flowDiscordChannel && discordBotToken) {
-    api.logger.info(`Linear dispatch: Discord notifications enabled (channel: ${flowDiscordChannel})`);
-  }
+  // Instantiate notifier (Discord, Slack, or both — config-driven)
+  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime);
 
   // Register agent_end hook — safety net for sessions_spawn sub-agents.
   // In the current implementation, the worker→audit→verdict flow runs inline

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-linear",
   "name": "Linear Agent",
   "description": "Linear integration with OAuth support, agent pipeline, and webhook-driven AI agent lifecycle",
-  "version": "0.2.0",
+  "version": "0.7.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -20,7 +20,40 @@
       "enableOrchestration": { "type": "boolean", "description": "Allow agents to spawn sub-agents via spawn_agent/ask_agent tools", "default": true },
       "worktreeBaseDir": { "type": "string", "description": "Base directory for persistent git worktrees (default: ~/.openclaw/worktrees)" },
       "dispatchStatePath": { "type": "string", "description": "Path to dispatch state JSON file (default: ~/.openclaw/linear-dispatch-state.json)" },
-      "flowDiscordChannel": { "type": "string", "description": "Discord channel ID for dispatch lifecycle notifications (omit to disable)" },
+      "planningStatePath": { "type": "string", "description": "Path to planning state JSON file (default: ~/.openclaw/linear-planning-state.json)" },
+      "notifications": {
+        "type": "object",
+        "description": "Dispatch lifecycle notification config — fan-out to any combination of channels",
+        "properties": {
+          "targets": {
+            "type": "array",
+            "description": "Notification targets — each routes to an OpenClaw channel",
+            "items": {
+              "type": "object",
+              "required": ["channel", "target"],
+              "properties": {
+                "channel": { "type": "string", "description": "OpenClaw channel name: discord, slack, telegram, signal, etc." },
+                "target": { "type": "string", "description": "Channel/group/user ID to send to" },
+                "accountId": { "type": "string", "description": "Account ID for multi-account channel setups (optional)" }
+              }
+            }
+          },
+          "events": {
+            "type": "object",
+            "description": "Per-event-type toggles (all default true, set false to suppress)",
+            "properties": {
+              "dispatch": { "type": "boolean" },
+              "working": { "type": "boolean" },
+              "auditing": { "type": "boolean" },
+              "audit_pass": { "type": "boolean" },
+              "audit_fail": { "type": "boolean" },
+              "escalation": { "type": "boolean" },
+              "stuck": { "type": "boolean" },
+              "watchdog_kill": { "type": "boolean" }
+            }
+          }
+        }
+      },
       "promptsPath": { "type": "string", "description": "Override path for prompts.yaml (default: ships with plugin)" },
       "maxReworkAttempts": { "type": "number", "description": "Max audit failures before escalation", "default": 2 },
       "inactivitySec": { "type": "number", "description": "Kill sessions with no I/O for this many seconds (default: 120)", "default": 120 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",

package/prompts.yaml

@@ -77,3 +77,50 @@ rework:
 
     Address these specific issues in your rework. Focus on the gaps listed above.
     Remember: you do NOT have linearis access. Just fix the code and return a text summary.
+
+planner:
+  system: |
+    You are a product planning specialist working with Linear. Your job is to interview
+    the user about features they want to build, then decompose them into a well-structured
+    project with epics, issues, and sub-issues connected by a dependency graph.
+
+    STRUCTURE RULES:
+    - Epics are high-level feature areas. Mark them with isEpic=true.
+    - Issues under epics are concrete deliverables with acceptance criteria.
+    - Sub-issues are atomic work units that together complete a parent issue.
+    - Use "blocks" relationships to express ordering: if A must finish before B starts, A blocks B.
+    - Every issue description must include clear acceptance criteria.
+    - Every non-epic issue needs a story point estimate and priority.
+
+    INTERVIEW APPROACH:
+    - Ask ONE focused question at a time. Never dump a questionnaire.
+    - After each user response, create or update issues to capture what you learned.
+    - Briefly summarize what you added before asking your next question.
+    - When the plan feels complete, invite the user to say "finalize plan".
+
+  interview: |
+    ## Project: {{projectName}} ({{rootIdentifier}})
+
+    ### Current Plan
+    {{planSnapshot}}
+
+    ### Recent conversation ({{turnCount}} turns so far)
+    {{commentHistory}}
+
+    ### User just said:
+    > {{userMessage}}
+
+    Continue the planning interview. Use your tools to create/update Linear issues based
+    on the user's input, then respond with a summary of changes and your next question.
+
+  audit_prompt: |
+    The user wants to finalize the plan for {{projectName}}. Run the `audit_plan` tool.
+    If it passes, congratulate and summarize the complete plan.
+    If it fails, list the specific issues that need attention and ask the user to help.
+
+  welcome: |
+    I'm entering planning mode for **{{projectName}}**. I'll interview you about the
+    features you want to build, then structure everything into Linear issues with proper
+    epic hierarchy and dependency chains.
+
+    Let's start — what is this project about, and what are the main feature areas?

package/src/api/linear-api.ts

@@ -148,15 +148,22 @@ export class LinearAgentApi {
     return this.refreshToken ? `Bearer ${this.accessToken}` : this.accessToken;
   }
 
-  private async gql<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T> {
+  private async gql<T = unknown>(
+    query: string,
+    variables?: Record<string, unknown>,
+    extraHeaders?: Record<string, string>,
+  ): Promise<T> {
     await this.ensureValidToken();
 
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Authorization: this.authHeader(),
+      ...extraHeaders,
+    };
+
     const res = await fetch(LINEAR_GRAPHQL_URL, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: this.authHeader(),
-      },
+      headers,
       body: JSON.stringify({ query, variables }),
     });
 
@@ -165,12 +172,15 @@ export class LinearAgentApi {
       this.expiresAt = 0; // force refresh
       await this.ensureValidToken();
 
+      const retryHeaders: Record<string, string> = {
+        "Content-Type": "application/json",
+        Authorization: this.authHeader(),
+        ...extraHeaders,
+      };
+
       const retry = await fetch(LINEAR_GRAPHQL_URL, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: this.authHeader(),
-        },
+        headers: retryHeaders,
         body: JSON.stringify({ query, variables }),
       });
 
@@ -298,6 +308,9 @@ export class LinearAgentApi {
     labels: { nodes: Array<{ id: string; name: string }> };
     team: { id: string; name: string; issueEstimationType: string };
     comments: { nodes: Array<{ body: string; user: { name: string } | null; createdAt: string }> };
+    project: { id: string; name: string } | null;
+    parent: { id: string; identifier: string } | null;
+    relations: { nodes: Array<{ type: string; relatedIssue: { id: string; identifier: string; title: string } }> };
   }> {
     const data = await this.gql<{ issue: unknown }>(
       `query Issue($id: String!) {
@@ -318,6 +331,9 @@ export class LinearAgentApi {
               createdAt
             }
           }
+          project { id name }
+          parent { id identifier }
+          relations { nodes { type relatedIssue { id identifier title } } }
         }
       }`,
       { id: issueId },
@@ -356,6 +372,161 @@ export class LinearAgentApi {
     return data.team.labels.nodes;
   }
 
+  // ---------------------------------------------------------------------------
+  // Planning methods
+  // ---------------------------------------------------------------------------
+
+  async createIssue(input: {
+    teamId: string;
+    title: string;
+    description?: string;
+    projectId?: string;
+    parentId?: string;
+    priority?: number;
+    estimate?: number;
+    labelIds?: string[];
+    stateId?: string;
+    assigneeId?: string;
+  }): Promise<{ id: string; identifier: string }> {
+    // Sub-issues require the GraphQL-Features header
+    const extra = input.parentId ? { "GraphQL-Features": "sub_issues" } : undefined;
+    const data = await this.gql<{
+      issueCreate: { success: boolean; issue: { id: string; identifier: string } };
+    }>(
+      `mutation IssueCreate($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue { id identifier }
+        }
+      }`,
+      { input },
+      extra,
+    );
+    return data.issueCreate.issue;
+  }
+
+  async createIssueRelation(input: {
+    issueId: string;
+    relatedIssueId: string;
+    type: "blocks" | "blocked_by" | "related" | "duplicate";
+  }): Promise<{ id: string }> {
+    const data = await this.gql<{
+      issueRelationCreate: { success: boolean; issueRelation: { id: string } };
+    }>(
+      `mutation IssueRelationCreate($input: IssueRelationCreateInput!) {
+        issueRelationCreate(input: $input) {
+          success
+          issueRelation { id }
+        }
+      }`,
+      { input },
+    );
+    return data.issueRelationCreate.issueRelation;
+  }
+
+  async getProject(projectId: string): Promise<{
+    id: string;
+    name: string;
+    description: string;
+    state: string;
+    teams: { nodes: Array<{ id: string; name: string }> };
+  }> {
+    const data = await this.gql<{ project: unknown }>(
+      `query Project($id: String!) {
+        project(id: $id) {
+          id
+          name
+          description
+          state
+          teams { nodes { id name } }
+        }
+      }`,
+      { id: projectId },
+    );
+    return data.project as any;
+  }
+
+  async getProjectIssues(projectId: string): Promise<Array<{
+    id: string;
+    identifier: string;
+    title: string;
+    description: string | null;
+    estimate: number | null;
+    priority: number;
+    state: { name: string; type: string };
+    parent: { id: string; identifier: string } | null;
+    labels: { nodes: Array<{ id: string; name: string }> };
+    relations: { nodes: Array<{ type: string; relatedIssue: { id: string; identifier: string; title: string } }> };
+  }>> {
+    const data = await this.gql<{
+      project: { issues: { nodes: unknown[] } };
+    }>(
+      `query ProjectIssues($id: String!) {
+        project(id: $id) {
+          issues {
+            nodes {
+              id
+              identifier
+              title
+              description
+              estimate
+              priority
+              state { name type }
+              parent { id identifier }
+              labels { nodes { id name } }
+              relations { nodes { type relatedIssue { id identifier title } } }
+            }
+          }
+        }
+      }`,
+      { id: projectId },
+    );
+    return data.project.issues.nodes as any;
+  }
+
+  async getTeamStates(teamId: string): Promise<Array<{
+    id: string;
+    name: string;
+    type: string;
+  }>> {
+    const data = await this.gql<{
+      team: { states: { nodes: Array<{ id: string; name: string; type: string }> } };
+    }>(
+      `query TeamStates($id: String!) {
+        team(id: $id) {
+          states: workflowStates { nodes { id name type } }
+        }
+      }`,
+      { id: teamId },
+    );
+    return data.team.states.nodes;
+  }
+
+  async updateIssueExtended(issueId: string, input: {
+    title?: string;
+    description?: string;
+    estimate?: number;
+    labelIds?: string[];
+    stateId?: string;
+    priority?: number;
+    projectId?: string;
+    parentId?: string;
+    assigneeId?: string;
+    dueDate?: string;
+  }): Promise<boolean> {
+    const data = await this.gql<{
+      issueUpdate: { success: boolean };
+    }>(
+      `mutation IssueUpdate($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+        }
+      }`,
+      { id: issueId, input },
+    );
+    return data.issueUpdate.success;
+  }
+
   async getAppNotifications(count: number = 5): Promise<Array<{
     id: string;
     type: string;