@amistio/cli 0.1.9 → 0.1.11

package/README.md

@@ -13,6 +13,8 @@ The package install only installs the `amistio` command. Repository cloning, pro
 
 Runner lifecycle controls in the web app, such as update, restart, and remove, apply only to the runner paired by that user unless the active organization role is an admin role. The runner API binds command polling, command status, logs, activity, and tool sessions to the local runner credential that produced them.
 
+Runner Update installs the official `@amistio/cli` package and then refreshes the runner runtime. Background runners attempt a replacement restart so the next heartbeat reports the new CLI version. Foreground `amistio run --watch` sessions stop after a successful install with restart guidance; start the command again to load the updated package.
+
 Repository brain auto-sync is disabled until the repository link option is enabled in the app. After pairing, run `amistio sync watch` from the paired checkout to push recognized external brain Markdown/MDX files, including local ADRs, plans, prompts, workflows, memory, context, architecture, and feature docs, to the app for review. `amistio run --watch` also runs the same cycle between work polls when the option is enabled. The CLI skips templates, unsupported paths, oversized files, unchanged managed docs, and conflicts instead of silently overwriting web state.
 
 After pairing, confirm that at least one local AI tool is available:
@@ -37,6 +39,8 @@ When `--tool copilot` uses the GitHub Copilot SDK, Amistio approves read-only pe
 
 `amistio runner status` reports local background runner state, latest heartbeat, and bounded resource usage when available. Resource usage is latest-sample runner process memory/CPU plus safe aggregate system memory/load signals; it does not include source files, environment variables, command lines, process lists, credentials, or arbitrary local paths.
 
+The runner advertises its supported work kinds in heartbeats. Current runners can claim read-only issue diagnosis jobs from the web Issues panel, generate root-cause analysis and a proposed fix, and submit that result without modifying source. Implementation is queued separately only after the user approves the analysis in the app.
+
 Runner setup and local-tool execution use bounded failure controls. `amistio run --watch` retries Git worktree preflight failures by releasing the claim for another attempt, then fails the work item after `--max-preflight-attempts` attempts, defaulting to 3. Active local-tool runs renew the work lease, and `--tool-timeout-seconds` caps tool execution, defaulting to 1800 seconds.
 
 For headless startup after login on supported user-level service managers:

package/dist/index.js

@@ -20,6 +20,7 @@ var itemTypeSchema = z.enum([
   "repositoryLink",
   "brainDocument",
   "generatedDraft",
+  "issue",
   "syncCursor",
   "syncConflict",
   "workItem",
@@ -66,11 +67,15 @@ var workStatusSchema = z.enum([
 ]);
 var sourceSchema = z.enum(["web", "repo", "generated", "runner"]);
 var executionModeSchema = z.enum(["localRunner", "cloudSandbox"]);
-var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview"]);
+var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis"]);
 var generatedDraftStatusSchema = z.enum(["queued", "generating", "reviewing", "approved", "rejected", "changesRequested", "failed"]);
 var assistantQuestionModeSchema = z.enum(["brainOnly", "sourceAware"]);
 var impactRiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
 var impactReportStatusSchema = z.enum(["queued", "running", "completed", "failed", "stale"]);
+var issueCategorySchema = z.enum(["bug", "regression", "brokenWorkflow", "security", "operational", "other"]);
+var issueSeveritySchema = z.enum(["low", "medium", "high", "critical"]);
+var issueStatusSchema = z.enum(["queued", "diagnosing", "analysisReady", "approved", "changesRequested", "rejected", "implementationQueued", "implemented", "failed"]);
+var issueApprovalStateSchema = z.enum(["proposed", "approved", "changesRequested", "rejected", "implemented", "blocked"]);
 var activityEventTypeSchema = z.enum([
   "commandSubmitted",
   "generationQueued",
@@ -89,6 +94,11 @@ var activityEventTypeSchema = z.enum([
   "impactPreviewCompleted",
   "impactPreviewFailed",
   "impactPreviewStale",
+  "issueDiagnosisQueued",
+  "issueDiagnosisCompleted",
+  "issueDiagnosisFailed",
+  "issueReview",
+  "issueImplementationQueued",
   "handoffExported"
 ]);
 var activityEventActorSchema = z.enum(["webUser", "runner", "cli", "system"]);
@@ -338,6 +348,7 @@ var workItemSchema = baseItemSchema.extend({
   approvedByUserId: z.string().min(1).optional(),
   sourceWish: z.string().min(1).optional(),
   generatedDraftId: z.string().min(1).optional(),
+  issueId: z.string().min(1).optional(),
   repositoryLinkId: z.string().min(1).optional(),
   reviewThreadId: z.string().min(1).optional(),
   reviewDocumentId: z.string().min(1).optional(),
@@ -386,6 +397,7 @@ var runnerHeartbeatItemSchema = baseItemSchema.extend({
   mode: z.enum(["foreground", "background"]).optional(),
   hostname: z.string().min(1).optional(),
   runnerName: z.string().min(1).optional(),
+  supportedWorkKinds: z.array(workKindSchema).optional(),
   supportsBranchIsolation: z.boolean().optional(),
   supportsGitWorktreeIsolation: z.boolean().optional(),
   currentWorkItemId: z.string().min(1).optional(),
@@ -720,6 +732,47 @@ var impactPreviewResultSchema = z.object({
   analyzedRepoRevision: z.number().int().nonnegative().optional(),
   repoFingerprint: z.string().min(1).optional()
 });
+var issueDiagnosisResultSchema = z.object({
+  summary: z.string().trim().min(1),
+  impact: z.string().trim().min(1),
+  evidence: z.array(z.string().trim().min(1)).default([]),
+  affectedSurfaces: z.array(z.string().trim().min(1)).default([]),
+  rootCauseAnalysis: z.string().trim().min(1),
+  falsifiableHypothesis: z.string().trim().min(1).optional(),
+  nextCheck: z.string().trim().min(1).optional(),
+  proposedFix: z.string().trim().min(1),
+  expectedBehavior: z.string().trim().min(1),
+  verificationPlan: z.array(z.string().trim().min(1)).min(1),
+  riskLevel: impactRiskLevelSchema.default("medium"),
+  likelyPaths: z.array(impactPathSchema).default([]),
+  approvalState: issueApprovalStateSchema.default("proposed")
+});
+var issueItemSchema = baseItemSchema.extend({
+  type: z.literal("issue"),
+  projectId: z.string().min(1),
+  issueId: z.string().min(1),
+  title: z.string().trim().min(1).max(200),
+  description: z.string().trim().min(1).max(12e3),
+  category: issueCategorySchema.default("bug"),
+  severity: issueSeveritySchema.default("medium"),
+  status: issueStatusSchema,
+  approvalState: issueApprovalStateSchema.default("proposed"),
+  submittedByUserId: z.string().min(1).optional(),
+  repositoryLinkId: z.string().min(1).optional(),
+  diagnosisWorkItemId: z.string().min(1).optional(),
+  implementationWorkItemId: z.string().min(1).optional(),
+  diagnosis: issueDiagnosisResultSchema.optional(),
+  reviewNotes: z.string().trim().min(1).optional(),
+  approvedByUserId: z.string().min(1).optional(),
+  approvedAt: isoDateTimeSchema.optional(),
+  requestedChangesByUserId: z.string().min(1).optional(),
+  requestedChangesAt: isoDateTimeSchema.optional(),
+  rejectedByUserId: z.string().min(1).optional(),
+  rejectedAt: isoDateTimeSchema.optional(),
+  diagnosedAt: isoDateTimeSchema.optional(),
+  runnerId: z.string().min(1).optional(),
+  lastDiagnosisError: z.string().optional()
+});
 var activityEventItemSchema = baseItemSchema.extend({
   type: z.literal("activityEvent"),
   projectId: z.string().min(1),
@@ -734,6 +787,7 @@ var activityEventItemSchema = baseItemSchema.extend({
   occurredAt: isoDateTimeSchema,
   relatedWorkItemId: z.string().min(1).optional(),
   relatedDocumentId: z.string().min(1).optional(),
+  relatedIssueId: z.string().min(1).optional(),
   generatedDraftId: z.string().min(1).optional(),
   runnerId: z.string().min(1).optional(),
   repositoryLinkId: z.string().min(1).optional(),
@@ -790,6 +844,7 @@ var projectItemUnionSchema = z.discriminatedUnion("type", [
   repositoryLinkItemSchema,
   brainDocumentItemSchema,
   generatedDraftItemSchema,
+  issueItemSchema,
   syncCursorItemSchema,
   syncConflictItemSchema,
   workItemSchema,
@@ -1527,6 +1582,13 @@ var ApiClient = class {
       { method: "GET" }
     );
   }
+  async listIssues(projectId) {
+    return this.request(
+      `/projects/${projectId}/issues`,
+      z3.object({ issues: z3.array(issueItemSchema) }),
+      { method: "GET" }
+    );
+  }
   async pushBrainDocuments(projectId, documents) {
     return this.request(
       `/projects/${projectId}/brain-documents`,
@@ -1684,6 +1746,16 @@ var ApiClient = class {
       }
     );
   }
+  async submitIssueDiagnosisResult(projectId, workItemId, result) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/issue-result`,
+      z3.object({ issue: issueItemSchema, workItem: workItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify(result)
+      }
+    );
+  }
   async request(urlPath, schema, init) {
     const response = await fetch(resolveApiUrl(this.options.apiUrl, urlPath), {
       ...init,
@@ -3652,6 +3724,8 @@ var assistantAnswerStart = "AMISTIO_ASSISTANT_ANSWER_START";
 var assistantAnswerEnd = "AMISTIO_ASSISTANT_ANSWER_END";
 var impactPreviewStart = "AMISTIO_IMPACT_PREVIEW_START";
 var impactPreviewEnd = "AMISTIO_IMPACT_PREVIEW_END";
+var issueDiagnosisStart = "AMISTIO_ISSUE_DIAGNOSIS_START";
+var issueDiagnosisEnd = "AMISTIO_ISSUE_DIAGNOSIS_END";
 function createWorkExecutionPrompt(workItem, context) {
   if (workItem.workKind === "brainGeneration") {
     return createBrainGenerationPrompt(workItem);
@@ -3665,6 +3739,9 @@ function createWorkExecutionPrompt(workItem, context) {
   if (workItem.workKind === "impactPreview") {
     return createImpactPreviewPrompt(workItem, context?.impactPreview);
   }
+  if (workItem.workKind === "issueDiagnosis") {
+    return createIssueDiagnosisPrompt(workItem, context?.issueDiagnosis);
+  }
   return [
     "# Amistio Work Execution",
     "",
@@ -3693,6 +3770,56 @@ function createWorkExecutionPrompt(workItem, context) {
     "- Run relevant verification commands when feasible and summarize results."
   ].join("\n");
 }
+function createIssueDiagnosisPrompt(workItem, context) {
+  const issue = context?.issue;
+  const approvedContext = (context?.documents ?? []).filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced").slice(0, 16).map((document) => [
+    `### ${document.title}`,
+    `documentId: ${document.documentId}`,
+    `documentType: ${document.documentType}`,
+    `repoPath: ${document.repoPath}`,
+    `revision: ${document.revision}`,
+    document.content.slice(0, 3e3)
+  ].join("\n")).join("\n\n");
+  return [
+    "# Amistio Issue Diagnosis",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Diagnose the submitted bug or operational issue and prepare the approval-gated fix analysis.",
+    "This is a diagnosis-only task. Do not modify files, create branches, run implementation commands, or commit changes.",
+    "",
+    "## Submitted Issue",
+    "",
+    `Issue ID: ${workItem.issueId ?? issue?.issueId ?? "unknown"}`,
+    `Title: ${issue?.title ?? workItem.title}`,
+    `Category: ${issue?.category ?? "bug"}`,
+    `Severity: ${issue?.severity ?? "medium"}`,
+    "",
+    issue?.description ?? workItem.sourceWish ?? workItem.title,
+    "",
+    "## Approved Project Brain Context",
+    "",
+    approvedContext || "No approved project-brain records were loaded. Inspect local repository files as needed and explain the gap in evidence.",
+    "",
+    "## Analysis Requirements",
+    "",
+    "- Document user-visible impact and concrete evidence or reproduction status.",
+    "- Name affected surfaces and likely paths using concise path summaries only.",
+    "- Provide rootCauseAnalysis. If unconfirmed, include falsifiableHypothesis and nextCheck.",
+    "- Propose the fix and expected behavior, then provide a verification plan.",
+    "- Keep repository source and secrets local. Do not include raw source dumps, credentials, local secret paths, or provider session references.",
+    "- Leave approvalState as proposed. Implementation must wait for user approval in Amistio.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below. The CLI will submit only this structured diagnosis back to Amistio.",
+    "",
+    issueDiagnosisStart,
+    '{"summary":"The issue is caused by a missing state transition in the workspace action flow.","impact":"Users see a submitted action but no follow-up analysis appears.","evidence":["Reproduced by submitting an issue from the workspace UI"],"affectedSurfaces":["Workspace UI","Runner claim API"],"rootCauseAnalysis":"The issue path queues normal implementation work instead of diagnosis work.","falsifiableHypothesis":"Adding issueDiagnosis work and a dedicated result route will produce analysis without source mutation.","nextCheck":"Run focused web and CLI typechecks after wiring the route.","proposedFix":"Add a first-class issue diagnosis work kind, result parser, and approval-gated implementation queue.","expectedBehavior":"Submitted issues show a complete analysis and only queue implementation after approval.","verificationPlan":["Run shared, web, and CLI typechecks","Submit an issue with a compatible runner and verify analysis appears"],"riskLevel":"medium","likelyPaths":[{"repoPath":"src/apps/web/legacy/api/projects/[projectId]/issues.ts","reason":"Issue submission and approval route"}],"approvalState":"proposed"}',
+    issueDiagnosisEnd,
+    "",
+    "Do not put Markdown fences around the markers. Do not implement the fix."
+  ].join("\n");
+}
 function createImpactPreviewPrompt(workItem, context) {
   const implementationPrompt = context?.implementationPrompt;
   const approvedContext = (context?.documents ?? []).filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced").slice(0, 16).map((document) => [
@@ -3869,6 +3996,16 @@ function parseImpactPreviewResult(output) {
   const parsed = JSON.parse(stripJsonFence(payload));
   return impactPreviewResultSchema.parse(parsed);
 }
+function parseIssueDiagnosisResult(output) {
+  const start = output.indexOf(issueDiagnosisStart);
+  const end = output.indexOf(issueDiagnosisEnd, start + issueDiagnosisStart.length);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Local AI diagnosis did not return an Amistio issue diagnosis block.");
+  }
+  const payload = output.slice(start + issueDiagnosisStart.length, end).trim();
+  const parsed = JSON.parse(stripJsonFence(payload));
+  return issueDiagnosisResultSchema.parse(parsed);
+}
 function createBrainGenerationPrompt(workItem) {
   const wish = workItem.sourceWish ?? workItem.title;
   return [
@@ -4412,6 +4549,39 @@ async function runOfficialCliUpdate() {
   }
   return { succeeded: false, message: "Official Amistio CLI update command failed.", error: result.output || `npm exited with code ${result.exitCode}.` };
 }
+async function runOfficialCliUpdateWithRuntimeRefresh(options) {
+  const updateResult = await (options.runUpdate ?? runOfficialCliUpdate)();
+  if (!updateResult.succeeded) {
+    return updateResult;
+  }
+  if (options.mode === "foreground") {
+    return {
+      succeeded: true,
+      stopRunner: true,
+      message: `${updateResult.message} Restart the local runner command to load the updated CLI version.`
+    };
+  }
+  if (!options.restartBackgroundRunner) {
+    return {
+      succeeded: false,
+      message: `${updateResult.message} Background runner restart was not available after update. Restart the runner manually to load the updated CLI version.`,
+      error: "Background runner restart hook was not provided."
+    };
+  }
+  const restartResult = await options.restartBackgroundRunner();
+  if (restartResult.succeeded) {
+    return {
+      succeeded: true,
+      stopRunner: true,
+      message: `${updateResult.message} ${restartResult.message}`
+    };
+  }
+  return {
+    succeeded: false,
+    message: `${updateResult.message} Background runner restart failed after update. Restart the runner manually to load the updated CLI version.`,
+    error: restartResult.error ?? restartResult.message
+  };
+}
 function runOfficialUpdateProcess(command, args, timeoutMs) {
   return new Promise((resolve) => {
     const child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -4548,6 +4718,7 @@ var DEFAULT_MAX_PREFLIGHT_ATTEMPTS = 3;
 var DEFAULT_TOOL_TIMEOUT_SECONDS = 30 * 60;
 var RUNNER_WORK_LEASE_SECONDS = 300;
 var RUNNER_WORK_LEASE_RENEWAL_MS = 12e4;
+var runnerSupportedWorkKinds = ["brainGeneration", "implementation", "planRevision", "assistantQuestion", "impactPreview", "issueDiagnosis"];
 program.name("amistio").description("Amistio project brain CLI").version(CLI_VERSION);
 program.command("init").description("Create Amistio control-plane folders for a new project").option("--root <path>", "Repository root", defaultRoot).action(async (options) => {
   const created = await initControlPlane(options.root);
@@ -5510,6 +5681,24 @@ async function runNextWorkItem({
       return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
     }
   }
+  if (result.workItem.workKind === "issueDiagnosis") {
+    try {
+      return await finalizeIssueDiagnosisWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
+  }
   const finalStatus = toolResult.exitCode === 0 ? "completed" : "failed";
   const durationMs = Date.now() - startedAt;
   const failureExcerpt = toolResult.exitCode === 0 ? void 0 : truncateLogExcerpt(toolResult.stderr || toolResult.stdout);
@@ -5712,6 +5901,7 @@ async function recordRunnerMilestone(apiClient, projectId, workItem, runnerId, r
     repositoryLinkId,
     relatedWorkItemId: workItem.workItemId,
     ...workItem.reviewDocumentId ? { relatedDocumentId: workItem.reviewDocumentId } : workItem.impactDocumentId ? { relatedDocumentId: workItem.impactDocumentId } : {},
+    ...workItem.issueId ? { relatedIssueId: workItem.issueId } : {},
     ...workItem.generatedDraftId ? { generatedDraftId: workItem.generatedDraftId } : {},
     ...input
   }).catch(() => void 0);
@@ -5759,7 +5949,10 @@ async function executeRunnerCommand(command, context) {
   if (command.commandKind === "restart") {
     return restartCurrentRunner(context);
   }
-  return runOfficialCliUpdate();
+  return runOfficialCliUpdateWithRuntimeRefresh({
+    mode: currentRunnerMode(),
+    restartBackgroundRunner: () => restartCurrentRunner(context)
+  });
 }
 async function restartCurrentRunner(context) {
   if (currentRunnerMode() !== "background") {
@@ -6047,6 +6240,92 @@ ${toolResult.stderr}`);
   console.error(previewError ?? "Local runner impact preview failed.");
   return { status: "failed", exitCode: toolResult.exitCode || 1 };
 }
+async function finalizeIssueDiagnosisWork({
+  apiClient,
+  durationMs,
+  projectId,
+  repositoryLinkId,
+  runnerId,
+  sessionContext,
+  toolConfig,
+  toolName,
+  toolResult,
+  workItem
+}) {
+  let diagnosis = void 0;
+  let diagnosisError;
+  if (toolResult.exitCode === 0) {
+    try {
+      diagnosis = parseIssueDiagnosisResult(`${toolResult.stdout}
+${toolResult.stderr}`);
+    } catch (error) {
+      diagnosisError = errorMessage3(error);
+    }
+  } else {
+    diagnosisError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
+  }
+  const finalStatus = diagnosis ? "completed" : "failed";
+  const updatedToolSession = await finalizeToolSession({
+    apiClient,
+    projectId,
+    status: finalStatus,
+    runnerId,
+    workItemId: workItem.workItemId,
+    stdout: toolResult.stdout,
+    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+  });
+  const sessionTelemetry = {
+    sessionPolicy: sessionContext.policy,
+    sessionDecision: sessionContext.decision,
+    sessionDecisionReason: sessionContext.reason,
+    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
+    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
+  };
+  if (diagnosis) {
+    const result = await apiClient.submitIssueDiagnosisResult(projectId, workItem.workItemId, {
+      status: "completed",
+      runnerId,
+      idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
+      diagnosis,
+      tool: toolName,
+      durationMs,
+      ...sessionTelemetry,
+      message: `${toolName} returned an issue root-cause analysis.`
+    });
+    await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+      status: "completed",
+      summary: `${toolName} returned an issue root-cause analysis.`,
+      idempotencyKey: `runner_milestone_issue_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, riskLevel: diagnosis.riskLevel, likelyPathCount: diagnosis.likelyPaths.length, verificationSummary: diagnosis.verificationPlan.join(" | ") }
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    console.log("Issue diagnosis returned for approval.");
+    return { status: "completed", exitCode: 0 };
+  }
+  const failedResult = await apiClient.submitIssueDiagnosisResult(projectId, workItem.workItemId, {
+    status: "failed",
+    runnerId,
+    idempotencyKey: `issue_${workItem.workItemId}_${randomUUID()}`,
+    tool: toolName,
+    durationMs,
+    ...sessionTelemetry,
+    message: `${toolName} did not produce a valid issue diagnosis.`,
+    ...diagnosisError ? { error: diagnosisError } : {}
+  });
+  await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+    status: "failed",
+    summary: diagnosisError ?? `${toolName} did not produce a valid issue diagnosis.`,
+    idempotencyKey: `runner_milestone_issue_failed_${workItem.workItemId}_${failedResult.workItem.idempotencyKey}`,
+    metadata: { tool: toolName, durationMs, verificationSummary: "Issue diagnosis output did not include valid structured JSON." }
+  });
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  console.error(diagnosisError ?? "Local runner issue diagnosis failed.");
+  return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
 async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
   if (workItem.workKind === "assistantQuestion") {
     const [{ documents: documents2 }, { messages: messages2 }] = await Promise.all([
@@ -6068,6 +6347,19 @@ async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
       }
     });
   }
+  if (workItem.workKind === "issueDiagnosis") {
+    const [{ documents: documents2 }, { issues }] = await Promise.all([
+      apiClient.listBrainDocuments(projectId),
+      apiClient.listIssues(projectId)
+    ]);
+    const issue = issues.find((item) => item.issueId === workItem.issueId || item.id === workItem.issueId);
+    return createWorkExecutionPrompt(workItem, {
+      issueDiagnosis: {
+        documents: documents2,
+        ...issue ? { issue } : {}
+      }
+    });
+  }
   if (workItem.workKind !== "planRevision" || !workItem.reviewDocumentId) {
     return createWorkExecutionPrompt(workItem);
   }
@@ -6545,6 +6837,7 @@ function toRunnerToolCapabilities(tools) {
 function runnerIsolationCapabilityMetadata() {
   return {
     machineId: runnerMachineId(),
+    supportedWorkKinds: runnerSupportedWorkKinds,
     supportsBranchIsolation: true,
     supportsGitWorktreeIsolation: true
   };