@calltelemetry/openclaw-linear 0.8.8 → 0.9.0

package/src/pipeline/dispatch-state.ts

@@ -20,7 +20,7 @@ import { homedir } from "node:os";
 // Types
 // ---------------------------------------------------------------------------
 
-export type Tier = "junior" | "medior" | "senior";
+export type Tier = "small" | "medium" | "high";
 
 export type DispatchStatus =
   | "dispatched"
@@ -79,6 +79,8 @@ export interface SessionMapping {
 }
 
 export interface DispatchState {
+  /** Schema version — used by migrateState() for forward-compatible upgrades */
+  version: 2;
   dispatches: {
     active: Record<string, ActiveDispatch>;
     completed: Record<string, CompletedDispatch>;
@@ -114,26 +116,38 @@ import { acquireLock, releaseLock } from "../infra/file-lock.js";
 
 function emptyState(): DispatchState {
   return {
+    version: 2,
     dispatches: { active: {}, completed: {} },
     sessionMap: {},
     processedEvents: [],
   };
 }
 
-/** Migrate v1 state (no sessionMap/processedEvents) to v2 */
+/** Migrate state from any known version to the current version (2). */
 function migrateState(raw: any): DispatchState {
-  const state = raw as DispatchState;
-  if (!state.sessionMap) state.sessionMap = {};
-  if (!state.processedEvents) state.processedEvents = [];
-  // Ensure all active dispatches have attempt field
-  for (const d of Object.values(state.dispatches.active)) {
-    if ((d as any).attempt === undefined) (d as any).attempt = 0;
-  }
-  // Migrate old status "running" → "working"
-  for (const d of Object.values(state.dispatches.active)) {
-    if ((d as any).status === "running") (d as any).status = "working";
+  const version = raw?.version ?? 1;
+  switch (version) {
+    case 1: {
+      // v1 → v2: add sessionMap, processedEvents, attempt defaults, status rename
+      const state = raw as DispatchState;
+      if (!state.sessionMap) state.sessionMap = {};
+      if (!state.processedEvents) state.processedEvents = [];
+      // Ensure all active dispatches have attempt field
+      for (const d of Object.values(state.dispatches.active)) {
+        if ((d as any).attempt === undefined) (d as any).attempt = 0;
+      }
+      // Migrate old status "running" → "working"
+      for (const d of Object.values(state.dispatches.active)) {
+        if ((d as any).status === "running") (d as any).status = "working";
+      }
+      state.version = 2;
+      return state;
+    }
+    case 2:
+      return raw as DispatchState;
+    default:
+      throw new Error(`Unknown dispatch state version: ${version}`);
   }
-  return state;
 }
 
 export async function readDispatchState(configPath?: string): Promise<DispatchState> {
@@ -143,6 +157,15 @@ export async function readDispatchState(configPath?: string): Promise<DispatchSt
     return migrateState(JSON.parse(raw));
   } catch (err: any) {
     if (err.code === "ENOENT") return emptyState();
+    if (err instanceof SyntaxError) {
+      // State file corrupted — log and recover
+      console.error(`Dispatch state corrupted at ${filePath}: ${err.message}. Starting fresh.`);
+      // Rename corrupted file for forensics
+      try {
+        await fs.rename(filePath, `${filePath}.corrupted.${Date.now()}`);
+      } catch { /* best-effort */ }
+      return emptyState();
+    }
     throw err;
   }
 }
@@ -434,6 +457,18 @@ export async function pruneCompleted(
   }
 }
 
+/**
+ * Garbage-collect completed dispatches older than maxAgeMs.
+ * Convenience wrapper with a 7-day default.
+ * Returns the count of pruned entries.
+ */
+export async function pruneCompletedDispatches(
+  maxAgeMs: number = 7 * 24 * 60 * 60_000,
+  configPath?: string,
+): Promise<number> {
+  return pruneCompleted(maxAgeMs, configPath);
+}
+
 /**
  * Remove an active dispatch (e.g. when worktree is gone and branch is gone).
  */

package/src/pipeline/e2e-dispatch.test.ts

@@ -100,7 +100,7 @@ function makeDispatch(worktreePath: string, overrides?: Partial<ActiveDispatch>)
     issueIdentifier: "ENG-100",
     worktreePath,
     branch: "codex/ENG-100",
-    tier: "junior" as const,
+    tier: "small" as const,
     model: "test-model",
     status: "dispatched",
     dispatchedAt: new Date().toISOString(),
@@ -468,7 +468,7 @@ describe("E2E dispatch pipeline", () => {
     writeManifest(worktree, {
       issueIdentifier: "ENG-100",
       issueId: "issue-1",
-      tier: "junior",
+      tier: "small",
       status: "dispatched",
       attempts: 0,
       dispatchedAt: new Date().toISOString(),

package/src/pipeline/intent-classify.test.ts

@@ -151,16 +151,34 @@ describe("classifyIntent", () => {
     expect(result.fromFallback).toBe(true);
   });
 
-  it("uses 12s timeout for classification", async () => {
+  it("uses 10s timeout for classification", async () => {
     await classifyIntent(createApi(), createCtx());
 
     expect(runAgentMock).toHaveBeenCalledWith(
       expect.objectContaining({
-        timeoutMs: 12_000,
+        timeoutMs: 10_000,
       }),
     );
   });
 
+  it("falls back to regex when classification times out via Promise.race", async () => {
+    // Simulate runAgent hanging beyond the 10s timeout
+    runAgentMock.mockImplementationOnce(
+      () => new Promise((resolve) => setTimeout(resolve, 60_000)),
+    );
+
+    // Use fake timers to avoid actually waiting
+    vi.useFakeTimers();
+    const promise = classifyIntent(createApi(), createCtx({ commentBody: "fix the bug" }));
+    // Advance past the 10s timeout
+    await vi.advanceTimersByTimeAsync(10_001);
+    const result = await promise;
+    vi.useRealTimers();
+
+    expect(result.fromFallback).toBe(true);
+    expect(result.intent).toBe("general"); // regex fallback for "fix the bug" with no agent names matched
+  });
+
   it("includes context in the prompt", async () => {
     await classifyIntent(createApi(), createCtx({
       commentBody: "what can I do?",

package/src/pipeline/intent-classify.ts

@@ -7,9 +7,8 @@
  *
  * Cost: one short agent turn (~300 tokens). Latency: ~2-5s.
  */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { resolveDefaultAgent } from "../infra/shared-profiles.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -115,13 +114,19 @@ export async function classifyIntent(
   try {
     const { runAgent } = await import("../agent/agent.js");
     const classifierAgent = resolveClassifierAgent(api, pluginConfig);
-    const result = await runAgent({
-      api,
-      agentId: classifierAgent,
-      sessionId: `intent-classify-${Date.now()}`,
-      message,
-      timeoutMs: 12_000, // 12s — fast classification
-    });
+    const CLASSIFY_TIMEOUT_MS = 10_000;
+    const result = await Promise.race([
+      runAgent({
+        api,
+        agentId: classifierAgent,
+        sessionId: `intent-classify-${Date.now()}`,
+        message,
+        timeoutMs: CLASSIFY_TIMEOUT_MS,
+      }),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Intent classification timed out")), CLASSIFY_TIMEOUT_MS)
+      ),
+    ]);
 
     if (result.output) {
       const parsed = parseIntentResponse(result.output, ctx);
@@ -252,18 +257,3 @@ function resolveClassifierAgent(api: OpenClawPluginApi, pluginConfig?: Record<st
   // 2. Fall back to default agent
   return resolveDefaultAgent(api);
 }
-
-function resolveDefaultAgent(api: OpenClawPluginApi): string {
-  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
-  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
-
-  try {
-    const profilesPath = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
-    const raw = readFileSync(profilesPath, "utf8");
-    const profiles = JSON.parse(raw).agents ?? {};
-    const defaultAgent = Object.entries(profiles).find(([, p]: [string, any]) => p.isDefault);
-    if (defaultAgent) return defaultAgent[0];
-  } catch { /* fall through */ }
-
-  return "default";
-}

package/src/pipeline/pipeline.ts

@@ -48,6 +48,7 @@ import {
 } from "./artifacts.js";
 import { resolveWatchdogConfig } from "../agent/watchdog.js";
 import { emitDiagnostic } from "../infra/observability.js";
+import { renderTemplate } from "../infra/template.js";
 
 // ---------------------------------------------------------------------------
 // Prompt loading
@@ -166,14 +167,6 @@ export function clearPromptCache(): void {
   _projectPromptCache.clear();
 }
 
-function renderTemplate(template: string, vars: Record<string, string>): string {
-  let result = template;
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
-}
-
 // ---------------------------------------------------------------------------
 // Task builders
 // ---------------------------------------------------------------------------
@@ -568,7 +561,15 @@ async function handleAuditPass(
   ).catch((err) => api.logger.error(`${TAG} failed to post audit pass comment: ${err}`));
 
   api.logger.info(`${TAG} audit PASSED — dispatch completed (attempt ${dispatch.attempt})`);
-  emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "done", attempt: dispatch.attempt });
+  emitDiagnostic(api, {
+    event: "verdict_processed",
+    identifier: dispatch.issueIdentifier,
+    issueId: dispatch.issueId,
+    phase: "done",
+    attempt: dispatch.attempt,
+    tier: dispatch.tier,
+    agentId: (pluginConfig?.defaultAgentId as string) ?? "default",
+  });
 
   await notify("audit_pass", {
     identifier: dispatch.issueIdentifier,
@@ -644,7 +645,15 @@ async function handleAuditFail(
     ).catch((err) => api.logger.error(`${TAG} failed to post escalation comment: ${err}`));
 
     api.logger.warn(`${TAG} audit FAILED ${nextAttempt}x — escalating to human`);
-    emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "stuck", attempt: nextAttempt });
+    emitDiagnostic(api, {
+      event: "verdict_processed",
+      identifier: dispatch.issueIdentifier,
+      issueId: dispatch.issueId,
+      phase: "stuck",
+      attempt: nextAttempt,
+      tier: dispatch.tier,
+      agentId: (pluginConfig?.defaultAgentId as string) ?? "default",
+    });
 
     await notify("escalation", {
       identifier: dispatch.issueIdentifier,
@@ -820,7 +829,15 @@ export async function spawnWorker(
     const thresholdSec = Math.round(wdConfig.inactivityMs / 1000);
 
     api.logger.warn(`${TAG} worker killed by inactivity watchdog 2x — escalating to stuck`);
-    emitDiagnostic(api, { event: "watchdog_kill", identifier: dispatch.issueIdentifier, attempt: dispatch.attempt });
+    emitDiagnostic(api, {
+      event: "watchdog_kill",
+      identifier: dispatch.issueIdentifier,
+      issueId: dispatch.issueId,
+      attempt: dispatch.attempt,
+      tier: dispatch.tier,
+      durationMs: workerElapsed,
+      agentId,
+    });
 
     try {
       appendLog(dispatch.worktreePath, {

package/src/pipeline/planner.ts

@@ -26,6 +26,7 @@ import {
 import { runClaude } from "../tools/claude-tool.js";
 import { runCodex } from "../tools/codex-tool.js";
 import { runGemini } from "../tools/gemini-tool.js";
+import { renderTemplate } from "../infra/template.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -72,14 +73,6 @@ function loadPlannerPrompts(pluginConfig?: Record<string, unknown>): PlannerProm
   return defaults;
 }
 
-function renderTemplate(template: string, vars: Record<string, string>): string {
-  let result = template;
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
-}
-
 // ---------------------------------------------------------------------------
 // Planning initiation
 // ---------------------------------------------------------------------------

package/src/pipeline/planning-state.ts

@@ -71,6 +71,15 @@ export async function readPlanningState(configPath?: string): Promise<PlanningSt
     return parsed;
   } catch (err: any) {
     if (err.code === "ENOENT") return emptyState();
+    if (err instanceof SyntaxError) {
+      // State file corrupted — log and recover
+      console.error(`Planning state corrupted at ${filePath}: ${err.message}. Starting fresh.`);
+      // Rename corrupted file for forensics
+      try {
+        await fs.rename(filePath, `${filePath}.corrupted.${Date.now()}`);
+      } catch { /* best-effort */ }
+      return emptyState();
+    }
     throw err;
   }
 }

package/src/pipeline/tier-assess.test.ts

@@ -44,10 +44,10 @@ function makeIssue(overrides?: Partial<IssueContext>): IssueContext {
 // ---------------------------------------------------------------------------
 
 describe("TIER_MODELS", () => {
-  it("maps junior to haiku, medior to sonnet, senior to opus", () => {
-    expect(TIER_MODELS.junior).toBe("anthropic/claude-haiku-4-5");
-    expect(TIER_MODELS.medior).toBe("anthropic/claude-sonnet-4-6");
-    expect(TIER_MODELS.senior).toBe("anthropic/claude-opus-4-6");
+  it("maps small to haiku, medium to sonnet, high to opus", () => {
+    expect(TIER_MODELS.small).toBe("anthropic/claude-haiku-4-5");
+    expect(TIER_MODELS.medium).toBe("anthropic/claude-sonnet-4-6");
+    expect(TIER_MODELS.high).toBe("anthropic/claude-opus-4-6");
   });
 });
 
@@ -59,19 +59,19 @@ describe("assessTier", () => {
   it("returns parsed tier from agent response", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"senior","reasoning":"Multi-service architecture change"}',
+      output: '{"tier":"high","reasoning":"Multi-service architecture change"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("senior");
-    expect(result.model).toBe(TIER_MODELS.senior);
+    expect(result.tier).toBe("high");
+    expect(result.model).toBe(TIER_MODELS.high);
     expect(result.reasoning).toBe("Multi-service architecture change");
     expect(api.logger.info).toHaveBeenCalled();
   });
 
-  it("falls back to medior when agent fails (success: false) with no parseable JSON", async () => {
+  it("falls back to medium when agent fails (success: false) with no parseable JSON", async () => {
     mockRunAgent.mockResolvedValue({
       success: false,
       output: "Agent process exited with code 1",
@@ -80,13 +80,13 @@ describe("assessTier", () => {
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("medior");
-    expect(result.model).toBe(TIER_MODELS.medior);
-    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(result.tier).toBe("medium");
+    expect(result.model).toBe(TIER_MODELS.medium);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medium");
     expect(api.logger.warn).toHaveBeenCalled();
   });
 
-  it("falls back to medior when output has no JSON", async () => {
+  it("falls back to medium when output has no JSON", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
       output: "I think this is a medium complexity issue because it involves multiple files.",
@@ -95,12 +95,12 @@ describe("assessTier", () => {
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("medior");
-    expect(result.model).toBe(TIER_MODELS.medior);
-    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(result.tier).toBe("medium");
+    expect(result.model).toBe(TIER_MODELS.medium);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medium");
   });
 
-  it("falls back to medior when JSON has invalid tier", async () => {
+  it("falls back to medium when JSON has invalid tier", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
       output: '{"tier":"expert","reasoning":"Very hard problem"}',
@@ -109,8 +109,8 @@ describe("assessTier", () => {
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("medior");
-    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.tier).toBe("medium");
+    expect(result.model).toBe(TIER_MODELS.medium);
   });
 
   it("handles agent throwing an error", async () => {
@@ -119,9 +119,9 @@ describe("assessTier", () => {
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("medior");
-    expect(result.model).toBe(TIER_MODELS.medior);
-    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(result.tier).toBe("medium");
+    expect(result.model).toBe(TIER_MODELS.medium);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medium");
     expect(api.logger.warn).toHaveBeenCalledWith(
       expect.stringContaining("Tier assessment error for CT-123"),
     );
@@ -131,7 +131,7 @@ describe("assessTier", () => {
     const longDescription = "A".repeat(3000);
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"junior","reasoning":"Simple copy change"}',
+      output: '{"tier":"small","reasoning":"Simple copy change"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
@@ -149,7 +149,7 @@ describe("assessTier", () => {
   it("uses configured agentId when provided", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"junior","reasoning":"Typo fix"}',
+      output: '{"tier":"small","reasoning":"Typo fix"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
@@ -162,42 +162,42 @@ describe("assessTier", () => {
   it("parses JSON even when wrapped in markdown fences", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '```json\n{"tier":"junior","reasoning":"Config tweak"}\n```',
+      output: '```json\n{"tier":"small","reasoning":"Config tweak"}\n```',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("junior");
-    expect(result.model).toBe(TIER_MODELS.junior);
+    expect(result.tier).toBe("small");
+    expect(result.model).toBe(TIER_MODELS.small);
     expect(result.reasoning).toBe("Config tweak");
   });
 
   it("handles null description gracefully", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"junior","reasoning":"Trivial"}',
+      output: '{"tier":"small","reasoning":"Trivial"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue({ description: null }));
 
-    expect(result.tier).toBe("junior");
+    expect(result.tier).toBe("small");
   });
 
   it("handles empty labels and no comments", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"medior","reasoning":"Standard feature"}',
+      output: '{"tier":"medium","reasoning":"Standard feature"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue({ labels: [], commentCount: undefined }));
 
-    expect(result.tier).toBe("medior");
+    expect(result.tier).toBe("medium");
   });
 
-  it("falls back to medior on malformed JSON (half JSON)", async () => {
+  it("falls back to medium on malformed JSON (half JSON)", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
       output: '{"tier":"seni',
@@ -206,40 +206,40 @@ describe("assessTier", () => {
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("medior");
-    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(result.tier).toBe("medium");
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medium");
   });
 
   it("provides default reasoning when missing from response", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"senior"}',
+      output: '{"tier":"high"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("senior");
+    expect(result.tier).toBe("high");
     expect(result.reasoning).toBe("no reasoning provided");
   });
 
   it("extracts JSON from output with success=false but valid JSON", async () => {
     mockRunAgent.mockResolvedValue({
       success: false,
-      output: 'Agent exited early but: {"tier":"junior","reasoning":"Simple fix"}',
+      output: 'Agent exited early but: {"tier":"small","reasoning":"Simple fix"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });
     const result = await assessTier(api, makeIssue());
 
-    expect(result.tier).toBe("junior");
+    expect(result.tier).toBe("small");
     expect(result.reasoning).toBe("Simple fix");
   });
 
   it("defaults agentId from pluginConfig when not passed", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"medior","reasoning":"Normal"}',
+      output: '{"tier":"medium","reasoning":"Normal"}',
     });
 
     const api = makeApi({ defaultAgentId: "zoe" });
@@ -252,7 +252,7 @@ describe("assessTier", () => {
   it("uses 30s timeout for assessment", async () => {
     mockRunAgent.mockResolvedValue({
       success: true,
-      output: '{"tier":"medior","reasoning":"Normal"}',
+      output: '{"tier":"medium","reasoning":"Normal"}',
     });
 
     const api = makeApi({ defaultAgentId: "mal" });

package/src/pipeline/tier-assess.ts

@@ -7,19 +7,18 @@
  *
  * Cost: one short agent turn (~500 tokens). Latency: ~2-5s.
  */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { Tier } from "./dispatch-state.js";
+import { resolveDefaultAgent } from "../infra/shared-profiles.js";
 
 // ---------------------------------------------------------------------------
 // Tier → Model mapping
 // ---------------------------------------------------------------------------
 
 export const TIER_MODELS: Record<Tier, string> = {
-  junior: "anthropic/claude-haiku-4-5",
-  medior: "anthropic/claude-sonnet-4-6",
-  senior: "anthropic/claude-opus-4-6",
+  small: "anthropic/claude-haiku-4-5",
+  medium: "anthropic/claude-sonnet-4-6",
+  high: "anthropic/claude-opus-4-6",
 };
 
 export interface TierAssessment {
@@ -43,9 +42,9 @@ export interface IssueContext {
 const ASSESS_PROMPT = `You are a complexity assessor. Assess this issue and respond ONLY with JSON.
 
 Tiers:
-- junior: typos, copy changes, config tweaks, simple CSS, env var additions
-- medior: features, bugfixes, moderate refactoring, adding tests, API changes
-- senior: architecture changes, database migrations, security fixes, multi-service coordination
+- small: typos, copy changes, config tweaks, simple CSS, env var additions
+- medium: features, bugfixes, moderate refactoring, adding tests, API changes
+- high: architecture changes, database migrations, security fixes, multi-service coordination
 
 Consider:
 1. How many files/services are likely affected?
@@ -53,12 +52,12 @@ Consider:
 3. Is the description clear and actionable?
 4. Are there dependencies or unknowns?
 
-Respond ONLY with: {"tier":"junior|medior|senior","reasoning":"one sentence"}`;
+Respond ONLY with: {"tier":"small|medium|high","reasoning":"one sentence"}`;
 
 /**
  * Assess issue complexity using the agent's configured model.
  *
- * Falls back to "medior" if the agent call fails or returns invalid JSON.
+ * Falls back to "medium" if the agent call fails or returns invalid JSON.
  */
 export async function assessTier(
   api: OpenClawPluginApi,
@@ -105,13 +104,13 @@ export async function assessTier(
     api.logger.warn(`Tier assessment error for ${issue.identifier}: ${err}`);
   }
 
-  // Fallback: medior is the safest default
+  // Fallback: medium is the safest default
   const fallback: TierAssessment = {
-    tier: "medior",
-    model: TIER_MODELS.medior,
-    reasoning: "Assessment failed — defaulting to medior",
+    tier: "medium",
+    model: TIER_MODELS.medium,
+    reasoning: "Assessment failed — defaulting to medium",
   };
-  api.logger.info(`Tier assessment fallback for ${issue.identifier}: medior`);
+  api.logger.info(`Tier assessment fallback for ${issue.identifier}: medium`);
   return fallback;
 }
 
@@ -119,23 +118,6 @@ export async function assessTier(
 // Helpers
 // ---------------------------------------------------------------------------
 
-function resolveDefaultAgent(api: OpenClawPluginApi): string {
-  // Use the plugin's configured default agent (same one that runs the pipeline)
-  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
-  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
-
-  // Fall back to isDefault in agent profiles
-  try {
-    const profilesPath = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
-    const raw = readFileSync(profilesPath, "utf8");
-    const profiles = JSON.parse(raw).agents ?? {};
-    const defaultAgent = Object.entries(profiles).find(([, p]: [string, any]) => p.isDefault);
-    if (defaultAgent) return defaultAgent[0];
-  } catch { /* fall through */ }
-
-  return "default";
-}
-
 function parseAssessment(raw: string): TierAssessment | null {
   // Extract JSON from the response (may have markdown wrapping)
   const jsonMatch = raw.match(/\{[^}]+\}/);
@@ -144,7 +126,7 @@ function parseAssessment(raw: string): TierAssessment | null {
   try {
     const parsed = JSON.parse(jsonMatch[0]);
     const tier = parsed.tier as string;
-    if (tier !== "junior" && tier !== "medior" && tier !== "senior") return null;
+    if (tier !== "small" && tier !== "medium" && tier !== "high") return null;
 
     return {
       tier: tier as Tier,