First Release of Claw3D (#11)

Co-authored-by: iamlukethedev <iamlukethedev@users.noreply.github.com>
2026-03-19 23:14:04 -05:00
parent 5ea96b2650
commit 4fa4f13558
431 changed files with 105438 additions and 14 deletions
@@ -0,0 +1,179 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  applyTerminalCommit,
+  createRuntimeTerminalState,
+  deriveChatTerminalDecision,
+  deriveLifecycleTerminalDecision,
+  isClosedRun,
+  markClosedRun,
+  pruneClosedRuns,
+} from "@/features/agents/state/runtimeTerminalWorkflow";
+
+describe("runtime terminal workflow", () => {
+  it("marks same-or-lower chat final sequence as stale, but accepts higher sequence", () => {
+    let state = createRuntimeTerminalState();
+    state = applyTerminalCommit(state, {
+      runId: "run-1",
+      source: "chat-final",
+      seq: 4,
+    });
+
+    const sameSeq = deriveChatTerminalDecision({
+      state,
+      runId: "run-1",
+      isFinal: true,
+      seq: 4,
+    });
+    expect(sameSeq.isStaleTerminal).toBe(true);
+    expect(sameSeq.lastTerminalSeqBeforeFinal).toBe(4);
+    expect(sameSeq.commitSourceBeforeFinal).toBe("chat-final");
+
+    const lowerSeq = deriveChatTerminalDecision({
+      state,
+      runId: "run-1",
+      isFinal: true,
+      seq: 3,
+    });
+    expect(lowerSeq.isStaleTerminal).toBe(true);
+
+    const higherSeq = deriveChatTerminalDecision({
+      state,
+      runId: "run-1",
+      isFinal: true,
+      seq: 5,
+    });
+    expect(higherSeq.isStaleTerminal).toBe(false);
+  });
+
+  it("schedules lifecycle fallback only when lifecycle end arrives before chat final", () => {
+    const freshState = createRuntimeTerminalState();
+    const pendingFallback = deriveLifecycleTerminalDecision({
+      mode: "event",
+      state: freshState,
+      runId: "run-2",
+      phase: "end",
+      hasPendingFallbackTimer: false,
+      fallbackDelayMs: 250,
+      fallbackFinalText: "fallback final",
+      transitionClearsRunTracking: true,
+    });
+    expect(pendingFallback.deferTransitionPatch).toBe(true);
+    expect(pendingFallback.commands).toEqual(
+      expect.arrayContaining([
+        { kind: "cancelLifecycleFallback", runId: "run-2" },
+        {
+          kind: "scheduleLifecycleFallback",
+          runId: "run-2",
+          delayMs: 250,
+          finalText: "fallback final",
+        },
+      ])
+    );
+
+    let chatSeenState = createRuntimeTerminalState();
+    chatSeenState = applyTerminalCommit(chatSeenState, {
+      runId: "run-2",
+      source: "chat-final",
+      seq: 1,
+    });
+    const noFallback = deriveLifecycleTerminalDecision({
+      mode: "event",
+      state: chatSeenState,
+      runId: "run-2",
+      phase: "end",
+      hasPendingFallbackTimer: false,
+      fallbackDelayMs: 250,
+      fallbackFinalText: "fallback final",
+      transitionClearsRunTracking: true,
+    });
+    expect(noFallback.deferTransitionPatch).toBe(false);
+    expect(
+      noFallback.commands.find((command) => command.kind === "scheduleLifecycleFallback")
+    ).toBeUndefined();
+    expect(noFallback.commands).toEqual(
+      expect.arrayContaining([
+        { kind: "markRunClosed", runId: "run-2" },
+        { kind: "clearRunTracking", runId: "run-2" },
+      ])
+    );
+  });
+
+  it("supports closed-run mark, lookup, and prune semantics", () => {
+    let state = createRuntimeTerminalState();
+    state = applyTerminalCommit(state, {
+      runId: "run-closed",
+      source: "lifecycle-fallback",
+      seq: null,
+    });
+    state = markClosedRun(state, {
+      runId: "run-closed",
+      now: 1000,
+      ttlMs: 30,
+    });
+
+    expect(isClosedRun(state, "run-closed")).toBe(true);
+    const beforeExpiry = pruneClosedRuns(state, { at: 1029 });
+    expect(beforeExpiry.expiredRunIds).toEqual([]);
+    expect(isClosedRun(beforeExpiry.state, "run-closed")).toBe(true);
+
+    const afterExpiry = pruneClosedRuns(beforeExpiry.state, { at: 1030 });
+    expect(afterExpiry.expiredRunIds).toEqual(["run-closed"]);
+    expect(isClosedRun(afterExpiry.state, "run-closed")).toBe(false);
+  });
+
+  it("transitions commit source from lifecycle fallback to chat final", () => {
+    let state = createRuntimeTerminalState();
+    state = applyTerminalCommit(state, {
+      runId: "run-3",
+      source: "lifecycle-fallback",
+      seq: null,
+    });
+
+    const missingSeqAfterFallback = deriveChatTerminalDecision({
+      state,
+      runId: "run-3",
+      isFinal: true,
+      seq: null,
+    });
+    expect(missingSeqAfterFallback.isStaleTerminal).toBe(false);
+    expect(missingSeqAfterFallback.commitSourceBeforeFinal).toBe("lifecycle-fallback");
+
+    state = applyTerminalCommit(state, {
+      runId: "run-3",
+      source: "chat-final",
+      seq: 2,
+    });
+    const missingSeqAfterChatFinal = deriveChatTerminalDecision({
+      state,
+      runId: "run-3",
+      isFinal: true,
+      seq: null,
+    });
+    expect(missingSeqAfterChatFinal.isStaleTerminal).toBe(true);
+    expect(missingSeqAfterChatFinal.commitSourceBeforeFinal).toBe("chat-final");
+  });
+
+  it("generates fallback schedule intent with explicit delay and no timer handles", () => {
+    const decision = deriveLifecycleTerminalDecision({
+      mode: "event",
+      state: createRuntimeTerminalState(),
+      runId: "run-4",
+      phase: "end",
+      hasPendingFallbackTimer: false,
+      fallbackDelayMs: 777,
+      fallbackFinalText: "fallback",
+      transitionClearsRunTracking: true,
+    });
+
+    const schedule = decision.commands.find(
+      (command) => command.kind === "scheduleLifecycleFallback"
+    );
+    expect(schedule).toEqual({
+      kind: "scheduleLifecycleFallback",
+      runId: "run-4",
+      delayMs: 777,
+      finalText: "fallback",
+    });
+  });
+});