@calltelemetry/openclaw-linear 0.5.0 → 0.5.1

package/index.ts

@@ -196,15 +196,21 @@ export default function register(api: OpenClawPluginApi) {
     try {
       const raw = execFileSync(bin, ["--version"], {
         encoding: "utf8",
-        timeout: 5_000,
+        timeout: 15_000,
         env: { ...process.env, CLAUDECODE: undefined } as any,
       }).trim();
       cliChecks[name] = raw || "unknown";
     } catch {
-      cliChecks[name] = "not found";
-      api.logger.warn(
-        `${name} CLI not found at ${bin}. The ${name}_run tool will fail. Install with: ${installCmd}`,
-      );
+      // Fallback: check if the file exists (execFileSync can fail in worker contexts)
+      try {
+        require("node:fs").accessSync(bin, require("node:fs").constants.X_OK);
+        cliChecks[name] = "installed (version check skipped)";
+      } catch {
+        cliChecks[name] = "not found";
+        api.logger.warn(
+          `${name} CLI not found at ${bin}. The ${name}_run tool will fail. Install with: ${installCmd}`,
+        );
+      }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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

@@ -5,13 +5,19 @@
 #
 # Edit these to customize worker/audit behavior without rebuilding the plugin.
 # Override path via `promptsPath` in plugin config.
+#
+# Access model:
+#   Zoe (orchestrator) — linearis READ ONLY (issues read/list/search)
+#   Worker             — NO linearis access. Return text output only.
+#   Auditor            — linearis READ + WRITE (can update status, close, comment)
 
 worker:
   system: |
-    You are implementing a Linear issue. Your job is to plan and code the solution.
-    Post an implementation summary as a Linear comment when done.
-    DO NOT mark the issue as Done — that is handled by the audit system.
-    DO NOT attempt to change the issue status or labels.
+    You are a coding worker implementing a Linear issue. Your ONLY job is to write code and return a text summary.
+    You do NOT have access to linearis or any Linear issue management tools.
+    Do NOT attempt to update, close, comment on, or modify the Linear issue in any way.
+    Do NOT mark the issue as Done — the audit system handles all issue lifecycle.
+    Just write code and return your implementation summary as text.
   task: |
     Implement issue {{identifier}}: {{title}}
 
@@ -25,15 +31,22 @@ worker:
     2. Plan your approach
     3. Implement the solution in the worktree
     4. Run tests to verify your changes
-    5. Post an implementation summary as a comment on the Linear issue
-    6. Include what was changed, what tests were run, and any notes
+    5. Return a text summary of what you changed, what tests you ran, and any notes
+
+    Your text output will be captured automatically. Do NOT use linearis or attempt to post comments.
 
 audit:
   system: |
-    You are an independent auditor. Your job is to verify that work was completed correctly.
+    You are an independent auditor. Your job is to verify that work was completed correctly
+    and then update the Linear issue accordingly.
     The Linear issue body is the SOURCE OF TRUTH for what "done" means.
-    Worker comments are secondary evidence of what was attempted.
+    Worker output is secondary evidence of what was attempted.
     You must be thorough and objective. Do not rubber-stamp.
+
+    You have WRITE access to linearis. After auditing, you are responsible for:
+    - Posting an audit summary comment on the issue
+    - Updating the issue status if the audit passes
+    Use `linearis` CLI via exec for these operations.
   task: |
     Audit issue {{identifier}}: {{title}}
 
@@ -44,12 +57,16 @@ audit:
 
     Checklist:
     1. Identify ALL acceptance criteria from the issue body
-    2. Read worker comments on the issue (use linearis)
+    2. Read worker comments: `linearis issues read {{identifier}}`
     3. Verify each acceptance criterion is addressed in the code
     4. Run tests in the worktree — verify they pass
     5. Check test coverage if expectations are stated in the issue
     6. Review the code diff for quality and correctness
 
+    After auditing:
+    - Post your audit findings as a comment: `linearis comments create {{identifier}} --body "..."`
+    - If PASS: update status: `linearis issues update {{identifier}} --status "Done"`
+
     You MUST return a JSON verdict as the last line of your response:
     {"pass": true/false, "criteria": ["list of criteria found"], "gaps": ["list of unmet criteria"], "testResults": "summary of test output"}
 
@@ -59,3 +76,4 @@ rework:
     {{gaps}}
 
     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.

package/src/agent.ts

@@ -1,7 +1,36 @@
 import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { mkdirSync, readFileSync } from "node:fs";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { LinearAgentApi, ActivityContent } from "./linear-api.js";
 
+// ---------------------------------------------------------------------------
+// Agent directory resolution (config-based, not ext API which ignores agentId)
+// ---------------------------------------------------------------------------
+
+interface AgentDirs {
+  workspaceDir: string;
+  agentDir: string;
+}
+
+function resolveAgentDirs(agentId: string, config: Record<string, any>): AgentDirs {
+  const home = process.env.HOME ?? "/home/claw";
+  const agentList = config?.agents?.list as Array<Record<string, any>> | undefined;
+  const agentEntry = agentList?.find((a) => a.id === agentId);
+
+  // Workspace: agent-specific override → agents.defaults.workspace → fallback
+  const workspaceDir = agentEntry?.workspace
+    ?? config?.agents?.defaults?.workspace
+    ?? join(home, ".openclaw", "workspace");
+
+  // Agent runtime dir: always ~/.openclaw/agents/{agentId}/agent
+  // (matches OpenClaw's internal structure)
+  const agentDir = join(home, ".openclaw", "agents", agentId, "agent");
+  mkdirSync(agentDir, { recursive: true });
+
+  return { workspaceDir, agentDir };
+}
+
 // Import extensionAPI for embedded agent runner (internal, not in public SDK)
 let _extensionAPI: typeof import("/home/claw/.npm-global/lib/node_modules/openclaw/dist/extensionAPI.js") | null = null;
 async function getExtensionAPI() {
@@ -66,17 +95,22 @@ async function runEmbedded(
 ): Promise<AgentRunResult> {
   const ext = await getExtensionAPI();
 
-  const workspaceDir = ext.resolveAgentWorkspaceDir({ agentId });
-  const sessionFile = ext.resolveSessionFilePath(sessionId);
-  const agentDir = ext.resolveAgentDir({ agentId });
+  // Load config so we can resolve agent dirs and providers correctly.
+  const config = await api.runtime.config.loadConfig();
+  const configAny = config as Record<string, any>;
+
+  // Resolve workspace and agent dirs from config (ext API ignores agentId).
+  const dirs = resolveAgentDirs(agentId, configAny);
+  const { workspaceDir, agentDir } = dirs;
   const runId = randomUUID();
 
-  // Load config so embedded runner can resolve providers, API keys, etc.
-  const config = await api.runtime.config.loadConfig();
+  // Build session file path under the correct agent's sessions directory.
+  const sessionsDir = join(agentDir, "sessions");
+  try { mkdirSync(sessionsDir, { recursive: true }); } catch {}
+  const sessionFile = join(sessionsDir, `${sessionId}.jsonl`);
 
   // Resolve model/provider from config — default is anthropic which requires
   // a separate API key. Our agents use openrouter.
-  const configAny = config as Record<string, any>;
   const agentList = configAny?.agents?.list as Array<Record<string, any>> | undefined;
   const agentEntry = agentList?.find((a) => a.id === agentId);
   const modelRef: string =
@@ -89,7 +123,7 @@ async function runEmbedded(
   const provider = slashIdx > 0 ? modelRef.slice(0, slashIdx) : ext.DEFAULT_PROVIDER;
   const model = slashIdx > 0 ? modelRef.slice(slashIdx + 1) : modelRef;
 
-  api.logger.info(`Embedded agent run: agent=${agentId} session=${sessionId} runId=${runId} provider=${provider} model=${model}`);
+  api.logger.info(`Embedded agent run: agent=${agentId} session=${sessionId} runId=${runId} provider=${provider} model=${model} workspaceDir=${workspaceDir} agentDir=${agentDir}`);
 
   const emit = (content: ActivityContent) => {
     streaming.linearApi.emitActivity(streaming.agentSessionId, content).catch((err) => {

package/src/claude-tool.ts

@@ -138,7 +138,6 @@ export async function runClaude(
   if (model ?? pluginConfig?.claudeModel) {
     args.push("--model", (model ?? pluginConfig?.claudeModel) as string);
   }
-  args.push("-C", workingDir);
   args.push("-p", prompt);
 
   api.logger.info(`Claude exec: ${CLAUDE_BIN} ${args.join(" ").slice(0, 200)}...`);
@@ -150,6 +149,7 @@ export async function runClaude(
 
     const child = spawn(CLAUDE_BIN, args, {
       stdio: ["ignore", "pipe", "pipe"],
+      cwd: workingDir,
       env,
       timeout: 0,
     });

package/src/webhook.ts

@@ -187,12 +187,18 @@ export async function handleLinearWebhook(
       .map((c: any) => `  - **${c.user?.name ?? "Unknown"}**: ${c.body?.slice(0, 200)}`)
       .join("\n");
 
+    const notifIssueRef = enrichedIssue?.identifier ?? issue.id;
     const message = [
-      `IMPORTANT: You are responding to a Linear issue notification. Your ENTIRE text output will be automatically posted as a comment on the issue. Do NOT attempt to post to Linear yourself — no tools, no CLI, no API calls. Just write your response as plain text/markdown.`,
+      `You are an orchestrator responding to a Linear issue notification. Your text output will be automatically posted as a comment on the issue (do NOT post a comment yourself — the handler does it).`,
       ``,
-      `You were mentioned/assigned in a Linear issue. Respond naturally and helpfully.`,
+      `**Tool access:**`,
+      `- \`linearis\` CLI: READ ONLY. You can read issues (\`linearis issues read ${notifIssueRef}\`), list, and search. Do NOT use linearis to update, close, comment, or modify issues.`,
+      `- \`code_run\`: Dispatch coding work to a worker. Workers return text — they cannot access linearis.`,
+      `- Standard tools: exec, read, edit, write, web_search, etc.`,
       ``,
-      `## Issue: ${enrichedIssue?.identifier ?? issue.id} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
+      `**Your role:** Dispatcher. For work requests, use \`code_run\`. You do NOT update issue status — the audit system handles lifecycle.`,
+      ``,
+      `## Issue: ${notifIssueRef} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
       `**Status:** ${enrichedIssue?.state?.name ?? "Unknown"} | **Assignee:** ${enrichedIssue?.assignee?.name ?? "Unassigned"}`,
       ``,
       `**Description:**`,
@@ -200,7 +206,7 @@ export async function handleLinearWebhook(
       commentSummary ? `\n**Recent comments:**\n${commentSummary}` : "",
       comment?.body ? `\n**Triggering comment:**\n> ${comment.body}` : "",
       ``,
-      `Respond concisely. If there's a task, explain what you'll do and do it.`,
+      `Respond concisely. For work requests, dispatch via \`code_run\` and summarize the result.`,
     ].filter(Boolean).join("\n");
 
     // Dispatch agent with session lifecycle (non-blocking)
@@ -363,11 +369,19 @@ export async function handleLinearWebhook(
       .map((c: any) => `**${c.user?.name ?? c.actorName ?? "User"}**: ${(c.body ?? "").slice(0, 300)}`)
       .join("\n\n");
 
+    const issueRef = enrichedIssue?.identifier ?? issue.identifier ?? issue.id;
     const message = [
-      `You are an AI agent responding in a Linear issue session. Your text output will be posted as activities visible to the user.`,
-      `You have access to tools including \`code_run\` for coding tasks, \`spawn_agent\`/\`ask_agent\` for delegation, and standard tools (exec, read, edit, write, web_search, etc.). To manage Linear issues (update status, close, assign, comment, etc.) use the \`linearis\` CLI via exec — e.g. \`linearis issues update API-123 --status done\` to close an issue, \`linearis issues update API-123 --status "In Progress"\` to change status, \`linearis issues list\` to list issues. Run \`linearis usage\` for full command reference.`,
+      `You are an orchestrator responding in a Linear issue session. Your text output will be posted as activities visible to the user.`,
+      ``,
+      `**Tool access:**`,
+      `- \`linearis\` CLI: READ ONLY. You can read issues (\`linearis issues read ${issueRef}\`), list issues (\`linearis issues list\`), and search (\`linearis issues search "..."\`). Do NOT use linearis to update, close, comment, or modify issues.`,
+      `- \`code_run\`: Dispatch coding work to a worker. Workers return text — they cannot access linearis.`,
+      `- \`spawn_agent\`/\`ask_agent\`: Delegate to other crew agents.`,
+      `- Standard tools: exec, read, edit, write, web_search, etc.`,
       ``,
-      `## Issue: ${enrichedIssue?.identifier ?? issue.identifier ?? issue.id} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
+      `**Your role:** You are the dispatcher. For any coding or implementation work, use \`code_run\` to dispatch it. Workers return text output. You summarize results. You do NOT update issue status or post linearis comments — the audit system handles lifecycle transitions.`,
+      ``,
+      `## Issue: ${issueRef} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
       `**Status:** ${enrichedIssue?.state?.name ?? "Unknown"} | **Assignee:** ${enrichedIssue?.assignee?.name ?? "Unassigned"}`,
       ``,
       `**Description:**`,
@@ -375,7 +389,7 @@ export async function handleLinearWebhook(
       commentContext ? `\n**Conversation:**\n${commentContext}` : "",
       userMessage ? `\n**Latest message:**\n> ${userMessage}` : "",
       ``,
-      `Respond to the user's request. If they ask you to write code or make changes, use the \`code_run\` tool. Be concise and action-oriented.`,
+      `Respond to the user's request. For work requests, dispatch via \`code_run\` and summarize the result. Be concise and action-oriented.`,
     ].filter(Boolean).join("\n");
 
     // Run agent directly (non-blocking)
@@ -543,11 +557,19 @@ export async function handleLinearWebhook(
         .map((c: any) => `**${c.user?.name ?? "User"}**: ${(c.body ?? "").slice(0, 300)}`)
         .join("\n\n");
 
+      const followUpIssueRef = enrichedIssue?.identifier ?? issue.identifier ?? issue.id;
       const message = [
-        `You are an AI agent responding in a Linear issue session. Your text output will be posted as activities visible to the user.`,
-        `You have access to tools including \`code_run\` for coding tasks, \`spawn_agent\`/\`ask_agent\` for delegation, and standard tools (exec, read, edit, write, web_search, etc.). To manage Linear issues (update status, close, assign, comment, etc.) use the \`linearis\` CLI via exec — e.g. \`linearis issues update API-123 --status done\` to close an issue, \`linearis issues update API-123 --status "In Progress"\` to change status, \`linearis issues list\` to list issues. Run \`linearis usage\` for full command reference.`,
+        `You are an orchestrator responding in a Linear issue session. Your text output will be posted as activities visible to the user.`,
+        ``,
+        `**Tool access:**`,
+        `- \`linearis\` CLI: READ ONLY. You can read issues (\`linearis issues read ${followUpIssueRef}\`), list, and search. Do NOT use linearis to update, close, comment, or modify issues.`,
+        `- \`code_run\`: Dispatch coding work to a worker. Workers return text — they cannot access linearis.`,
+        `- \`spawn_agent\`/\`ask_agent\`: Delegate to other crew agents.`,
+        `- Standard tools: exec, read, edit, write, web_search, etc.`,
         ``,
-        `## Issue: ${enrichedIssue?.identifier ?? issue.identifier ?? issue.id} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
+        `**Your role:** Dispatcher. For work requests, use \`code_run\`. You do NOT update issue status — the audit system handles lifecycle.`,
+        ``,
+        `## Issue: ${followUpIssueRef} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
         `**Status:** ${enrichedIssue?.state?.name ?? "Unknown"} | **Assignee:** ${enrichedIssue?.assignee?.name ?? "Unassigned"}`,
         ``,
         `**Description:**`,
@@ -555,7 +577,7 @@ export async function handleLinearWebhook(
         commentContext ? `\n**Recent conversation:**\n${commentContext}` : "",
         `\n**User's follow-up message:**\n> ${userMessage}`,
         ``,
-        `Respond to the user's follow-up. Be concise and action-oriented.`,
+        `Respond to the user's follow-up. For work requests, dispatch via \`code_run\`. Be concise and action-oriented.`,
       ].filter(Boolean).join("\n");
 
       setActiveSession({
@@ -683,6 +705,14 @@ export async function handleLinearWebhook(
 
     api.logger.info(`Comment mention: @${mentionedAgent} on ${issue.identifier ?? issue.id} by ${commentor}`);
 
+    // Guard: skip if an agent run is already active for this issue
+    // (prevents dual-dispatch when both Comment.create and AgentSessionEvent fire)
+    if (activeRuns.has(issue.id)) {
+      api.logger.info(`Comment mention: agent already running for ${issue.identifier ?? issue.id} — skipping`);
+      return true;
+    }
+    activeRuns.add(issue.id);
+
     // React with eyes to acknowledge the comment
     if (comment?.id) {
       linearApi.createReaction(comment.id, "eyes").catch(() => {});
@@ -712,9 +742,14 @@ export async function handleLinearWebhook(
     const assignee = enrichedIssue.assignee?.name ?? "Unassigned";
 
     const taskMessage = [
-      `IMPORTANT: You are responding to a Linear issue comment. Your ENTIRE text output will be automatically posted as a comment on the issue. Do NOT attempt to post to Linear yourself — no tools, no CLI, no API calls. Just write your response as plain text/markdown.`,
+      `You are an orchestrator responding to a Linear issue comment. Your text output will be automatically posted as a comment on the issue (do NOT post a comment yourself — the handler does it).`,
+      ``,
+      `**Tool access:**`,
+      `- \`linearis\` CLI: READ ONLY. You can read issues (\`linearis issues read ${enrichedIssue.identifier ?? "API-XXX"}\`), list issues (\`linearis issues list\`), and search (\`linearis issues search "..."\`). Do NOT use linearis to update, close, comment, or modify issues.`,
+      `- \`code_run\`: Dispatch coding work to a worker. Workers return text — they cannot access linearis.`,
+      `- Standard tools: exec, read, edit, write, web_search, etc.`,
       ``,
-      `You were mentioned by name. Respond naturally and helpfully as a team member. Be concise, markdown-friendly. Do NOT use JSON or structured output.`,
+      `**Your role:** You are the dispatcher. For any coding or implementation work, use \`code_run\` to dispatch it. Workers return text output. You summarize results. You do NOT update issue status or post linearis comments — the audit system handles lifecycle transitions.`,
       ``,
       `**Issue:** ${enrichedIssue.identifier ?? enrichedIssue.id} — ${enrichedIssue.title ?? "(untitled)"}`,
       `**Status:** ${state} | **Priority:** ${priority} | **Assignee:** ${assignee} | **Labels:** ${labels}`,
@@ -725,7 +760,7 @@ export async function handleLinearWebhook(
       `**${commentor} wrote:**`,
       `> ${commentBody}`,
       ``,
-      `Respond to their message. Be concise and direct. If they're asking you to do work, explain what you'll do and do it.`,
+      `Respond to their message. Be concise and direct. For work requests, dispatch via \`code_run\` and summarize the result.`,
     ].filter(Boolean).join("\n");
 
     // Dispatch to agent with full session lifecycle (non-blocking)
@@ -814,6 +849,7 @@ export async function handleLinearWebhook(
         }
       } finally {
         clearActiveSession(issue.id);
+        activeRuns.delete(issue.id);
       }
     })();