@united-workforce/cli 0.2.1-rc.9 → 0.4.0

package/src/commands/workflow.ts

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { dirname, resolve as resolvePath } from "node:path";
+import { basename, dirname, isAbsolute, resolve as resolvePath } from "node:path";
 
 import type { JSONSchema } from "@ocas/core";
 import { putSchema, validate } from "@ocas/core";
@@ -12,11 +12,17 @@ import {
   discoverProjectWorkflows,
   findRegistryName,
   loadWorkflowRegistry,
+  resolveProjectWorkflowFile,
   resolveWorkflowHash,
   saveWorkflowRegistry,
   type UwfStore,
 } from "../store.js";
-import { checkWorkflowFilenameConsistency, parseWorkflowPayload } from "../validate.js";
+import {
+  checkWorkflowFilenameConsistency,
+  isCasRef,
+  isMissingVersion,
+  parseWorkflowPayload,
+} from "../validate.js";
 import { validateWorkflow } from "../validate-semantic.js";
 
 export type WorkflowOrigin = "local" | "global";
@@ -105,6 +111,7 @@ export async function materializeWorkflowPayload(
     };
   }
   return {
+    version: raw.version,
     name: raw.name,
     description: raw.description,
     roles,
@@ -112,6 +119,47 @@ export async function materializeWorkflowPayload(
   };
 }
 
+/**
+ * Validate a workflow YAML file without registering it.
+ *
+ * CI-friendly: does not touch CAS or the workflow registry. On success,
+ * returns silently (no stdout/stderr) and exits 0. On any error, writes a
+ * single message to stderr and exits 1.
+ */
+export async function cmdWorkflowValidate(filePath: string): Promise<void> {
+  let text: string;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch {
+    fail(`file not found: ${filePath}`);
+  }
+
+  let raw: unknown;
+  try {
+    raw = parse(text, {
+      customTags: [createIncludeTag(dirname(resolvePath(filePath)))],
+    }) as unknown;
+  } catch (e) {
+    fail(`invalid YAML: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  const payload = parseWorkflowPayload(raw);
+  if (payload === null) {
+    fail("invalid workflow YAML: expected WorkflowPayload shape");
+  }
+
+  const filenameError = checkWorkflowFilenameConsistency(filePath, payload);
+  if (filenameError !== null) {
+    fail(filenameError);
+  }
+
+  const semanticErrors = validateWorkflow(payload);
+  if (semanticErrors.length > 0) {
+    fail(`workflow validation failed:\n${semanticErrors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  // success: silent return
+}
+
 export async function cmdWorkflowAdd(
   storageRoot: string,
   filePath: string,
@@ -137,6 +185,12 @@ export async function cmdWorkflowAdd(
     fail("invalid workflow YAML: expected WorkflowPayload shape");
   }
 
+  if (isMissingVersion(raw)) {
+    process.stderr.write(
+      `warning: workflow YAML "${basename(filePath)}" is missing top-level \`version\` field; falling back to version 1. Add \`version: 1\` to silence this warning.\n`,
+    );
+  }
+
   const filenameError = checkWorkflowFilenameConsistency(filePath, payload);
   if (filenameError !== null) {
     fail(filenameError);
@@ -161,13 +215,113 @@ export async function cmdWorkflowAdd(
   return { name: materialized.name, hash };
 }
 
+// ── workflow show resolution helpers ──────────────────────────────────────────
+
+function isFilePath(input: string): boolean {
+  return (
+    input.includes("/") || input.includes("\\") || input.endsWith(".yaml") || input.endsWith(".yml")
+  );
+}
+
+async function materializeLocalWorkflowForShow(uwf: UwfStore, filePath: string): Promise<CasRef> {
+  let text: string;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch {
+    fail(`project workflow file not found: ${filePath}`);
+  }
+
+  let raw: unknown;
+  try {
+    raw = parse(text, { customTags: [createIncludeTag(dirname(filePath))] }) as unknown;
+  } catch (e) {
+    fail(`invalid YAML in ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  const payload = parseWorkflowPayload(raw);
+  if (payload === null) {
+    fail(`invalid workflow YAML in ${filePath}: expected WorkflowPayload shape`);
+  }
+
+  const filenameError = checkWorkflowFilenameConsistency(filePath, payload);
+  if (filenameError !== null) {
+    fail(filenameError);
+  }
+
+  const semanticErrors = validateWorkflow(payload);
+  if (semanticErrors.length > 0) {
+    fail(`workflow validation failed:\n${semanticErrors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+
+  const materialized = await materializeWorkflowPayload(uwf, payload);
+  const hash = await uwf.store.cas.put(uwf.schemas.workflow, materialized);
+  const stored = uwf.store.cas.get(hash);
+  if (stored === null || !validate(uwf.store, stored)) {
+    fail("stored local workflow failed schema validation");
+  }
+
+  return hash;
+}
+
+async function resolveWorkflowCasRefForShow(
+  uwf: UwfStore,
+  workflowId: string,
+  projectRoot: string,
+): Promise<CasRef> {
+  // Validate input
+  const trimmed = workflowId.trim();
+  if (trimmed === "") {
+    fail("workflow ID cannot be empty");
+  }
+
+  // Strategy 1: Direct CAS hash
+  if (isCasRef(trimmed)) {
+    const node = uwf.store.cas.get(trimmed);
+    if (node === null) {
+      fail(`CAS node not found: ${trimmed}`);
+    }
+    if (node.type !== uwf.schemas.workflow) {
+      fail(`node ${trimmed} is not a Workflow (type ${node.type})`);
+    }
+    return trimmed;
+  }
+
+  // Strategy 2: Explicit file path (relative or absolute)
+  if (isFilePath(trimmed)) {
+    const absolutePath = isAbsolute(trimmed) ? trimmed : resolvePath(projectRoot, trimmed);
+    return materializeLocalWorkflowForShow(uwf, absolutePath);
+  }
+
+  // Strategy 3: Local discovery (reuses discoverProjectWorkflows from store.ts)
+  const localEntries = await discoverProjectWorkflows(projectRoot);
+  const localPath = resolveProjectWorkflowFile(localEntries, trimmed);
+  if (localPath !== null) {
+    return materializeLocalWorkflowForShow(uwf, localPath);
+  }
+
+  // Strategy 4: Global registry fallback
+  const registry = loadWorkflowRegistry(uwf.varStore);
+  const hash = resolveWorkflowHash(registry, trimmed);
+  if (!isCasRef(hash)) {
+    fail(`workflow not found: ${trimmed}`);
+  }
+  const node = uwf.store.cas.get(hash);
+  if (node === null) {
+    fail(`CAS node not found: ${hash}`);
+  }
+  if (node.type !== uwf.schemas.workflow) {
+    fail(`node ${hash} is not a Workflow (type ${node.type})`);
+  }
+  return hash;
+}
+
 export async function cmdWorkflowShow(
   storageRoot: string,
   id: string,
+  projectRoot: string,
 ): Promise<WorkflowShowOutput> {
   const uwf = await createUwfStore(storageRoot);
-  const registry = loadWorkflowRegistry(uwf.varStore);
-  const hash = resolveWorkflowHash(registry, id);
+  const hash = await resolveWorkflowCasRefForShow(uwf, id, projectRoot);
 
   const node = uwf.store.cas.get(hash);
   if (node === null) {
@@ -178,6 +332,7 @@ export async function cmdWorkflowShow(
   }
 
   const payload = node.payload as WorkflowPayload;
+  const registry = loadWorkflowRegistry(uwf.varStore);
   return {
     hash,
     name: findRegistryName(registry, hash),

package/src/moderator/__tests__/evaluate.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, test } from "vitest";
 import { evaluate } from "../evaluate.js";
-import { isSuspendResult } from "../types.js";
 
 describe("Edge prompt template variable resolution", () => {
   test("returns error when rendered prompt is empty string", () => {
     const graph = {
       $START: {
-        new: { role: "classifier", prompt: "{{{userPrompt}}}", location: null },
+        new: { role: "classifier", prompt: "{{ userPrompt }}", location: null },
       },
     };
 
@@ -22,7 +21,7 @@ describe("Edge prompt template variable resolution", () => {
   test("returns error when rendered prompt is whitespace-only", () => {
     const graph = {
       $START: {
-        new: { role: "classifier", prompt: "  {{{userPrompt}}}  ", location: null },
+        new: { role: "classifier", prompt: "  {{ userPrompt }}  ", location: null },
       },
     };
 
@@ -38,7 +37,7 @@ describe("Edge prompt template variable resolution", () => {
   test("succeeds when all template variables resolve to non-empty values", () => {
     const graph = {
       $START: {
-        new: { role: "classifier", prompt: "{{{userPrompt}}}", location: null },
+        new: { role: "classifier", prompt: "{{ userPrompt }}", location: null },
       },
     };
 
@@ -68,7 +67,7 @@ describe("Edge prompt template variable resolution", () => {
   test("succeeds when prompt has mix of static text and unresolved variables", () => {
     const graph = {
       $START: {
-        new: { role: "classifier", prompt: "Please handle: {{{userPrompt}}}", location: null },
+        new: { role: "classifier", prompt: "Please handle: {{ userPrompt }}", location: null },
       },
     };
 
@@ -83,7 +82,7 @@ describe("Edge prompt template variable resolution", () => {
   test("returns error when ALL variables missing and no static text remains", () => {
     const graph = {
       $START: {
-        new: { role: "classifier", prompt: "{{{a}}}{{{b}}}", location: null },
+        new: { role: "classifier", prompt: "{{ a }}{{ b }}", location: null },
       },
     };
 
@@ -91,6 +90,24 @@ describe("Edge prompt template variable resolution", () => {
 
     expect(result.ok).toBe(false);
   });
+
+  test("does not HTML-escape characters like <, >, &", () => {
+    const graph = {
+      $START: {
+        new: { role: "classifier", prompt: "{{ content }}", location: null },
+      },
+    };
+
+    const result = evaluate(graph, "$START", {
+      $status: "new",
+      content: "<div>Hello & welcome</div>",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.prompt).toBe("<div>Hello & welcome</div>");
+    }
+  });
 });
 
 describe("Moderator location resolution", () => {
@@ -108,7 +125,7 @@ describe("Moderator location resolution", () => {
     const result = evaluate(graph, "planner", { $status: "ready" });
 
     expect(result.ok).toBe(true);
-    if (result.ok && !isSuspendResult(result.value)) {
+    if (result.ok) {
       expect(result.value.location).toBe(null);
     }
   });
@@ -127,18 +144,18 @@ describe("Moderator location resolution", () => {
     const result = evaluate(graph, "planner", { $status: "ready" });
 
     expect(result.ok).toBe(true);
-    if (result.ok && !isSuspendResult(result.value)) {
+    if (result.ok) {
       expect(result.value.location).toBe("/static/path");
     }
   });
 
-  test("resolves mustache template location", () => {
+  test("resolves liquid template location", () => {
     const graph = {
       planner: {
         ready: {
           role: "coder",
           prompt: "Implement the code",
-          location: "{{{repoPath}}}",
+          location: "{{ repoPath }}",
         },
       },
     };
@@ -149,18 +166,18 @@ describe("Moderator location resolution", () => {
     });
 
     expect(result.ok).toBe(true);
-    if (result.ok && !isSuspendResult(result.value)) {
+    if (result.ok) {
       expect(result.value.location).toBe("/home/user/repo");
     }
   });
 
-  test("resolves mustache template with multiple variables", () => {
+  test("resolves liquid template with multiple variables", () => {
     const graph = {
       planner: {
         ready: {
           role: "coder",
           prompt: "Implement the code",
-          location: "{{{basePath}}}/{{{projectName}}}",
+          location: "{{ basePath }}/{{ projectName }}",
         },
       },
     };
@@ -172,7 +189,7 @@ describe("Moderator location resolution", () => {
     });
 
     expect(result.ok).toBe(true);
-    if (result.ok && !isSuspendResult(result.value)) {
+    if (result.ok) {
       expect(result.value.location).toBe("/home/user/myproject");
     }
   });
@@ -183,7 +200,7 @@ describe("Moderator location resolution", () => {
         ready: {
           role: "coder",
           prompt: "Implement the code",
-          location: "{{{repoPath}}}",
+          location: "{{ repoPath }}",
         },
       },
     };
@@ -191,8 +208,8 @@ describe("Moderator location resolution", () => {
     const result = evaluate(graph, "planner", { $status: "ready" });
 
     expect(result.ok).toBe(true);
-    if (result.ok && !isSuspendResult(result.value)) {
-      // Mustache renders missing variables as empty string
+    if (result.ok) {
+      // LiquidJS renders missing variables as empty string
       expect(result.value.location).toBe("");
     }
   });

package/src/moderator/evaluate.ts

@@ -1,12 +1,9 @@
 import type { Target } from "@united-workforce/protocol";
-import mustache from "mustache";
+import { Liquid } from "liquidjs";
 
 import type { EvaluateResult, Result } from "./types.js";
 
-// Disable HTML escaping — prompts are plain text, not HTML.
-mustache.escape = (text: string) => text;
-
-const SUSPEND_ROLE = "$SUSPEND";
+const engine = new Liquid();
 
 type LastOutput = Record<string, unknown>;
 
@@ -44,7 +41,7 @@ export function evaluate(
   }
 
   try {
-    const prompt = mustache.render(target.prompt, lastOutput);
+    const prompt = engine.parseAndRenderSync(target.prompt, lastOutput);
     if (prompt.trim() === "") {
       return {
         ok: false,
@@ -53,18 +50,9 @@ export function evaluate(
         ),
       };
     }
-    if (target.role === SUSPEND_ROLE) {
-      return {
-        ok: true,
-        value: {
-          action: "suspend",
-          suspendedRole: lastRole,
-          prompt,
-        },
-      };
-    }
 
-    const location = target.location !== null ? mustache.render(target.location, lastOutput) : null;
+    const location =
+      target.location !== null ? engine.parseAndRenderSync(target.location, lastOutput) : null;
     return { ok: true, value: { role: target.role, prompt, location } };
   } catch (error) {
     return {

package/src/moderator/index.ts

@@ -1,7 +1,2 @@
 export { evaluate } from "./evaluate.js";
-export type {
-  EvaluateResult,
-  EvaluateRouteResult,
-  EvaluateSuspendResult,
-} from "./types.js";
-export { isSuspendResult } from "./types.js";
+export type { EvaluateResult, EvaluateRouteResult } from "./types.js";

package/src/moderator/types.ts

@@ -8,17 +8,9 @@ export type EvaluateRouteResult = {
   location: string | null;
 };
 
-/** Moderator routes the thread to `$SUSPEND` — waiting for external input. */
-export type EvaluateSuspendResult = {
-  action: "suspend";
-  /** Role whose output triggered the suspend transition. */
-  suspendedRole: string;
-  prompt: string;
-};
-
-/** The result of moderator evaluation. */
-export type EvaluateResult = EvaluateRouteResult | EvaluateSuspendResult;
-
-export function isSuspendResult(result: EvaluateResult): result is EvaluateSuspendResult {
-  return "action" in result && result.action === "suspend";
-}
+/**
+ * The result of moderator evaluation. `$SUSPEND` is no longer a moderator
+ * concern — it is an engine-level reserved `$status` intercepted before the
+ * moderator runs.
+ */
+export type EvaluateResult = EvaluateRouteResult;

package/src/schemas.ts

@@ -1,6 +1,12 @@
 import type { Hash, Store } from "@ocas/core";
 import { putSchema } from "@ocas/core";
-import { START_NODE_SCHEMA, STEP_NODE_SCHEMA, WORKFLOW_SCHEMA } from "@united-workforce/protocol";
+import {
+  ERROR_OUTPUT_SCHEMA,
+  START_NODE_SCHEMA,
+  STEP_NODE_SCHEMA,
+  SUSPEND_OUTPUT_SCHEMA,
+  WORKFLOW_SCHEMA,
+} from "@united-workforce/protocol";
 
 export const TEXT_SCHEMA = { type: "string" as const };
 
@@ -9,6 +15,8 @@ export type UwfSchemaHashes = {
   startNode: Hash;
   stepNode: Hash;
   text: Hash;
+  errorOutput: Hash;
+  suspendOutput: Hash;
 };
 
 /**
@@ -16,11 +24,13 @@ export type UwfSchemaHashes = {
  * Idempotent: safe to call on every CLI invocation.
  */
 export async function registerUwfSchemas(store: Store): Promise<UwfSchemaHashes> {
-  const [workflow, startNode, stepNode, text] = await Promise.all([
+  const [workflow, startNode, stepNode, text, errorOutput, suspendOutput] = await Promise.all([
     putSchema(store, WORKFLOW_SCHEMA),
     putSchema(store, START_NODE_SCHEMA),
     putSchema(store, STEP_NODE_SCHEMA),
     putSchema(store, TEXT_SCHEMA),
+    putSchema(store, ERROR_OUTPUT_SCHEMA),
+    putSchema(store, SUSPEND_OUTPUT_SCHEMA),
   ]);
-  return { workflow, startNode, stepNode, text };
+  return { workflow, startNode, stepNode, text, errorOutput, suspendOutput };
 }

package/src/store.ts

@@ -2,7 +2,7 @@ import type { Dirent } from "node:fs";
 import { existsSync } from "node:fs";
 import { access, mkdir, readdir, readFile, rename } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join, resolve as resolvePath } from "node:path";
 
 import { bootstrap, type Hash, type Store, type VarStore } from "@ocas/core";
 import { createFsStore, createSqliteVarStore } from "@ocas/fs";
@@ -20,7 +20,7 @@ export const REGISTRY_VAR_PREFIX = "@uwf/registry/";
 /** Variable name prefix for active thread entries (`@uwf/thread/<thread-id>`). */
 export const THREAD_VAR_PREFIX = "@uwf/thread/";
 
-/** A workflow entry discovered from the project-local .workflows/ directory. */
+/** A workflow entry discovered from the project-local .workflows/ (primary) or .workflow/ (legacy) directory. */
 export type ProjectWorkflowEntry = {
   /** Workflow name (from YAML `name` field, equals filename stem). */
   name: string;
@@ -82,16 +82,11 @@ async function scanWorkflowDir(dir: string): Promise<ProjectWorkflowEntry[]> {
   return result;
 }
 
-/**
- * Scan `<projectRoot>/.workflow/` (preferred) and `.workflows/` (legacy) for workflow entries.
- * .workflow/ takes priority: if a name is found in both, .workflow/ wins.
- * Returns an empty array if neither directory exists.
- */
-export async function discoverProjectWorkflows(
-  projectRoot: string,
-): Promise<ProjectWorkflowEntry[]> {
-  const primary = await scanWorkflowDir(join(projectRoot, ".workflow"));
-  const legacy = await scanWorkflowDir(join(projectRoot, ".workflows"));
+/** Merge primary (.workflows/) and legacy (.workflow/) entries, primary wins on name collision. */
+function mergeWorkflowEntries(
+  primary: ProjectWorkflowEntry[],
+  legacy: ProjectWorkflowEntry[],
+): ProjectWorkflowEntry[] {
   const seen = new Set(primary.map((e) => e.name));
   const merged = [...primary];
   for (const entry of legacy) {
@@ -102,6 +97,63 @@ export async function discoverProjectWorkflows(
   return merged;
 }
 
+/** Check if a directory contains a .git marker (directory or file). */
+async function hasGitMarker(dir: string): Promise<boolean> {
+  try {
+    await access(join(dir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Discover project-local workflows by walking from `startDir` up through parent
+ * directories. The nearest directory that contains a `.workflows/` or `.workflow/`
+ * directory wins — once a match is found, traversal stops (entries from more
+ * distant ancestors are NOT merged in).
+ *
+ * Within the winning directory:
+ * - `.workflows/` (preferred/primary) takes priority over `.workflow/` (legacy fallback).
+ * - If both exist in that directory, `.workflows/` entries win when names collide.
+ *
+ * This matches the resolution strategy of `findWorkflowInParents` used by
+ * `uwf thread start`, so `uwf workflow list` and `uwf thread start` agree on
+ * what's discoverable from any given subdirectory.
+ *
+ * Traversal stops at the first `.git` boundary (directory or file) or the
+ * filesystem root. Returns an empty array if no `.workflows/` or `.workflow/`
+ * directory exists within that range.
+ */
+export async function discoverProjectWorkflows(startDir: string): Promise<ProjectWorkflowEntry[]> {
+  let currentDir = resolvePath(startDir);
+  const root = resolvePath("/");
+
+  while (true) {
+    const primary = await scanWorkflowDir(join(currentDir, ".workflows"));
+    const legacy = await scanWorkflowDir(join(currentDir, ".workflow"));
+
+    if (primary.length > 0 || legacy.length > 0) {
+      return mergeWorkflowEntries(primary, legacy);
+    }
+
+    // Stop at .git boundary (repo root)
+    if (await hasGitMarker(currentDir)) {
+      return [];
+    }
+
+    // Stop at filesystem root
+    if (currentDir === root) {
+      return [];
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return [];
+    }
+    currentDir = parentDir;
+  }
+}
+
 /** Default filesystem root for uwf data (`~/.uwf`). */
 export function getDefaultStorageRoot(): string {
   return join(homedir(), ".uwf");
@@ -335,35 +387,35 @@ export function setThread(varStore: VarStore, threadId: ThreadId, entry: ThreadI
   varStore.set(name, entry.head, { tags });
 }
 
-/** Load only active threads (status not in completed/cancelled). */
+/** Load only active threads (status not in end/cancelled). */
 export function loadActiveThreads(varStore: VarStore): ThreadsIndex {
   const all = loadAllThreads(varStore);
   const active: ThreadsIndex = {};
   for (const [threadId, entry] of Object.entries(all)) {
-    if (entry.status !== "completed" && entry.status !== "cancelled") {
+    if (entry.status !== "end" && entry.status !== "cancelled") {
       active[threadId as ThreadId] = entry;
     }
   }
   return active;
 }
 
-/** Load only completed/cancelled threads (history). */
+/** Load only end/cancelled threads (history). */
 export function loadHistoryThreads(varStore: VarStore): ThreadsIndex {
   const all = loadAllThreads(varStore);
   const history: ThreadsIndex = {};
   for (const [threadId, entry] of Object.entries(all)) {
-    if (entry.status === "completed" || entry.status === "cancelled") {
+    if (entry.status === "end" || entry.status === "cancelled") {
       history[threadId as ThreadId] = entry;
     }
   }
   return history;
 }
 
-/** Complete a thread by marking it completed or cancelled. */
+/** Complete a thread by marking it end or cancelled. */
 export function completeThread(
   varStore: VarStore,
   threadId: ThreadId,
-  reason: "completed" | "cancelled",
+  reason: "end" | "cancelled",
 ): void {
   const entry = getThread(varStore, threadId);
   if (entry === null) {
@@ -377,6 +429,20 @@ export function completeThread(
     completedAt: Date.now(),
   } as ThreadIndexEntry;
   setThread(varStore, threadId, completed);
+  clearThreadFailedAttempts(varStore, threadId);
+}
+
+/**
+ * Remove all `@uwf/thread-failed/<threadId>/*` variables for a thread.
+ * Called on thread completion / cancellation so retry-lineage state does not
+ * leak into the variable store after the thread is archived.
+ */
+export function clearThreadFailedAttempts(varStore: VarStore, threadId: ThreadId): void {
+  const prefix = `@uwf/thread-failed/${threadId}/`;
+  const vars = varStore.list({ namePrefix: prefix });
+  for (const v of vars) {
+    varStore.remove(v.name);
+  }
 }
 
 type LegacyHistoryEntry = {
@@ -439,7 +505,7 @@ export async function migrateHistoryIfNeeded(
     }
     const entry = parseLegacyHistoryJsonlLine(trimmed);
     if (entry !== null) {
-      const status = entry.reason === "cancelled" ? "cancelled" : "completed";
+      const status = entry.reason === "cancelled" ? "cancelled" : "end";
       const threadEntry: ThreadIndexEntry = {
         head: entry.head,
         status: status as ThreadIndexEntry["status"],
@@ -462,7 +528,7 @@ export function migrateHistoryVarsToThreadVars(varStore: VarStore): void {
   for (const v of vars) {
     const threadId = v.name.slice(LEGACY_HISTORY_VAR_PREFIX.length) as ThreadId;
     const reason = v.tags.reason;
-    const status = reason === "cancelled" ? "cancelled" : "completed";
+    const status = reason === "cancelled" ? "cancelled" : "end";
     const completedAt = Number(v.tags.completedAt ?? Date.now());
 
     const threadEntry: ThreadIndexEntry = {