@arcadeai/hypotenuse 0.11.1 → 0.13.0

package/dist/hypotenuse.js

@@ -343,7 +343,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@arcadeai/hypotenuse",
-  version: "0.11.1",
+  version: "0.13.0",
   description: "Hypotenuse \u2014 run coding agents on your machine for Linear agent sessions",
   type: "module",
   license: "Apache-2.0",
@@ -852,14 +852,28 @@ var CANCEL_REASONS = [
   "dashboard",
   "delegate_removed",
   "issue_closed",
+  "unassigned",
   "integration_revoked",
   "superseded"
 ];
 var Cancel = z3.looseObject({
   workItemId: z3.number().int().positive(),
   reason: z3.union([z3.enum(CANCEL_REASONS), z3.string().min(1).max(64)]),
-  by: z3.string().min(1).max(200).optional()
+  by: z3.string().min(1).max(200).optional(),
+  said: z3.string().min(1).max(2000).optional()
 });
+var STOP_QUOTE_MAX = 500;
+function stopQuote(said) {
+  const text = said?.trim();
+  if (!text || /^stop[.!]*$/i.test(text))
+    return "";
+  const cut = text.length > STOP_QUOTE_MAX ? `${text.slice(0, STOP_QUOTE_MAX)}\u2026` : text;
+  return `
+
+> You said: ${cut.split(`
+`).join(`
+> `)}`;
+}
 var Answer = z3.looseObject({
   workItemId: z3.number().int().positive(),
   activityId: z3.number().int().positive(),
@@ -912,10 +926,14 @@ var SelectMetadata = z5.strictObject({
     value: z5.string().trim().min(1).max(1024)
   })).min(1).max(25)
 });
+var AuthProvider = z5.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/).describe("An agent id, `github`, or a git host");
 var AuthMetadata = z5.strictObject({
-  url: z5.url(),
+  url: z5.url().optional(),
+  provider: AuthProvider.optional(),
   userId: z5.string().max(255).optional(),
   providerName: z5.string().max(255).optional()
+}).refine((m) => m.url !== undefined || m.provider !== undefined, {
+  message: "an auth elicitation needs a url or a provider"
 });
 var ThoughtEvent = z5.strictObject({
   ...envelope,
@@ -3524,7 +3542,7 @@ function stopActivity(ctx) {
     case "stop":
       return {
         type: "response",
-        body: `Stopped at your request. Changes so far are ${where}.`
+        body: `Stopped at your request. Changes so far are ${where}.${stopQuote(ctx.note)}`
       };
     case "kill":
       return {
@@ -4451,7 +4469,7 @@ function formFields(request) {
     };
   });
 }
-function elicitationQuestion(request, agentTitle) {
+function elicitationQuestion(request, agentTitle, provider = "agent") {
   const message = truncate(request.message.trim() || "The agent has a question.", 60000);
   const cancelled = () => ({ action: "cancel" });
   const declined = () => ({ action: "decline" });
@@ -4468,7 +4486,11 @@ function elicitationQuestion(request, agentTitle) {
         type: "elicitation",
         body: message,
         signal: "auth",
-        signalMetadata: { url, providerName: truncate(agentTitle, 255) }
+        signalMetadata: {
+          url,
+          provider,
+          providerName: truncate(agentTitle, 255)
+        }
       } : { type: "elicitation", body: `${message}
 
 ${url}` },
@@ -4705,6 +4727,14 @@ var SILENT_KINDS = new Set([
   "compaction_update",
   "compaction_summary_chunk"
 ]);
+function responseSignature(who) {
+  const version = who.agentVersion ? ` ${who.agentVersion}` : "";
+  return `
+
++++ \u2014 Hypotenuse (${who.role}, ${who.agentTitle})
+An AI coding agent: \`${who.agentId}\`${version} on runner \`${who.runnerName}\`, delegated through Hypotenuse.
++++`;
+}
 
 class TurnMapper {
   options;
@@ -4868,9 +4898,10 @@ class TurnMapper {
     switch (stopReason) {
       case "end_turn": {
         const last = this.lastActionSummary;
+        const signature = context.signature ?? "";
         events.push({
           type: "response",
-          body: truncate(said || (last ? `Done. Last step: ${last}.` : "Done."), 60000)
+          body: `${truncate(said || (last ? `Done. Last step: ${last}.` : "Done."), 60000 - signature.length)}${signature}`
         });
         break;
       }
@@ -5079,26 +5110,101 @@ class PrDetector {
   }
 }
 
+// src/acp/preflight.ts
+function providerSlug(agentId) {
+  const slug = agentId.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, 64);
+  return slug || "agent";
+}
+var PREFLIGHT_TIMEOUT_MS = 20000;
+var AUTH_FAILURE = /authentication failed|could not read username|could not read password|permission denied \(publickey|invalid username or password|terminal prompts disabled|support for password authentication was removed|http basic: access denied|403 forbidden|returned error: 40[13]/i;
+function isGitAuthFailure(output) {
+  return AUTH_FAILURE.test(output);
+}
+function remoteHost(remote) {
+  try {
+    const url = new URL(remote);
+    if (url.protocol === "file:")
+      return null;
+    return url.hostname.toLowerCase() || null;
+  } catch {
+    const scp = remote.match(/^(?:[^@/\s]+@)?([^:/\s]+):(?!\/)/);
+    return scp ? scp[1].toLowerCase() : null;
+  }
+}
+function remoteProvider(remote) {
+  const host = remoteHost(remote) ?? "git";
+  if (host === "github.com")
+    return { provider: "github", providerName: "GitHub" };
+  return { provider: host, providerName: host };
+}
+var runCommand2 = async (argv, options) => {
+  try {
+    const proc = Bun.spawn(argv, {
+      cwd: options.cwd,
+      env: {
+        ...options.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GH_PROMPT_DISABLED: "1"
+      },
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timer = setTimeout(() => proc.kill(), options.timeoutMs);
+    const [stdout, stderr, code] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]).finally(() => clearTimeout(timer));
+    return { code, stdout, stderr };
+  } catch (error) {
+    return {
+      code: null,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+async function checkRepositoryAuth(input, run = runCommand2) {
+  const { remote, cwd, env, runnerName } = input;
+  if (!remote || remoteHost(remote) === null)
+    return null;
+  const provider = remoteProvider(remote);
+  const listed = await run(["git", "ls-remote", "--heads", remote], {
+    cwd,
+    env,
+    timeoutMs: PREFLIGHT_TIMEOUT_MS
+  });
+  if (listed.code !== 0 && isGitAuthFailure(`${listed.stderr}
+${listed.stdout}`)) {
+    return {
+      ...provider,
+      body: `Runner ${runnerName} can't sign in to ${provider.providerName} to reach \`${remote}\`, so it could fetch and push nothing. Its owner can fix it on that machine \u2014 the link says how. Reply here once it's done and I'll carry on.`
+    };
+  }
+  if (provider.provider !== "github" || !input.pullRequests)
+    return null;
+  const gh = await run(["gh", "auth", "status", "--hostname", "github.com"], {
+    cwd,
+    env,
+    timeoutMs: PREFLIGHT_TIMEOUT_MS
+  });
+  if (gh.code === null || gh.code === 127)
+    return null;
+  if (gh.code !== 0) {
+    return {
+      ...provider,
+      body: `The GitHub CLI on runner ${runnerName} is not signed in, so I couldn't open a pull request. Its owner can fix it on that machine \u2014 the link says how. Reply here once it's done and I'll carry on.`
+    };
+  }
+  return null;
+}
+
 // src/acp/templates/manager.md
 var manager_default = "You are the planning agent for this Linear workspace, acting as the app user `@hypotenuse`, on\n{{issue.identifier}} \u2014 {{issue.title}}. You are an AI agent; say so if anyone asks.\n\n## What you produce\n\n- **A PRD.** When the issue concerns a whole project, write it into the project's content with\n  `linear_update_project` (read it first with `linear_get_project`). When a person already owns that content, put\n  the PRD in a document attached to the project with `linear_create_document`, and revise it later with\n  `linear_update_document`. Sections: Problem, Goals, Non-goals, User stories, Requirements, Open questions,\n  Rollout. Read the code in your working directory so the PRD fits the codebase as it is.\n- **A breakdown into issues**, each small enough for one agent session: sub-issues of this issue\n  (`linear_create_sub_issue`) or new issues (`linear_create_issue`), edited with `linear_update_issue`. Every issue\n  has a title and a description with an **Acceptance criteria** checklist (`- [ ] \u2026`); labels chosen from\n  `linear_list_labels`, never invented; an estimate where the team uses them; and `blocks` or `related` relations\n  (`linear_create_relation`) where order matters. Look for existing issues first with `linear_search_issues` and\n  `linear_get_issue`, so you do not file duplicates.\n\n## How you ask\n\nAsk clarifying questions with `linear_ask_user`, with `options` whenever the answer is a choice. Ask everything you\nneed at once, not one question per turn, then end your turn. Read what people already said with\n`linear_list_comments`.\n\n## What you never do\n\n- Write or change code, or run commands: your working directory is read-only. If answering a question needs\n  something run, file a small spike issue and dispatch it.\n- Open or merge pull requests: `linear_report_pr` is for workers, and a worker's pull requests reach you in its\n  review.\n- Move an issue to a completed or canceled state with `linear_set_issue_state` unless the tool tells you that is\n  permitted. Moving an issue to an \"In Review\"-type started state is fine.\n- Dispatch an issue you did not create, or that a person has not delegated to you or put under this issue.\n- Have more dispatched issues in progress at once than the tool allows; it will tell you when you are at the\n  limit.\n\n## How you dispatch\n\nDispatch only issues whose acceptance criteria are written: one `hypotenuse_dispatch` per issue, with\n`instructions` for context the worker needs that does not belong in the issue. A worker session starts on the\nissue on whichever runner can take it. Keep this session's plan current with `linear_set_plan` if your own plan\nupdates do not already appear.\n\n## How you review\n\nWhen a dispatched worker finishes, you get a review turn with its result: its outcome, final response, plan, and\npull requests. Check the result against the issue's acceptance criteria (`linear_get_issue`), then do one of:\n\n- **Accept**: say so in a `linear_comment` on the worker's issue (\"Reviewed against the acceptance criteria: \u2026\"),\n  optionally moving it to an \"In Review\"-type state with `linear_set_issue_state`. A person merges the pull\n  request.\n- **Request changes**: one `hypotenuse_dispatch` with `mode: \"changes\"` and specific `instructions` \u2014 what is\n  missing or wrong, against which criterion. The same worker session continues on the same branch.\n- **File follow-ups**: new issues with `linear_create_issue`, related to the original with\n  `linear_create_relation` (`related`). Dispatch them now only if they are ready.\n\nWhen requesting changes is refused because the review round limit is reached, stop sending the work back: end\nwith `linear_ask_user`, addressed to the person who started this session, explaining what is still wrong.\n\nEnd every review turn with a response that says which you chose, and why.\n\n## Writing in Linear\n\nTo mention a person or an issue, use its Linear URL, not an @name. Finish every turn with a short summary of what\nyou decided and what happens next.\n";
 
 // src/acp/templates/worker.md
-var worker_default = `Implement {{issue.identifier}} \u2014 {{issue.title}} \u2014 in the working directory.
-
-- Read the issue and the Linear context below before you change anything, and keep a plan current as you go.
-  \`linear_get_issue\` and \`linear_list_comments\` read the issue and its thread when you need more.
-- Commit in small steps; reference {{issue.identifier}} in every commit message.
-- When the work is ready, push the branch and open a pull request that links {{issue.url}}, then call
-  \`linear_report_pr\` with its URL straight away.
-- If a decision belongs to a person (scope, product behaviour, anything destructive), ask once, clearly, with
-  \`linear_ask_user\` \u2014 with options when there are a few clear choices \u2014 and end your turn there. Their answer
-  arrives as your next prompt.
-- Your thoughts, tool calls, and final message already appear in Linear. Do not repeat them with \`linear_comment\`;
-  that is for a question someone left elsewhere on the issue, or a blocker for someone not following this session.
-- To mention a person or an issue in Linear, use its Linear URL, not an @name.
-- Finish with a short summary: what changed, what you tested, and what a reviewer should look at first. Do not list
-  every file.
-`;
+var worker_default = "Implement {{issue.identifier}} \u2014 {{issue.title}} \u2014 in the working directory. You are an AI agent working as the\nLinear app user `@hypotenuse`; say so if anyone asks.\n\n- Read the issue and the Linear context below before you change anything, and keep a plan current as you go.\n  `linear_get_issue` and `linear_list_comments` read the issue and its thread when you need more.\n- Commit in small steps; reference {{issue.identifier}} in every commit message.\n- When the work is ready, push the branch and open a pull request that links {{issue.url}}, then call\n  `linear_report_pr` with its URL straight away.\n- If a decision belongs to a person (scope, product behaviour, anything destructive), ask once, clearly, with\n  `linear_ask_user` \u2014 with options when there are a few clear choices \u2014 and end your turn there. Their answer\n  arrives as your next prompt.\n- Your thoughts, tool calls, and final message already appear in Linear. Do not repeat them with `linear_comment`;\n  that is for a question someone left elsewhere on the issue, or a blocker for someone not following this session.\n- To mention a person or an issue in Linear, use its Linear URL, not an @name.\n- Finish with a short summary: what changed, what you tested, and what a reviewer should look at first. Do not list\n  every file.\n";
 
 // src/acp/prompt.ts
 var DEFAULT_TEMPLATES = {
@@ -5298,6 +5404,21 @@ class TurnFailure extends Error {
   }
 }
 
+class AuthRequired extends Error {
+  need;
+  unavailable;
+  constructor(need, unavailable) {
+    super(need.body);
+    this.need = need;
+    this.unavailable = unavailable;
+  }
+}
+var SIGNED_IN_BODY = "Signed in \u2014 continuing.";
+function resumesAfterAuth(assignment) {
+  const last = (assignment.history ?? []).filter((h) => h.direction === "outbound").at(-1);
+  return last?.type === "elicitation" && last.signal === "auth";
+}
+
 class AcpSessionExecutor {
   options;
   constructor(options = {}) {
@@ -5337,6 +5458,7 @@ class Turn {
   conn = null;
   acpSessionId = null;
   agentTitle;
+  agentVersion = null;
   endReason = null;
   ended;
   endNow;
@@ -5446,9 +5568,30 @@ class Turn {
       });
       await this.prepare();
       await this.start();
+      if (resumesAfterAuth(ctx.assignment))
+        this.emit({ type: "thought", body: SIGNED_IN_BODY, ephemeral: false });
       timer = setInterval(() => this.tick(), this.options.tickMs ?? TICK_MS);
       return await this.prompt();
     } catch (error) {
+      if (error instanceof AuthRequired && !this.endReason) {
+        if (error.unavailable)
+          ctx.agentAvailability(false, error.unavailable);
+        this.log.note(`needs a login: ${error.need.provider}`);
+        this.emitAll(this.mapper.flushThought(false));
+        this.emit({
+          type: "elicitation",
+          body: error.need.body,
+          signal: "auth",
+          signalMetadata: {
+            provider: error.need.provider,
+            providerName: error.need.providerName.slice(0, 255)
+          }
+        });
+        this.mapper.askedUser = true;
+        return this.result("completed");
+      }
+      if (error instanceof AuthRequired)
+        return await this.stopped();
       if (error instanceof TurnFailure) {
         if (error.unavailable)
           ctx.agentAvailability(false, error.unavailable);
@@ -5482,6 +5625,14 @@ class Turn {
           env: (branch) => sessionEnvironment(ctx.env, sessionVariables(assignment, branch))
         });
       } catch (error) {
+        const remote = ctx.assignment.repository?.remote ?? null;
+        if (error instanceof WorkspaceError && remote && isGitAuthFailure(error.body)) {
+          const provider = remoteProvider(remote);
+          throw new AuthRequired({
+            ...provider,
+            body: `Runner ${ctx.runnerName} can't sign in to ${provider.providerName} to fetch \`${remote}\`. Its owner can fix it on that machine \u2014 the link says how. Reply here once it's done and I'll carry on.`
+          });
+        }
         if (error instanceof WorkspaceError)
           throw new TurnFailure(error.body);
         throw error;
@@ -5491,6 +5642,17 @@ class Turn {
     } else {
       mkdirSync6(this.cwd, { recursive: true, mode: 448 });
     }
+    if (this.endReason)
+      throw new TurnFailure("stopped");
+    const need = await checkRepositoryAuth({
+      remote: this.workspace?.repository?.remote ?? null,
+      cwd: this.cwd,
+      env: ctx.env,
+      runnerName: ctx.runnerName,
+      pullRequests: (assignment.role ?? "worker") === "worker"
+    }, this.options.run);
+    if (need)
+      throw new AuthRequired(need);
     if (this.endReason)
       throw new TurnFailure("stopped");
     this.mapperOptions.cwd = this.cwd;
@@ -5566,7 +5728,7 @@ class Turn {
               throw this.fsError(error);
             }
           },
-          createElicitation: (params) => this.questions.ask(elicitationQuestion(params, this.agentTitle)),
+          createElicitation: (params) => this.questions.ask(elicitationQuestion(params, this.agentTitle, providerSlug(this.agentId))),
           unknown: (method) => this.log.note(`unhandled ${method}`)
         }
       });
@@ -5579,6 +5741,7 @@ class Turn {
     ctx.setState("starting");
     const init = await this.guard(conn.initialize(package_default.version), launch.startupTimeoutMs, `${this.agentId} did not answer initialize within ${launch.startupTimeoutMs / 1000}s (\`${launch.command.join(" ")}\`).`, true);
     this.agentTitle = init.agentInfo?.title ?? init.agentInfo?.name ?? this.agentId;
+    this.agentVersion = init.agentInfo?.version ?? null;
     ctx.log.debug(`${this.agentId} initialized: ${init.agentInfo?.name ?? "?"} ${init.agentInfo?.version ?? ""}`, { session: assignment.agentSessionId });
     await this.openSession(init, launch.authMethod);
     ctx.agentAvailability(true);
@@ -5620,21 +5783,30 @@ class Turn {
         await this.chooseSession(init.agentCapabilities ?? {});
         return;
       } catch (error) {
-        if (!isAuthRequired(error) || authenticated) {
+        if (isAuthRequired(error) && authenticated) {
+          throw new AuthRequired(this.loginNeed(), "not logged in");
+        }
+        if (!isAuthRequired(error)) {
           if (error instanceof TurnFailure)
             throw error;
           throw new TurnFailure(`${this.agentId} could not open a session: ${errorMessage(error)}${quoteTail(this.log.tail())}`);
         }
         const method = this.authMethodFor(init.authMethods ?? [], configuredMethod);
-        if (!method) {
-          throw new TurnFailure(`${this.agentId} on runner ${this.ctx.runnerName} is not logged in. On that machine, run: \`hypotenuse agents login ${this.agentId}\``, "not logged in");
-        }
+        if (!method)
+          throw new AuthRequired(this.loginNeed(), "not logged in");
         this.log.note(`authenticate ${method}`);
         await this.guard(this.conn.authenticate(method), 0, "");
         authenticated = true;
       }
     }
   }
+  loginNeed() {
+    return {
+      provider: providerSlug(this.agentId),
+      providerName: this.agentTitle,
+      body: `${this.agentTitle} on runner ${this.ctx.runnerName} is not logged in. Its owner can sign in on that machine with \`hypotenuse agents login ${this.agentId}\` \u2014 the link has the steps. Reply here once it's done and I'll carry on.`
+    };
+  }
   authMethodFor(methods, configured) {
     const agentRun = methods.filter((m) => m.type !== "terminal");
     if (configured)
@@ -5772,7 +5944,16 @@ class Turn {
     const stop = answer.stopReason === "cancelled" ? "end_turn" : answer.stopReason;
     if (this.mapper.askedUser && this.mapper.hasMessage)
       this.log.note(`said after asking (kept out of Linear): ${this.mapper.message().slice(0, 2000)}`);
-    this.emitAll(this.mapper.finish(stop, { branch: this.branch }));
+    this.emitAll(this.mapper.finish(stop, {
+      branch: this.branch,
+      signature: responseSignature({
+        role: this.ctx.assignment.role ?? "worker",
+        agentId: this.agentId,
+        agentTitle: this.agentTitle,
+        agentVersion: this.agentVersion,
+        runnerName: this.ctx.runnerName
+      })
+    }));
     return stop === "end_turn" ? this.result("completed") : this.result("failed", `stopReason: ${stop}`);
   }
   repositoryName() {
@@ -8094,8 +8275,9 @@ class Supervisor {
       this.silence(id);
     for (const cancel of answer.cancels) {
       const slot = this.slots.get(cancel.workItemId);
-      if (slot && !slot.reason && cancel.by)
-        slot.killNote = cancel.by;
+      const note = cancel.by ?? cancel.said;
+      if (slot && !slot.reason && note)
+        slot.killNote = note;
       this.stop(cancel.workItemId, cancel.reason);
     }
     for (const reply of answer.answers ?? [])
@@ -10201,6 +10383,98 @@ function registerDoctorCommand(program) {
   });
 }
 
+// src/commands/event.ts
+function routedAs(event) {
+  const s = event.session;
+  if (!s?.role)
+    return "-";
+  const why = s.routingRule ? `rule ${s.routingRule.name}` : s.dispatched ? "dispatched" : "default";
+  return `${s.role} (${why})`;
+}
+function turnPlace(event) {
+  const t = event.turn;
+  if (!t)
+    return "-";
+  if (t.status === "queued") {
+    return `queued: ${t.waitingCode ?? t.waitingReason ?? "waiting"}`;
+  }
+  if (t.status === "cancelled") {
+    return `cancelled${t.cancelReason ? `: ${t.cancelReason}` : ""}`;
+  }
+  return t.runner ? `${t.status} on ${t.runner.name}` : t.status;
+}
+function describeEvent(event, payload) {
+  const lines = [
+    `${event.eventType} ${event.action}${event.issueIdentifier ? `  ${event.issueIdentifier}` : ""}`,
+    `outcome    ${event.outcome}`,
+    `summary    ${event.summary ?? "-"}`,
+    `received   ${when(event.receivedAt)}`,
+    `processed  ${when(event.processedAt)}`,
+    `delivery   ${event.deliveryId}`
+  ];
+  if (event.error)
+    lines.push(`error      ${event.error}`);
+  if (event.session) {
+    lines.push(`session    ${event.session.id} (${event.session.status})`);
+    lines.push(`routed as  ${routedAs(event)}`);
+  }
+  if (event.turn) {
+    lines.push(`turn       ${event.turn.id} ${event.turn.kind}, ${turnPlace(event)}`);
+    if (event.turn.waitingReason && event.turn.status === "queued") {
+      lines.push(`waiting    ${event.turn.waitingReason}`);
+    }
+  }
+  lines.push("", payload ? JSON.stringify(payload, null, 2) : "payload    (project admins only)");
+  return lines.join(`
+`);
+}
+function registerEventCommands(program) {
+  const event = program.command("event").description("The selected project's event log: Linear's webhooks and how each was routed");
+  withPaging(event.command("list").description("List webhook events, newest first").option("--type <eventType>", "only this event type, e.g. AgentSessionEvent, Issue, PermissionChange").option("--outcome <outcome>", "only this outcome: handled, ignored, duplicate_of_dispatch, noted, mention_without_session, assigned_not_delegated, disengaged, failed, pending").option("--hide-ignored", "leave out events Hypotenuse did not act on").option("--session <id>", "only events about this agent session").option("--since <time>", "only events since: ISO-8601, epoch ms, or 7d / 12h / 30m")).action(async function() {
+    await runCommand(this, async (ctx) => {
+      const opts = this.opts();
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("GET", "/trigger-events", {
+        query: {
+          projectId,
+          eventType: opts.type,
+          outcome: opts.outcome,
+          hideIgnored: opts.hideIgnored ? true : undefined,
+          agentSessionId: opts.session,
+          since: opts.since ? parseTime(opts.since) : undefined,
+          ...pageQuery(this)
+        }
+      });
+      emit(ctx, result, () => table(result.triggerEvents.map((e) => ({
+        id: e.id,
+        received: when(e.receivedAt),
+        event: `${e.eventType} ${e.action}`,
+        issue: e.issueIdentifier ?? "-",
+        outcome: e.outcome,
+        "routed as": routedAs(e),
+        turn: turnPlace(e),
+        summary: e.summary ?? ""
+      })), [
+        { key: "id" },
+        { key: "received" },
+        { key: "event" },
+        { key: "issue" },
+        { key: "outcome" },
+        { key: "routed as" },
+        { key: "turn", maxWidth: 40 },
+        { key: "summary", maxWidth: 70 }
+      ]) + pageFooter(result.pagination));
+    });
+  });
+  event.command("view <id>").description("Show one event: what it did, how it was routed, and (admins) its payload").action(async function(id) {
+    await runCommand(this, async (ctx) => {
+      const projectId = await ctx.projectId();
+      const result = await ctx.signedInClient().request("GET", `/trigger-event/${id}`, { query: { projectId } });
+      emit(ctx, result, () => describeEvent(result.triggerEvent, result.payload));
+    });
+  });
+}
+
 // src/commands/identity.ts
 function linkedViaText(via) {
   return via === "email" ? "e-mail match" : via === "oauth" ? "Linear sign-in" : "admin";
@@ -11995,6 +12269,7 @@ function buildProgram() {
   registerAuditCommands(program);
   registerIntegrationCommands(program);
   registerSessionCommands(program);
+  registerEventCommands(program);
   registerRunnerCommands(program);
   registerRoutingCommands(program);
   registerIdentityCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcadeai/hypotenuse",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "Hypotenuse — run coding agents on your machine for Linear agent sessions",
   "type": "module",
   "license": "Apache-2.0",

package/skills/hypotenuse.md

@@ -35,6 +35,7 @@ server. It calls the same HTTP actions the dashboard does, as the person who sig
 | `hypotenuse audit list [--since 7d] [--until <time>] [--action tag:edit]` | Who changed what, newest first (admin). Times are ISO-8601, epoch ms, or `7d` / `12h` / `30m`. |
 | `hypotenuse integration list\|view\|connect\|disconnect` | The selected project's trigger integrations — today the only type is `linear`, its Linear workspace connection. `list` shows each type this server supports and whether the project is connected. `view <type>` shows the workspace, the `@hypotenuse` app user, scopes, and token health (never a token). `connect <type>` (admin) prints the consent URL — a **workspace admin** of that system (for `linear`, a Linear workspace admin) must approve it in a browser — and waits until the integration is active (`--no-browser`, `--timeout <seconds>`). `disconnect <type> --yes` (admin) revokes the tokens; the agent stops answering there at once. |
 | `hypotenuse session list\|view\|cancel` | The selected project's agent sessions — each time `@hypotenuse` was delegated an issue or mentioned, in any trigger type (Linear today). `list [--status <status>] [--role manager\|worker] [--type linear] [--issue ENG-123] [--runner <id>]`, newest first; `view <id\|ENG-123>` (an issue identifier names its newest session) shows the session (issue, status, origin, role, runner, issuer, links), its turns (kind, status, runner, and for a waiting turn its reason code such as `offline` or `no_capacity`), and every activity in order, both directions, with each write's delivery status (`pending`, `sent`, `failed`, `superseded`); `--transcript` prints only the activities; `--follow [--interval <seconds>]` keeps printing new ones until interrupted (one JSON object per line under `--json`); `cancel <id>` stops its work as Stop in Linear does (work not started is cancelled; a running turn is told to stop and report). |
+| `hypotenuse event list\|view` | The selected project's event log: every webhook its Linear workspace sent in the last 14 days and how each was routed. `list [--type AgentSessionEvent\|Issue\|…] [--outcome handled\|ignored\|duplicate_of_dispatch\|failed\|pending] [--hide-ignored] [--session <id>] [--since 12h]`, newest first, shows each event's issue, outcome, what it did, the role it was routed as and why (`worker (default)`, `manager (rule /manage)`, `worker (dispatched)`), and where its turn is now (`queued: no_capacity`, `running on <runner>`); `view <id>` shows one in full, with the payload Linear sent for project admins only. |
 | `hypotenuse runner register\|list\|view\|edit\|revoke` | The selected project's runners — machines that run coding agents. `register [--name <name>] [--replace] [--force]` registers **this** machine as the signed-in person, saves the runner token to `credentials.json` (never printed), and sends a first heartbeat; `--replace` revokes the runner of that name first. `list [--status online\|offline\|draining\|revoked] [--all]`; `view <id\|name>` shows capabilities, subscriptions, and whether its socket is attached; `edit <id\|name> [--name] [--enable\|--disable]` renames or pauses it; `revoke <id\|name> --yes` revokes it for good (its owner or an admin). |
 | `hypotenuse routing list\|add\|edit\|remove\|reorder\|preview\|settings` | The selected project's routing rules — the first enabled rule whose match holds decides whether a new session gets a **manager** or a **worker** (no match: worker). `list`; `add --name <name> --role manager\|worker [--label <l>] [--team <key>] [--linear-project <id>] [--prefix /manage] [--has-parent\|--no-parent] [--origin delegation\|mention] [--repository <repo>] [--disabled]` (labels and team keys are checked against the connected workspace); `edit <id>` with the same flags (any match flag replaces the whole match) plus `--enable\|--disable` and `--clear-repository`; `remove <id>`; `reorder <id...>` lists every rule id in the new order; `preview <ENG-123> [--prompt "/manage ..."] [--with-repository]` shows how the issue would route if delegated now — the matching rule, the role, every runner with whether it could take the work and its reason codes, and the repository (any member; `--with-repository` asks Linear to rank repositories, spending its API budget); `settings` shows the routing timers, `settings [--queue-timeout 30m] [--sticky-timeout 10m] [--offer-ttl 10s] [--stop-grace 30s] [--repository-confidence 0.7] [--max-review-rounds 3] [--reset <key>]` changes them. Changes are admin-only. |
 | `hypotenuse identity list\|link\|unlink` | Links between people in the project's Linear workspace and project members; routing prefers the runners of whoever started a session. `list [--user <id>]` shows each link and how it was made (e-mail match, Linear sign-in, admin); `link --user <id> --linear-user <id> [--name] [--email]` links one (admin); `unlink <id>` removes your own link, or anyone's as an admin. |