@mhingston5/lasso 0.1.0

package/test/pi/commands.test.ts

@@ -0,0 +1,623 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("node:crypto", () => ({
+  randomUUID: () => "instance-123",
+}));
+
+vi.mock("../../src/reference/catalog.js", async (importOriginal) => {
+  const mod = await importOriginal<typeof import("../../src/reference/catalog.js")>();
+  return {
+    ...mod,
+    buildReferenceHarnessSpec: vi.fn(),
+  };
+});
+
+vi.mock("../../src/compiler/compile.js", () => ({
+  compileHarnessSpec: vi.fn(),
+}));
+
+vi.mock("../../src/planner/synthesize.js", () => ({
+  planWorkflowRequest: vi.fn(),
+}));
+
+vi.mock("../../src/replanner/synthesize.js", () => ({
+  parseReplanRequest: vi.fn(),
+  replanWorkflowRequest: vi.fn(),
+}));
+
+import { compileHarnessSpec } from "../../src/compiler/compile.js";
+import { planWorkflowRequest } from "../../src/planner/synthesize.js";
+import { parseReplanRequest, replanWorkflowRequest } from "../../src/replanner/synthesize.js";
+import { buildReferenceHarnessSpec } from "../../src/reference/catalog.js";
+import { createLassoCommands, clearCompiledHarnesses } from "../../src/pi/commands.js";
+
+describe("Lasso pi commands", () => {
+  const prBundle = {
+    repoPath: "/tmp/repo",
+    sourceBranch: "feature/pr-change",
+    targetBranch: "main",
+    reviewInstructions: "Review carefully.",
+    verificationCommands: ['node -e "process.exit(0)"'],
+  };
+
+  const patchRequest = {
+    workflow: "patch-validation",
+    input: {
+      repoPath: "/tmp/repo",
+      baselineRef: "HEAD",
+      candidateSource: { kind: "branch", value: "fix/bug-123" },
+      reproduceCommands: ["npm test -- failing.spec.ts"],
+      verificationCommands: ["npm test"],
+      reviewInstructions: "Approve only if the bug reproduces on baseline and all checks pass on the candidate.",
+      approvalRequired: true,
+    },
+  };
+
+  const replanInput = {
+    workflow: "patch-validation" as const,
+    originalRequest: patchRequest,
+    observedOutcome: {
+      terminalNodeId: "validated-fix" as const,
+      notes: ["prod hotfix"],
+    },
+  };
+
+  const prSpec = { name: "pr-review-merge", graph: { entryNodeId: "start", nodes: [], edges: [] } };
+  const patchSpec = { name: "patch-validation", graph: { entryNodeId: "run-baseline", nodes: [], edges: [] } };
+  const customSpec = {
+    name: "custom-echo",
+    graph: {
+      entryNodeId: "echo",
+      nodes: [
+        {
+          id: "echo",
+          kind: "tool" as const,
+          tool: "bash",
+          args: ["-lc", "echo hello"],
+        },
+      ],
+      edges: [],
+    },
+  };
+
+  const prCompiled = {
+    name: "pr-review-merge",
+    spec: prSpec,
+    cir: { name: "pr-review-merge", entryNodeId: "start", nodes: [], transitions: [] },
+    workflows: [],
+    register: vi.fn(),
+  };
+
+  const patchCompiled = {
+    name: "patch-validation",
+    spec: patchSpec,
+    cir: { name: "patch-validation", entryNodeId: "run-baseline", nodes: [], transitions: [] },
+    workflows: [],
+    register: vi.fn(),
+  };
+
+  const customCompiled = {
+    name: "custom-echo",
+    spec: customSpec,
+    cir: { name: "custom-echo", entryNodeId: "echo", nodes: [], transitions: [] },
+    workflows: [],
+    register: vi.fn(),
+  };
+
+  beforeEach(() => {
+    clearCompiledHarnesses();
+    vi.mocked(buildReferenceHarnessSpec).mockReset();
+    vi.mocked(compileHarnessSpec).mockReset();
+    vi.mocked(planWorkflowRequest).mockReset();
+    vi.mocked(parseReplanRequest).mockReset();
+    vi.mocked(replanWorkflowRequest).mockReset();
+    vi.mocked(buildReferenceHarnessSpec).mockReturnValue(prSpec as any);
+    vi.mocked(compileHarnessSpec).mockReturnValue(prCompiled as any);
+    prCompiled.register.mockReset();
+    patchCompiled.register.mockReset();
+    customCompiled.register.mockReset();
+  });
+
+  it("creates compile, run, inspect, plan, and replan commands", () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+
+    expect(commands.map(command => command.name)).toEqual([
+      "lasso:compile",
+      "lasso:run",
+      "lasso:inspect",
+      "lasso:plan",
+      "lasso:replan",
+    ]);
+  });
+
+  it("compile command routes legacy raw LocalPrBundle to the pr-review-merge builder", async () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(prBundle), ctx as any);
+
+    expect(buildReferenceHarnessSpec).toHaveBeenCalledWith({ workflow: "pr-review-merge", input: prBundle });
+    expect(compileHarnessSpec).toHaveBeenCalledWith(prSpec);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Compiled `pr-review-merge`"), "info");
+  });
+
+  it("compile command routes explicit patch-validation envelope to the patch-validation builder", async () => {
+    vi.mocked(buildReferenceHarnessSpec).mockReturnValue(patchSpec as any);
+    vi.mocked(compileHarnessSpec).mockReturnValue(patchCompiled as any);
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(patchRequest), ctx as any);
+
+    expect(buildReferenceHarnessSpec).toHaveBeenCalledWith(patchRequest);
+    expect(compileHarnessSpec).toHaveBeenCalledWith(patchSpec);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Compiled `patch-validation`"), "info");
+  });
+
+  it("compile command compiles raw HarnessSpec JSON without going through the reference builder", async () => {
+    vi.mocked(compileHarnessSpec).mockReturnValue(customCompiled as any);
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(customSpec), ctx as any);
+
+    expect(buildReferenceHarnessSpec).not.toHaveBeenCalled();
+    expect(compileHarnessSpec).toHaveBeenCalledWith(customSpec);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Compiled `custom-echo`"), "info");
+  });
+
+  it("run command compiles, registers, and starts the pr-review-merge workflow from a legacy bundle", async () => {
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const runCommand = commands.find(command => command.name === "lasso:run");
+    const ctx = createCommandContext();
+
+    await runCommand?.handler(JSON.stringify(prBundle), ctx as any);
+
+    expect(buildReferenceHarnessSpec).toHaveBeenCalledWith({ workflow: "pr-review-merge", input: prBundle });
+    expect(compileHarnessSpec).toHaveBeenCalledWith(prSpec);
+    expect(prCompiled.register).toHaveBeenCalledWith();
+    
+    const startOrchestrationCall = vi.mocked(registry.client.startOrchestration).mock.calls[0];
+    expect(startOrchestrationCall[0]).toBe("instance-123");
+    expect(startOrchestrationCall[1]).toBe("pr-review-merge");
+    
+    const adaptiveInput = startOrchestrationCall[2];
+    expect(adaptiveInput).toHaveProperty("input");
+    expect(adaptiveInput).toHaveProperty("__lassoAdaptiveRuntime");
+    expect(adaptiveInput.input).toEqual({});
+    expect(adaptiveInput.__lassoAdaptiveRuntime.currentRequest).toEqual({ workflow: "pr-review-merge", input: prBundle });
+    
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Started `pr-review-merge`"), "info");
+  });
+
+  it("run command compiles, registers, and starts a patch-validation workflow", async () => {
+    vi.mocked(buildReferenceHarnessSpec).mockReturnValue(patchSpec as any);
+    vi.mocked(compileHarnessSpec).mockReturnValue(patchCompiled as any);
+
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const runCommand = commands.find(command => command.name === "lasso:run");
+    const ctx = createCommandContext();
+
+    await runCommand?.handler(JSON.stringify(patchRequest), ctx as any);
+
+    expect(buildReferenceHarnessSpec).toHaveBeenCalledWith(patchRequest);
+    expect(patchCompiled.register).toHaveBeenCalledWith();
+    
+    const startOrchestrationCall = vi.mocked(registry.client.startOrchestration).mock.calls[0];
+    expect(startOrchestrationCall[0]).toBe("instance-123");
+    expect(startOrchestrationCall[1]).toBe("patch-validation");
+    
+    const adaptiveInput = startOrchestrationCall[2];
+    expect(adaptiveInput).toHaveProperty("input");
+    expect(adaptiveInput).toHaveProperty("__lassoAdaptiveRuntime");
+    expect(adaptiveInput.input).toEqual({});
+    expect(adaptiveInput.__lassoAdaptiveRuntime.currentRequest).toEqual(patchRequest);
+    
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Started `patch-validation`"), "info");
+  });
+
+  it("run command starts a custom HarnessSpec with explicit runtime input", async () => {
+    vi.mocked(compileHarnessSpec).mockReturnValue(customCompiled as any);
+
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const runCommand = commands.find(command => command.name === "lasso:run");
+    const ctx = createCommandContext();
+    const request = {
+      spec: customSpec,
+      input: { memberId: "12345", dryRun: true },
+    };
+
+    await runCommand?.handler(JSON.stringify(request), ctx as any);
+
+    expect(buildReferenceHarnessSpec).not.toHaveBeenCalled();
+    expect(compileHarnessSpec).toHaveBeenCalledWith(customSpec);
+    expect(customCompiled.register).toHaveBeenCalledWith();
+    expect(registry.client.startOrchestration).toHaveBeenCalledWith("instance-123", "custom-echo", request.input);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Started `custom-echo`"), "info");
+  });
+
+  it("run command defaults raw custom HarnessSpec input to an empty object", async () => {
+    vi.mocked(compileHarnessSpec).mockReturnValue(customCompiled as any);
+
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const runCommand = commands.find(command => command.name === "lasso:run");
+    const ctx = createCommandContext();
+
+    await runCommand?.handler(JSON.stringify(customSpec), ctx as any);
+
+    expect(registry.client.startOrchestration).toHaveBeenCalledWith("instance-123", "custom-echo", {});
+  });
+
+  it("inspect command prints the spec, cir, and workflow state", async () => {
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const inspectCommand = commands.find(command => command.name === "lasso:inspect");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(prBundle), ctx as any);
+    await inspectCommand?.handler("pr-review-merge", ctx as any);
+
+    expect(registry.client.listAllInstances).toHaveBeenCalled();
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining("### Lasso Workflow `pr-review-merge`"),
+      "info",
+    );
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining('"name": "pr-review-merge"'),
+      "info",
+    );
+  });
+
+  it("inspect command prints a custom HarnessSpec after compiling it directly", async () => {
+    vi.mocked(compileHarnessSpec).mockReturnValue(customCompiled as any);
+
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const inspectCommand = commands.find(command => command.name === "lasso:inspect");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(customSpec), ctx as any);
+    await inspectCommand?.handler("custom-echo", ctx as any);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining("### Lasso Workflow `custom-echo`"),
+      "info",
+    );
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining('"name": "custom-echo"'),
+      "info",
+    );
+  });
+
+  it("inspect command displays adaptive lineage when available", async () => {
+    const adaptiveCompiled = {
+      ...prCompiled,
+      adaptive: {
+        currentVersion: {
+          version: 3,
+          parentVersion: 2,
+          reason: "risk-escalation: verification failures detected",
+          spec: prSpec,
+          generatedAt: 1700000002000,
+        },
+        lineage: [
+          {
+            version: 1,
+            terminalNodeId: "merged",
+            outputs: {},
+            nodeResults: {},
+            failures: [],
+            metrics: { retries: 0, durationMs: 1500 },
+            trace: [],
+            completedAt: 1700000000000,
+          },
+          {
+            version: 2,
+            terminalNodeId: "failed-verification",
+            outputs: {},
+            nodeResults: {},
+            failures: [
+              {
+                domainType: "lasso",
+                rootCause: "verification_failed",
+                nodeId: "run-checks",
+                message: "Tests failed on candidate branch",
+              },
+            ],
+            metrics: { retries: 2, durationMs: 4500 },
+            trace: [],
+            completedAt: 1700000001000,
+          },
+        ],
+      },
+    };
+
+    vi.mocked(compileHarnessSpec).mockReturnValue(adaptiveCompiled as any);
+
+    const registry = createMockRegistry();
+    const commands = createLassoCommands(registry as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const inspectCommand = commands.find(command => command.name === "lasso:inspect");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify(prBundle), ctx as any);
+    await inspectCommand?.handler("pr-review-merge", ctx as any);
+
+    const notifyCalls = vi.mocked(ctx.ui.notify).mock.calls;
+    const output = notifyCalls[notifyCalls.length - 1][0] as string;
+
+    expect(output).toContain("#### Adaptive Lineage");
+    expect(output).toContain("Version: 3");
+    expect(output).toContain("Parent: 2");
+    expect(output).toContain("Reason: risk-escalation: verification failures detected");
+    expect(output).toContain("| # | Outcome | Duration | Failures | Needs Input |");
+    expect(output).toContain("| 1 | merged | 1.5s | 0 | no |");
+    expect(output).toContain("| 2 | failed-verification | 4.5s | 1 | no |");
+    expect(output).toContain("Status: evolving (version 3 of 5)");
+  });
+
+  it("compile command reports malformed JSON cleanly", async () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler("{not-json", ctx as any);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      "Invalid compile input. Expected workflow request JSON, HarnessSpec JSON, {spec|specPath,input?}, or an absolute spec path.",
+      "error",
+    );
+  });
+
+  it("compile command reports malformed patch-validation envelope cleanly", async () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const compileCommand = commands.find(command => command.name === "lasso:compile");
+    const ctx = createCommandContext();
+
+    await compileCommand?.handler(JSON.stringify({ workflow: "patch-validation", input: {} }), ctx as any);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Invalid patch-validation input", "error");
+  });
+
+  it("plan command renders a draft request without compiling or running anything", async () => {
+    vi.mocked(planWorkflowRequest).mockReturnValue({
+      status: "draft_request",
+      workflow: "patch-validation",
+      request: patchRequest as any,
+      rationale: ["Classified as patch-validation workflow", "Baseline: HEAD"],
+      warnings: ["approvalRequired not specified; defaulting to false"],
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const planCommand = commands.find(command => command.name === "lasso:plan");
+    const ctx = createCommandContext();
+    const brief = "Validate the fix in /tmp/repo against HEAD";
+
+    await planCommand?.handler(brief, ctx as any);
+
+    expect(planWorkflowRequest).toHaveBeenCalledWith(brief);
+    expect(buildReferenceHarnessSpec).not.toHaveBeenCalled();
+    expect(compileHarnessSpec).not.toHaveBeenCalled();
+
+    const [message, level] = ctx.ui.notify.mock.calls[0];
+    expect(level).toBe("info");
+    expect(message).toContain("### Planner Draft `patch-validation`");
+    expect(message).toContain("#### Rationale");
+    expect(message).toContain("#### Warnings");
+    expect(message).toContain("```json");
+    expect(message).toContain('"workflow": "patch-validation"');
+    expect(message).toContain("/lasso:compile");
+    expect(message).toContain("/lasso:run");
+  });
+
+  it("plan command renders clarification output without emitting partial JSON", async () => {
+    vi.mocked(planWorkflowRequest).mockReturnValue({
+      status: "needs_clarification",
+      candidateWorkflow: "pr-review-merge",
+      reasons: ["PR review/merge workflow requires: repoPath, verificationCommands"],
+      missingFields: ["repoPath", "verificationCommands"],
+      guidance: ["Provide repoPath", "Provide verificationCommands"],
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const planCommand = commands.find(command => command.name === "lasso:plan");
+    const ctx = createCommandContext();
+
+    await planCommand?.handler("Review and merge this branch", ctx as any);
+
+    expect(planWorkflowRequest).toHaveBeenCalledWith("Review and merge this branch");
+    expect(buildReferenceHarnessSpec).not.toHaveBeenCalled();
+    expect(compileHarnessSpec).not.toHaveBeenCalled();
+
+    const [message, level] = ctx.ui.notify.mock.calls[0];
+    expect(level).toBe("info");
+    expect(message).toContain("### Planner Needs Clarification");
+    expect(message).toContain("Likely workflow: `pr-review-merge`");
+    expect(message).toContain("#### Missing Fields");
+    expect(message).toContain("repoPath");
+    expect(message).toContain("verificationCommands");
+    expect(message).not.toContain("```json");
+  });
+
+  it("plan command reports usage for an empty brief", async () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const planCommand = commands.find(command => command.name === "lasso:plan");
+    const ctx = createCommandContext();
+
+    await planCommand?.handler("   ", ctx as any);
+
+    expect(planWorkflowRequest).not.toHaveBeenCalled();
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Usage: /lasso:plan <freeform brief>", "error");
+  });
+
+  it("plan command reports unexpected planner failures cleanly", async () => {
+    vi.mocked(planWorkflowRequest).mockImplementation(() => {
+      throw new Error("Internal planner error");
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const planCommand = commands.find(command => command.name === "lasso:plan");
+    const ctx = createCommandContext();
+
+    await planCommand?.handler("Review and merge this branch", ctx as any);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Internal planner error", "error");
+  });
+
+  it("replan command renders a revised draft request without compiling or running anything", async () => {
+    vi.mocked(parseReplanRequest).mockReturnValue(replanInput);
+    vi.mocked(replanWorkflowRequest).mockReturnValue({
+      status: "draft_request",
+      workflow: "patch-validation",
+      request: {
+        workflow: "patch-validation",
+        input: {
+          ...patchRequest.input,
+          approvalRequired: true,
+        },
+      },
+      trigger: "risk-escalation",
+      riskLevel: "high",
+      rationale: ["Patch-file candidates are treated as high risk for adaptive replanning."],
+      warnings: [],
+      changes: ["approvalRequired: false -> true"],
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const replanCommand = commands.find(command => command.name === "lasso:replan");
+    const ctx = createCommandContext();
+    const requestJson = JSON.stringify(replanInput);
+
+    await replanCommand?.handler(requestJson, ctx as any);
+
+    expect(parseReplanRequest).toHaveBeenCalledWith(requestJson);
+    expect(replanWorkflowRequest).toHaveBeenCalledWith(replanInput);
+    expect(buildReferenceHarnessSpec).not.toHaveBeenCalled();
+    expect(compileHarnessSpec).not.toHaveBeenCalled();
+
+    const [message, level] = ctx.ui.notify.mock.calls[0];
+    expect(level).toBe("info");
+    expect(message).toContain("### Replan Draft `patch-validation`");
+    expect(message).toContain("Trigger: `risk-escalation`");
+    expect(message).toContain("Risk level: `high`");
+    expect(message).toContain("#### Changes");
+    expect(message).toContain("approvalRequired: false -> true");
+    expect(message).toContain("```json");
+    expect(message).toContain('"workflow": "patch-validation"');
+    expect(message).toContain("/lasso:compile");
+    expect(message).toContain("/lasso:run");
+  });
+
+  it("replan command renders operator-input guidance without emitting partial JSON", async () => {
+    vi.mocked(parseReplanRequest).mockReturnValue(replanInput);
+    vi.mocked(replanWorkflowRequest).mockReturnValue({
+      status: "needs_operator_input",
+      candidateWorkflow: "pr-review-merge",
+      riskLevel: "medium",
+      reasons: ["Verification failed before merge."],
+      missingFields: ["sourceBranch", "verificationCommands"],
+      guidance: ["Update the branch", "Review the verification commands"],
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const replanCommand = commands.find(command => command.name === "lasso:replan");
+    const ctx = createCommandContext();
+
+    await replanCommand?.handler(JSON.stringify(replanInput), ctx as any);
+
+    const [message, level] = ctx.ui.notify.mock.calls[0];
+    expect(level).toBe("info");
+    expect(message).toContain("### Replan Needs Operator Input");
+    expect(message).toContain("Likely workflow: `pr-review-merge`");
+    expect(message).toContain("Risk level: `medium`");
+    expect(message).toContain("#### Missing Fields");
+    expect(message).not.toContain("```json");
+  });
+
+  it("replan command renders stop output without emitting partial JSON", async () => {
+    vi.mocked(parseReplanRequest).mockReturnValue(replanInput);
+    vi.mocked(replanWorkflowRequest).mockReturnValue({
+      status: "stop",
+      workflow: "patch-validation",
+      riskLevel: "high",
+      reasons: ["The previous attempt was rejected by a human reviewer."],
+      guidance: ["Review the candidate manually before retrying."],
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const replanCommand = commands.find(command => command.name === "lasso:replan");
+    const ctx = createCommandContext();
+
+    await replanCommand?.handler(JSON.stringify(replanInput), ctx as any);
+
+    const [message, level] = ctx.ui.notify.mock.calls[0];
+    expect(level).toBe("info");
+    expect(message).toContain("### Replan Stop");
+    expect(message).toContain("Workflow: `patch-validation`");
+    expect(message).toContain("Risk level: `high`");
+    expect(message).not.toContain("```json");
+  });
+
+  it("replan command reports usage for an empty request", async () => {
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const replanCommand = commands.find(command => command.name === "lasso:replan");
+    const ctx = createCommandContext();
+
+    await replanCommand?.handler("   ", ctx as any);
+
+    expect(parseReplanRequest).not.toHaveBeenCalled();
+    expect(replanWorkflowRequest).not.toHaveBeenCalled();
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Usage: /lasso:replan <replan request JSON>", "error");
+  });
+
+  it("replan command reports malformed replan JSON cleanly", async () => {
+    vi.mocked(parseReplanRequest).mockImplementation(() => {
+      throw new Error("Invalid replan request JSON");
+    });
+
+    const commands = createLassoCommands(createMockRegistry() as any);
+    const replanCommand = commands.find(command => command.name === "lasso:replan");
+    const ctx = createCommandContext();
+
+    await replanCommand?.handler("{not-json", ctx as any);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith("Invalid replan request JSON", "error");
+  });
+});
+
+function createMockRegistry() {
+  const client = {
+    startOrchestration: vi.fn().mockResolvedValue(undefined),
+    listAllInstances: vi.fn().mockResolvedValue([
+      { instanceId: "instance-123", name: "pr-review-merge", status: "Running" },
+    ]),
+  };
+
+  return {
+    client,
+    getRuntime: () => ({
+      getClient: () => client,
+      isRunning: () => true,
+    }),
+  };
+}
+
+function createCommandContext() {
+  return {
+    pi: {},
+    ui: {
+      notify: vi.fn(),
+    },
+  };
+}

package/test/planner/classify-template.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { classifyTemplate } from "../../src/planner/template-rules.js";
+
+describe("classifyTemplate", () => {
+  describe("existing behavior", () => {
+    it("should return pr-review-merge for PR-related briefs", () => {
+      expect(classifyTemplate("Review the pull request")).toBe("pr-review-merge");
+    });
+
+    it("should return patch-validation for patch-related briefs", () => {
+      expect(classifyTemplate("Validate the patch against baseline")).toBe("patch-validation");
+    });
+
+    it("should return ambiguous for mixed signals", () => {
+      expect(classifyTemplate("Review this PR and validate the patch baseline")).toBe("ambiguous");
+    });
+  });
+
+  describe("custom workflow families", () => {
+    it("should return 'custom' for unrecognized briefs with a workflow hint", () => {
+      expect(classifyTemplate("Deploy to staging environment")).toBe("custom");
+    });
+
+    it("should return 'custom' for completely generic briefs", () => {
+      expect(classifyTemplate("Run the data pipeline on the new dataset")).toBe("custom");
+    });
+
+    it("should return 'custom' for briefs with no workflow indicators", () => {
+      expect(classifyTemplate("Do some stuff with the codebase")).toBe("custom");
+    });
+  });
+});