Slice 4 hardening: bounded resolver, terminal states, reconciliation

Addresses review findings before Slice 5 sandbox work.

Resolver primitives:
- resolveOutcome maps an attempt outcome to retry-or-terminal; removed the
  no-op isTerminalClassification.
- WORK_STATUS_FOR_OUTCOME preserves real terminal Work status instead of
  collapsing everything back to ready.
- Lifecycle: completed is terminal, cancelled reopens only to ready, and the
  invalid awaiting-design-approval -> awaiting-definition-approval reopening
  is gone.

Execution (workExecution.ts):
- finishAttempt replaces completeAttempt: auto-retries within the kit budget
  and settles Work at the real classification (Succeeded->completed,
  PermanentFailure/BudgetExhausted->failed, NeedsInput->needs-input,
  Blocked->blocked). No Work stays silently runnable after a failure.
- startSimulatedExecution validates sliceId against the current approved
  Design (foreign ids rejected; defaults to the first slice) and advances
  slice status running -> completed/ready.
- retrySimulatedExecution is now an explicit user restart with a retryable-
  state guard, not the automatic resolver path.
- reconcileExpiredAttempts is bounded: a dead lease terminates as Blocked,
  resumes within budget or settles the Run/Work so nothing runs forever.
- crons.ts runs the reconciler every 30s, string-referenced so it does not
  depend on the stale codegen.

Planning (workPlanning.ts):
- saveDefinition/saveDesign reject revision while a Run is executing.
- submitQuestion validates and persists a durable workQuestions row instead
  of discarding planner questions.
- Design revision invalidates active design approvals.

Verification: primitives 69 tests (+4), backend 22 tests (+10) covering
retry/cancel/failure/restart, slice validation, reconciliation, the
revision guard, and question persistence. Root typecheck, web+agents build,
and the configured Ultracite gate (53 files) all pass.

package.json: the recurring check gate now covers workExecution, workPlanning,
crons, resolver, and work-lifecycle.

.env.example

@@ -17,9 +17,7 @@ DAEMON_NAME=Local MacBook
 DAEMON_VERSION=0.0.0
 DAEMON_HEARTBEAT_MS=15000
 DAEMON_COMMAND_LEASE_MS=60000
-RIVET_ENDPOINT=http://localhost:6420
-RIVET_PUBLIC_ENDPOINT=http://localhost:6420
-RIVET_WORKSPACE_TOKEN=replace-with-a-long-random-workspace-token
+# RIVET_ENDPOINT=http://localhost:6420
 
 # Flue persistence adapter
 FLUE_DB_TOKEN=replace-with-a-long-random-token

.npmrc

@@ -1 +0,0 @@
-verify-deps-before-run=false

apps/web/Dockerfile

@@ -1,36 +0,0 @@
-FROM oven/bun:1.3.14 AS bun
-
-FROM node:24-bookworm-slim AS build
-
-COPY --from=bun /usr/local/bin/bun /usr/local/bin/bun
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-  ca-certificates \
-  g++ \
-  make \
-  python3 \
-  && rm -rf /var/lib/apt/lists/*
-
-COPY . .
-ARG VITE_AUTH_URL
-ARG VITE_CONVEX_URL
-ENV VITE_AUTH_URL=$VITE_AUTH_URL
-ENV VITE_CONVEX_URL=$VITE_CONVEX_URL
-RUN bun install --frozen-lockfile
-RUN bun run --filter web build
-
-FROM node:24-bookworm-slim
-
-ENV HOST=0.0.0.0
-ENV NODE_ENV=production
-ENV PORT=3000
-
-WORKDIR /app/apps/web
-
-COPY --from=build /app /app
-
-EXPOSE 3000
-
-CMD ["node", "node_modules/.bin/react-router-serve", "build/server/index.js"]

apps/web/package.json

@@ -26,14 +26,14 @@
     "react-dom": "catalog:",
     "react-router": "^8.1.0",
     "sonner": "catalog:",
-    "streamdown": "catalog:"
+    "streamdown": "2.5.0"
   },
   "devDependencies": {
     "@code/config": "workspace:*",
     "@react-router/dev": "^8.1.0",
-    "@tailwindcss/vite": "catalog:",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:",
+    "@tailwindcss/vite": "^4.3.2",
+    "@types/node": "^22.13.14",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "catalog:",
     "react-router-devtools": "^6.2.1",
     "tailwindcss": "catalog:",

apps/web/src/components/slice-one/slice-one-page.tsx

@@ -0,0 +1,657 @@
+import { projectWorkNotices } from "@code/primitives/work";
+import {
+  Conversation,
+  ConversationContent,
+} from "@code/ui/components/ai-elements/conversation";
+import { Button } from "@code/ui/components/button";
+import {
+  ChevronRight,
+  Check,
+  FolderGit2,
+  Hammer,
+  LoaderCircle,
+  Menu,
+  MessageSquareText,
+  ImagePlus,
+  Play,
+  RotateCcw,
+  Send,
+  Sparkles,
+  X,
+} from "lucide-react";
+import { useMemo, useRef, useState } from "react";
+
+import { PendingChatAttachments } from "@/components/chat/chat-attachments";
+import { ChatMessage } from "@/components/chat/chat-message";
+import { ChatThinkingResponse } from "@/components/chat/chat-thinking-response";
+import { useChatImages } from "@/hooks/chat/use-chat-images";
+import { useSliceOne } from "@/hooks/slice-one/use-slice-one";
+import { useVisualViewportStyle } from "@/hooks/slice-one/use-visual-viewport";
+import {
+  buildSliceOneTimeline,
+  findSourceMessageTarget,
+} from "@/lib/slice-one/presentation";
+
+type SliceWork = NonNullable<ReturnType<typeof useSliceOne>["works"]>[number];
+const EMPTY_WORKS: readonly SliceWork[] = [];
+
+interface WorkCardProps {
+  readonly onSourceSelect: (rawText: string) => void;
+  readonly work: SliceWork;
+  readonly slice: SliceOneState;
+}
+
+const starterDefinition = (work: SliceWork) => ({
+  acceptanceCriteria: ["The requested outcome is observable and documented"],
+  affectedUsers: ["Project users"],
+  assumptions: [],
+  constraints: [],
+  desiredOutcome: work.objective,
+  inScope: [work.objective],
+  outOfScope: ["Unrelated product changes"],
+  problem: work.objective,
+  questions: [],
+  requiredArtifacts: ["Simulation activity and terminal outcome"],
+  risk: "medium",
+});
+
+const starterDesign = (work: SliceWork) => ({
+  architectureSummary:
+    "Validate the approved Definition, then exercise one deterministic fake slice.",
+  callFlowDelta: [
+    "Work -> Run -> Attempt -> normalized events -> terminal outcome",
+  ],
+  concerns: [],
+  evidenceRequirements: ["Terminal Run classification"],
+  fileTreeDelta: [],
+  impactMap: {
+    files: [],
+    modules: [],
+    risks: [],
+    summary: "Compact vertical-slice simulation",
+  },
+  invariants: [
+    "Simulation never claims implementation",
+    "Every Attempt reaches a terminal classification",
+  ],
+  keyInterfaces: ["HarnessRuntime", "AttemptOutcome"],
+  slices: [
+    {
+      codeBoundaries: ["workExecution"],
+      dependsOn: [],
+      evidenceRequirements: ["Normalized activity events"],
+      id: "slice-1",
+      objective: work.objective,
+      observableBehavior: "A terminal fake Run is visible",
+      reviewRequired: false,
+      title: "Deterministic simulation",
+      verification: ["Run completes with a terminal classification"],
+    },
+  ],
+  tradeoffs: ["Fake runtime proves contract before sandbox integration"],
+});
+
+// oxlint-disable-next-line complexity -- the expanded card intentionally keeps the three review sections together.
+const WorkCard = ({ onSourceSelect, work, slice }: WorkCardProps) => {
+  const [sourcesOpen, setSourcesOpen] = useState(false);
+  const [expanded, setExpanded] = useState(false);
+  const sources = work.signals.flatMap((signal) => signal.sources);
+  const { definition } = work;
+  const { design } = work;
+  const [latestRun] = work.runs;
+  return (
+    <article className="border border-[#d7d3c7] bg-[#fffefa] p-4 text-[#20201d] shadow-[0_10px_30px_rgba(30,30,20,0.06)]">
+      <div className="flex items-start gap-3">
+        <span className="grid size-8 shrink-0 place-items-center bg-[#dcff68]">
+          <Sparkles className="size-4" />
+        </span>
+        <div className="min-w-0 flex-1">
+          <p className="text-[10px] font-semibold uppercase text-[#65713a]">
+            Proposed Work
+          </p>
+          <h2 className="mt-1 text-[15px] font-semibold leading-5">
+            {work.title}
+          </h2>
+          <p className="mt-1.5 text-[13px] leading-5 text-[#626057]">
+            {work.objective}
+          </p>
+        </div>
+      </div>
+      <button
+        className="mt-3 flex w-full items-center justify-between border-t border-[#e7e3d9] pt-3 text-left text-xs text-[#69675e]"
+        onClick={() => setSourcesOpen((open) => !open)}
+        type="button"
+      >
+        <span>
+          {sources.length} exact source{" "}
+          {sources.length === 1 ? "message" : "messages"}
+        </span>
+        <ChevronRight
+          className={`size-4 transition-transform ${sourcesOpen ? "rotate-90" : ""}`}
+        />
+      </button>
+      <button
+        className="mt-2 flex w-full items-center justify-between border-t border-[#e7e3d9] pt-3 text-left text-xs font-medium text-[#20201d]"
+        onClick={() => setExpanded((open) => !open)}
+        type="button"
+      >
+        <span>{expanded ? "Hide Work details" : "Open Work details"}</span>
+        <ChevronRight
+          className={`size-4 transition-transform ${expanded ? "rotate-90" : ""}`}
+        />
+      </button>
+      {sourcesOpen ? (
+        <div className="mt-3 space-y-2">
+          {sources.map((source) => (
+            <button
+              className="flex w-full items-start gap-2 border-l-2 border-[#a8b750] bg-[#f4f2e9] px-3 py-2 text-left text-xs leading-5 hover:bg-[#ece9dd]"
+              key={source.messageId}
+              onClick={() => onSourceSelect(source.rawText)}
+              type="button"
+            >
+              <MessageSquareText className="mt-1 size-3.5 shrink-0 text-[#65713a]" />
+              <span className="min-w-0 flex-1">{source.rawText}</span>
+            </button>
+          ))}
+        </div>
+      ) : null}
+      {expanded ? (
+        <div className="mt-4 space-y-4 border-t border-[#e7e3d9] pt-4 text-xs">
+          <section>
+            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
+              Outcome
+            </p>
+            <p className="mt-1 leading-5 text-[#626057]">{work.objective}</p>
+            <p className="mt-2 text-[#747168]">
+              Risk: {definition?.risk ?? "not defined"}
+            </p>
+            {definition?.questions?.length ? (
+              <p className="mt-1 text-amber-800">
+                {
+                  definition.questions.filter(
+                    (question) => question.status === "open"
+                  ).length
+                }{" "}
+                open question(s)
+              </p>
+            ) : null}
+            <div className="mt-2 flex flex-wrap gap-2">
+              {work.status === "proposed" ? (
+                <Button
+                  size="sm"
+                  onClick={() => void slice.requestDefinition(work._id)}
+                >
+                  <Sparkles className="size-3.5" /> Define
+                </Button>
+              ) : null}
+              {work.status === "defining" ? (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() =>
+                    void slice.saveDefinition(work._id, starterDefinition(work))
+                  }
+                >
+                  <Hammer className="size-3.5" /> Save definition
+                </Button>
+              ) : null}
+              {work.status === "awaiting-definition-approval" &&
+              work.definitionVersion ? (
+                <Button
+                  size="sm"
+                  onClick={() =>
+                    void slice.approveDefinition(
+                      work._id,
+                      work.definitionVersion as number
+                    )
+                  }
+                >
+                  <Check className="size-3.5" /> Approve
+                </Button>
+              ) : null}
+            </div>
+          </section>
+          <section>
+            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
+              Design
+            </p>
+            <p className="mt-1 leading-5 text-[#626057]">
+              {design?.architectureSummary ?? "No Design Packet yet."}
+            </p>
+            {design?.slices?.map((item) => (
+              <p className="mt-1 text-[#747168]" key={item.id}>
+                {item.title}: {item.observableBehavior}
+              </p>
+            ))}
+            <div className="mt-2 flex flex-wrap gap-2">
+              {work.status === "designing" ? (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() =>
+                    void slice.saveDesign(work._id, starterDesign(work))
+                  }
+                >
+                  <Hammer className="size-3.5" /> Save design
+                </Button>
+              ) : null}
+              {work.status === "awaiting-design-approval" &&
+              work.definitionApprovalVersion &&
+              work.designVersion ? (
+                <Button
+                  size="sm"
+                  onClick={() =>
+                    void slice.approveDesign(
+                      work._id,
+                      work.definitionApprovalVersion as number,
+                      work.designVersion as number
+                    )
+                  }
+                >
+                  <Check className="size-3.5" /> Approve design
+                </Button>
+              ) : null}
+            </div>
+          </section>
+          <section>
+            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
+              Build
+            </p>
+            {latestRun ? (
+              <p className="mt-1 leading-5 text-[#626057]">
+                Run {latestRun.status}:{" "}
+                {latestRun.terminalSummary ??
+                  latestRun.terminalClassification ??
+                  "activity is still arriving"}
+              </p>
+            ) : (
+              <p className="mt-1 text-[#747168]">No simulation Run yet.</p>
+            )}
+            <div className="mt-2 flex flex-wrap gap-2">
+              {work.status === "ready" ? (
+                <Button
+                  size="sm"
+                  onClick={() =>
+                    void slice.startSimulation(
+                      work._id,
+                      "success",
+                      design?.slices?.[0]?.id
+                    )
+                  }
+                >
+                  <Play className="size-3.5" /> Simulate
+                </Button>
+              ) : null}
+              {latestRun?.status === "running" ? (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() => void slice.cancelSimulation(latestRun._id)}
+                >
+                  <X className="size-3.5" /> Cancel
+                </Button>
+              ) : null}
+              {latestRun?.status === "terminal" &&
+              latestRun.terminalClassification === "RetryableFailure" ? (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() => void slice.retrySimulation(latestRun._id)}
+                >
+                  <RotateCcw className="size-3.5" /> Retry
+                </Button>
+              ) : null}
+            </div>
+          </section>
+        </div>
+      ) : null}
+    </article>
+  );
+};
+
+const ConversationLoading = () => (
+  <output
+    aria-label="Loading conversation"
+    className="mx-auto flex min-h-[55vh] w-full max-w-md flex-col justify-center gap-4"
+  >
+    <span className="h-16 w-4/5 animate-pulse rounded-sm bg-[#e3e0d5]" />
+    <span className="ml-auto h-12 w-3/5 animate-pulse rounded-sm bg-[#dedbd0]" />
+    <span className="h-24 w-full animate-pulse rounded-sm bg-[#e3e0d5]" />
+    <span className="sr-only">Loading conversation…</span>
+  </output>
+);
+
+const ConversationEmptyState = () => (
+  <div className="grid min-h-[55vh] place-items-center text-center">
+    <div>
+      <MessageSquareText className="mx-auto size-7 text-[#8a887f]" />
+      <h1 className="mt-4 text-xl font-semibold">What should move forward?</h1>
+      <p className="mx-auto mt-2 max-w-sm text-sm leading-6 text-[#69675f]">
+        Describe an outcome or problem. Casual conversation stays conversation.
+      </p>
+    </div>
+  </div>
+);
+type SliceOneState = ReturnType<typeof useSliceOne>;
+
+const ProjectsLoading = () => (
+  <div className="grid min-h-svh place-items-center bg-[#f2f0e7]">
+    <LoaderCircle className="size-5 animate-spin" />
+  </div>
+);
+const ConnectProject = ({ slice }: { slice: SliceOneState }) => (
+  <main className="grid min-h-svh place-items-center bg-[#f2f0e7] px-5 text-[#20201d]">
+    <form
+      className="w-full max-w-sm"
+      onSubmit={(event) => {
+        event.preventDefault();
+        void slice.connectRepository();
+      }}
+    >
+      <span className="grid size-11 place-items-center bg-[#20201d] text-white">
+        <FolderGit2 className="size-5" />
+      </span>
+      <h1 className="mt-6 text-2xl font-semibold">Connect one project</h1>
+      <p className="mt-2 text-sm leading-6 text-[#68665e]">
+        Slice 1 turns actionable conversation into proposed Work with exact
+        provenance.
+      </p>
+      <input
+        aria-label="Public Git repository URL"
+        className="mt-6 h-12 w-full border border-[#c9c5b9] bg-[#fffefa] px-3 text-sm outline-none focus:border-[#55564e]"
+        onChange={(event) => slice.setRepository(event.target.value)}
+        placeholder="https://github.com/owner/repository"
+        required
+        value={slice.repository}
+      />
+      {slice.error ? (
+        <p className="mt-2 text-xs text-red-700">{slice.error.message}</p>
+      ) : null}
+      <Button
+        className="mt-3 h-12 w-full"
+        disabled={slice.pending}
+        type="submit"
+      >
+        {slice.pending ? (
+          <LoaderCircle className="size-4 animate-spin" />
+        ) : null}
+        {slice.pending ? "Connecting" : "Connect project"}
+      </Button>
+    </form>
+  </main>
+);
+
+export const SliceOnePage = () => {
+  const slice = useSliceOne();
+  const viewportStyle = useVisualViewportStyle();
+  const [draft, setDraft] = useState("");
+  const attachments = useChatImages();
+  const imageInput = useRef<HTMLInputElement>(null);
+  const [drawerOpen, setDrawerOpen] = useState(false);
+  const [highlightedMessageId, setHighlightedMessageId] = useState<string>();
+  const highlightTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const works = slice.works ?? EMPTY_WORKS;
+  const workById = useMemo(
+    () => new Map(works.map((work) => [String(work._id), work])),
+    [works]
+  );
+  const notices = useMemo(() => projectWorkNotices(works), [works]);
+  const timeline = useMemo(
+    () => buildSliceOneTimeline(slice.agent.messages, notices),
+    [notices, slice.agent.messages]
+  );
+  const busy =
+    slice.agent.status === "submitted" || slice.agent.status === "streaming";
+
+  const revealSourceMessage = (rawText: string) => {
+    const messageId = findSourceMessageTarget(slice.agent.messages, rawText);
+    if (!messageId) {
+      return;
+    }
+    setDrawerOpen(false);
+    setHighlightedMessageId(messageId);
+    if (highlightTimer.current) {
+      clearTimeout(highlightTimer.current);
+    }
+    requestAnimationFrame(() => {
+      document
+        .querySelector(`#${CSS.escape(`slice-message-${messageId}`)}`)
+        ?.scrollIntoView({ behavior: "smooth", block: "center" });
+    });
+    highlightTimer.current = setTimeout(
+      () => setHighlightedMessageId(undefined),
+      1800
+    );
+  };
+
+  if (slice.projects === undefined) {
+    return <ProjectsLoading />;
+  }
+
+  if (!slice.selectedProject) {
+    return <ConnectProject slice={slice} />;
+  }
+
+  const send = async () => {
+    const message = draft.trim();
+    if (!message || busy) {
+      return;
+    }
+    await slice.agent.sendMessage(message, {
+      images: attachments.images.map((image) => image.file),
+    });
+    setDraft("");
+    attachments.clear();
+  };
+
+  return (
+    <main
+      className="slice-one-surface fixed inset-x-0 top-0 flex min-h-0 overflow-hidden bg-[#f2f0e7] text-[#20201d]"
+      style={viewportStyle}
+    >
+      <section className="flex min-w-0 flex-1 flex-col">
+        <header className="flex h-14 shrink-0 items-center border-b border-[#d7d3c7] bg-[#faf9f4] px-4">
+          <div className="min-w-0 flex-1 pr-2">
+            <select
+              aria-label="Current project"
+              className="block h-7 max-w-full border-0 bg-transparent pr-7 text-sm font-semibold text-[#20201d] outline-none"
+              onChange={(event) => slice.selectProject(event.target.value)}
+              value={slice.selectedProject.id}
+            >
+              {slice.projects.map((project) => (
+                <option key={project.id} value={project.id}>
+                  {project.name}
+                </option>
+              ))}
+            </select>
+            <p className="text-[10px] uppercase text-[#858277]">
+              Conversation to proposed Work
+            </p>
+          </div>
+          <button
+            className="flex h-9 items-center gap-2 border border-[#c9c5b9] bg-white px-3 text-xs lg:hidden"
+            onClick={() => setDrawerOpen(true)}
+            type="button"
+          >
+            <Menu className="size-4" /> Work{" "}
+            {slice.works === undefined ? "…" : works.length}
+          </button>
+        </header>
+        <Conversation className="min-h-0 flex-1">
+          <ConversationContent className="mx-auto min-h-full w-full max-w-2xl gap-4 px-4 py-5 sm:px-6">
+            {!slice.agent.historyReady && timeline.length === 0 ? (
+              <ConversationLoading />
+            ) : null}
+            {slice.agent.historyReady && timeline.length === 0 ? (
+              <ConversationEmptyState />
+            ) : null}
+            {timeline.map((item) => {
+              if (item.kind === "work") {
+                const work = workById.get(item.notice.workId);
+                return work ? (
+                  <div
+                    className="chat-message ml-7"
+                    key={`notice-${item.notice.eventId}`}
+                  >
+                    <p className="mb-2 text-[10px] font-semibold uppercase text-[#65713a]">
+                      Work proposed from this conversation
+                    </p>
+                    <WorkCard
+                      onSourceSelect={revealSourceMessage}
+                      slice={slice}
+                      work={work}
+                    />
+                  </div>
+                ) : null;
+              }
+              return (
+                <div
+                  className={`rounded-sm transition-colors duration-300 ${
+                    highlightedMessageId === item.message.id
+                      ? "bg-[#dcff68]/70 ring-2 ring-[#7f9130] ring-offset-4 ring-offset-[#f2f0e7]"
+                      : ""
+                  }`}
+                  id={`slice-message-${item.message.id}`}
+                  key={item.message.id}
+                >
+                  <ChatMessage message={item.message} />
+                </div>
+              );
+            })}
+            {slice.agent.status === "submitted" ? (
+              <ChatThinkingResponse />
+            ) : null}
+          </ConversationContent>
+        </Conversation>
+        <div className="shrink-0 border-t border-[#d7d3c7] bg-[#faf9f4] p-3 pb-[max(0.75rem,env(safe-area-inset-bottom))]">
+          {attachments.images.length > 0 ? (
+            <div className="mx-auto max-w-2xl">
+              <PendingChatAttachments
+                images={attachments.images}
+                onRemove={attachments.handleRemove}
+              />
+            </div>
+          ) : null}
+          {slice.agent.error ? (
+            <p className="mx-auto mb-2 max-w-2xl text-xs text-red-700">
+              {slice.agent.error.message}
+            </p>
+          ) : null}
+          {attachments.error ? (
+            <p className="mx-auto mb-2 max-w-2xl text-xs text-red-700">
+              {attachments.error}
+            </p>
+          ) : null}
+          <div className="mx-auto flex max-w-2xl items-end gap-2">
+            <input
+              accept="image/*"
+              aria-label="Attach images"
+              className="sr-only"
+              multiple
+              onChange={(event) => {
+                attachments.addFiles(event.target.files);
+                event.target.value = "";
+              }}
+              ref={imageInput}
+              type="file"
+            />
+            <Button
+              aria-label="Attach images"
+              className="size-11 shrink-0"
+              disabled={busy}
+              onClick={() => imageInput.current?.click()}
+              size="icon"
+              type="button"
+              variant="outline"
+            >
+              <ImagePlus className="size-4" />
+            </Button>
+            <textarea
+              aria-label="Message Zopu"
+              className="max-h-32 min-h-11 flex-1 resize-none border border-[#c9c5b9] bg-white px-3 py-2.5 text-sm outline-none focus:border-[#55564e]"
+              disabled={busy}
+              onChange={(event) => setDraft(event.target.value)}
+              onKeyDown={(event) => {
+                if (event.key === "Enter" && !event.shiftKey) {
+                  event.preventDefault();
+                  void send();
+                }
+              }}
+              placeholder="Describe an outcome or problem…"
+              rows={1}
+              value={draft}
+            />
+            <Button
+              aria-label="Send message"
+              className="size-11 shrink-0"
+              disabled={!draft.trim() || busy}
+              onClick={() => void send()}
+              size="icon"
+              type="button"
+            >
+              {busy ? (
+                <LoaderCircle className="size-4 animate-spin" />
+              ) : (
+                <Send className="size-4" />
+              )}
+            </Button>
+          </div>
+        </div>
+      </section>
+      <aside className="hidden w-[380px] shrink-0 overflow-y-auto border-l border-[#d7d3c7] bg-[#e9e7de] p-4 lg:block">
+        <h2 className="text-sm font-semibold">Proposed Work</h2>
+        <p className="mb-4 text-xs text-[#747168]">
+          {works.length} durable outcomes
+        </p>
+        <div className="space-y-3">
+          {works.map((work) => (
+            <WorkCard
+              key={work._id}
+              onSourceSelect={revealSourceMessage}
+              slice={slice}
+              work={work}
+            />
+          ))}
+        </div>
+      </aside>
+      {drawerOpen ? (
+        <div className="fixed inset-0 z-50 bg-black/30 lg:hidden">
+          <button
+            aria-label="Close Work drawer"
+            className="absolute inset-0"
+            onClick={() => setDrawerOpen(false)}
+            type="button"
+          />
+          <section className="absolute inset-y-0 right-0 flex w-[min(92vw,380px)] flex-col bg-[#e9e7de] shadow-2xl">
+            <header className="flex h-14 items-center border-b border-[#cfcbc0] px-4">
+              <h2 className="flex-1 text-sm font-semibold">Proposed Work</h2>
+              <button
+                aria-label="Close Work drawer"
+                className="grid size-9 place-items-center"
+                onClick={() => setDrawerOpen(false)}
+                type="button"
+              >
+                <X className="size-4" />
+              </button>
+            </header>
+            <div className="flex-1 space-y-3 overflow-y-auto p-4">
+              {works.length === 0 ? (
+                <p className="py-12 text-center text-sm text-[#747168]">
+                  Actionable messages will appear here.
+                </p>
+              ) : null}
+              {works.map((work) => (
+                <WorkCard
+                  key={work._id}
+                  onSourceSelect={revealSourceMessage}
+                  slice={slice}
+                  work={work}
+                />
+              ))}
+            </div>
+          </section>
+        </div>
+      ) : null}
+    </main>
+  );
+};

apps/web/src/components/workspace/conversation-composer.tsx

@@ -1,112 +0,0 @@
-import { Button } from "@code/ui/components/button";
-import { ImagePlus, LoaderCircle, Send } from "lucide-react";
-import { useRef } from "react";
-
-import { PendingChatAttachments } from "@/components/chat/chat-attachments";
-import { useChatImages } from "@/hooks/chat/use-chat-images";
-import type { WorkspaceState } from "@/lib/workspace/types";
-
-export const ConversationComposer = ({
-  draft,
-  onDraftChange,
-  workspace,
-}: {
-  readonly draft: string;
-  readonly onDraftChange: (draft: string) => void;
-  readonly workspace: WorkspaceState;
-}) => {
-  const imageInput = useRef<HTMLInputElement>(null);
-  const attachments = useChatImages();
-  const busy =
-    workspace.agent.status === "submitted" ||
-    workspace.agent.status === "streaming";
-
-  const send = async () => {
-    const message = draft.trim();
-    if (!message || busy) {
-      return;
-    }
-    await workspace.agent.sendMessage(message, {
-      images: attachments.images.map((image) => image.file),
-    });
-    onDraftChange("");
-    attachments.clear();
-  };
-
-  return (
-    <div className="shrink-0 border-t border-[#d7d3c7] bg-[#faf9f4] p-3 pb-[max(0.75rem,env(safe-area-inset-bottom))]">
-      {attachments.images.length > 0 ? (
-        <div className="mx-auto max-w-2xl">
-          <PendingChatAttachments
-            images={attachments.images}
-            onRemove={attachments.handleRemove}
-          />
-        </div>
-      ) : null}
-      {workspace.agent.error ? (
-        <p className="mx-auto mb-2 max-w-2xl text-xs text-red-700">
-          {workspace.agent.error.message}
-        </p>
-      ) : null}
-      {attachments.error ? (
-        <p className="mx-auto mb-2 max-w-2xl text-xs text-red-700">
-          {attachments.error}
-        </p>
-      ) : null}
-      <div className="mx-auto flex max-w-2xl items-end gap-2">
-        <input
-          accept="image/*"
-          aria-label="Attach images"
-          className="sr-only"
-          multiple
-          onChange={(event) => {
-            attachments.addFiles(event.target.files);
-            event.target.value = "";
-          }}
-          ref={imageInput}
-          type="file"
-        />
-        <Button
-          aria-label="Attach images"
-          className="size-11 shrink-0"
-          disabled={busy}
-          onClick={() => imageInput.current?.click()}
-          size="icon"
-          type="button"
-          variant="outline"
-        >
-          <ImagePlus className="size-4" />
-        </Button>
-        <textarea
-          aria-label="Message Zopu"
-          className="max-h-32 min-h-11 flex-1 resize-none border border-[#c9c5b9] bg-white px-3 py-2.5 text-sm outline-none focus:border-[#55564e]"
-          disabled={busy}
-          onChange={(event) => onDraftChange(event.target.value)}
-          onKeyDown={(event) => {
-            if (event.key === "Enter" && !event.shiftKey) {
-              event.preventDefault();
-              void send();
-            }
-          }}
-          placeholder="Describe an outcome or problem…"
-          rows={1}
-          value={draft}
-        />
-        <Button
-          aria-label="Send message"
-          className="size-11 shrink-0"
-          disabled={!draft.trim() || busy}
-          onClick={() => void send()}
-          size="icon"
-          type="button"
-        >
-          {busy ? (
-            <LoaderCircle className="size-4 animate-spin" />
-          ) : (
-            <Send className="size-4" />
-          )}
-        </Button>
-      </div>
-    </div>
-  );
-};

apps/web/src/components/workspace/conversation-feed.tsx

@@ -1,108 +0,0 @@
-import { projectWorkNotices } from "@code/primitives/work";
-import {
-  Conversation,
-  ConversationContent,
-} from "@code/ui/components/ai-elements/conversation";
-import { MessageSquareText } from "lucide-react";
-import { useMemo } from "react";
-
-import { ChatMessage } from "@/components/chat/chat-message";
-import { ChatThinkingResponse } from "@/components/chat/chat-thinking-response";
-import { buildWorkspaceTimeline } from "@/lib/workspace/presentation";
-import type { WorkRecord, WorkspaceState } from "@/lib/workspace/types";
-
-import { WorkCard } from "./work-card";
-
-const ConversationLoading = () => (
-  <output
-    aria-label="Loading conversation"
-    className="mx-auto flex min-h-[55vh] w-full max-w-md flex-col justify-center gap-4"
-  >
-    <span className="h-16 w-4/5 animate-pulse rounded-sm bg-[#e3e0d5]" />
-    <span className="ml-auto h-12 w-3/5 animate-pulse rounded-sm bg-[#dedbd0]" />
-    <span className="h-24 w-full animate-pulse rounded-sm bg-[#e3e0d5]" />
-    <span className="sr-only">Loading conversation…</span>
-  </output>
-);
-
-const ConversationEmptyState = () => (
-  <div className="grid min-h-[55vh] place-items-center text-center">
-    <div>
-      <MessageSquareText className="mx-auto size-7 text-[#8a887f]" />
-      <h1 className="mt-4 text-xl font-semibold">What should move forward?</h1>
-      <p className="mx-auto mt-2 max-w-sm text-sm leading-6 text-[#69675f]">
-        Describe an outcome or problem. Casual conversation stays conversation.
-      </p>
-    </div>
-  </div>
-);
-
-export const ConversationFeed = ({
-  highlightedMessageId,
-  onSourceSelect,
-  workspace,
-}: {
-  readonly highlightedMessageId?: string;
-  readonly onSourceSelect: (rawText: string) => void;
-  readonly workspace: WorkspaceState;
-}) => {
-  const works = workspace.works ?? [];
-  const workById = new Map(
-    works.map((work) => [String(work._id), work] as const)
-  );
-  const notices = projectWorkNotices(works);
-  const timeline = useMemo(
-    () => buildWorkspaceTimeline(workspace.agent.messages, notices),
-    [notices, workspace.agent.messages]
-  );
-
-  return (
-    <Conversation className="min-h-0 flex-1">
-      <ConversationContent className="mx-auto min-h-full w-full max-w-2xl gap-4 px-4 py-5 sm:px-6">
-        {!workspace.agent.historyReady && timeline.length === 0 ? (
-          <ConversationLoading />
-        ) : null}
-        {workspace.agent.historyReady && timeline.length === 0 ? (
-          <ConversationEmptyState />
-        ) : null}
-        {timeline.map((item) => {
-          if (item.kind === "work") {
-            const work = workById.get(item.notice.workId) as
-              | WorkRecord
-              | undefined;
-            return work ? (
-              <div
-                className="chat-message ml-7"
-                key={`notice-${item.notice.eventId}`}
-              >
-                <p className="mb-2 text-[10px] font-semibold uppercase text-[#65713a]">
-                  Work proposed from this conversation
-                </p>
-                <div className="rounded-sm">
-                  <span className="sr-only">Proposed Work</span>
-                  <WorkCard
-                    onSourceSelect={onSourceSelect}
-                    work={work}
-                    workspace={workspace}
-                  />
-                </div>
-              </div>
-            ) : null;
-          }
-          return (
-            <div
-              className={`rounded-sm transition-colors duration-300 ${highlightedMessageId === item.message.id ? "bg-[#dcff68]/70 ring-2 ring-[#7f9130] ring-offset-4 ring-offset-[#f2f0e7]" : ""}`}
-              id={`workspace-message-${item.message.id}`}
-              key={item.message.id}
-            >
-              <ChatMessage message={item.message} />
-            </div>
-          );
-        })}
-        {workspace.agent.status === "submitted" ? (
-          <ChatThinkingResponse />
-        ) : null}
-      </ConversationContent>
-    </Conversation>
-  );
-};

apps/web/src/components/workspace/project-connect-form.tsx

@@ -1,50 +0,0 @@
-import { Button } from "@code/ui/components/button";
-import { FolderGit2, LoaderCircle } from "lucide-react";
-
-import type { WorkspaceState } from "@/lib/workspace/types";
-
-export const ProjectConnectForm = ({
-  workspace,
-}: {
-  readonly workspace: WorkspaceState;
-}) => (
-  <main className="grid min-h-svh place-items-center bg-[#f2f0e7] px-5 text-[#20201d]">
-    <form
-      className="w-full max-w-sm"
-      onSubmit={(event) => {
-        event.preventDefault();
-        void workspace.connectRepository();
-      }}
-    >
-      <span className="grid size-11 place-items-center bg-[#20201d] text-white">
-        <FolderGit2 className="size-5" />
-      </span>
-      <h1 className="mt-6 text-2xl font-semibold">Connect a project</h1>
-      <p className="mt-2 text-sm leading-6 text-[#68665e]">
-        Turn actionable project conversation into proposed Work with exact
-        provenance.
-      </p>
-      <input
-        aria-label="Public Git repository URL"
-        className="mt-6 h-12 w-full border border-[#c9c5b9] bg-[#fffefa] px-3 text-sm outline-none focus:border-[#55564e]"
-        onChange={(event) => workspace.setRepository(event.target.value)}
-        placeholder="https://github.com/owner/repository"
-        required
-        value={workspace.repository}
-      />
-      {workspace.error ? (
-        <p className="mt-2 text-xs text-red-700">{workspace.error.message}</p>
-      ) : null}
-      <Button
-        className="mt-3 h-12 w-full"
-        disabled={workspace.pending}
-        type="submit"
-      >
-        {workspace.pending ? (
-          <LoaderCircle className="size-4 animate-spin" />
-        ) : null}
-        {workspace.pending ? "Connecting" : "Connect project"}
-      </Button>
-    </form>
-  </main>
-);

apps/web/src/components/workspace/project-header.tsx

@@ -1,63 +0,0 @@
-import { Button } from "@code/ui/components/button";
-import { Menu, Settings } from "lucide-react";
-import { useState } from "react";
-
-import type { WorkspaceState } from "@/lib/workspace/types";
-
-import { ProjectSettingsPanel } from "./project-settings-panel";
-
-export const ProjectHeader = ({
-  onOpenDrawer,
-  workspace,
-}: {
-  readonly onOpenDrawer: () => void;
-  readonly workspace: WorkspaceState;
-}) => {
-  const [settingsOpen, setSettingsOpen] = useState(false);
-  const works = workspace.works ?? [];
-
-  return (
-    <header className="relative flex h-14 shrink-0 items-center border-b border-[#d7d3c7] bg-[#faf9f4] px-4">
-      <div className="min-w-0 flex-1 pr-2">
-        <select
-          aria-label="Current project"
-          className="block h-7 max-w-full border-0 bg-transparent pr-7 text-sm font-semibold text-[#20201d] outline-none"
-          onChange={(event) => workspace.selectProject(event.target.value)}
-          value={workspace.selectedProject?.id ?? ""}
-        >
-          {(workspace.projects ?? []).map((project) => (
-            <option key={project.id} value={project.id}>
-              {project.name}
-            </option>
-          ))}
-        </select>
-        <p className="text-[10px] uppercase text-[#858277]">
-          Conversation to proposed Work
-        </p>
-      </div>
-      <Button
-        aria-label="Project settings"
-        className="mr-2 size-9"
-        onClick={() => setSettingsOpen((open) => !open)}
-        size="icon"
-        variant="outline"
-      >
-        <Settings className="size-4" />
-      </Button>
-      <button
-        className="flex h-9 items-center gap-2 border border-[#c9c5b9] bg-white px-3 text-xs lg:hidden"
-        onClick={onOpenDrawer}
-        type="button"
-      >
-        <Menu className="size-4" /> Work{" "}
-        {workspace.works === undefined ? "…" : works.length}
-      </button>
-      {settingsOpen ? (
-        <ProjectSettingsPanel
-          onClose={() => setSettingsOpen(false)}
-          workspace={workspace}
-        />
-      ) : null}
-    </header>
-  );
-};

apps/web/src/components/workspace/project-settings-panel.tsx

@@ -1,100 +0,0 @@
-import { Button } from "@code/ui/components/button";
-import { AlertTriangle, X } from "lucide-react";
-import { useState } from "react";
-
-import type { WorkspaceState } from "@/lib/workspace/types";
-
-export const ProjectSettingsPanel = ({
-  onClose,
-  workspace,
-}: {
-  readonly onClose: () => void;
-  readonly workspace: WorkspaceState;
-}) => {
-  const [serverUrl, setServerUrl] = useState("https://git.openputer.com");
-  const [username, setUsername] = useState("");
-  const [token, setToken] = useState("");
-  const handleClearOperationError = () => workspace.clearOperationError();
-
-  return (
-    <section className="absolute right-4 top-12 z-40 w-[min(92vw,360px)] border border-[#c9c5b9] bg-[#fffefa] p-4 shadow-xl">
-      <div className="flex items-center justify-between">
-        <h2 className="text-sm font-semibold">Project Git</h2>
-        <button aria-label="Close settings" onClick={onClose} type="button">
-          <X className="size-4" />
-        </button>
-      </div>
-      <p className="mt-1 text-xs text-[#747168]">
-        {workspace.projectGitConnection
-          ? `${workspace.projectGitConnection.provider} · ${workspace.projectGitConnection.serverUrl}`
-          : "No Git credentials attached"}
-      </p>
-      {workspace.operationError ? (
-        <p className="mt-2 flex items-start gap-1.5 border border-red-300 bg-red-50 px-2 py-1.5 text-xs text-red-800">
-          <AlertTriangle className="mt-0.5 size-3.5 shrink-0" />
-          <span className="min-w-0 flex-1 leading-5">
-            {workspace.operationError.message}
-          </span>
-          <button
-            aria-label="Dismiss error"
-            className="shrink-0"
-            onClick={handleClearOperationError}
-            type="button"
-          >
-            <X className="size-3.5" />
-          </button>
-        </p>
-      ) : null}
-      <div className="mt-4 flex gap-2">
-        <Button
-          size="sm"
-          variant="outline"
-          onClick={() => void workspace.authorizeGithub()}
-        >
-          Authorize GitHub
-        </Button>
-        <Button size="sm" onClick={() => void workspace.connectLinkedGithub()}>
-          Use GitHub
-        </Button>
-      </div>
-      <div className="mt-4 space-y-2 border-t border-[#e7e3d9] pt-4">
-        <input
-          aria-label="Gitea server URL"
-          className="h-9 w-full border px-2 text-xs"
-          onChange={(event) => setServerUrl(event.target.value)}
-          value={serverUrl}
-        />
-        <input
-          aria-label="Gitea username"
-          className="h-9 w-full border px-2 text-xs"
-          onChange={(event) => setUsername(event.target.value)}
-          placeholder="Username (optional)"
-          value={username}
-        />
-        <input
-          aria-label="Gitea access token"
-          className="h-9 w-full border px-2 text-xs"
-          onChange={(event) => setToken(event.target.value)}
-          placeholder="Personal access token"
-          type="password"
-          value={token}
-        />
-        <Button
-          className="w-full"
-          disabled={!token.trim()}
-          size="sm"
-          onClick={() => {
-            void workspace.connectGitea({
-              serverUrl,
-              token,
-              username: username || undefined,
-            });
-            setToken("");
-          }}
-        >
-          Connect Gitea
-        </Button>
-      </div>
-    </section>
-  );
-};

apps/web/src/components/workspace/project-workspace-page.tsx

@@ -1,123 +0,0 @@
-import { useRef, useState } from "react";
-
-import { useProjectWorkspace } from "@/hooks/workspace/use-project-workspace";
-import { useVisualViewportStyle } from "@/hooks/workspace/use-visual-viewport";
-import { findSourceMessageTarget } from "@/lib/workspace/presentation";
-
-import { ConversationComposer } from "./conversation-composer";
-import { ConversationFeed } from "./conversation-feed";
-import { ProjectConnectForm } from "./project-connect-form";
-import { ProjectHeader } from "./project-header";
-import { WorkFeed } from "./work-feed";
-
-const ProjectLoading = () => (
-  <main className="grid min-h-svh place-items-center bg-[#f2f0e7]">
-    <span className="size-5 animate-spin rounded-full border-2 border-[#20201d] border-t-transparent" />
-  </main>
-);
-
-export const ProjectWorkspacePage = () => {
-  const workspace = useProjectWorkspace();
-  const viewportStyle = useVisualViewportStyle();
-  const [draft, setDraft] = useState("");
-  const [drawerOpen, setDrawerOpen] = useState(false);
-  const [highlightedMessageId, setHighlightedMessageId] = useState<string>();
-  const highlightTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  if (workspace.projects === undefined) {
-    return <ProjectLoading />;
-  }
-  if (!workspace.selectedProject) {
-    return <ProjectConnectForm workspace={workspace} />;
-  }
-
-  const works = workspace.works ?? [];
-  const revealSourceMessage = (rawText: string) => {
-    const messageId = findSourceMessageTarget(
-      workspace.agent.messages,
-      rawText
-    );
-    if (!messageId) {
-      return;
-    }
-    setDrawerOpen(false);
-    setHighlightedMessageId(messageId);
-    if (highlightTimer.current) {
-      clearTimeout(highlightTimer.current);
-    }
-    requestAnimationFrame(() =>
-      document
-        .querySelector(`#workspace-message-${CSS.escape(messageId)}`)
-        ?.scrollIntoView({ behavior: "smooth", block: "center" })
-    );
-    highlightTimer.current = setTimeout(
-      () => setHighlightedMessageId(undefined),
-      1800
-    );
-  };
-
-  return (
-    <main
-      className="workspace-surface fixed inset-x-0 top-0 flex min-h-0 overflow-hidden bg-[#f2f0e7] text-[#20201d]"
-      style={viewportStyle}
-    >
-      <section className="flex min-w-0 flex-1 flex-col">
-        <ProjectHeader
-          onOpenDrawer={() => setDrawerOpen(true)}
-          workspace={workspace}
-        />
-        <ConversationFeed
-          highlightedMessageId={highlightedMessageId}
-          onSourceSelect={revealSourceMessage}
-          workspace={workspace}
-        />
-        <ConversationComposer
-          draft={draft}
-          onDraftChange={setDraft}
-          workspace={workspace}
-        />
-      </section>
-      <aside className="hidden w-[380px] shrink-0 overflow-y-auto border-l border-[#d7d3c7] bg-[#e9e7de] p-4 lg:block">
-        <h2 className="text-sm font-semibold">Proposed Work</h2>
-        <p className="mb-4 text-xs text-[#747168]">
-          {works.length} durable outcomes
-        </p>
-        <WorkFeed
-          onSourceSelect={revealSourceMessage}
-          works={works}
-          workspace={workspace}
-        />
-      </aside>
-      {drawerOpen ? (
-        <div className="fixed inset-0 z-50 bg-black/30 lg:hidden">
-          <button
-            aria-label="Close Work drawer"
-            className="absolute inset-0"
-            onClick={() => setDrawerOpen(false)}
-            type="button"
-          />
-          <section className="absolute inset-y-0 right-0 flex w-[min(92vw,380px)] flex-col bg-[#e9e7de] shadow-2xl">
-            <header className="flex h-14 items-center border-b border-[#cfcbc0] px-4">
-              <h2 className="flex-1 text-sm font-semibold">Proposed Work</h2>
-              <button
-                aria-label="Close Work drawer"
-                className="grid size-9 place-items-center"
-                onClick={() => setDrawerOpen(false)}
-                type="button"
-              >
-                ×
-              </button>
-            </header>
-            <div className="flex-1 overflow-y-auto p-4">
-              <WorkFeed
-                onSourceSelect={revealSourceMessage}
-                works={works}
-                workspace={workspace}
-              />
-            </div>
-          </section>
-        </div>
-      ) : null}
-    </main>
-  );
-};

apps/web/src/components/workspace/work-card.tsx

@@ -1,395 +0,0 @@
-import { Button } from "@code/ui/components/button";
-import {
-  AlertTriangle,
-  Check,
-  ChevronRight,
-  FileCode2,
-  Hammer,
-  Play,
-  RotateCcw,
-  ScrollText,
-  Sparkles,
-  X,
-} from "lucide-react";
-import { useState } from "react";
-
-import { changedFilesFor } from "@/lib/workspace/types";
-import type { WorkRecord, WorkspaceState } from "@/lib/workspace/types";
-
-interface WorkCardProps {
-  readonly onSourceSelect: (rawText: string) => void;
-  readonly work: WorkRecord;
-  readonly workspace: WorkspaceState;
-}
-
-const starterDefinition = (work: WorkRecord) => ({
-  acceptanceCriteria: ["The requested outcome is observable and documented"],
-  affectedUsers: ["Project users"],
-  assumptions: [],
-  constraints: [],
-  desiredOutcome: work.objective,
-  inScope: [work.objective],
-  outOfScope: ["Unrelated product changes"],
-  problem: work.objective,
-  questions: [],
-  requiredArtifacts: ["Simulation activity and terminal outcome"],
-  risk: "medium",
-});
-
-const starterDesign = (work: WorkRecord) => ({
-  architectureSummary:
-    "Validate the approved Definition, then exercise one deterministic fake slice.",
-  callFlowDelta: [
-    "Work -> Run -> Attempt -> normalized events -> terminal outcome",
-  ],
-  concerns: [],
-  evidenceRequirements: ["Terminal Run classification"],
-  fileTreeDelta: [],
-  impactMap: {
-    files: [],
-    modules: [],
-    risks: [],
-    summary: "Compact vertical-slice simulation",
-  },
-  invariants: [
-    "Simulation never claims implementation",
-    "Every Attempt reaches a terminal classification",
-  ],
-  keyInterfaces: ["HarnessRuntime", "AttemptOutcome"],
-  slices: [
-    {
-      codeBoundaries: ["workExecution"],
-      dependsOn: [],
-      evidenceRequirements: ["Normalized activity events"],
-      id: "deterministic-simulation",
-      objective: work.objective,
-      observableBehavior: "A terminal fake Run is visible",
-      reviewRequired: false,
-      title: "Deterministic simulation",
-      verification: ["Run completes with a terminal classification"],
-    },
-  ],
-  tradeoffs: ["Fake runtime proves contract before sandbox integration"],
-});
-
-// oxlint-disable-next-line complexity -- this card intentionally coordinates review actions and run evidence.
-export const WorkCard = ({
-  onSourceSelect,
-  work,
-  workspace,
-}: WorkCardProps) => {
-  const [sourcesOpen, setSourcesOpen] = useState(false);
-  const [expanded, setExpanded] = useState(false);
-  const [logsOpen, setLogsOpen] = useState(false);
-  const sources = work.signals.flatMap((signal) => signal.sources);
-  const [latestRun] = work.runs;
-  const openQuestions =
-    work.definition?.questions?.filter((question) => question.status === "open")
-      .length ?? 0;
-
-  return (
-    <article className="border border-[#d7d3c7] bg-[#fffefa] p-4 text-[#20201d] shadow-[0_10px_30px_rgba(30,30,20,0.06)]">
-      <div className="flex items-start gap-3">
-        <span className="grid size-8 shrink-0 place-items-center bg-[#dcff68]">
-          <Sparkles className="size-4" />
-        </span>
-        <div className="min-w-0 flex-1">
-          <p className="text-[10px] font-semibold uppercase text-[#65713a]">
-            Proposed Work
-          </p>
-          <h2 className="mt-1 text-[15px] font-semibold leading-5">
-            {work.title}
-          </h2>
-          <p className="mt-1.5 text-[13px] leading-5 text-[#626057]">
-            {work.objective}
-          </p>
-        </div>
-      </div>
-      <button
-        className="mt-3 flex w-full items-center justify-between border-t border-[#e7e3d9] pt-3 text-left text-xs text-[#69675e]"
-        onClick={() => setSourcesOpen((open) => !open)}
-        type="button"
-      >
-        <span>
-          {sources.length} exact source{" "}
-          {sources.length === 1 ? "message" : "messages"}
-        </span>
-        <ChevronRight
-          className={`size-4 transition-transform ${sourcesOpen ? "rotate-90" : ""}`}
-        />
-      </button>
-      <button
-        className="mt-2 flex w-full items-center justify-between border-t border-[#e7e3d9] pt-3 text-left text-xs font-medium text-[#20201d]"
-        onClick={() => setExpanded((open) => !open)}
-        type="button"
-      >
-        <span>{expanded ? "Hide Work details" : "Open Work details"}</span>
-        <ChevronRight
-          className={`size-4 transition-transform ${expanded ? "rotate-90" : ""}`}
-        />
-      </button>
-      {sourcesOpen ? (
-        <div className="mt-3 space-y-2">
-          {sources.map((source) => (
-            <button
-              className="flex w-full items-start gap-2 border-l-2 border-[#a8b750] bg-[#f4f2e9] px-3 py-2 text-left text-xs leading-5 hover:bg-[#ece9dd]"
-              key={source.messageId}
-              onClick={() => onSourceSelect(source.rawText)}
-              type="button"
-            >
-              <span className="min-w-0 flex-1">{source.rawText}</span>
-            </button>
-          ))}
-        </div>
-      ) : null}
-      {expanded ? (
-        <div className="mt-4 space-y-4 border-t border-[#e7e3d9] pt-4 text-xs">
-          <section>
-            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
-              Outcome
-            </p>
-            <p className="mt-1 leading-5 text-[#626057]">{work.objective}</p>
-            <p className="mt-2 text-[#747168]">
-              Risk: {work.definition?.risk ?? "not defined"}
-            </p>
-            {openQuestions > 0 ? (
-              <p className="mt-1 text-amber-800">
-                {openQuestions} open question(s)
-              </p>
-            ) : null}
-            <div className="mt-2 flex flex-wrap gap-2">
-              {work.status === "proposed" ? (
-                <Button
-                  size="sm"
-                  onClick={() => void workspace.requestDefinition(work._id)}
-                >
-                  <Sparkles className="size-3.5" /> Define
-                </Button>
-              ) : null}
-              {work.status === "defining" ? (
-                <Button
-                  size="sm"
-                  variant="outline"
-                  onClick={() =>
-                    void workspace.saveDefinition(
-                      work._id,
-                      starterDefinition(work)
-                    )
-                  }
-                >
-                  <Hammer className="size-3.5" /> Save definition
-                </Button>
-              ) : null}
-              {work.status === "awaiting-definition-approval" &&
-              work.definitionVersion ? (
-                <Button
-                  size="sm"
-                  onClick={() =>
-                    void workspace.approveDefinition(
-                      work._id,
-                      work.definitionVersion as number
-                    )
-                  }
-                >
-                  <Check className="size-3.5" /> Approve
-                </Button>
-              ) : null}
-            </div>
-          </section>
-          <section>
-            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
-              Design
-            </p>
-            <p className="mt-1 leading-5 text-[#626057]">
-              {work.design?.architectureSummary ?? "No Design Packet yet."}
-            </p>
-            {work.design?.slices?.map((item) => (
-              <p className="mt-1 text-[#747168]" key={item.id}>
-                {item.title}: {item.observableBehavior}
-              </p>
-            ))}
-            <div className="mt-2 flex flex-wrap gap-2">
-              {work.status === "designing" ? (
-                <Button
-                  size="sm"
-                  variant="outline"
-                  onClick={() =>
-                    void workspace.saveDesign(work._id, starterDesign(work))
-                  }
-                >
-                  <Hammer className="size-3.5" /> Save design
-                </Button>
-              ) : null}
-              {work.status === "awaiting-design-approval" &&
-              work.definitionApprovalVersion &&
-              work.designVersion ? (
-                <Button
-                  size="sm"
-                  onClick={() =>
-                    void workspace.approveDesign(
-                      work._id,
-                      work.definitionApprovalVersion as number,
-                      work.designVersion as number
-                    )
-                  }
-                >
-                  <Check className="size-3.5" /> Approve design
-                </Button>
-              ) : null}
-            </div>
-          </section>
-          <section>
-            <p className="font-semibold uppercase tracking-wide text-[#65713a]">
-              Build
-            </p>
-            {workspace.operationError ? (
-              <p className="mt-2 flex items-start gap-1.5 border border-red-300 bg-red-50 px-2 py-1.5 text-red-800">
-                <AlertTriangle className="mt-0.5 size-3.5 shrink-0" />
-                <span className="min-w-0 flex-1 leading-5">
-                  {workspace.operationError.message}
-                </span>
-                <button
-                  aria-label="Dismiss error"
-                  className="shrink-0"
-                  onClick={() => workspace.clearOperationError()}
-                  type="button"
-                >
-                  <X className="size-3.5" />
-                </button>
-              </p>
-            ) : null}
-            {latestRun ? (
-              <div className="mt-1 space-y-2 text-[#626057]">
-                <p className="leading-5">
-                  {latestRun.executionKind === "real"
-                    ? "AgentOS"
-                    : "Simulation"}{" "}
-                  run {latestRun.status}:{" "}
-                  {latestRun.terminalSummary ??
-                    latestRun.terminalClassification ??
-                    "activity is still arriving"}
-                </p>
-                {latestRun.baseRevision ? (
-                  <p className="font-mono text-[10px] text-[#747168]">
-                    {latestRun.baseRevision.slice(0, 8)} →{" "}
-                    {latestRun.candidateRevision?.slice(0, 8) ?? "working"}
-                  </p>
-                ) : null}
-                {latestRun.artifacts?.map((artifact) => (
-                  <div key={artifact._id} className="space-y-1">
-                    <p className="font-medium">
-                      {artifact.uri ? (
-                        <a
-                          className="underline"
-                          href={artifact.uri}
-                          rel="noreferrer"
-                          target="_blank"
-                        >
-                          {artifact.title}
-                        </a>
-                      ) : (
-                        artifact.title
-                      )}
-                    </p>
-                    {changedFilesFor(artifact).length > 0 ? (
-                      <ul className="space-y-0.5">
-                        {changedFilesFor(artifact).map((file) => (
-                          <li
-                            className="flex items-start gap-1.5 font-mono text-[11px] leading-5 text-[#747168]"
-                            key={file}
-                          >
-                            <FileCode2 className="mt-0.5 size-3 shrink-0 text-[#9a985f]" />
-                            <span className="min-w-0 break-all">{file}</span>
-                          </li>
-                        ))}
-                      </ul>
-                    ) : null}
-                  </div>
-                ))}
-                {latestRun.attemptEvents &&
-                latestRun.attemptEvents.length > 0 ? (
-                  <div className="space-y-1">
-                    {(logsOpen
-                      ? latestRun.attemptEvents
-                      : latestRun.attemptEvents.slice(-3)
-                    ).map((item) => (
-                      <p
-                        className="border-l-2 border-[#b8c760] pl-2 leading-5"
-                        key={item._id}
-                      >
-                        {item.message}
-                      </p>
-                    ))}
-                    {latestRun.attemptEvents.length > 3 ? (
-                      <button
-                        className="flex items-center gap-1 font-medium text-[#65713a] hover:underline"
-                        onClick={() => setLogsOpen((open) => !open)}
-                        type="button"
-                      >
-                        <ScrollText className="size-3.5" />
-                        {logsOpen
-                          ? "Show recent activity"
-                          : `Show full activity log (${latestRun.attemptEvents.length})`}
-                        <ChevronRight
-                          className={`size-3.5 transition-transform ${logsOpen ? "rotate-90" : ""}`}
-                        />
-                      </button>
-                    ) : null}
-                  </div>
-                ) : null}
-              </div>
-            ) : (
-              <p className="mt-1 text-[#747168]">No implementation Run yet.</p>
-            )}
-            <div className="mt-2 flex flex-wrap gap-2">
-              {work.status === "ready" ? (
-                <>
-                  <Button
-                    size="sm"
-                    disabled={!workspace.projectGitConnection}
-                    onClick={() => void workspace.startExecution(work._id)}
-                  >
-                    <Play className="size-3.5" /> Run
-                  </Button>
-                  <Button
-                    size="sm"
-                    variant="outline"
-                    onClick={() =>
-                      void workspace.startSimulation(work._id, "success")
-                    }
-                  >
-                    <Play className="size-3.5" /> Simulate
-                  </Button>
-                </>
-              ) : null}
-              {latestRun?.status === "running" ? (
-                <Button
-                  size="sm"
-                  variant="outline"
-                  onClick={() =>
-                    void (latestRun.executionKind === "real"
-                      ? workspace.cancelExecution(latestRun._id)
-                      : workspace.cancelSimulation(latestRun._id))
-                  }
-                >
-                  <X className="size-3.5" /> Cancel
-                </Button>
-              ) : null}
-              {latestRun?.executionKind !== "real" &&
-              latestRun?.status === "terminal" &&
-              latestRun.terminalClassification === "RetryableFailure" ? (
-                <Button
-                  size="sm"
-                  variant="outline"
-                  onClick={() => void workspace.retrySimulation(latestRun._id)}
-                >
-                  <RotateCcw className="size-3.5" /> Retry
-                </Button>
-              ) : null}
-            </div>
-          </section>
-        </div>
-      ) : null}
-    </article>
-  );
-};

apps/web/src/components/workspace/work-feed.tsx

@@ -1,29 +0,0 @@
-import type { WorkRecord, WorkspaceState } from "@/lib/workspace/types";
-
-import { WorkCard } from "./work-card";
-
-export const WorkFeed = ({
-  onSourceSelect,
-  works,
-  workspace,
-}: {
-  readonly onSourceSelect: (rawText: string) => void;
-  readonly works: readonly WorkRecord[];
-  readonly workspace: WorkspaceState;
-}) => (
-  <div className="space-y-3">
-    {works.length === 0 ? (
-      <p className="py-12 text-center text-sm text-[#747168]">
-        Actionable messages will appear here.
-      </p>
-    ) : null}
-    {works.map((work) => (
-      <WorkCard
-        key={work._id}
-        onSourceSelect={onSourceSelect}
-        work={work}
-        workspace={workspace}
-      />
-    ))}
-  </div>
-);

apps/web/src/hooks/chat/use-chat-agent.ts

@@ -55,12 +55,7 @@ export const useOrganizationChatAgent = (
 
   const projected = projectConversation(rows ?? []);
 
-  let status: AgentStatus = "idle";
-  if (projected.streaming) {
-    status = "streaming";
-  } else if (projected.pending) {
-    status = "submitted";
-  }
+  let status: AgentStatus = projected.pending ? "submitted" : "idle";
   if (!organizationId || rows === undefined) {
     status = organization.error ? "error" : "connecting";
   } else if (projected.failedError || sendError) {

apps/web/src/hooks/slice-one/use-slice-one.ts

@@ -0,0 +1,209 @@
+import { api } from "@code/backend/convex/_generated/api";
+import type { Id } from "@code/backend/convex/_generated/dataModel";
+import { useAction, useMutation, useQuery } from "convex/react";
+import { makeFunctionReference } from "convex/server";
+import { useMemo, useState } from "react";
+
+import { useOrganizationChatAgent } from "@/hooks/chat/use-chat-agent";
+import { usePersonalOrganization } from "@/hooks/use-personal-organization";
+
+const toError = (error: unknown) =>
+  error instanceof Error ? error : new Error(String(error));
+
+interface WorkRecord {
+  readonly _id: Id<"works">;
+  readonly title: string;
+  readonly objective: string;
+  readonly status: string;
+  readonly definitionVersion?: number;
+  readonly definitionApprovalVersion?: number;
+  readonly designVersion?: number;
+  readonly designApprovalVersion?: number;
+  readonly signals: readonly {
+    sources: readonly { messageId: string; rawText: string }[];
+  }[];
+  readonly events: readonly { _id: string; createdAt: number; kind: string }[];
+  readonly definitions: readonly unknown[];
+  readonly designs: readonly unknown[];
+  readonly slices: readonly unknown[];
+  readonly runs: readonly {
+    _id: Id<"workRuns">;
+    status: string;
+    terminalClassification?: string;
+    terminalSummary?: string;
+  }[];
+  readonly definition: {
+    risk?: string;
+    questions?: { status: string }[];
+  } | null;
+  readonly design: {
+    architectureSummary?: string;
+    slices?: { id: string; title: string; observableBehavior: string }[];
+  } | null;
+}
+
+const workListRef = makeFunctionReference<
+  "query",
+  { projectId: Id<"projects"> },
+  WorkRecord[]
+>("workPlanning:listForProject");
+const requestDefinitionRef = makeFunctionReference<
+  "mutation",
+  { workId: Id<"works"> },
+  unknown
+>("workPlanning:requestDefinition");
+const saveDefinitionRef = makeFunctionReference<
+  "mutation",
+  { workId: Id<"works">; payloadJson: string },
+  unknown
+>("workPlanning:saveDefinitionProposal");
+const approveDefinitionRef = makeFunctionReference<
+  "mutation",
+  { workId: Id<"works">; version: number },
+  unknown
+>("workPlanning:approveDefinition");
+const saveDesignRef = makeFunctionReference<
+  "mutation",
+  { workId: Id<"works">; payloadJson: string },
+  unknown
+>("workPlanning:saveDesignProposal");
+const approveDesignRef = makeFunctionReference<
+  "mutation",
+  { workId: Id<"works">; definitionVersion: number; designVersion: number },
+  unknown
+>("workPlanning:approveDesign");
+const startSimulationRef = makeFunctionReference<
+  "mutation",
+  {
+    workId: Id<"works">;
+    scenario:
+      | "success"
+      | "transient-failure-then-success"
+      | "needs-input"
+      | "permanent-failure"
+      | "cancelled";
+    sliceId?: string;
+  },
+  unknown
+>("workExecution:startSimulatedExecution");
+const cancelSimulationRef = makeFunctionReference<
+  "mutation",
+  { runId: Id<"workRuns"> },
+  unknown
+>("workExecution:cancelSimulatedExecution");
+const retrySimulationRef = makeFunctionReference<
+  "mutation",
+  { runId: Id<"workRuns"> },
+  unknown
+>("workExecution:retrySimulatedExecution");
+
+export const useSliceOne = () => {
+  const organization = usePersonalOrganization();
+  const projects = useQuery(
+    api.projects.list,
+    organization.organizationId ? {} : "skip"
+  );
+  const importPublicGit = useAction(api.projects.importPublicGit);
+  const agent = useOrganizationChatAgent(organization);
+  const [selectedProjectId, setSelectedProjectId] =
+    useState<Id<"projects"> | null>(null);
+  const [repository, setRepository] = useState("");
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState<Error>();
+  const selectedProjectStillExists = projects?.some(
+    (project) => project.id === (selectedProjectId as unknown as string)
+  );
+  const activeProjectId = selectedProjectStillExists
+    ? selectedProjectId
+    : ((projects?.[0]?.id as unknown as Id<"projects"> | undefined) ?? null);
+  const works = useQuery(
+    workListRef,
+    activeProjectId ? { projectId: activeProjectId } : "skip"
+  );
+  const requestDefinitionMutation = useMutation(requestDefinitionRef);
+  const saveDefinitionMutation = useMutation(saveDefinitionRef);
+  const approveDefinitionMutation = useMutation(approveDefinitionRef);
+  const saveDesignMutation = useMutation(saveDesignRef);
+  const approveDesignMutation = useMutation(approveDesignRef);
+  const startSimulationMutation = useMutation(startSimulationRef);
+  const cancelSimulationMutation = useMutation(cancelSimulationRef);
+  const retrySimulationMutation = useMutation(retrySimulationRef);
+  const selectedProject = useMemo(
+    () =>
+      projects?.find(
+        (project) => project.id === (activeProjectId as unknown as string)
+      ) ?? null,
+    [activeProjectId, projects]
+  );
+
+  const connectRepository = async () => {
+    const repositoryUrl = repository.trim();
+    if (!repositoryUrl || pending) {
+      return;
+    }
+    setPending(true);
+    setError(undefined);
+    try {
+      const project = await importPublicGit({ repositoryUrl });
+      setSelectedProjectId(project.id as unknown as Id<"projects">);
+      setRepository("");
+    } catch (caughtError) {
+      setError(toError(caughtError));
+    } finally {
+      setPending(false);
+    }
+  };
+
+  const selectProject = (projectId: string) => {
+    setSelectedProjectId(projectId as unknown as Id<"projects">);
+  };
+
+  const requestDefinition = (workId: Id<"works">) =>
+    requestDefinitionMutation({ workId });
+  const saveDefinition = (workId: Id<"works">, payload: unknown) =>
+    saveDefinitionMutation({ payloadJson: JSON.stringify(payload), workId });
+  const approveDefinition = (workId: Id<"works">, version: number) =>
+    approveDefinitionMutation({ version, workId });
+  const saveDesign = (workId: Id<"works">, payload: unknown) =>
+    saveDesignMutation({ payloadJson: JSON.stringify(payload), workId });
+  const approveDesign = (
+    workId: Id<"works">,
+    definitionVersion: number,
+    designVersion: number
+  ) => approveDesignMutation({ definitionVersion, designVersion, workId });
+  const startSimulation = (
+    workId: Id<"works">,
+    scenario:
+      | "success"
+      | "transient-failure-then-success"
+      | "needs-input"
+      | "permanent-failure"
+      | "cancelled",
+    sliceId?: string
+  ) => startSimulationMutation({ scenario, sliceId, workId });
+  const cancelSimulation = (runId: Id<"workRuns">) =>
+    cancelSimulationMutation({ runId });
+  const retrySimulation = (runId: Id<"workRuns">) =>
+    retrySimulationMutation({ runId });
+
+  return {
+    agent,
+    approveDefinition,
+    approveDesign,
+    cancelSimulation,
+    connectRepository,
+    error,
+    pending,
+    projects,
+    repository,
+    requestDefinition,
+    retrySimulation,
+    saveDefinition,
+    saveDesign,
+    selectProject,
+    selectedProject,
+    setRepository,
+    startSimulation,
+    works,
+  } as const;
+};

apps/web/src/hooks/slice-one/use-visual-viewport.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "vitest";
 
 import { visualViewportStyle } from "./use-visual-viewport";
 
-describe("Workspace visual viewport", () => {
+describe("Slice 1 visual viewport", () => {
   test("shrinks the application surface to the keyboard-visible height", () => {
     expect(visualViewportStyle({ height: 500, offsetTop: 0 })).toEqual({
       height: "500px",

apps/web/src/hooks/slice-one/use-visual-viewport.ts

@@ -33,7 +33,7 @@ export const useVisualViewportStyle = (): CSSProperties => {
       });
     };
 
-    root.classList.add("workspace-viewport-lock");
+    root.classList.add("slice-one-viewport-lock");
     update();
     window.addEventListener("resize", update);
     viewport?.addEventListener("resize", update);
@@ -41,7 +41,7 @@ export const useVisualViewportStyle = (): CSSProperties => {
 
     return () => {
       cancelAnimationFrame(animationFrame);
-      root.classList.remove("workspace-viewport-lock");
+      root.classList.remove("slice-one-viewport-lock");
       window.removeEventListener("resize", update);
       viewport?.removeEventListener("resize", update);
       viewport?.removeEventListener("scroll", update);

apps/web/src/hooks/workspace/use-project-workspace.ts

@@ -1,276 +0,0 @@
-import { authClient } from "@code/auth/web";
-import { api } from "@code/backend/convex/_generated/api";
-import type { Id } from "@code/backend/convex/_generated/dataModel";
-import { useAction, useMutation, useQuery } from "convex/react";
-import { makeFunctionReference } from "convex/server";
-import { useMemo, useState } from "react";
-
-import { useOrganizationChatAgent } from "@/hooks/chat/use-chat-agent";
-import { usePersonalOrganization } from "@/hooks/use-personal-organization";
-import type { WorkRecord, WorkspaceState } from "@/lib/workspace/types";
-
-const toError = (error: unknown) =>
-  error instanceof Error ? error : new Error(String(error));
-
-type ExecutionScenario =
-  | "success"
-  | "transient-failure-then-success"
-  | "needs-input"
-  | "permanent-failure"
-  | "cancelled";
-
-const workListRef = makeFunctionReference<
-  "query",
-  { projectId: Id<"projects"> },
-  WorkRecord[]
->("workPlanning:listForProject");
-const requestDefinitionRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works"> },
-  unknown
->("workPlanning:requestDefinition");
-const saveDefinitionRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; payloadJson: string },
-  unknown
->("workPlanning:saveDefinitionProposal");
-const approveDefinitionRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; version: number },
-  unknown
->("workPlanning:approveDefinition");
-const saveDesignRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; payloadJson: string },
-  unknown
->("workPlanning:saveDesignProposal");
-const approveDesignRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; definitionVersion: number; designVersion: number },
-  unknown
->("workPlanning:approveDesign");
-const startSimulationRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; scenario: ExecutionScenario; sliceId?: string },
-  unknown
->("workExecution:startSimulatedExecution");
-const cancelSimulationRef = makeFunctionReference<
-  "mutation",
-  { runId: Id<"workRuns"> },
-  unknown
->("workExecution:cancelSimulatedExecution");
-const retrySimulationRef = makeFunctionReference<
-  "mutation",
-  { runId: Id<"workRuns"> },
-  unknown
->("workExecution:retrySimulatedExecution");
-const startExecutionRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; sliceId?: string },
-  unknown
->("workExecutionWorkflow:startExecution");
-const cancelExecutionRef = makeFunctionReference<
-  "mutation",
-  { runId: Id<"workRuns"> },
-  unknown
->("workExecutionWorkflow:cancelExecution");
-const listGitConnectionsRef = makeFunctionReference<
-  "query",
-  Record<string, never>,
-  readonly {
-    id: string;
-    provider: "github" | "gitea";
-    serverUrl: string;
-    username?: string;
-  }[]
->("gitConnectionData:list");
-const projectGitConnectionRef = makeFunctionReference<
-  "query",
-  { projectId: Id<"projects"> },
-  {
-    id: string;
-    provider: "github" | "gitea";
-    serverUrl: string;
-    username?: string;
-  } | null
->("gitConnectionData:getForProject");
-const connectGiteaRef = makeFunctionReference<
-  "action",
-  { serverUrl: string; token: string; username?: string },
-  { connectionId: Id<"gitConnections"> }
->("gitConnections:connectGitea");
-const connectGithubRef = makeFunctionReference<
-  "action",
-  Record<string, never>,
-  { connectionId: Id<"gitConnections"> }
->("gitConnections:connectGithub");
-const attachGitConnectionRef = makeFunctionReference<
-  "mutation",
-  { connectionId: Id<"gitConnections">; projectId: Id<"projects"> },
-  unknown
->("gitConnectionData:attachToProject");
-
-export const useProjectWorkspace = (): WorkspaceState => {
-  const organization = usePersonalOrganization();
-  const projects = useQuery(
-    api.projects.list,
-    organization.organizationId ? {} : "skip"
-  );
-  const importPublicGit = useAction(api.projects.importPublicGit);
-  const agent = useOrganizationChatAgent(organization);
-  const [selectedProjectId, setSelectedProjectId] =
-    useState<Id<"projects"> | null>(null);
-  const [repository, setRepository] = useState("");
-  const [pending, setPending] = useState(false);
-  const [error, setError] = useState<Error>();
-  const [operationError, setOperationError] = useState<Error>();
-
-  const selectedProjectStillExists = projects?.some(
-    (project) => project.id === (selectedProjectId as unknown as string)
-  );
-  const activeProjectId = selectedProjectStillExists
-    ? selectedProjectId
-    : ((projects?.[0]?.id as unknown as Id<"projects"> | undefined) ?? null);
-  const works = useQuery(
-    workListRef,
-    activeProjectId ? { projectId: activeProjectId } : "skip"
-  );
-  const gitConnections = useQuery(
-    listGitConnectionsRef,
-    organization.organizationId ? {} : "skip"
-  );
-  const projectGitConnection = useQuery(
-    projectGitConnectionRef,
-    activeProjectId ? { projectId: activeProjectId } : "skip"
-  );
-  const requestDefinitionMutation = useMutation(requestDefinitionRef);
-  const saveDefinitionMutation = useMutation(saveDefinitionRef);
-  const approveDefinitionMutation = useMutation(approveDefinitionRef);
-  const saveDesignMutation = useMutation(saveDesignRef);
-  const approveDesignMutation = useMutation(approveDesignRef);
-  const startSimulationMutation = useMutation(startSimulationRef);
-  const cancelSimulationMutation = useMutation(cancelSimulationRef);
-  const retrySimulationMutation = useMutation(retrySimulationRef);
-  const startExecutionMutation = useMutation(startExecutionRef);
-  const cancelExecutionMutation = useMutation(cancelExecutionRef);
-  const attachGitConnectionMutation = useMutation(attachGitConnectionRef);
-  const connectGiteaAction = useAction(connectGiteaRef);
-  const connectGithubAction = useAction(connectGithubRef);
-  const selectedProject = useMemo(
-    () =>
-      projects?.find(
-        (project) => project.id === (activeProjectId as unknown as string)
-      ) ?? null,
-    [activeProjectId, projects]
-  );
-
-  const runOperation = async <T>(operation: () => Promise<T>): Promise<T> => {
-    setOperationError(undefined);
-    try {
-      return await operation();
-    } catch (caughtError) {
-      setOperationError(toError(caughtError));
-      throw caughtError;
-    }
-  };
-
-  const connectRepository = async () => {
-    const repositoryUrl = repository.trim();
-    if (!repositoryUrl || pending) {
-      return;
-    }
-    setPending(true);
-    setError(undefined);
-    try {
-      const project = await importPublicGit({ repositoryUrl });
-      setSelectedProjectId(project.id as unknown as Id<"projects">);
-      setRepository("");
-    } catch (caughtError) {
-      setError(toError(caughtError));
-    } finally {
-      setPending(false);
-    }
-  };
-
-  const attachConnection = async (connectionId: Id<"gitConnections">) => {
-    if (!activeProjectId) {
-      throw new Error("Select a project first");
-    }
-    await attachGitConnectionMutation({
-      connectionId,
-      projectId: activeProjectId,
-    });
-  };
-
-  const connectGitea = (input: {
-    serverUrl: string;
-    token: string;
-    username?: string;
-  }) =>
-    runOperation(async () => {
-      const result = await connectGiteaAction(input);
-      await attachConnection(result.connectionId);
-    });
-
-  const connectLinkedGithub = () =>
-    runOperation(async () => {
-      const result = await connectGithubAction({});
-      await attachConnection(result.connectionId);
-    });
-
-  return {
-    agent,
-    approveDefinition: (workId: Id<"works">, version: number) =>
-      approveDefinitionMutation({ version, workId }),
-    approveDesign: (
-      workId: Id<"works">,
-      definitionVersion: number,
-      designVersion: number
-    ) => approveDesignMutation({ definitionVersion, designVersion, workId }),
-    authorizeGithub: () =>
-      authClient.signIn.social({
-        callbackURL: window.location.href,
-        provider: "github",
-      }),
-    cancelExecution: (runId: Id<"workRuns">) =>
-      runOperation(() => cancelExecutionMutation({ runId })),
-    cancelSimulation: (runId: Id<"workRuns">) =>
-      runOperation(() => cancelSimulationMutation({ runId })),
-    clearOperationError: () => setOperationError(undefined),
-    connectGitea,
-    connectLinkedGithub,
-    connectRepository,
-    error,
-    gitConnections,
-    operationError,
-    pending,
-    projectGitConnection,
-    projects,
-    repository,
-    requestDefinition: (workId: Id<"works">) =>
-      requestDefinitionMutation({ workId }),
-    retrySimulation: (runId: Id<"workRuns">) =>
-      runOperation(() => retrySimulationMutation({ runId })),
-    saveDefinition: (workId: Id<"works">, payload: unknown) =>
-      saveDefinitionMutation({ payloadJson: JSON.stringify(payload), workId }),
-    saveDesign: (workId: Id<"works">, payload: unknown) =>
-      saveDesignMutation({ payloadJson: JSON.stringify(payload), workId }),
-    selectProject: (projectId: string) =>
-      setSelectedProjectId(projectId as unknown as Id<"projects">),
-    selectedProject: selectedProject
-      ? { id: selectedProject.id, name: selectedProject.name }
-      : null,
-    setRepository,
-    startExecution: (workId: Id<"works">, sliceId?: string) =>
-      runOperation(() => startExecutionMutation({ sliceId, workId })),
-    startSimulation: (
-      workId: Id<"works">,
-      scenario: ExecutionScenario,
-      sliceId?: string
-    ) =>
-      runOperation(() =>
-        startSimulationMutation({ scenario, sliceId, workId })
-      ),
-    works,
-  };
-};

apps/web/src/index.css

@@ -6,8 +6,8 @@ body {
   min-height: 100%;
 }
 
-html.workspace-viewport-lock,
-html.workspace-viewport-lock body {
+html.slice-one-viewport-lock,
+html.slice-one-viewport-lock body {
   height: 100%;
   overflow: hidden;
   overscroll-behavior: none;
@@ -116,9 +116,9 @@ html.workspace-viewport-lock body {
   color: var(--foreground);
 }
 
-.workspace-surface .chat-markdown,
-.workspace-surface .chat-reasoning,
-.workspace-surface .thinking-line {
+.slice-one-surface .chat-markdown,
+.slice-one-surface .chat-reasoning,
+.slice-one-surface .thinking-line {
   color: #232321;
 }
 

apps/web/src/lib/chat/conversation.test.ts

@@ -20,7 +20,7 @@ describe("projectConversation", () => {
         messageId: "user-1",
         rawText: "Build it",
         role: "user",
-        status: "dispatching",
+        status: "processing",
       }),
       row({ messageId: "assistant-1", role: "assistant", status: "queued" }),
     ]);
@@ -28,21 +28,6 @@ describe("projectConversation", () => {
     expect(state.messages).toHaveLength(1);
   });
 
-  test("projects partial assistant text as streaming", () => {
-    const state = projectConversation([
-      row({
-        messageId: "assistant-streaming",
-        rawText: "Working",
-        role: "assistant",
-        status: "running",
-      }),
-    ]);
-    expect(state.streaming).toBe(true);
-    expect(state.messages[0]?.parts).toEqual([
-      { state: "streaming", text: "Working", type: "text" },
-    ]);
-  });
-
   test("projects completed Convex rows into renderable messages", () => {
     const state = projectConversation([
       row({

apps/web/src/lib/chat/conversation.ts

@@ -11,67 +11,40 @@ export interface ConversationRow {
   readonly messageId: string;
   readonly rawText: string;
   readonly role: "assistant" | "user";
-  readonly status:
-    | "aborted"
-    | "completed"
-    | "dispatching"
-    | "failed"
-    | "queued"
-    | "running";
+  readonly status: "completed" | "failed" | "processing" | "queued";
 }
 
-export const projectConversation = (rows: readonly ConversationRow[]) => {
-  const streaming = rows.some(
+export const projectConversation = (rows: readonly ConversationRow[]) => ({
+  failedError: rows.findLast(
+    (row) => row.role === "assistant" && row.status === "failed"
+  )?.error,
+  messages: rows
+    .filter((row) => row.role === "user" || row.status === "completed")
+    .map<ConversationMessage>((row) => ({
+      id: row.messageId,
+      parts: [
+        ...row.attachments.map((attachment) => ({
+          filename: attachment.filename ?? undefined,
+          id: attachment.id,
+          mediaType: attachment.mediaType,
+          type: "file" as const,
+          url: attachment.url ?? undefined,
+        })),
+        ...(row.rawText
+          ? [
+              {
+                state: "done" as const,
+                text: row.rawText,
+                type: "text" as const,
+              },
+            ]
+          : []),
+      ],
+      role: row.role,
+    })),
+  pending: rows.some(
     (row) =>
       row.role === "assistant" &&
-      row.status === "running" &&
-      row.rawText.length > 0
-  );
-  return {
-    failedError: rows.findLast(
-      (row) => row.role === "assistant" && row.status === "failed"
-    )?.error,
-    messages: rows
-      .filter(
-        (row) =>
-          row.role === "user" ||
-          row.status === "completed" ||
-          (row.role === "assistant" &&
-            row.status === "running" &&
-            row.rawText.length > 0)
-      )
-      .map<ConversationMessage>((row) => ({
-        id: row.messageId,
-        parts: [
-          ...row.attachments.map((attachment) => ({
-            filename: attachment.filename ?? undefined,
-            id: attachment.id,
-            mediaType: attachment.mediaType,
-            type: "file" as const,
-            url: attachment.url ?? undefined,
-          })),
-          ...(row.rawText
-            ? [
-                {
-                  state:
-                    row.status === "running"
-                      ? ("streaming" as const)
-                      : ("done" as const),
-                  text: row.rawText,
-                  type: "text" as const,
-                },
-              ]
-            : []),
-        ],
-        role: row.role,
-      })),
-    pending: rows.some(
-      (row) =>
-        row.role === "assistant" &&
-        (row.status === "queued" ||
-          row.status === "dispatching" ||
-          row.status === "running")
-    ),
-    streaming,
-  };
-};
+      (row.status === "queued" || row.status === "processing")
+  ),
+});

apps/web/src/lib/slice-one/frontend-regressions.test.ts

@@ -5,36 +5,27 @@ import { describe, expect, test } from "vitest";
 const source = (relativePath: string) =>
   readFileSync(new URL(relativePath, import.meta.url), "utf-8");
 
-describe("Workspace frontend regression contracts", () => {
+describe("Slice 1 frontend regression contracts", () => {
   test("keeps keyboard resizing on the visual viewport instead of page scroll", () => {
-    const page = source(
-      "../../components/workspace/project-workspace-page.tsx"
-    );
-    const viewport = source("../../hooks/workspace/use-visual-viewport.ts");
+    const page = source("../../components/slice-one/slice-one-page.tsx");
     const root = source("../../root.tsx");
     const styles = source("../../index.css");
 
     expect(root).toContain("interactive-widget=resizes-content");
     expect(page).toContain("style={viewportStyle}");
     expect(page).toContain("fixed inset-x-0 top-0");
-    expect(viewport).toContain("workspace-viewport-lock");
-    expect(styles).toContain("html.workspace-viewport-lock body");
+    expect(page).not.toContain("slice-one-surface flex h-svh");
+    expect(styles).toContain("html.slice-one-viewport-lock body");
     expect(styles).toContain("overflow: hidden");
   });
 
   test("keeps the responsive shell shrinkable with a pinned composer", () => {
-    const page = source(
-      "../../components/workspace/project-workspace-page.tsx"
-    );
-    const feed = source("../../components/workspace/conversation-feed.tsx");
-    const composer = source(
-      "../../components/workspace/conversation-composer.tsx"
-    );
+    const page = source("../../components/slice-one/slice-one-page.tsx");
 
     expect(page).toContain('className="flex min-w-0 flex-1 flex-col"');
-    expect(feed).toContain('<Conversation className="min-h-0 flex-1">');
-    expect(composer).toContain('className="shrink-0 border-t');
-    expect(composer).toContain(
+    expect(page).toContain('<Conversation className="min-h-0 flex-1">');
+    expect(page).toContain('className="shrink-0 border-t');
+    expect(page).toContain(
       'className="mx-auto flex max-w-2xl items-end gap-2"'
     );
   });

apps/web/src/lib/slice-one/presentation.test.ts

@@ -3,10 +3,7 @@ import { describe, expect, test } from "vitest";
 
 import type { ConversationMessage } from "@/lib/chat/types";
 
-import {
-  buildWorkspaceTimeline,
-  findSourceMessageTarget,
-} from "./presentation";
+import { buildSliceOneTimeline, findSourceMessageTarget } from "./presentation";
 
 const textMessage = (
   id: string,
@@ -26,9 +23,9 @@ const notice: WorkNotice = {
   workId: "work-1",
 };
 
-describe("Workspace presentation", () => {
+describe("Slice 1 presentation", () => {
   test("places proposed Work after the assistant response to its source", () => {
-    const timeline = buildWorkspaceTimeline(
+    const timeline = buildSliceOneTimeline(
       [
         textMessage("user-1", "user", "Build the phone flow."),
         textMessage("assistant-1", "assistant", "Captured and proposed Work."),

apps/web/src/lib/slice-one/presentation.ts

@@ -7,9 +7,14 @@ import {
 } from "@/lib/chat/transforms";
 import type { ConversationMessage } from "@/lib/chat/types";
 
-import type { WorkspaceTimelineItem } from "./types";
+export type SliceTimelineItem =
+  | {
+      readonly kind: "message";
+      readonly message: ConversationMessage;
+    }
+  | { readonly kind: "work"; readonly notice: WorkNotice };
 
-export const isVisibleConversationMessage = (
+export const isSliceOneVisibleMessage = (
   message: ConversationMessage
 ): boolean =>
   message.role === "user" ||
@@ -37,11 +42,11 @@ const targetIndexForNotice = (
   return responseOffset === -1 ? sourceIndex : sourceIndex + responseOffset + 1;
 };
 
-export const buildWorkspaceTimeline = (
+export const buildSliceOneTimeline = (
   allMessages: readonly ConversationMessage[],
   notices: readonly WorkNotice[]
-): readonly WorkspaceTimelineItem[] => {
-  const messages = allMessages.filter(isVisibleConversationMessage);
+): readonly SliceTimelineItem[] => {
+  const messages = allMessages.filter(isSliceOneVisibleMessage);
   const noticesByMessageIndex = new Map<number, WorkNotice[]>();
   for (const notice of notices) {
     const targetIndex = targetIndexForNotice(messages, notice);
@@ -50,7 +55,7 @@ export const buildWorkspaceTimeline = (
     noticesByMessageIndex.set(targetIndex, atTarget);
   }
 
-  const timeline: WorkspaceTimelineItem[] = [];
+  const timeline: SliceTimelineItem[] = [];
   for (const [index, message] of messages.entries()) {
     timeline.push({ kind: "message", message });
     for (const notice of noticesByMessageIndex.get(index) ?? []) {

apps/web/src/lib/workspace/types.ts

@@ -1,163 +0,0 @@
-import type { Id } from "@code/backend/convex/_generated/dataModel";
-import type { WorkNotice } from "@code/primitives/work";
-
-import type { ConversationMessage } from "@/lib/chat/types";
-
-export interface WorkRecord {
-  readonly _id: Id<"works">;
-  readonly title: string;
-  readonly objective: string;
-  readonly status: string;
-  readonly definitionVersion?: number;
-  readonly definitionApprovalVersion?: number;
-  readonly designVersion?: number;
-  readonly signals: readonly {
-    readonly sources: readonly { messageId: string; rawText: string }[];
-  }[];
-  readonly runs: readonly WorkRun[];
-  readonly definition: {
-    readonly risk?: string;
-    readonly questions?: readonly { status: string }[];
-  } | null;
-  readonly design: {
-    readonly architectureSummary?: string;
-    readonly slices?: readonly {
-      readonly id: string;
-      readonly title: string;
-      readonly observableBehavior: string;
-    }[];
-  } | null;
-}
-
-export interface WorkRun {
-  readonly artifacts?: readonly WorkArtifact[];
-  readonly attemptEvents?: readonly WorkAttemptEvent[];
-  readonly baseRevision?: string;
-  readonly candidateRevision?: string;
-  readonly executionKind?: string;
-  readonly _id: Id<"workRuns">;
-  readonly status: string;
-  readonly terminalClassification?: string;
-  readonly terminalSummary?: string;
-}
-
-export interface WorkArtifact {
-  readonly _id: string;
-  readonly metadataJson: string;
-  readonly title: string;
-  readonly uri?: string;
-}
-
-export interface WorkAttemptEvent {
-  readonly _id: string;
-  readonly message: string;
-}
-
-export interface GitConnection {
-  readonly id: string;
-  readonly provider: "github" | "gitea";
-  readonly serverUrl: string;
-  readonly username?: string;
-}
-
-export interface ProjectListItem {
-  readonly id: string;
-  readonly name: string;
-}
-
-export interface WorkspaceState {
-  readonly agent: {
-    readonly error?: Error;
-    readonly historyReady: boolean;
-    readonly messages: readonly ConversationMessage[];
-    readonly sendMessage: (
-      message: string,
-      options?: { readonly images?: readonly File[] }
-    ) => Promise<void>;
-    readonly status:
-      | "connecting"
-      | "error"
-      | "idle"
-      | "streaming"
-      | "submitted";
-  };
-  readonly approveDefinition: (
-    workId: Id<"works">,
-    version: number
-  ) => Promise<unknown>;
-  readonly approveDesign: (
-    workId: Id<"works">,
-    definitionVersion: number,
-    designVersion: number
-  ) => Promise<unknown>;
-  readonly authorizeGithub: () => Promise<unknown>;
-  readonly cancelExecution: (runId: Id<"workRuns">) => Promise<unknown>;
-  readonly cancelSimulation: (runId: Id<"workRuns">) => Promise<unknown>;
-  readonly clearOperationError: () => void;
-  readonly connectGitea: (input: {
-    readonly serverUrl: string;
-    readonly token: string;
-    readonly username?: string;
-  }) => Promise<void>;
-  readonly connectLinkedGithub: () => Promise<void>;
-  readonly connectRepository: () => Promise<void>;
-  readonly error?: Error;
-  readonly gitConnections: readonly GitConnection[] | undefined;
-  readonly operationError?: Error;
-  readonly pending: boolean;
-  readonly projectGitConnection: GitConnection | null | undefined;
-  readonly projects: readonly ProjectListItem[] | undefined;
-  readonly repository: string;
-  readonly requestDefinition: (workId: Id<"works">) => Promise<unknown>;
-  readonly retrySimulation: (runId: Id<"workRuns">) => Promise<unknown>;
-  readonly saveDefinition: (
-    workId: Id<"works">,
-    payload: unknown
-  ) => Promise<unknown>;
-  readonly saveDesign: (
-    workId: Id<"works">,
-    payload: unknown
-  ) => Promise<unknown>;
-  readonly selectProject: (projectId: string) => void;
-  readonly selectedProject: ProjectListItem | null;
-  readonly setRepository: (value: string) => void;
-  readonly startExecution: (
-    workId: Id<"works">,
-    sliceId?: string
-  ) => Promise<unknown>;
-  readonly startSimulation: (
-    workId: Id<"works">,
-    scenario:
-      | "success"
-      | "transient-failure-then-success"
-      | "needs-input"
-      | "permanent-failure"
-      | "cancelled",
-    sliceId?: string
-  ) => Promise<unknown>;
-  readonly works: readonly WorkRecord[] | undefined;
-}
-
-export type WorkspaceTimelineItem =
-  | { readonly kind: "message"; readonly message: ConversationMessage }
-  | { readonly kind: "work"; readonly notice: WorkNotice };
-
-export interface ArtifactMetadata {
-  readonly changedFiles?: readonly string[];
-}
-
-export const parseArtifactMetadata = (
-  artifact: WorkArtifact
-): ArtifactMetadata => {
-  if (!artifact.metadataJson) {
-    return {};
-  }
-  try {
-    return JSON.parse(artifact.metadataJson) as ArtifactMetadata;
-  } catch {
-    return {};
-  }
-};
-
-export const changedFilesFor = (artifact: WorkArtifact): readonly string[] =>
-  parseArtifactMetadata(artifact).changedFiles ?? [];

apps/web/src/routes.ts

@@ -6,5 +6,8 @@ export default [
     route("login", "./routes/auth/login/page.tsx"),
     route("signup", "./routes/auth/signup/page.tsx"),
   ]),
-  layout("./routes/app/layout.tsx", [index("./routes/app/workspace/page.tsx")]),
+  layout("./routes/app/layout.tsx", [
+    index("./routes/app/mobile/page.tsx"),
+    route("dashboard", "./routes/app/dashboard/page.tsx"),
+  ]),
 ] satisfies RouteConfig;

apps/web/src/routes/app/dashboard/page.tsx

@@ -0,0 +1,5 @@
+import { SliceOnePage } from "@/components/slice-one/slice-one-page";
+
+export default function Dashboard() {
+  return <SliceOnePage />;
+}

apps/web/src/routes/app/mobile/page.tsx

@@ -0,0 +1,5 @@
+import { SliceOnePage } from "@/components/slice-one/slice-one-page";
+
+export default function MobileLandingRedirect() {
+  return <SliceOnePage />;
+}

apps/web/src/routes/app/workspace/page.tsx

@@ -1,5 +0,0 @@
-import { ProjectWorkspacePage } from "@/components/workspace/project-workspace-page";
-
-export default function ProjectWorkspaceRoute() {
-  return <ProjectWorkspacePage />;
-}

apps/web/vite.config.ts

@@ -7,9 +7,6 @@ import { defineConfig } from "vite-plus";
 export default defineConfig({
   envDir: path.resolve(import.meta.dirname, "../.."),
   plugins: [tailwindcss(), reactRouter()],
-  ssr: {
-    noExternal: true,
-  },
   resolve: {
     dedupe: ["convex", "react", "react-dom"],
     tsconfigPaths: true,

deploy/dokploy/agent.Dockerfile

@@ -1,20 +0,0 @@
-FROM oven/bun:1.3.14 AS build
-
-WORKDIR /app
-
-COPY . .
-RUN bun install --frozen-lockfile
-RUN bun run --filter @code/agents build
-
-FROM node:24-bookworm-slim
-
-ENV NODE_ENV=production
-ENV PORT=3000
-
-WORKDIR /app
-
-COPY --from=build /app /app
-
-EXPOSE 3000
-
-CMD ["node", "packages/agents/dist/server.mjs"]

deploy/dokploy/backend.compose.yml

@@ -1,31 +0,0 @@
-services:
-  backend:
-    build:
-      context: ../..
-      dockerfile: packages/agents/Dockerfile
-    environment:
-      AGENT_BACKEND_URL: ${AGENT_BACKEND_URL}
-      AGENT_MODEL_API: ${AGENT_MODEL_API}
-      AGENT_MODEL_API_KEY: ${AGENT_MODEL_API_KEY}
-      AGENT_MODEL_BASE_URL: ${AGENT_MODEL_BASE_URL}
-      AGENT_MODEL_CONTEXT_WINDOW: ${AGENT_MODEL_CONTEXT_WINDOW}
-      AGENT_MODEL_MAX_TOKENS: ${AGENT_MODEL_MAX_TOKENS}
-      AGENT_MODEL_NAME: ${AGENT_MODEL_NAME}
-      AGENT_MODEL_PROVIDER: ${AGENT_MODEL_PROVIDER}
-      CONVEX_URL: ${CONVEX_URL}
-      DAEMON_ID: zopu-agent-backend
-      FLUE_DB_TOKEN: ${FLUE_DB_TOKEN}
-      GITEA_TOKEN: ${GITEA_TOKEN:-}
-      GITEA_URL: ${GITEA_URL:-https://git.openputer.com}
-      PORT: "3000"
-      RIVET_ENDPOINT: ${RIVET_ENDPOINT}
-      RIVET_PUBLIC_ENDPOINT: ${RIVET_PUBLIC_ENDPOINT}
-      RIVET_WORKSPACE_TOKEN: ${RIVET_WORKSPACE_TOKEN}
-    networks:
-      - default
-      - dokploy-network
-    restart: unless-stopped
-
-networks:
-  dokploy-network:
-    external: true

deploy/dokploy/frontend.compose.yml

@@ -1,15 +0,0 @@
-services:
-  frontend:
-    build:
-      context: ../..
-      dockerfile: apps/web/Dockerfile
-      args:
-        VITE_AUTH_URL: ${VITE_AUTH_URL}
-        VITE_CONVEX_URL: ${VITE_CONVEX_URL}
-    environment:
-      HOST: 0.0.0.0
-      NODE_ENV: production
-      PORT: "3000"
-      VITE_AUTH_URL: ${VITE_AUTH_URL}
-      VITE_CONVEX_URL: ${VITE_CONVEX_URL}
-    restart: unless-stopped

deploy/dokploy/runner.Dockerfile

@@ -1,23 +0,0 @@
-FROM oven/bun:1.3.14 AS bun
-
-FROM node:24-bookworm-slim
-
-COPY --from=bun /usr/local/bin/bun /usr/local/bin/bun
-
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends ca-certificates g++ git make python3 \
-  && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /opt/zopu-source
-
-COPY . .
-RUN bun install --frozen-lockfile
-
-ENV AGENT_WORKSPACE_ROOT=/var/lib/zopu/workspaces
-ENV BUN_EXECUTABLE=/usr/local/bin/bun
-ENV DAEMON_ID=zopu-agentos-runner
-ENV ZOPU_SOURCE_REPOSITORY=/opt/zopu-source
-
-VOLUME ["/var/lib/zopu/workspaces"]
-
-CMD ["bun", "packages/agents/src/runner.ts"]

deploy/dokploy/runner.compose.yml

@@ -1,26 +0,0 @@
-services:
-  runner:
-    build:
-      context: .
-      dockerfile: deploy/dokploy/runner.Dockerfile
-    environment:
-      AGENT_MODEL_API: ${AGENT_MODEL_API}
-      AGENT_MODEL_API_KEY: ${AGENT_MODEL_API_KEY}
-      AGENT_MODEL_BASE_URL: ${AGENT_MODEL_BASE_URL}
-      AGENT_MODEL_CONTEXT_WINDOW: ${AGENT_MODEL_CONTEXT_WINDOW}
-      AGENT_MODEL_MAX_TOKENS: ${AGENT_MODEL_MAX_TOKENS}
-      AGENT_MODEL_NAME: ${AGENT_MODEL_NAME}
-      AGENT_MODEL_PROVIDER: ${AGENT_MODEL_PROVIDER}
-      CONVEX_URL: ${CONVEX_URL}
-      DAEMON_ID: zopu-agentos-runner
-      FLUE_DB_TOKEN: ${FLUE_DB_TOKEN}
-      RIVET_ENDPOINT: ${RIVET_ENDPOINT}
-      RIVET_PUBLIC_ENDPOINT: ${RIVET_PUBLIC_ENDPOINT}
-      RIVET_WORKSPACE_TOKEN: ${RIVET_WORKSPACE_TOKEN}
-      ZOPU_SOURCE_REPOSITORY: /opt/zopu-source
-    volumes:
-      - runner-workspaces:/var/lib/zopu/workspaces
-    restart: unless-stopped
-
-volumes:
-  runner-workspaces:

deploy/dokploy/web.Dockerfile

@@ -1,21 +0,0 @@
-FROM oven/bun:1.3.14 AS build
-
-WORKDIR /app
-
-COPY . .
-RUN bun install --frozen-lockfile
-RUN bun run --filter web build
-
-FROM node:24-bookworm-slim
-
-ENV HOST=0.0.0.0
-ENV NODE_ENV=production
-ENV PORT=3000
-
-WORKDIR /app
-
-COPY --from=build /app /app
-
-EXPOSE 3000
-
-CMD ["node", "apps/web/node_modules/.bin/react-router-serve", "apps/web/build/server/index.js"]

deploy/zopu-runtime/.env.template

@@ -25,7 +25,14 @@ CONVEX_INSTANCE_NAME=zopu-production
 CONVEX_INSTANCE_SECRET=
 
 # ---------------------------------------------------------------------------
-# 2. Model gateway — REQUIRED
+# 2. Self-hosted Git / Gitea — REQUIRED for issue lifecycle
+#    The agent daemon clones repos and creates PRs through Gitea.
+# ---------------------------------------------------------------------------
+GITEA_URL=https://git.openputer.com
+GITEA_TOKEN=replace-with-gitea-api-token
+
+# ---------------------------------------------------------------------------
+# 3. Model gateway — REQUIRED
 #    All model calls route through this OpenAI-compatible endpoint.
 # ---------------------------------------------------------------------------
 AGENT_MODEL_PROVIDER=cheaptricks
@@ -37,25 +44,24 @@ AGENT_MODEL_CONTEXT_WINDOW=262000
 AGENT_MODEL_MAX_TOKENS=131072
 
 # ---------------------------------------------------------------------------
-# 3. AgentOS / Rivet Engine — REQUIRED for the execution runner
-#    The runner creates isolated worktrees from ZOPU_SOURCE_REPOSITORY and
-#    connects to AgentOS through the public engine endpoint.
+# 4. AgentOS / RivetKit — OPTIONAL (defaults shown)
+#    registry.start() in the daemon boots an in-process RivetKit engine
+#    (envoy mode) backed by a native Rust sidecar. createClient() connects
+#    back to RIVET_ENDPOINT. No separate Rivet Engine process is required
+#    for single-node operation. Leave RIVET_ENDPOINT unset to use the
+#    library default (http://localhost:6420).
 # ---------------------------------------------------------------------------
-RIVET_ENDPOINT=https://default:@rivet.example.com
-RIVET_PUBLIC_ENDPOINT=https://default@rivet.example.com
-RIVET_RUNNER_VERSION=1
-RIVET_WORKSPACE_TOKEN=replace-with-a-long-random-workspace-token
-ZOPU_SOURCE_REPOSITORY=/opt/zopu-source
+#RIVET_ENDPOINT=http://localhost:6420
+
 # ---------------------------------------------------------------------------
-# 4. Zopu agent service (Flue)
+# 5. Zopu agent service (Flue)
 #    FLUE_DB_TOKEN authenticates the Flue persistence adapter.
 #    zopu-agent.service pins the Flue Node server to port 3583.
 # ---------------------------------------------------------------------------
 FLUE_DB_TOKEN=replace-with-long-random-token
-AGENT_BACKEND_URL=https://zopu-agent.example.com
 
 # ---------------------------------------------------------------------------
-# 5. Daemon identity
+# 6. Daemon identity
 # ---------------------------------------------------------------------------
 DAEMON_ID=zopu-dedicated
 DAEMON_NAME=Zopu-Dedicated-Server

deploy/zopu-runtime/runner/Dockerfile

@@ -1,23 +0,0 @@
-FROM oven/bun:1.3.14 AS bun
-
-FROM node:24-bookworm-slim
-
-COPY --from=bun /usr/local/bin/bun /usr/local/bin/bun
-
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends ca-certificates g++ git make python3 \
-  && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /opt/zopu-source
-
-COPY . .
-RUN bun install --frozen-lockfile
-
-ENV AGENT_WORKSPACE_ROOT=/var/lib/zopu/workspaces
-ENV BUN_EXECUTABLE=/usr/local/bin/bun
-ENV DAEMON_ID=zopu-agentos-runner
-ENV ZOPU_SOURCE_REPOSITORY=/opt/zopu-source
-
-VOLUME ["/var/lib/zopu/workspaces"]
-
-CMD ["bun", "packages/agents/src/runner.ts"]

deploy/zopu-runtime/runner/docker-compose.yml

@@ -1,26 +0,0 @@
-services:
-  zopu-agentos-runner:
-    build:
-      context: ../../..
-      dockerfile: deploy/zopu-runtime/runner/Dockerfile
-    environment:
-      AGENT_MODEL_API: ${AGENT_MODEL_API}
-      AGENT_MODEL_API_KEY: ${AGENT_MODEL_API_KEY}
-      AGENT_MODEL_BASE_URL: ${AGENT_MODEL_BASE_URL}
-      AGENT_MODEL_CONTEXT_WINDOW: ${AGENT_MODEL_CONTEXT_WINDOW}
-      AGENT_MODEL_MAX_TOKENS: ${AGENT_MODEL_MAX_TOKENS}
-      AGENT_MODEL_NAME: ${AGENT_MODEL_NAME}
-      AGENT_MODEL_PROVIDER: ${AGENT_MODEL_PROVIDER}
-      CONVEX_URL: ${CONVEX_URL}
-      DAEMON_ID: zopu-agentos-runner
-      FLUE_DB_TOKEN: ${FLUE_DB_TOKEN}
-      RIVET_ENDPOINT: ${RIVET_ENDPOINT}
-      RIVET_PUBLIC_ENDPOINT: ${RIVET_PUBLIC_ENDPOINT}
-      RIVET_WORKSPACE_TOKEN: ${RIVET_WORKSPACE_TOKEN}
-      ZOPU_SOURCE_REPOSITORY: /opt/zopu-source
-    volumes:
-      - zopu-agentos-workspaces:/var/lib/zopu/workspaces
-    restart: unless-stopped
-
-volumes:
-  zopu-agentos-workspaces:

docs/TECH.md

@@ -18,28 +18,29 @@ Convex application backend
 ├── normalized product data
 ├── conversation turn queue
 └── reactive client projections
-          │ durable Workflow steps + service-authenticated dispatch
+          │ service-authenticated dispatch
           ▼
-Private agent backend
-├── FLUE product agents and typed tools
-├── AgentOS execution environments
-├── Codex implementation harness
-└── canonical events/results returned to Convex
-          │ optional attached full sandbox
+FLUE orchestration service
+├── model calls
+├── typed tools
+└── canonical Flue persistence in Convex
+          │ later execution commands
           ▼
-Cube/E2B-compatible runtime (later)
+Rivet Engine + AgentOS (post-Slice 1)
+└── sandboxes, harnesses, and durable execution
 ```
 
-Clients MUST communicate only with Convex. FLUE and future Rivet/AgentOS services are private workers: Convex admits durable commands, invokes the worker, and stores the product-facing result before clients observe it.
+Clients MUST communicate only with Convex. FLUE and future Rivet/AgentOS
+services are private workers: Convex admits durable commands, invokes the
+worker, and stores the product-facing result before clients observe it.
 
 ### Ownership
 
 | Layer | Owns |
-| --- | --- |
+|---|---|
 | Convex | authentication, normalized product records, command admission, reactive reads |
-| Convex Workflow | durable sequencing, retries, cancellation, scheduling, and completion callbacks |
-| Agent backend | private programmable agents and execution adapters |
-| Rivet Engine + runners | placement, routing, sleep/wake, and execution ownership for AgentOS workspaces |
+| FLUE | private programmable orchestration and domain-specific agents |
+| Rivet actors (later) | serialized execution ownership, recovery, timers, leases |
 | Harness | bounded coding/tool loop |
 | Sandbox/runtime | filesystem, processes, network, isolation |
 | Git | source revision history |
@@ -62,7 +63,11 @@ signals ──< signalWorkAttachments >── works
 works ──< workEvents
 ```
 
-Convex mutations provide atomic transactions and optimistic serializability. Foreign-key integrity and uniqueness are enforced in the owning mutations; composite indexes back every identity and relation lookup. Flue's adapter tables remain isolated infrastructure persistence and are not product-domain relations.
+Convex mutations provide atomic transactions and optimistic serializability.
+Foreign-key integrity and uniqueness are enforced in the owning mutations;
+composite indexes back every identity and relation lookup. Flue's adapter
+tables remain isolated infrastructure persistence and are not product-domain
+relations.
 
 ## 2. Domain boundaries
 
@@ -101,93 +106,93 @@ Avoid package proliferation in v0; logical boundaries may begin as folders.
 Minimal durable model:
 
 ```ts
-type Id = string;
+type Id = string
 
 interface Message {
-  id: Id;
-  projectId: Id;
-  content: string;
-  createdAt: number;
+  id: Id
+  projectId: Id
+  content: string
+  createdAt: number
 }
 
 interface Signal {
-  id: Id;
-  projectId: Id;
-  sourceType: string;
-  sourceId: string;
-  sourcePayloadRef?: string;
-  summary: string;
-  fingerprint: string;
-  status: "candidate" | "accepted" | "dismissed";
+  id: Id
+  projectId: Id
+  sourceType: string
+  sourceId: string
+  sourcePayloadRef?: string
+  summary: string
+  fingerprint: string
+  status: "candidate" | "accepted" | "dismissed"
 }
 
 interface Work {
-  id: Id;
-  projectId: Id;
-  title: string;
-  objective: string;
-  risk: "low" | "medium" | "high";
-  status: WorkStatus;
-  definitionVersion?: number;
-  designVersion?: number;
-  createdAt: number;
-  updatedAt: number;
+  id: Id
+  projectId: Id
+  title: string
+  objective: string
+  risk: "low" | "medium" | "high"
+  status: WorkStatus
+  definitionVersion?: number
+  designVersion?: number
+  createdAt: number
+  updatedAt: number
 }
 
 interface Step {
-  id: Id;
-  workId: Id;
-  sliceId?: Id;
-  kind: "design" | "implement" | "verify" | "integrate" | "publish" | "observe";
-  objective: string;
-  dependsOn: readonly Id[];
-  status: StepStatus;
+  id: Id
+  workId: Id
+  sliceId?: Id
+  kind: "design" | "implement" | "verify" | "integrate" | "publish" | "observe"
+  objective: string
+  dependsOn: readonly Id[]
+  status: StepStatus
 }
 
 interface Run {
-  id: Id;
-  workId: Id;
-  stepId: Id;
-  kitVersion: string;
-  status: RunStatus;
+  id: Id
+  workId: Id
+  stepId: Id
+  kitVersion: string
+  status: RunStatus
 }
 
 interface Attempt {
-  id: Id;
-  runId: Id;
-  number: number;
-  harness: string;
-  runtime: string;
-  sourceRevision: string;
-  status: AttemptStatus;
-  startedAt?: number;
-  endedAt?: number;
+  id: Id
+  runId: Id
+  number: number
+  harness: string
+  runtime: string
+  sourceRevision: string
+  status: AttemptStatus
+  startedAt?: number
+  endedAt?: number
 }
 
 interface Artifact {
-  id: Id;
-  workId: Id;
-  stepId?: Id;
-  runId?: Id;
-  attemptId?: Id;
-  type: string;
-  uri?: string;
-  contentHash?: string;
-  sourceRevision?: string;
-  environmentId?: string;
-  metadata: unknown;
+  id: Id
+  workId: Id
+  stepId?: Id
+  runId?: Id
+  attemptId?: Id
+  type: string
+  uri?: string
+  contentHash?: string
+  sourceRevision?: string
+  environmentId?: string
+  metadata: unknown
 }
 
 interface Question {
-  id: Id;
-  workId: Id;
-  stepId?: Id;
-  attemptId?: Id;
-  prompt: string;
-  recommendation?: string;
-  alternatives: readonly string[];
-  status: "open" | "answered" | "withdrawn";
-  answer?: string;
+  id: Id
+  workId: Id
+  stepId?: Id
+  attemptId?: Id
+  prompt: string
+  recommendation?: string
+  alternatives: readonly string[]
+  status: "open" | "answered" | "withdrawn"
+  answer?: string
 }
 ```
 
@@ -332,49 +337,35 @@ Keep domain/application code provider-neutral.
 
 ```ts
 interface HarnessRuntime {
-  open(input: OpenHarnessInput): Effect.Effect<HarnessSession, HarnessError>;
-  prompt(id: string, content: string): Effect.Effect<void, HarnessError>;
-  events(id: string): Stream.Stream<HarnessEvent, HarnessError>;
-  approve(input: PermissionDecision): Effect.Effect<void, HarnessError>;
-  abort(id: string): Effect.Effect<void, HarnessError>;
-  close(id: string): Effect.Effect<void, HarnessError>;
+  open(input: OpenHarnessInput): Effect.Effect<HarnessSession, HarnessError>
+  prompt(id: string, content: string): Effect.Effect<void, HarnessError>
+  events(id: string): Stream.Stream<HarnessEvent, HarnessError>
+  approve(input: PermissionDecision): Effect.Effect<void, HarnessError>
+  abort(id: string): Effect.Effect<void, HarnessError>
+  close(id: string): Effect.Effect<void, HarnessError>
 }
 
 interface SandboxRuntime {
-  create(spec: SandboxSpec): Effect.Effect<SandboxLease, SandboxError>;
-  exec(
-    lease: SandboxLease,
-    cmd: Command
-  ): Effect.Effect<CommandResult, SandboxError>;
-  readFile(
-    lease: SandboxLease,
-    path: string
-  ): Effect.Effect<Uint8Array, SandboxError>;
-  writeFile(
-    lease: SandboxLease,
-    path: string,
-    body: Uint8Array
-  ): Effect.Effect<void, SandboxError>;
-  pause(lease: SandboxLease): Effect.Effect<void, SandboxError>;
-  resume(id: string): Effect.Effect<SandboxLease, SandboxError>;
-  terminate(lease: SandboxLease): Effect.Effect<void, SandboxError>;
+  create(spec: SandboxSpec): Effect.Effect<SandboxLease, SandboxError>
+  exec(lease: SandboxLease, cmd: Command): Effect.Effect<CommandResult, SandboxError>
+  readFile(lease: SandboxLease, path: string): Effect.Effect<Uint8Array, SandboxError>
+  writeFile(lease: SandboxLease, path: string, body: Uint8Array): Effect.Effect<void, SandboxError>
+  pause(lease: SandboxLease): Effect.Effect<void, SandboxError>
+  resume(id: string): Effect.Effect<SandboxLease, SandboxError>
+  terminate(lease: SandboxLease): Effect.Effect<void, SandboxError>
 }
 
 interface SourceControl {
-  prepareWorktree(input: WorktreeInput): Effect.Effect<Worktree, GitError>;
-  diff(worktree: Worktree): Effect.Effect<DiffArtifact, GitError>;
-  commit(input: CommitInput): Effect.Effect<CommitArtifact, GitError>;
-  push(input: PushInput): Effect.Effect<BranchArtifact, GitError>;
-  createPullRequest(
-    input: PullRequestInput
-  ): Effect.Effect<PullRequestArtifact, GitError>;
+  prepareWorktree(input: WorktreeInput): Effect.Effect<Worktree, GitError>
+  diff(worktree: Worktree): Effect.Effect<DiffArtifact, GitError>
+  commit(input: CommitInput): Effect.Effect<CommitArtifact, GitError>
+  push(input: PushInput): Effect.Effect<BranchArtifact, GitError>
+  createPullRequest(input: PullRequestInput): Effect.Effect<PullRequestArtifact, GitError>
 }
 
 interface VerificationRuntime {
-  execute(
-    plan: VerificationPlan,
-    env: EnvironmentRef
-  ): Effect.Effect<VerificationResult, VerificationError>;
+  execute(plan: VerificationPlan, env: EnvironmentRef):
+    Effect.Effect<VerificationResult, VerificationError>
 }
 ```
 
@@ -429,10 +420,6 @@ Zopu owns Work, branches, worktrees, budgets, approvals, artifacts, and completi
 
 ## 10. Runtime strategy
 
-### Convex orchestration
-
-Slice 5 uses the Convex Workflow component as the durable product orchestration layer. Workflow steps call private agent-backend actions, while all user-visible state, events, artifacts, idempotency keys, and cancellation remain canonical in Convex.
-
 ### CubeSandbox
 
 Best for full Linux execution:
@@ -456,7 +443,7 @@ Best for:
 - actor-adjacent orchestration;
 - context/files/networking that fit runtime limits.
 
-Slice 5 starts here with one Codex-backed AgentOS actor and one authenticated repository checkout per project. Convex Workflow owns product orchestration; Rivet Engine coordinates placement while a normal runner executes the actor. Use an attached full sandbox through the E2B-compatible boundary when native/heavy tooling is needed.
+Use an attached full sandbox when native/heavy tooling is needed.
 
 ### Persistent project machine
 

docs/slices.md

@@ -211,18 +211,16 @@ Zopu implements one approved slice in an isolated repository environment and str
 Initial adapter choice:
 
 ```text
-SandboxRuntime = AgentOsSandboxLive
-HarnessRuntime = CodexHarnessLive
-Durable orchestration = Convex Workflow
+SandboxRuntime = CubeSandboxLive
+HarnessRuntime = OmpHarnessLive (or one chosen harness)
 ```
 
 Flow:
 
 ```text
-load the project's authenticated Git connection
-→ start durable Convex workflow
-→ create AgentOS execution environment
-→ clone the single configured repo
+prepare worktree
+→ create sandbox
+→ clone/mount repo
 → inject context
 → run one slice
 → normalize events
@@ -232,15 +230,14 @@ load the project's authenticated Git connection
 
 Security:
 
-- GitHub OAuth or self-hosted Gitea PAT, scoped to one project;
-- scoped Git/model tokens passed only to private execution;
+- scoped Git/model tokens;
 - isolated HOME/worktree;
 - one mutating attempt per worktree;
 - timeout/cancel cleanup.
 
 ### Frontend
 
-Project selector/settings, Git connection status, current activity, changed files, artifact links, expandable raw logs, cancel/retry, and manual Git delivery controls.
+Current activity, changed files, artifact links, expandable raw logs.
 
 ### Acceptance
 
@@ -250,8 +247,6 @@ Project selector/settings, Git connection status, current activity, changed file
 - provider failure becomes classified attempt outcome;
 - exact base/candidate revision recorded.
 
-Rivet Engine coordinates AgentOS actor placement through a normal runner, but does not own product orchestration; Convex Workflow remains canonical for the Run lifecycle. Cube/Kubernetes sandbox support remains behind `SandboxRuntime` and can be mounted through AgentOS incrementally.
-
 ---
 
 ## Slice 6 — Independent verification and repair
@@ -495,4 +490,4 @@ browser-tester integration-coordinator
 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10 → 11 → 12
 ```
 
-Parallel engineering is allowed _within_ a slice after contracts land, but product release order remains sequential.
+Parallel engineering is allowed *within* a slice after contracts land, but product release order remains sequential.

oxlint.config.ts

@@ -5,28 +5,5 @@ import remix from "ultracite/oxlint/remix";
 
 export default defineConfig({
   extends: [core, react, remix],
-  ignorePatterns: [...core.ignorePatterns, "repos/**", "scripts/**"],
-  overrides: [
-    {
-      files: ["**/convex/**/*.ts", "**/convex/**/*.test.ts"],
-      rules: {
-        "unicorn/filename-case": "off",
-        // Convex targets ES2022: no toSorted/at; sequential awaits ensure atomicity
-        "unicorn/no-array-sort": "off",
-        "no-await-in-loop": "off",
-        // Convex query builders use `any` in index callbacks
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-non-null-assertion": "off",
-        "eslint/complexity": "off",
-      },
-    },
-    {
-      files: ["**/convex/**/*.test.ts"],
-      rules: {
-        "unicorn/no-await-expression-member": "off",
-        "eslint/require-await": "off",
-        "sort-keys": "off",
-      },
-    },
-  ],
+  ignorePatterns: core.ignorePatterns,
 });

package.json

@@ -1,13 +1,52 @@
 {
   "name": "code",
   "private": true,
+  "workspaces": {
+    "packages": [
+      "apps/web",
+      "packages/agents",
+      "packages/auth",
+      "packages/backend",
+      "packages/config",
+      "packages/env",
+      "packages/primitives",
+      "packages/ui"
+    ],
+    "catalog": {
+      "@rivet-dev/agentos": "^0.2.7",
+      "@rivet-dev/agentos-core": "^0.2.10",
+      "@effect/platform-bun": "4.0.0-beta.99",
+      "dotenv": "^17.4.2",
+      "zod": "^4.4.3",
+      "lucide-react": "^1.23.0",
+      "next-themes": "^0.4.6",
+      "react": "19.2.8",
+      "react-dom": "19.2.8",
+      "sonner": "^2.0.7",
+      "convex": "^1.42.1",
+      "better-auth": "1.6.15",
+      "@convex-dev/better-auth": "^0.12.5",
+      "@tanstack/react-form": "^1.33.0",
+      "@types/react-dom": "^19.2.3",
+      "tailwindcss": "^4.3.2",
+      "tailwind-merge": "^3.6.0",
+      "@better-auth/expo": "1.6.15",
+      "effect": "4.0.0-beta.99",
+      "typescript": "^6",
+      "@types/bun": "latest",
+      "heroui-native": "^1.0.5",
+      "vite": "^7.3.6",
+      "vitest": "^4.1.10",
+      "convex-test": "^0.0.54"
+    }
+  },
   "type": "module",
   "scripts": {
     "dev": "vp run -r dev",
     "build": "vp run -r build",
     "check-types": "vp run -r check-types",
-    "check": "ultracite check package.json vite.config.ts apps/web/package.json apps/web/src/root.tsx apps/web/src/index.css apps/web/src/components/chat apps/web/src/components/workspace apps/web/src/hooks/chat apps/web/src/hooks/workspace apps/web/src/lib/chat apps/web/src/lib/workspace apps/web/src/routes.ts apps/web/src/routes/app/dashboard/page.tsx apps/web/src/routes/app/workspace/page.tsx packages/agents/package.json packages/agents/src/agents/zopu.ts packages/agents/src/app.ts packages/agents/src/auth.ts packages/agents/src/tools/slice-one.ts packages/backend/package.json packages/backend/convex/conversationMessages.ts packages/backend/convex/conversationMessages.test.ts packages/backend/convex/fluePersistence.test.ts packages/backend/convex/projects.ts",
-    "lint": "oxlint --disable-nested-config",
+    "check": "ultracite check package.json vite.config.ts apps/web/package.json apps/web/src/root.tsx apps/web/src/index.css apps/web/src/components/chat apps/web/src/components/slice-one apps/web/src/hooks/chat apps/web/src/hooks/slice-one apps/web/src/lib/chat apps/web/src/lib/slice-one apps/web/src/routes.ts apps/web/src/routes/app/dashboard/page.tsx apps/web/src/routes/app/mobile/page.tsx packages/agents/package.json packages/agents/src/agents/zopu.ts packages/agents/src/app.ts packages/agents/src/auth.ts packages/agents/src/tools/slice-one.ts packages/backend/package.json packages/backend/convex/conversationMessages.ts packages/backend/convex/conversationMessages.test.ts packages/backend/convex/projects.ts packages/backend/convex/schema.ts packages/backend/convex/signalRouting.ts packages/backend/convex/signalRouting.test.ts packages/backend/convex/works.ts packages/backend/convex/works.test.ts packages/backend/convex/workExecution.ts packages/backend/convex/workExecution.test.ts packages/backend/convex/workPlanning.ts packages/backend/convex/workPlanning.test.ts packages/backend/convex/crons.ts packages/primitives/src/work.ts packages/primitives/src/work.test.ts packages/primitives/src/resolver.ts packages/primitives/src/work-lifecycle.ts packages/primitives/src/work-resolution.test.ts",
+    "lint": "vp lint",
     "format": "vp fmt",
     "staged": "vp staged",
     "hooks:setup": "vp config",
@@ -18,10 +57,14 @@
     "dev:server": "vp run --filter @code/backend dev",
     "dev:setup": "vp run --filter @code/backend dev:setup",
     "build:agents": "vp run --filter @code/agents build",
-    "docs:update": "node scripts/update-docs.ts",
-    "subtree": "node scripts/subtree.ts",
-    "fix": "ultracite fix"
+    "docs:update": "bun run scripts/update-docs.ts",
+    "subtree": "bun run scripts/subtree.ts",
+    "fix": "ultracite fix",
+    "slice1": "vp run -r dev",
+    "dev:zopu": "vp run --filter @code/agents dev",
+    "dev:zopu:web": "vp run --filter web dev"
   },
+  "dependencies": {},
   "devDependencies": {
     "@code/backend": "workspace:*",
     "@code/config": "workspace:*",
@@ -29,17 +72,20 @@
     "@code/primitives": "workspace:*",
     "@flue/sdk": "1.0.0-beta.9",
     "@types/bun": "catalog:",
-    "@types/node": "catalog:",
+    "@types/node": "^22.13.14",
     "convex": "catalog:",
     "convex-test": "catalog:",
     "effect": "catalog:",
-    "oxfmt": "0.61.0",
-    "oxlint": "1.76.0",
+    "oxfmt": "latest",
+    "oxlint": "latest",
     "rolldown": "1.1.4",
     "typescript": "catalog:",
     "ultracite": "7.9.3",
     "vite-plus": "0.2.2",
     "vitest": "catalog:"
   },
-  "packageManager": "pnpm@11.17.0"
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2"
+  },
+  "packageManager": "bun@1.3.14"
 }

packages/agents/Dockerfile

@@ -1,32 +0,0 @@
-FROM oven/bun:1.3.14 AS bun
-
-FROM node:24-bookworm-slim AS build
-
-COPY --from=bun /usr/local/bin/bun /usr/local/bin/bun
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-  ca-certificates \
-  g++ \
-  make \
-  python3 \
-  && rm -rf /var/lib/apt/lists/*
-
-COPY . .
-RUN bun install --frozen-lockfile
-RUN node packages/agents/node_modules/@flue/cli/bin/flue.mjs build --target node --root packages/agents
-
-FROM node:24-bookworm-slim
-
-ENV NODE_OPTIONS=--experimental-specifier-resolution=node
-
-ENV NODE_ENV=production
-ENV PORT=3000
-
-WORKDIR /app
-
-COPY --from=build /app /app
-EXPOSE 3000
-
-CMD ["node", "packages/agents/dist/server.mjs"]

packages/agents/flue.config.ts

@@ -1,5 +1,5 @@
-import { defineConfig } from "@flue/cli/config";
+import { defineConfig } from '@flue/cli/config';
 
 export default defineConfig({
-  target: "node",
+  target: 'node',
 });

packages/agents/package.json

@@ -4,37 +4,26 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "build": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs build",
-    "start": "node --env-file=../../.env dist/server.mjs",
+    "build": "bun --env-file=../../.env flue build",
     "check-types": "tsc --noEmit",
-    "dev": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs dev",
-    "dev:tailscale": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs dev",
-    "run": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs run",
-    "runner": "node --env-file=../../.env src/runner.ts",
-    "run:zopu": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs run zopu",
-    "run:work-planner": "node --env-file=../../.env node_modules/@flue/cli/bin/flue.mjs run work-planner"
+    "dev": "bun --env-file=../../.env flue dev",
+    "dev:tailscale": "bun --env-file=../../.env flue dev",
+    "run": "bun --env-file=../../.env flue run",
+    "run:zopu": "bun --env-file=../../.env flue run zopu",
+    "run:work-planner": "bun --env-file=../../.env flue run work-planner"
   },
   "dependencies": {
-    "@agentos-software/git": "0.3.3",
     "@code/backend": "workspace:*",
     "@code/env": "workspace:*",
-    "@code/primitives": "workspace:*",
     "@flue/runtime": "latest",
-    "@rivet-dev/agentos": "0.2.14",
-    "@rivet-dev/agentos-core": "0.2.14",
     "convex": "catalog:",
-    "hono": "catalog:",
-    "rivetkit": "2.3.9",
-    "valibot": "catalog:"
+    "hono": "4.12.31",
+    "valibot": "^1.4.2"
   },
   "devDependencies": {
     "@code/config": "workspace:*",
     "@flue/cli": "latest",
     "@types/bun": "catalog:",
-    "@types/node": "catalog:",
     "typescript": "catalog:"
-  },
-  "engines": {
-    "node": ">=22.18 <23 || >=23.6"
   }
 }

packages/agents/src/admission-context.ts

@@ -1,16 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-export interface TurnAdmissionContext {
-  readonly clientRequestId: string;
-  readonly turnId: string;
-}
-
-const turnAdmissionContext = new AsyncLocalStorage<TurnAdmissionContext>();
-
-export const currentTurnAdmission = (): TurnAdmissionContext | undefined =>
-  turnAdmissionContext.getStore();
-
-export const withTurnAdmission = <T>(
-  context: TurnAdmissionContext,
-  run: () => T
-): T => turnAdmissionContext.run(context, run);

packages/agents/src/agents/zopu.ts

@@ -1,9 +1,54 @@
 import { parseAgentEnv } from "@code/env/agent";
 import { defineAgent } from "@flue/runtime";
 
-import INSTRUCTIONS from "../prompts/zopu-instructions.md" with { type: "markdown" };
 import { createSliceOneTools } from "../tools/slice-one";
 
+const INSTRUCTIONS = `You are Zopu for product Slice 1 and the Work planning handoff.
+
+## Your role
+
+The application stores each user message as exact evidence before you process it. You may interpret that evidence, but never supply, rewrite, or invent source text.
+
+## Work routing loop
+
+When a user sends a message, follow this decision flow:
+
+1. **Assess actionability.** Does the message contain a concrete problem, request, blocker, opportunity, or decision that warrants a work unit? Greetings, questions about the system, casual conversation, and exploration do NOT create work. If the message is casual conversation, respond naturally and do nothing else.
+
+   Direct questions, casual conversation, and image-reading requests must be answered immediately without calling any tools.
+
+2. **Identify project context.** Call list_projects. If there is one project, use it. If there are several and the request is ambiguous, ask one focused question.
+
+3. **Create a Signal (only when actionable).** When the message is actionable:
+   a. Call list_signal_evidence to see the exact admitted user messages.
+   b. Select the message IDs that compose the problem statement.
+   c. Call create_signal with a structured problem statement (title, summary, desiredOutcome, constraints). The problem statement must faithfully represent the user's own intent. Do not invent scope they did not mention.
+   d. Include the projectId when the project is known.
+
+4. **Route the Signal.** After creating the Signal:
+   a. Call list_proposed_work for the project.
+   b. If the Signal clearly describes the same desired outcome as existing Work, call attach_signal_to_work.
+   c. Otherwise call create_work_from_signal.
+   e. If genuinely uncertain whether to attach or create, ask one focused question.
+
+5. **Explain the outcome.** Tell the user clearly what happened:
+   - "Captured [Signal title] and linked it to [Work title]."
+   - "Captured [Signal title] and proposed [Work title]."
+   - Keep the response brief; the product renders the durable Work card separately.
+
+## Rules
+
+- Never supply or rewrite the raw source message text. The control plane copies it server-side.
+- You receive and can see images attached to the current user message. This model supports image input. Never claim images are unavailable, omitted, or unsupported. If a message has attached images, inspect them before responding.
+- Never create Work from casual chat.
+- Ask at most one focused clarification when genuinely ambiguous.
+- Preserve project and organization scope at all times.
+- Repeated delivery of the same message must not create duplicate Signals or attachments. The backend is idempotent.
+- Never claim you created a Signal until the tool call returns successfully.
+- Do not start implementation, planning, sandboxes, Git, verification, or delivery. Those are explicitly outside Slice 1.
+   - After creating proposed Work, the system may invoke the private work-planner. Never claim that a Definition, Design, approval, or implementation exists unless Convex reports it.
+   - Proposed Work is the only Work status you directly create.`;
+
 export {
   convexAgentRoute as attachments,
   convexAgentRoute as route,

packages/agents/src/app.ts

@@ -1,16 +1,8 @@
 import { parseAgentEnv } from "@code/env/agent";
-import { WorkAttemptExecutionError } from "@code/primitives/execution-runtime";
 import { registerProvider } from "@flue/runtime";
-import type { Fetchable } from "@flue/runtime/routing";
 import { flue } from "@flue/runtime/routing";
 import { Hono } from "hono";
 
-import {
-  cancelAgentOsAttempt,
-  executeAgentOsAttempt,
-  runtimeRegistry,
-} from "./runtime/agent-os";
-
 const agentEnv = parseAgentEnv(process.env);
 
 registerProvider(agentEnv.AGENT_MODEL_PROVIDER, {
@@ -33,54 +25,6 @@ registerProvider(agentEnv.AGENT_MODEL_PROVIDER, {
 });
 
 const app = new Hono();
+app.route("/", flue() as unknown as Hono);
 
-app.post("/internal/work-attempts/execute", async (context) => {
-  if (
-    context.req.header("authorization") !== `Bearer ${agentEnv.FLUE_DB_TOKEN}`
-  ) {
-    return context.json({ error: "Unauthorized" }, 401);
-  }
-  try {
-    return context.json(await executeAgentOsAttempt(await context.req.json()));
-  } catch (error) {
-    const failure =
-      error instanceof WorkAttemptExecutionError
-        ? error
-        : new WorkAttemptExecutionError({
-            message:
-              error instanceof Error ? error.message : "Execution failed",
-            reason: "HarnessFailed",
-            retryable: false,
-          });
-    return context.json(
-      {
-        error: {
-          message: failure.message,
-          reason: failure.reason,
-          retryable: failure.retryable,
-        },
-      },
-      500
-    );
-  }
-});
-
-app.post("/internal/work-attempts/:workspaceKey/cancel", async (context) => {
-  if (
-    context.req.header("authorization") !== `Bearer ${agentEnv.FLUE_DB_TOKEN}`
-  ) {
-    return context.json({ error: "Unauthorized" }, 401);
-  }
-  const body = (await context.req.json()) as { attemptId?: unknown };
-  if (typeof body.attemptId !== "string" || body.attemptId.length === 0) {
-    return context.json({ error: "attemptId is required" }, 400);
-  }
-  await cancelAgentOsAttempt(context.req.param("workspaceKey"), body.attemptId);
-  return context.json({ cancelled: true });
-});
-
-app.all("/api/rivet/*", (context) => runtimeRegistry.handler(context.req.raw));
-
-app.route("/", flue());
-
-export default app satisfies Fetchable;
+export default app;

packages/agents/src/auth.ts

@@ -1,8 +1,6 @@
 import { parseAgentEnv } from "@code/env/agent";
 import type { AgentRouteHandler } from "@flue/runtime";
 
-import { withTurnAdmission } from "./admission-context";
-
 /** Only Convex may invoke or observe the organization-scoped Flue agent. */
 export const convexAgentRoute: AgentRouteHandler = async (context, next) => {
   const env = parseAgentEnv(process.env);
@@ -16,15 +14,5 @@ export const convexAgentRoute: AgentRouteHandler = async (context, next) => {
     return context.json({ error: "Forbidden" }, 403);
   }
 
-  if (context.req.method !== "POST") {
-    return await next();
-  }
-
-  const clientRequestId = context.req.header("x-zopu-request-id");
-  const turnId = context.req.header("x-zopu-turn-id");
-  if (!clientRequestId || !turnId) {
-    return context.json({ error: "Missing turn correlation headers" }, 400);
-  }
-
-  return await withTurnAdmission({ clientRequestId, turnId }, () => next());
+  return await next().then(() => context.res);
 };

packages/agents/src/prompts/zopu-instructions.md

@@ -1,45 +0,0 @@
-You are Zopu for product Slice 1 and the Work planning handoff.
-
-## Your role
-
-The application stores each user message as exact evidence before you process it. You may interpret that evidence, but never supply, rewrite, or invent source text.
-
-## Work routing loop
-
-When a user sends a message, follow this decision flow:
-
-1. **Assess actionability.** Does the message contain a concrete problem, request, blocker, opportunity, or decision that warrants a work unit? Greetings, questions about the system, casual conversation, and exploration do NOT create work. If the message is casual conversation, respond naturally and do nothing else.
-
-   Direct questions, casual conversation, and image-reading requests must be answered immediately without calling any tools.
-
-2. **Identify project context.** Call list_projects. If there is one project, use it. If there are several and the request is ambiguous, ask one focused question.
-
-3. **Create a Signal (only when actionable).** When the message is actionable:
-   a. Call list_signal_evidence to see the exact admitted user messages.
-   b. Select the message IDs that compose the problem statement.
-   c. Call create_signal with a structured problem statement (title, summary, desiredOutcome, constraints). The problem statement must faithfully represent the user's own intent. Do not invent scope they did not mention.
-   d. Include the projectId when the project is known.
-
-4. **Route the Signal.** After creating the Signal:
-   a. Call list_proposed_work for the project.
-   b. If the Signal clearly describes the same desired outcome as existing Work, call attach_signal_to_work.
-   c. Otherwise call create_work_from_signal.
-   e. If genuinely uncertain whether to attach or create, ask one focused question.
-
-5. **Explain the outcome.** Tell the user clearly what happened:
-   - "Captured [Signal title] and linked it to [Work title]."
-   - "Captured [Signal title] and proposed [Work title]."
-   - Keep the response brief; the product renders the durable Work card separately.
-
-## Rules
-
-- Never supply or rewrite the raw source message text. The control plane copies it server-side.
-- You receive and can see images attached to the current user message. This model supports image input. Never claim images are unavailable, omitted, or unsupported. If a message has attached images, inspect them before responding.
-- Never create Work from casual chat.
-- Ask at most one focused clarification when genuinely ambiguous.
-- Preserve project and organization scope at all times.
-- Repeated delivery of the same message must not create duplicate Signals or attachments. The backend is idempotent.
-- Never claim you created a Signal until the tool call returns successfully.
-- Do not start implementation, planning, sandboxes, Git, verification, or delivery. Those are explicitly outside Slice 1.
-   - After creating proposed Work, the system may invoke the private work-planner. Never claim that a Definition, Design, approval, or implementation exists unless Convex reports it.
-   - Proposed Work is the only Work status you directly create.

packages/agents/src/runner.ts

@@ -1,3 +0,0 @@
-import { runtimeRegistry } from "./runtime/agent-os";
-
-await runtimeRegistry.startAndWait();

packages/agents/src/runtime/agent-os.ts

@@ -1,255 +0,0 @@
-import { parseAgentEnv } from "@code/env/agent";
-import {
-  makePiAgentOsConfig,
-  makePiHomeFiles,
-  decodeWorkAttemptExecutionInput,
-  WorkAttemptExecutionError,
-  piSessionEnv,
-} from "@code/primitives";
-import type {
-  ExecutionEvent,
-  WorkAttemptExecutionResult,
-} from "@code/primitives";
-import { agentOS, setup } from "@rivet-dev/agentos";
-import { createHostDirBackend } from "@rivet-dev/agentos-core";
-import { createClient } from "@rivet-dev/agentos/client";
-import { Effect } from "effect";
-
-import { HostRepositoryWorkspace } from "./host-repository";
-
-const piConfig = makePiAgentOsConfig();
-const workspace = agentOS<undefined, { token: string }>({
-  onBeforeConnect: (_context, params) => {
-    if (params.token !== process.env.RIVET_WORKSPACE_TOKEN) {
-      throw new Error("Unauthorized workspace connection");
-    }
-  },
-  options: {
-    actionTimeout: 10 * 60 * 1000,
-  },
-  permissions: piConfig.permissions,
-  software: piConfig.software,
-});
-
-export const runtimeRegistry = setup({ use: { workspace } });
-
-const event = (
-  sequence: number,
-  kind: ExecutionEvent["kind"],
-  message: string,
-  metadata: Record<string, string> = {}
-): ExecutionEvent => ({
-  kind,
-  message,
-  metadata,
-  occurredAt: Date.now(),
-  sequence,
-});
-
-const executionError = (
-  message: string,
-  reason: WorkAttemptExecutionError["reason"],
-  retryable: boolean
-) => new WorkAttemptExecutionError({ message, reason, retryable });
-
-const classifyRuntimeFailure = (cause: unknown): WorkAttemptExecutionError => {
-  if (cause instanceof WorkAttemptExecutionError) {
-    return cause;
-  }
-  const message = cause instanceof Error ? cause.message : "Execution failed";
-  if (/auth|credential|401|403/iu.test(message)) {
-    return executionError(message, "Authentication", false);
-  }
-  if (/clone|checkout|repository|git /iu.test(message)) {
-    return executionError(message, "RepositoryFailed", false);
-  }
-  if (/timeout|timed out/iu.test(message)) {
-    return executionError(message, "Timeout", true);
-  }
-  if (/connect|network|unavailable|502|503|504/iu.test(message)) {
-    return executionError(message, "ProviderUnavailable", true);
-  }
-  return executionError(message, "HarnessFailed", false);
-};
-
-export const executeAgentOsAttempt = async (
-  rawInput: unknown
-): Promise<WorkAttemptExecutionResult> => {
-  try {
-    const input = await Effect.runPromise(
-      decodeWorkAttemptExecutionInput(rawInput)
-    );
-    const env = parseAgentEnv(process.env);
-    const client = createClient<typeof runtimeRegistry>({
-      disableMetadataLookup: true,
-      endpoint: env.RIVET_PUBLIC_ENDPOINT ?? env.RIVET_ENDPOINT,
-    });
-    const vm = client.workspace.getOrCreate([input.workspaceKey], {
-      params: { token: env.RIVET_WORKSPACE_TOKEN },
-    });
-    const events: ExecutionEvent[] = [
-      event(0, "runtime.preparing", "AgentOS workspace selected", {
-        workspaceKey: input.workspaceKey,
-      }),
-    ];
-    const hostRepository = new HostRepositoryWorkspace();
-    const prepared = await hostRepository.prepare({
-      attemptId: input.attemptId,
-      piHomeFiles: makePiHomeFiles({
-        api: env.AGENT_MODEL_API,
-        apiKeyEnvironmentVariable: "AGENT_MODEL_API_KEY",
-        baseUrl: env.AGENT_MODEL_BASE_URL,
-        contextWindow: env.AGENT_MODEL_CONTEXT_WINDOW,
-        maxTokens: env.AGENT_MODEL_MAX_TOKENS,
-        model: env.AGENT_MODEL_NAME,
-        provider: env.AGENT_MODEL_PROVIDER,
-      }),
-    });
-    events.push(
-      event(
-        1,
-        "runtime.preparing",
-        prepared.created
-          ? "Isolated Zopu worktree created on the execution host"
-          : "Isolated Zopu worktree recreated"
-      )
-    );
-    const mounts = [
-      {
-        hostPath: prepared.checkoutPath,
-        path: "/workspace/repository",
-        readOnly: false,
-      },
-      {
-        hostPath: prepared.sourceRepositoryPath,
-        path: prepared.sourceRepositoryPath,
-        readOnly: false,
-      },
-      {
-        hostPath: prepared.piHomePath,
-        path: "/home/zopu",
-        readOnly: false,
-      },
-      {
-        hostPath: prepared.toolsPath,
-        path: "/opt/zopu-tools",
-        readOnly: true,
-      },
-    ] as const;
-    const mountNext = async (index: number): Promise<void> => {
-      const mount = mounts[index];
-      if (!mount) {
-        return;
-      }
-      try {
-        await vm.mountFs({
-          path: mount.path,
-          plugin: createHostDirBackend({
-            hostPath: mount.hostPath,
-            readOnly: mount.readOnly,
-          }),
-          readOnly: mount.readOnly,
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw executionError(
-          `Failed to mount ${mount.hostPath} at ${mount.path}: ${message}`,
-          "HarnessFailed",
-          false
-        );
-      }
-      await mountNext(index + 1);
-    };
-    await mountNext(0);
-    const { baseRevision } = prepared;
-    events.push(
-      event(2, "repository.ready", "Repository checkout is ready", {
-        baseRevision,
-      })
-    );
-
-    const sessionId = `pi-${input.attemptId}`;
-    await vm.openSession({
-      additionalDirectories: [`${prepared.sourceRepositoryPath}/.git`],
-      additionalInstructions:
-        "Work only inside /workspace/repository. This is an isolated worktree of the Zopu product repository. Read AGENTS.md and the relevant product specifications before changing code. Never reveal credentials, modify the read-only base checkout, push, or open a pull request. Implement the requested change and run focused verification.",
-      agent: "pi",
-      cwd: "/workspace/repository",
-      env: piSessionEnv(env.AGENT_MODEL_API_KEY),
-      permissionPolicy: "allow_all",
-      sessionId,
-    });
-    events.push(
-      event(3, "harness.started", "Pi implementation session started")
-    );
-    const promptResult = await vm.prompt({
-      content: [{ text: input.prompt, type: "text" }],
-      idempotencyKey: input.attemptId,
-      sessionId,
-    });
-    if (promptResult.stopReason !== "end_turn") {
-      const reason =
-        promptResult.stopReason === "cancelled" ? "Cancelled" : "HarnessFailed";
-      throw executionError(
-        `Pi stopped with ${promptResult.stopReason}`,
-        reason,
-        promptResult.stopReason === "max_tokens" ||
-          promptResult.stopReason === "max_turn_requests"
-      );
-    }
-    events.push(
-      event(4, "harness.progress", "Pi implementation turn completed", {
-        stopReason: promptResult.stopReason,
-      })
-    );
-
-    const collected = await HostRepositoryWorkspace.collect({
-      attemptId: input.attemptId,
-      baseRevision,
-      checkoutPath: prepared.checkoutPath,
-    });
-    const { candidateRevision, changedFiles, diff } = collected;
-    events.push(
-      event(
-        5,
-        "repository.changed",
-        `${changedFiles.length} changed file(s) collected`,
-        {
-          candidateRevision,
-        }
-      ),
-      event(6, "runtime.completed", "AgentOS execution completed")
-    );
-
-    return {
-      baseRevision,
-      candidateRevision,
-      changedFiles,
-      diff,
-      environmentId: input.workspaceKey,
-      events,
-      summary:
-        changedFiles.length > 0
-          ? `Pi changed ${changedFiles.length} file(s)`
-          : "Pi completed without repository changes",
-    };
-  } catch (error) {
-    throw classifyRuntimeFailure(error);
-  }
-};
-
-export const cancelAgentOsAttempt = async (
-  workspaceKey: string,
-  attemptId: string
-) => {
-  const env = parseAgentEnv(process.env);
-  const client = createClient<typeof runtimeRegistry>({
-    disableMetadataLookup: true,
-    endpoint: env.RIVET_PUBLIC_ENDPOINT ?? env.RIVET_ENDPOINT,
-  });
-  await client.workspace
-    .getOrCreate([workspaceKey], {
-      params: { token: env.RIVET_WORKSPACE_TOKEN },
-    })
-    .cancelPrompt({ sessionId: `pi-${attemptId}` });
-};

packages/agents/src/runtime/host-repository.ts

@@ -1,274 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { once } from "node:events";
-import {
-  access,
-  chmod,
-  copyFile,
-  mkdir,
-  rm,
-  writeFile,
-} from "node:fs/promises";
-import path from "node:path";
-
-import type { PiHomeFiles } from "@code/primitives";
-
-interface PrepareRepositoryInput {
-  attemptId: string;
-  piHomeFiles: PiHomeFiles;
-}
-
-interface PreparedRepository {
-  baseRevision: string;
-  checkoutPath: string;
-  created: boolean;
-  piHomePath: string;
-  sourceRepositoryPath: string;
-  toolsPath: string;
-}
-
-interface CollectRepositoryInput {
-  attemptId: string;
-  baseRevision: string;
-  checkoutPath: string;
-}
-
-interface CollectedRepository {
-  candidateRevision: string;
-  changedFiles: string[];
-  diff: string;
-}
-
-interface ProcessResult {
-  exitCode: number;
-  stderr: string;
-  stdout: string;
-}
-
-const requireSuccess = (result: ProcessResult, operation: string): string => {
-  if (result.exitCode !== 0) {
-    throw new Error(`${operation} failed: ${result.stderr || result.stdout}`);
-  }
-  return result.stdout.trim();
-};
-
-const changedFilePath = (line: string): string => {
-  const filePath = line.slice(3).trim();
-  const renameSeparator = " -> ";
-  const renameIndex = filePath.lastIndexOf(renameSeparator);
-  return renameIndex === -1
-    ? filePath
-    : filePath.slice(renameIndex + renameSeparator.length);
-};
-
-const runProcess = async (
-  command: string,
-  args: readonly string[],
-  cwd: string,
-  env: Record<string, string> = {}
-): Promise<ProcessResult> => {
-  const environment = Object.fromEntries(
-    Object.entries(process.env).filter(
-      (entry): entry is [string, string] => entry[1] !== undefined
-    )
-  );
-  const child = spawn(command, args, {
-    cwd,
-    env: { ...environment, ...env },
-  });
-  const stderr: Uint8Array[] = [];
-  const stdout: Uint8Array[] = [];
-  child.stderr.on("data", (chunk: Uint8Array) => stderr.push(chunk));
-  child.stdout.on("data", (chunk: Uint8Array) => stdout.push(chunk));
-  const [exitCode] = await once(child, "close");
-  return {
-    exitCode: typeof exitCode === "number" ? exitCode : 1,
-    stderr: Buffer.concat(stderr).toString(),
-    stdout: Buffer.concat(stdout).toString(),
-  };
-};
-
-const runGit = (cwd: string, args: readonly string[]) =>
-  runProcess("git", args, cwd);
-
-const pathExists = async (target: string): Promise<boolean> => {
-  try {
-    await access(target);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export class HostRepositoryWorkspace {
-  readonly #root: string;
-  readonly #sourceRepositoryPath: string;
-  readonly #installDependencies: boolean;
-
-  constructor(
-    root = process.env.AGENT_WORKSPACE_ROOT ?? "/var/lib/zopu/workspaces",
-    sourceRepositoryPath = process.env.ZOPU_SOURCE_REPOSITORY ??
-      "/opt/zopu-source",
-    installDependencies = true
-  ) {
-    this.#root = root;
-    this.#sourceRepositoryPath = sourceRepositoryPath;
-    this.#installDependencies = installDependencies;
-  }
-
-  async prepare(input: PrepareRepositoryInput): Promise<PreparedRepository> {
-    if (!(await pathExists(path.join(this.#sourceRepositoryPath, ".git")))) {
-      throw new Error(
-        `Fixed Zopu source repository is unavailable at ${this.#sourceRepositoryPath}`
-      );
-    }
-
-    const identity = createHash("sha256")
-      .update(input.attemptId)
-      .digest("hex")
-      .slice(0, 24);
-    const workspacePath = path.join(this.#root, identity);
-    const checkoutPath = path.join(workspacePath, "repository");
-    const toolsPath = path.join(workspacePath, "tools");
-    const piHomePath = path.join(workspacePath, "home");
-    const branch = `zopu/attempt-${identity}`;
-    const created = !(await pathExists(path.join(checkoutPath, ".git")));
-
-    await mkdir(workspacePath, { recursive: true });
-    if (!created) {
-      requireSuccess(
-        await runGit(this.#sourceRepositoryPath, [
-          "worktree",
-          "remove",
-          "--force",
-          checkoutPath,
-        ]),
-        "Existing worktree removal"
-      );
-    }
-    await rm(checkoutPath, { force: true, recursive: true });
-    requireSuccess(
-      await runGit(this.#sourceRepositoryPath, [
-        "worktree",
-        "add",
-        "-B",
-        branch,
-        checkoutPath,
-        "HEAD",
-      ]),
-      "Zopu worktree creation"
-    );
-
-    const bunExecutable =
-      process.env.BUN_EXECUTABLE ??
-      execFileSync("which", ["bun"], { encoding: "utf-8" }).trim();
-
-    const sourceEnvPath = path.join(this.#sourceRepositoryPath, ".env");
-    if (await pathExists(sourceEnvPath)) {
-      await copyFile(sourceEnvPath, path.join(checkoutPath, ".env"));
-    }
-    if (this.#installDependencies) {
-      requireSuccess(
-        await runProcess(
-          bunExecutable,
-          ["install", "--frozen-lockfile"],
-          checkoutPath,
-          { CI: "1" }
-        ),
-        "Workspace dependency installation"
-      );
-    }
-
-    const toolsBinPath = path.join(toolsPath, "bin");
-    await mkdir(toolsBinPath, { recursive: true });
-    const bunPath = path.join(toolsBinPath, "bun");
-    await copyFile(bunExecutable, bunPath);
-    await chmod(bunPath, 0o755);
-
-    const piAgentPath = path.join(piHomePath, ".pi", "agent");
-    await mkdir(piAgentPath, { recursive: true });
-    await writeFile(
-      path.join(piAgentPath, "models.json"),
-      input.piHomeFiles.models
-    );
-    await writeFile(
-      path.join(piAgentPath, "settings.json"),
-      input.piHomeFiles.settings
-    );
-
-    return {
-      baseRevision: requireSuccess(
-        await runGit(checkoutPath, ["rev-parse", "HEAD"]),
-        "Base revision lookup"
-      ),
-      checkoutPath,
-      created,
-      piHomePath,
-      sourceRepositoryPath: this.#sourceRepositoryPath,
-      toolsPath,
-    };
-  }
-
-  static async collect(
-    input: CollectRepositoryInput
-  ): Promise<CollectedRepository> {
-    const status = requireSuccess(
-      await runGit(input.checkoutPath, ["status", "--porcelain"]),
-      "Changed file lookup"
-    );
-    let diff = "";
-    const changedFiles = status
-      .split("\n")
-      .filter(Boolean)
-      .map(changedFilePath);
-    let candidateRevision = input.baseRevision;
-
-    if (changedFiles.length > 0) {
-      requireSuccess(
-        await runGit(input.checkoutPath, ["add", "-A"]),
-        "Candidate staging"
-      );
-      diff = requireSuccess(
-        await runGit(input.checkoutPath, [
-          "diff",
-          "--binary",
-          "--cached",
-          "--no-ext-diff",
-          input.baseRevision,
-        ]),
-        "Diff collection"
-      );
-      const tree = requireSuccess(
-        await runGit(input.checkoutPath, ["write-tree"]),
-        "Candidate tree creation"
-      );
-      candidateRevision = requireSuccess(
-        await runProcess(
-          "git",
-          [
-            "commit-tree",
-            tree,
-            "-p",
-            input.baseRevision,
-            "-m",
-            `Zopu candidate for ${input.attemptId}`,
-          ],
-          input.checkoutPath,
-          {
-            GIT_AUTHOR_EMAIL: "agent@zopu.dev",
-            GIT_AUTHOR_NAME: "Zopu Agent",
-            GIT_COMMITTER_EMAIL: "agent@zopu.dev",
-            GIT_COMMITTER_NAME: "Zopu Agent",
-          }
-        ),
-        "Candidate revision creation"
-      );
-      requireSuccess(
-        await runGit(input.checkoutPath, ["reset"]),
-        "Candidate index reset"
-      );
-    }
-
-    return { candidateRevision, changedFiles, diff };
-  }
-}

packages/agents/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "extends": "@code/config/tsconfig.base.json",
-  "compilerOptions": { "allowImportingTsExtensions": true, "types": ["bun"] },
+  "compilerOptions": { "types": ["bun"] },
   "include": ["src/**/*.ts"],
   "exclude": ["dist"]
 }

packages/auth/package.json

@@ -23,13 +23,13 @@
     "expo-secure-store": "~57.0.0",
     "heroui-native": "catalog:",
     "react": "catalog:",
-    "react-native": "catalog:",
+    "react-native": "0.86.0",
     "sonner": "catalog:",
     "zod": "catalog:"
   },
   "devDependencies": {
     "@code/config": "workspace:*",
-    "@types/react": "catalog:",
+    "@types/react": "~19.2.17",
     "typescript": "catalog:",
     "vite": "catalog:",
     "vitest": "catalog:"

packages/backend/.oxlintrc.json

@@ -0,0 +1,10 @@
+{
+  "overrides": [
+    {
+      "files": ["convex/**/*.ts"],
+      "rules": {
+        "unicorn/filename-case": "off"
+      }
+    }
+  ]
+}

packages/backend/convex/README.md

@@ -1,6 +1,8 @@
 # Convex Backend
 
-Convex is the only application API used by web, desktop, and mobile clients. The active backend covers the durable control plane through Slice 4: tenancy, projects, conversation turns, Signals, Work planning, approved Design slices, simulated Runs and Attempts, artifacts/delivery metadata, and Flue persistence.
+Convex is the only application API used by web, desktop, and mobile clients.
+The active Slice 1 backend is intentionally limited to tenancy, projects,
+conversation turns, Signals, Work, and Flue's required persistence adapter.
 
 ## Domain relations
 
@@ -9,9 +11,6 @@ Convex is the only application API used by web, desktop, and mobile clients. The
 - `conversations`, `conversationTurns`, `conversationMessages`, and `conversationAttachments` own chat admission and reactive history.
 - `signals`, `signalConstraints`, and `signalSources` preserve structured intent and exact evidence.
 - `works`, `signalWorkAttachments`, and `workEvents` own proposed Work and provenance.
-- `workDefinitions`, `workQuestions`, and `workApprovals` own versioned outcome contracts and approvals.
-- `designPackets` and `workSlices` preserve versioned implementation intent and executable slice order.
-- `workRuns`, `workAttempts`, `workAttemptEvents`, and `resolverDecisions` own bounded simulated execution and recovery.
-- `workArtifacts` and `workDeliveries` preserve evidence and delivery metadata without performing Git or sandbox work.
 
-The `flue*` tables are infrastructure tables required by Flue's persistence contract. They are deliberately separate from the product relations.
+The `flue*` tables are infrastructure tables required by Flue's persistence
+contract. They are deliberately separate from the product relations.

packages/backend/convex/_generated/api.d.ts

@@ -11,11 +11,7 @@
 import type * as auth from "../auth.js";
 import type * as authz from "../authz.js";
 import type * as conversationMessages from "../conversationMessages.js";
-import type * as conversationProjections from "../conversationProjections.js";
-import type * as crons from "../crons.js";
 import type * as fluePersistence from "../fluePersistence.js";
-import type * as gitConnectionData from "../gitConnectionData.js";
-import type * as gitConnections from "../gitConnections.js";
 import type * as healthCheck from "../healthCheck.js";
 import type * as http from "../http.js";
 import type * as organizations from "../organizations.js";
@@ -23,11 +19,6 @@ import type * as privateData from "../privateData.js";
 import type * as projects from "../projects.js";
 import type * as publicGit from "../publicGit.js";
 import type * as signalRouting from "../signalRouting.js";
-import type * as workArtifacts from "../workArtifacts.js";
-import type * as workExecution from "../workExecution.js";
-import type * as workExecutionAgent from "../workExecutionAgent.js";
-import type * as workExecutionWorkflow from "../workExecutionWorkflow.js";
-import type * as workPlanning from "../workPlanning.js";
 import type * as works from "../works.js";
 
 import type {
@@ -40,11 +31,7 @@ declare const fullApi: ApiFromModules<{
   auth: typeof auth;
   authz: typeof authz;
   conversationMessages: typeof conversationMessages;
-  conversationProjections: typeof conversationProjections;
-  crons: typeof crons;
   fluePersistence: typeof fluePersistence;
-  gitConnectionData: typeof gitConnectionData;
-  gitConnections: typeof gitConnections;
   healthCheck: typeof healthCheck;
   http: typeof http;
   organizations: typeof organizations;
@@ -52,11 +39,6 @@ declare const fullApi: ApiFromModules<{
   projects: typeof projects;
   publicGit: typeof publicGit;
   signalRouting: typeof signalRouting;
-  workArtifacts: typeof workArtifacts;
-  workExecution: typeof workExecution;
-  workExecutionAgent: typeof workExecutionAgent;
-  workExecutionWorkflow: typeof workExecutionWorkflow;
-  workPlanning: typeof workPlanning;
   works: typeof works;
 }>;
 
@@ -88,5 +70,4 @@ export declare const internal: FilterApi<
 
 export declare const components: {
   betterAuth: import("@convex-dev/better-auth/_generated/component.js").ComponentApi<"betterAuth">;
-  workflow: import("@convex-dev/workflow/_generated/component.js").ComponentApi<"workflow">;
 };

packages/backend/convex/_generated/server.d.ts

@@ -25,14 +25,10 @@ import type { DataModel } from "./dataModel.js";
  * Typesafe environment variables declared in `convex.config.ts`.
  */
 type Env = {
-  readonly AGENT_BACKEND_URL: string | undefined;
   readonly FLUE_DB_TOKEN: string;
   readonly FLUE_URL: string | undefined;
   readonly GITEA_TOKEN: string | undefined;
   readonly GITEA_URL: string | undefined;
-  readonly GITHUB_CLIENT_ID: string | undefined;
-  readonly GITHUB_CLIENT_SECRET: string | undefined;
-  readonly GIT_CREDENTIAL_ENCRYPTION_KEY: string | undefined;
   readonly NATIVE_APP_URL: string | undefined;
   readonly SITE_URL: string;
 };

packages/backend/convex/auth.ts

@@ -30,15 +30,6 @@ const createAuth = (ctx: GenericCtx<DataModel>) =>
         jwksRotateOnTokenGenerationError: true,
       }),
     ],
-    socialProviders:
-      env.GITHUB_CLIENT_ID && env.GITHUB_CLIENT_SECRET
-        ? {
-            github: {
-              clientId: env.GITHUB_CLIENT_ID,
-              clientSecret: env.GITHUB_CLIENT_SECRET,
-            },
-          }
-        : {},
     trustedOrigins: [siteUrl, nativeAppUrl, "exp://"],
   });
 

packages/backend/convex/conversationMessages.test.ts

@@ -1,5 +1,5 @@
 import { convexTest } from "convex-test";
-import { anyApi, makeFunctionReference } from "convex/server";
+import { anyApi } from "convex/server";
 import { describe, expect, test } from "vitest";
 
 import schema from "./schema";
@@ -15,22 +15,6 @@ const api = anyApi;
 const identityA = { tokenIdentifier: "https://convex.test|user-a" };
 const identityB = { tokenIdentifier: "https://convex.test|user-b" };
 const newTest = () => convexTest({ modules, schema });
-const markProcessingRef = makeFunctionReference<
-  "mutation",
-  { turnId: string; attempt: number; leaseOwner: string },
-  boolean
->("conversationMessages:markProcessing");
-const failTurnRef = makeFunctionReference<
-  "mutation",
-  {
-    turnId: string;
-    attempt: number;
-    leaseOwner: string;
-    error: string;
-    retry: boolean;
-  },
-  boolean
->("conversationMessages:failTurn");
 
 const ensureOrg = async (
   t: ReturnType<typeof newTest>,
@@ -125,47 +109,4 @@ describe("conversationMessages", () => {
         })
     ).rejects.toThrow(/Organization membership required/u);
   });
-
-  test("fences stale dispatch failures after admission", async () => {
-    const t = newTest();
-    const organization = await ensureOrg(t, identityA);
-    const sent = await t
-      .withIdentity(identityA)
-      .mutation(api.conversationMessages.send, {
-        clientRequestId: "request-fenced",
-        images: [],
-        organizationId: organization._id,
-        rawText: "Keep only the admitted submission",
-      });
-
-    expect(
-      await t.mutation(markProcessingRef, {
-        attempt: 1,
-        leaseOwner: "worker-1",
-        turnId: sent.turnId,
-      })
-    ).toBe(true);
-    await t.run(async (ctx) => {
-      await ctx.db.patch(sent.turnId, {
-        leaseExpiresAt: undefined,
-        leaseOwner: undefined,
-        status: "running",
-        submissionId: "submission-1",
-      });
-    });
-
-    expect(
-      await t.mutation(failTurnRef, {
-        attempt: 1,
-        error: "lost 202",
-        leaseOwner: "worker-1",
-        retry: true,
-        turnId: sent.turnId,
-      })
-    ).toBe(false);
-    expect(await t.run((ctx) => ctx.db.get(sent.turnId))).toMatchObject({
-      status: "running",
-      submissionId: "submission-1",
-    });
-  });
 });

packages/backend/convex/conversationMessages.ts

@@ -31,23 +31,18 @@ const getTurnRef = makeFunctionReference<
 >("conversationMessages:getTurn");
 const markProcessingRef = makeFunctionReference<
   "mutation",
-  {
-    turnId: Id<"conversationTurns">;
-    attempt: number;
-    leaseOwner: string;
-  },
+  { turnId: Id<"conversationTurns"> },
   boolean
 >("conversationMessages:markProcessing");
+const completeTurnRef = makeFunctionReference<
+  "mutation",
+  { turnId: Id<"conversationTurns">; submissionId: string; text: string },
+  null
+>("conversationMessages:completeTurn");
 const failTurnRef = makeFunctionReference<
   "mutation",
-  {
-    turnId: Id<"conversationTurns">;
-    attempt: number;
-    leaseOwner: string;
-    error: string;
-    retry: boolean;
-  },
-  boolean
+  { turnId: Id<"conversationTurns">; error: string; retry: boolean },
+  null
 >("conversationMessages:failTurn");
 
 export const generateUploadUrl = mutation({
@@ -62,16 +57,16 @@ export const generateUploadUrl = mutation({
 
 export const send = mutation({
   args: {
+    organizationId: v.id("organizations"),
     clientRequestId: v.string(),
+    rawText: v.string(),
     images: v.array(
       v.object({
+        storageId: v.id("_storage"),
         filename: v.optional(v.string()),
         mimeType: v.string(),
-        storageId: v.id("_storage"),
       })
     ),
-    organizationId: v.id("organizations"),
-    rawText: v.string(),
   },
   handler: async (ctx, args) => {
     await requireOrganizationMember(ctx, args.organizationId);
@@ -120,7 +115,6 @@ export const send = mutation({
       .first();
     const ordinal = (lastMessage?.ordinal ?? -1) + 1;
     const turnId = await ctx.db.insert("conversationTurns", {
-      attemptNumber: 1,
       clientRequestId: args.clientRequestId,
       conversationId: conversation._id,
       createdAt,
@@ -239,57 +233,59 @@ export const getTurn = internalQuery({
 });
 
 export const markProcessing = internalMutation({
-  args: {
-    attempt: v.number(),
-    leaseOwner: v.string(),
-    turnId: v.id("conversationTurns"),
-  },
+  args: { turnId: v.id("conversationTurns") },
   handler: async (ctx, args): Promise<boolean> => {
     const turn = await ctx.db.get(args.turnId);
-    if (
-      !turn ||
-      turn.status !== "queued" ||
-      (turn.attemptNumber ?? 1) !== args.attempt
-    ) {
+    if (!turn || turn.status === "completed") {
       return false;
     }
-    await ctx.db.patch(turn._id, {
-      error: undefined,
-      leaseExpiresAt: Date.now() + 60_000,
-      leaseOwner: args.leaseOwner,
-      status: "dispatching",
-    });
+    await ctx.db.patch(turn._id, { error: undefined, status: "processing" });
     return true;
   },
 });
 
+export const completeTurn = internalMutation({
+  args: {
+    turnId: v.id("conversationTurns"),
+    submissionId: v.string(),
+    text: v.string(),
+  },
+  handler: async (ctx, args): Promise<null> => {
+    const assistant = await ctx.db
+      .query("conversationMessages")
+      .withIndex("by_turnId_and_role", (q) =>
+        q.eq("turnId", args.turnId).eq("role", "assistant")
+      )
+      .unique();
+    if (assistant) {
+      await ctx.db.patch(assistant._id, { content: args.text });
+    }
+    await ctx.db.patch(args.turnId, {
+      completedAt: Date.now(),
+      error: undefined,
+      status: "completed",
+      submissionId: args.submissionId,
+    });
+    return null;
+  },
+});
+
 export const failTurn = internalMutation({
   args: {
-    attempt: v.number(),
-    error: v.string(),
-    leaseOwner: v.string(),
-    retry: v.boolean(),
     turnId: v.id("conversationTurns"),
+    error: v.string(),
+    retry: v.boolean(),
   },
-  handler: async (ctx, args): Promise<boolean> => {
+  handler: async (ctx, args): Promise<null> => {
     const turn = await ctx.db.get(args.turnId);
-    if (
-      !turn ||
-      turn.status !== "dispatching" ||
-      turn.leaseOwner !== args.leaseOwner ||
-      (turn.attemptNumber ?? 1) !== args.attempt
-    ) {
-      return false;
+    if (turn && turn.status !== "completed") {
+      await ctx.db.patch(turn._id, {
+        completedAt: args.retry ? undefined : Date.now(),
+        error: args.error,
+        status: args.retry ? "queued" : "failed",
+      });
     }
-    await ctx.db.patch(turn._id, {
-      attemptNumber: args.retry ? args.attempt + 1 : args.attempt,
-      completedAt: args.retry ? undefined : Date.now(),
-      error: args.error,
-      leaseExpiresAt: undefined,
-      leaseOwner: undefined,
-      status: args.retry ? "queued" : "failed",
-    });
-    return true;
+    return null;
   },
 });
 
@@ -302,17 +298,12 @@ const toBase64 = (buffer: ArrayBuffer): string => {
 };
 
 export const runTurn = internalAction({
-  args: { attempt: v.number(), turnId: v.id("conversationTurns") },
+  args: { turnId: v.id("conversationTurns"), attempt: v.number() },
   handler: async (ctx, args): Promise<null> => {
-    const leaseOwner = `conversation:${args.turnId}:${args.attempt}`;
     const turn = await ctx.runQuery(getTurnRef, { turnId: args.turnId });
     if (
       !turn ||
-      !(await ctx.runMutation(markProcessingRef, {
-        attempt: args.attempt,
-        leaseOwner,
-        turnId: args.turnId,
-      }))
+      !(await ctx.runMutation(markProcessingRef, { turnId: args.turnId }))
     ) {
       return null;
     }
@@ -340,6 +331,7 @@ export const runTurn = internalAction({
         `agents/zopu/${encodeURIComponent(String(turn.organizationId))}`,
         `${flueUrl.replace(/\/+$/u, "")}/`
       );
+      endpoint.searchParams.set("wait", "result");
       const response = await fetch(endpoint, {
         body: JSON.stringify({ images, message: turn.user.content }),
         headers: {
@@ -347,29 +339,37 @@ export const runTurn = internalAction({
           "content-type": "application/json",
           "x-zopu-organization-id": String(turn.organizationId),
           "x-zopu-request-id": turn.turn.clientRequestId,
-          "x-zopu-turn-id": String(args.turnId),
         },
         method: "POST",
       });
-      if (!response.ok) {
-        throw new Error(
-          `Flue admission failed (${response.status}): ${await response.text().catch(() => "")}`
-        );
-      }
-      const admitted = await ctx.runQuery(getTurnRef, { turnId: args.turnId });
-      if (admitted?.turn.submissionId === undefined) {
-        throw new Error("Flue admission did not bind the product turn");
+      const payload: unknown = await response.json().catch(() => null);
+      if (
+        !response.ok ||
+        typeof payload !== "object" ||
+        payload === null ||
+        !("submissionId" in payload) ||
+        typeof payload.submissionId !== "string" ||
+        !("result" in payload) ||
+        typeof payload.result !== "object" ||
+        payload.result === null ||
+        !("text" in payload.result) ||
+        typeof payload.result.text !== "string"
+      ) {
+        throw new Error(`Flue turn failed (${response.status})`);
       }
+      await ctx.runMutation(completeTurnRef, {
+        submissionId: payload.submissionId,
+        text: payload.result.text,
+        turnId: args.turnId,
+      });
     } catch (error) {
       const retry = args.attempt < MAX_ATTEMPTS;
-      const failed = await ctx.runMutation(failTurnRef, {
-        attempt: args.attempt,
+      await ctx.runMutation(failTurnRef, {
         error: error instanceof Error ? error.message : String(error),
-        leaseOwner,
         retry,
         turnId: args.turnId,
       });
-      if (failed && retry) {
+      if (retry) {
         await ctx.scheduler.runAfter(args.attempt * 1000, runTurnRef, {
           attempt: args.attempt + 1,
           turnId: args.turnId,
@@ -379,42 +379,3 @@ export const runTurn = internalAction({
     return null;
   },
 });
-
-export const reconcileExpiredTurns = internalMutation({
-  args: {},
-  handler: async (ctx): Promise<{ reconciled: number }> => {
-    const expired = await ctx.db
-      .query("conversationTurns")
-      .withIndex("by_status_and_leaseExpiresAt", (q) =>
-        q.eq("status", "dispatching").lt("leaseExpiresAt", Date.now())
-      )
-      .collect();
-    for (const turn of expired) {
-      if (turn.submissionId !== undefined) {
-        await ctx.db.patch(turn._id, {
-          leaseExpiresAt: undefined,
-          leaseOwner: undefined,
-          status: "running",
-        });
-        continue;
-      }
-      const attempt = turn.attemptNumber ?? 1;
-      const retry = attempt < MAX_ATTEMPTS;
-      await ctx.db.patch(turn._id, {
-        attemptNumber: retry ? attempt + 1 : attempt,
-        completedAt: retry ? undefined : Date.now(),
-        error: "Conversation worker lease expired",
-        leaseExpiresAt: undefined,
-        leaseOwner: undefined,
-        status: retry ? "queued" : "failed",
-      });
-      if (retry) {
-        await ctx.scheduler.runAfter(0, runTurnRef, {
-          attempt: attempt + 1,
-          turnId: turn._id,
-        });
-      }
-    }
-    return { reconciled: expired.length };
-  },
-});

packages/backend/convex/conversationProjections.ts

@@ -1,145 +0,0 @@
-import type { Id } from "./_generated/dataModel";
-import type { MutationCtx } from "./_generated/server";
-
-interface ProjectionContext {
-  readonly assistantMessageId: Id<"conversationMessages"> | null;
-  readonly turnId: Id<"conversationTurns"> | null;
-}
-
-const parseStringField = (record: unknown, key: string): string | undefined => {
-  if (typeof record !== "object" || record === null) {
-    return undefined;
-  }
-  const value = (record as Record<string, unknown>)[key];
-  return typeof value === "string" ? value : undefined;
-};
-
-const resolveContext = async (
-  ctx: MutationCtx,
-  submissionId: string | undefined
-): Promise<ProjectionContext> => {
-  if (submissionId === undefined) {
-    return { assistantMessageId: null, turnId: null };
-  }
-  const turn = await ctx.db
-    .query("conversationTurns")
-    .withIndex("by_submissionId", (q) => q.eq("submissionId", submissionId))
-    .unique();
-  if (turn === null) {
-    return { assistantMessageId: null, turnId: null };
-  }
-  const assistant = await ctx.db
-    .query("conversationMessages")
-    .withIndex("by_turnId_and_role", (q) =>
-      q.eq("turnId", turn._id).eq("role", "assistant")
-    )
-    .unique();
-  return {
-    assistantMessageId: assistant?._id ?? null,
-    turnId: turn._id,
-  };
-};
-
-const terminalError = (record: unknown): string => {
-  if (typeof record !== "object" || record === null) {
-    return "Flue submission failed";
-  }
-  const value = (record as Record<string, unknown>).error;
-  if (typeof value === "string") {
-    return value.slice(0, 2000);
-  }
-  if (typeof value === "object" && value !== null) {
-    const { message } = value as Record<string, unknown>;
-    if (typeof message === "string") {
-      return message.slice(0, 2000);
-    }
-  }
-  return "Flue submission failed";
-};
-
-/**
- * Project the small product view from Flue's canonical conversation stream.
- * The raw stream remains authoritative; this function only updates the existing
- * assistant message and turn row that the web already reads.
- */
-export const projectConversationRecords = async (
-  ctx: MutationCtx,
-  recordsJson: string,
-  submissionId: string | undefined
-): Promise<void> => {
-  let records: unknown[];
-  try {
-    const parsed = JSON.parse(recordsJson) as unknown;
-    if (!Array.isArray(parsed)) {
-      return;
-    }
-    records = parsed;
-  } catch {
-    return;
-  }
-
-  const projection = await resolveContext(ctx, submissionId);
-  if (projection.turnId === null) {
-    return;
-  }
-
-  for (const record of records) {
-    const type = parseStringField(record, "type");
-    if (type === "assistant_text_delta" && projection.assistantMessageId) {
-      const delta = parseStringField(record, "delta");
-      if (delta !== undefined) {
-        const assistant = await ctx.db.get(projection.assistantMessageId);
-        if (assistant !== null) {
-          await ctx.db.patch(assistant._id, {
-            content: `${assistant.content}${delta}`,
-          });
-        }
-      }
-      continue;
-    }
-
-    if (type !== "submission_settled") {
-      continue;
-    }
-
-    const turn = await ctx.db.get(projection.turnId);
-    if (
-      turn === null ||
-      turn.status === "completed" ||
-      turn.status === "failed" ||
-      turn.status === "aborted"
-    ) {
-      continue;
-    }
-
-    const outcome = parseStringField(record, "outcome");
-    if (outcome === "completed" && projection.assistantMessageId) {
-      const result =
-        typeof record === "object" && record !== null
-          ? (record as Record<string, unknown>).result
-          : undefined;
-      const text =
-        typeof result === "object" && result !== null
-          ? (result as Record<string, unknown>).text
-          : undefined;
-      if (typeof text === "string") {
-        await ctx.db.patch(projection.assistantMessageId, { content: text });
-      }
-    }
-
-    let status: "aborted" | "completed" | "failed" = "failed";
-    if (outcome === "completed") {
-      status = "completed";
-    } else if (outcome === "aborted") {
-      status = "aborted";
-    }
-
-    await ctx.db.patch(turn._id, {
-      completedAt: Date.now(),
-      error: outcome === "failed" ? terminalError(record) : undefined,
-      leaseExpiresAt: undefined,
-      leaseOwner: undefined,
-      status,
-    });
-  }
-};

packages/backend/convex/convex.config.ts

@@ -1,23 +1,17 @@
 import betterAuth from "@convex-dev/better-auth/convex.config";
-import workflow from "@convex-dev/workflow/convex.config.js";
 import { defineApp } from "convex/server";
 import { v } from "convex/values";
 
 const app = defineApp({
   env: {
-    AGENT_BACKEND_URL: v.optional(v.string()),
-    FLUE_DB_TOKEN: v.string(),
-    FLUE_URL: v.optional(v.string()),
-    GITEA_TOKEN: v.optional(v.string()),
-    GITEA_URL: v.optional(v.string()),
-    GITHUB_CLIENT_ID: v.optional(v.string()),
-    GITHUB_CLIENT_SECRET: v.optional(v.string()),
-    GIT_CREDENTIAL_ENCRYPTION_KEY: v.optional(v.string()),
     NATIVE_APP_URL: v.optional(v.string()),
     SITE_URL: v.string(),
+    FLUE_DB_TOKEN: v.string(),
+    FLUE_URL: v.optional(v.string()),
+    GITEA_URL: v.optional(v.string()),
+    GITEA_TOKEN: v.optional(v.string()),
   },
 });
 app.use(betterAuth);
-app.use(workflow);
 
 export default app;

packages/backend/convex/crons.ts

@@ -7,11 +7,6 @@ const reconcileRef = makeFunctionReference<
   Record<string, never>,
   { reconciled: number } | null
 >("workExecution:reconcileExpiredAttempts");
-const reconcileConversationTurnsRef = makeFunctionReference<
-  "mutation",
-  Record<string, never>,
-  { reconciled: number }
->("conversationMessages:reconcileExpiredTurns");
 
 const crons = cronJobs();
 
@@ -20,10 +15,5 @@ crons.interval(
   { seconds: 30 },
   reconcileRef
 );
-crons.interval(
-  "reconcile expired conversation turns",
-  { seconds: 30 },
-  reconcileConversationTurnsRef
-);
 
 export default crons;

packages/backend/convex/fluePersistence.test.ts

@@ -1,189 +0,0 @@
-import { env } from "@code/env/convex";
-import { convexTest } from "convex-test";
-import { anyApi } from "convex/server";
-import { describe, expect, test } from "vitest";
-
-import schema from "./schema";
-
-declare global {
-  interface ImportMeta {
-    readonly glob: (pattern: string) => Record<string, () => Promise<unknown>>;
-  }
-}
-
-const modules = import.meta.glob("./**/*.ts");
-const api = anyApi;
-const token = env.FLUE_DB_TOKEN;
-
-describe("Flue Convex persistence", () => {
-  test("admits idempotently and claims only the session head", async () => {
-    const t = convexTest({ modules, schema });
-    const firstInput = {
-      acceptedAt: 1,
-      inputJson: '{"message":"first"}',
-      kind: "dispatch" as const,
-      sessionKey: "agent/instance/default",
-      submissionId: "dispatch-1",
-    };
-    const first = await t.mutation(api.fluePersistence.admitSubmission, {
-      input: firstInput,
-      token,
-    });
-    const replay = await t.mutation(api.fluePersistence.admitSubmission, {
-      input: firstInput,
-      token,
-    });
-    expect(first.kind).toBe("submission");
-    expect(replay.kind).toBe("retained_receipt");
-
-    await t.mutation(api.fluePersistence.admitSubmission, {
-      input: {
-        ...firstInput,
-        acceptedAt: 2,
-        inputJson: '{"message":"second"}',
-        submissionId: "dispatch-2",
-      },
-      token,
-    });
-    await t.mutation(api.fluePersistence.markSubmissionCanonicalReady, {
-      submissionId: "dispatch-1",
-      token,
-    });
-    await t.mutation(api.fluePersistence.markSubmissionCanonicalReady, {
-      submissionId: "dispatch-2",
-      token,
-    });
-    const secondClaim = await t.mutation(api.fluePersistence.claimSubmission, {
-      attemptId: "attempt-2",
-      leaseExpiresAt: 100,
-      ownerId: "owner",
-      submissionId: "dispatch-2",
-      token,
-    });
-    expect(secondClaim).toBeNull();
-    const firstClaim = await t.mutation(api.fluePersistence.claimSubmission, {
-      attemptId: "attempt-1",
-      leaseExpiresAt: 100,
-      ownerId: "owner",
-      submissionId: "dispatch-1",
-      token,
-    });
-    expect(firstClaim).toMatchObject({
-      attemptId: "attempt-1",
-      status: "running",
-    });
-  });
-
-  test("binds a direct admission to the product turn atomically", async () => {
-    const t = convexTest({ modules, schema });
-    const organizationId = await t.run(async (ctx) =>
-      ctx.db.insert("organizations", {
-        createdAt: 1,
-        createdBy: "user-1",
-        kind: "personal",
-        name: "Test",
-      })
-    );
-    const conversationId = await t.run(async (ctx) =>
-      ctx.db.insert("conversations", { createdAt: 1, organizationId })
-    );
-    const turnId = await t.run(async (ctx) =>
-      ctx.db.insert("conversationTurns", {
-        attemptNumber: 1,
-        clientRequestId: "request-1",
-        conversationId,
-        createdAt: 1,
-        leaseExpiresAt: 100,
-        leaseOwner: "worker",
-        status: "dispatching",
-      })
-    );
-
-    await t.mutation(api.fluePersistence.admitSubmission, {
-      clientRequestId: "request-1",
-      input: {
-        acceptedAt: 1,
-        chunksJson: "[]",
-        inputJson: '{"kind":"direct"}',
-        kind: "direct",
-        sessionKey: "agent/instance/default",
-        submissionId: "submission-1",
-      },
-      token,
-      turnId,
-    });
-    const turn = await t.run((ctx) => ctx.db.get(turnId));
-    expect(turn).toMatchObject({
-      status: "running",
-      submissionId: "submission-1",
-    });
-    expect(turn).not.toHaveProperty("leaseExpiresAt");
-    expect(turn).not.toHaveProperty("leaseOwner");
-  });
-
-  test("fences stale conversation producers and conflicting attachments", async () => {
-    const t = convexTest({ modules, schema });
-    await t.mutation(api.fluePersistence.createConversationStream, {
-      identity: { agentName: "work-planner", instanceId: "org-1" },
-      path: "agents/work-planner/org-1",
-      token,
-    });
-    const first = await t.mutation(
-      api.fluePersistence.acquireConversationProducer,
-      {
-        path: "agents/work-planner/org-1",
-        producerId: "producer-1",
-        token,
-      }
-    );
-    await t.mutation(api.fluePersistence.acquireConversationProducer, {
-      path: "agents/work-planner/org-1",
-      producerId: "producer-2",
-      token,
-    });
-    await expect(
-      t.mutation(api.fluePersistence.appendConversationBatch, {
-        incarnation: first.incarnation,
-        path: "agents/work-planner/org-1",
-        producerEpoch: first.producerEpoch,
-        producerId: "producer-1",
-        producerSequence: 0,
-        recordsJson: '[{"id":"record-1","type":"message"}]',
-        token,
-      })
-    ).rejects.toThrow(/producer ownership is stale/u);
-
-    const attachment = {
-      digest: "digest",
-      id: "attachment-1",
-      mimeType: "text/plain",
-      size: 3,
-    };
-    const inserted = await t.mutation(api.fluePersistence.putAttachment, {
-      attachment,
-      bytes: new TextEncoder().encode("one").buffer,
-      conversationId: "conversation-1",
-      streamPath: "agents/work-planner/org-1",
-      token,
-    });
-    const replay = await t.mutation(api.fluePersistence.putAttachment, {
-      attachment,
-      bytes: new TextEncoder().encode("one").buffer,
-      conversationId: "conversation-1",
-      streamPath: "agents/work-planner/org-1",
-      token,
-    });
-    const conflict = await t.mutation(api.fluePersistence.putAttachment, {
-      attachment,
-      bytes: new TextEncoder().encode("two").buffer,
-      conversationId: "conversation-1",
-      streamPath: "agents/work-planner/org-1",
-      token,
-    });
-    expect([inserted, replay, conflict]).toEqual([
-      "inserted",
-      "existing",
-      "conflict",
-    ]);
-  });
-});

packages/backend/convex/gitConnectionData.ts

@@ -1,143 +0,0 @@
-import { ConvexError, v } from "convex/values";
-
-import { internalMutation, mutation, query } from "./_generated/server";
-import { requireCurrentOrganization, requireProjectMember } from "./authz";
-
-// Provider ("forge") that owns a repository host. A project's source must be
-// served by the same forge whose credentials are attached, so a Gitea token is
-// never offered to GitHub and vice versa. Unknown hosts return null, leaving
-// the caller free to attach without a forge constraint.
-export const forgeForHost = (host: string): "github" | "gitea" | null => {
-  const normalized = host.toLowerCase();
-  if (normalized === "github.com" || normalized.endsWith(".githost.com")) {
-    return "github";
-  }
-  if (normalized === "git.openputer.com") {
-    return "gitea";
-  }
-  return null;
-};
-
-export const persist = internalMutation({
-  args: {
-    credentialCiphertext: v.string(),
-    credentialIv: v.string(),
-    credentialKind: v.union(v.literal("oauth"), v.literal("token")),
-    provider: v.union(v.literal("github"), v.literal("gitea")),
-    serverUrl: v.string(),
-    userId: v.string(),
-    username: v.optional(v.string()),
-  },
-  handler: async (ctx, args) => {
-    const organization = await ctx.db
-      .query("organizations")
-      .withIndex("by_createdBy_and_kind", (q) =>
-        q.eq("createdBy", args.userId).eq("kind", "personal")
-      )
-      .unique();
-    if (!organization) {
-      throw new ConvexError("Organization not found");
-    }
-    const existing = await ctx.db
-      .query("gitConnections")
-      .withIndex("by_organizationId_and_provider_and_serverUrl", (q) =>
-        q
-          .eq("organizationId", organization._id)
-          .eq("provider", args.provider)
-          .eq("serverUrl", args.serverUrl)
-      )
-      .unique();
-    const timestamp = Date.now();
-    if (existing) {
-      await ctx.db.patch(existing._id, {
-        credentialCiphertext: args.credentialCiphertext,
-        credentialIv: args.credentialIv,
-        credentialKind: args.credentialKind,
-        updatedAt: timestamp,
-        username: args.username,
-      });
-      return existing._id;
-    }
-    return await ctx.db.insert("gitConnections", {
-      connectedAt: timestamp,
-      credentialCiphertext: args.credentialCiphertext,
-      credentialIv: args.credentialIv,
-      credentialKind: args.credentialKind,
-      organizationId: organization._id,
-      provider: args.provider,
-      serverUrl: args.serverUrl,
-      updatedAt: timestamp,
-      username: args.username,
-    });
-  },
-});
-
-export const list = query({
-  args: {},
-  handler: async (ctx) => {
-    const { organizationId } = await requireCurrentOrganization(ctx);
-    const connections = await ctx.db
-      .query("gitConnections")
-      .withIndex("by_organizationId", (q) =>
-        q.eq("organizationId", organizationId)
-      )
-      .collect();
-    return connections.map((connection) => ({
-      connectedAt: connection.connectedAt,
-      credentialKind: connection.credentialKind,
-      id: String(connection._id),
-      provider: connection.provider,
-      serverUrl: connection.serverUrl,
-      username: connection.username,
-    }));
-  },
-});
-
-export const getForProject = query({
-  args: { projectId: v.id("projects") },
-  handler: async (ctx, args) => {
-    await requireProjectMember(ctx, args.projectId);
-    const project = await ctx.db.get(args.projectId);
-    const connection = project?.gitConnectionId
-      ? await ctx.db.get(project.gitConnectionId)
-      : null;
-    return connection
-      ? {
-          connectedAt: connection.connectedAt,
-          credentialKind: connection.credentialKind,
-          id: String(connection._id),
-          provider: connection.provider,
-          serverUrl: connection.serverUrl,
-          username: connection.username,
-        }
-      : null;
-  },
-});
-
-export const attachToProject = mutation({
-  args: {
-    connectionId: v.id("gitConnections"),
-    projectId: v.id("projects"),
-  },
-  handler: async (ctx, args) => {
-    const { organizationId } = await requireProjectMember(ctx, args.projectId);
-    const connection = await ctx.db.get(args.connectionId);
-    if (!connection || connection.organizationId !== organizationId) {
-      throw new ConvexError("Git connection not found");
-    }
-    const project = await ctx.db.get(args.projectId);
-    if (project) {
-      const expected = forgeForHost(project.sourceHost);
-      if (expected && connection.provider !== expected) {
-        throw new ConvexError(
-          `Git credential provider (${connection.provider}) does not match this project's forge (${expected})`
-        );
-      }
-    }
-    await ctx.db.patch(args.projectId, {
-      gitConnectionId: connection._id,
-      updatedAt: Date.now(),
-    });
-    return { attached: true };
-  },
-});

packages/backend/convex/gitConnections.ts

@@ -1,124 +0,0 @@
-"use node";
-
-import { env } from "@code/env/convex";
-import { decodeGitConnectionInput } from "@code/primitives/execution-runtime";
-import { ConvexError, v } from "convex/values";
-import { Effect } from "effect";
-
-import { internal } from "./_generated/api";
-import type { Id } from "./_generated/dataModel";
-import { action } from "./_generated/server";
-import { authComponent, createAuth } from "./auth";
-
-const encryptionKey = async (): Promise<CryptoKey> => {
-  if (!env.GIT_CREDENTIAL_ENCRYPTION_KEY) {
-    throw new ConvexError("Git credential encryption is not configured");
-  }
-  const bytes = Buffer.from(env.GIT_CREDENTIAL_ENCRYPTION_KEY, "base64url");
-  if (bytes.byteLength !== 32) {
-    throw new ConvexError("Git credential encryption key must be 32 bytes");
-  }
-  return await crypto.subtle.importKey("raw", bytes, "AES-GCM", false, [
-    "encrypt",
-    "decrypt",
-  ]);
-};
-
-const encryptCredential = async (credential: string) => {
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const encrypted = await crypto.subtle.encrypt(
-    { iv, name: "AES-GCM" },
-    await encryptionKey(),
-    new TextEncoder().encode(credential)
-  );
-  return {
-    credentialCiphertext: Buffer.from(encrypted).toString("base64url"),
-    credentialIv: Buffer.from(iv).toString("base64url"),
-  };
-};
-
-export const decryptCredential = async (
-  credentialCiphertext: string,
-  credentialIv: string
-): Promise<string> => {
-  const decrypted = await crypto.subtle.decrypt(
-    {
-      iv: Buffer.from(credentialIv, "base64url"),
-      name: "AES-GCM",
-    },
-    await encryptionKey(),
-    Buffer.from(credentialCiphertext, "base64url")
-  );
-  return new TextDecoder().decode(decrypted);
-};
-
-export const connectGitea = action({
-  args: {
-    serverUrl: v.string(),
-    token: v.string(),
-    username: v.optional(v.string()),
-  },
-  handler: async (
-    ctx,
-    args
-  ): Promise<{ connectionId: Id<"gitConnections"> }> => {
-    const userId = await ctx.auth.getUserIdentity().then((identity) => {
-      if (!identity) {
-        throw new ConvexError("Authentication required");
-      }
-      return identity.tokenIdentifier;
-    });
-    const connection = await Effect.runPromise(
-      decodeGitConnectionInput({
-        credential: args.token,
-        credentialKind: "token",
-        provider: "gitea",
-        serverUrl: args.serverUrl,
-        username: args.username,
-      })
-    );
-    const encrypted = await encryptCredential(connection.credential);
-    const connectionId = await ctx.runMutation(
-      internal.gitConnectionData.persist,
-      {
-        ...encrypted,
-        credentialKind: connection.credentialKind,
-        provider: connection.provider,
-        serverUrl: connection.serverUrl,
-        userId,
-        username: connection.username,
-      }
-    );
-    return { connectionId };
-  },
-});
-
-export const connectGithub = action({
-  args: {},
-  handler: async (ctx): Promise<{ connectionId: Id<"gitConnections"> }> => {
-    const identity = await ctx.auth.getUserIdentity();
-    if (!identity) {
-      throw new ConvexError("Authentication required");
-    }
-    const { auth, headers } = await authComponent.getAuth(createAuth, ctx);
-    const token = await auth.api.getAccessToken({
-      body: { providerId: "github" },
-      headers,
-    });
-    if (!token.accessToken) {
-      throw new ConvexError("GitHub account is not connected");
-    }
-    const encrypted = await encryptCredential(token.accessToken);
-    const connectionId = await ctx.runMutation(
-      internal.gitConnectionData.persist,
-      {
-        ...encrypted,
-        credentialKind: "oauth",
-        provider: "github",
-        serverUrl: "https://github.com",
-        userId: identity.tokenIdentifier,
-      }
-    );
-    return { connectionId };
-  },
-});

packages/backend/convex/healthCheck.ts

@@ -1,7 +1,7 @@
 import { query } from "./_generated/server";
 
 export const get = query({
-  handler: () => 
-    "OK"
-  ,
+  handler: async () => {
+    return "OK";
+  },
 });

packages/backend/convex/organizations.test.ts

@@ -23,7 +23,7 @@ const ID_B = "https://convex.test|user-b";
 const identityA = { tokenIdentifier: ID_A };
 const identityB = { tokenIdentifier: ID_B };
 
-const newTest = () => convexTest({ modules, schema });
+const newTest = () => convexTest({ schema, modules });
 
 describe("organizations", () => {
   test("first ensure creates one organization and owner membership", async () => {

packages/backend/convex/projects.ts

@@ -1,10 +1,8 @@
 import {
   decodePublicGitImportResult,
   preparePublicGitSource,
-} from "@code/primitives/project";
-import type {
-  ProjectImportOutcome,
-  ProjectView,
+  type ProjectImportOutcome,
+  type ProjectView,
 } from "@code/primitives/project";
 import { ConvexError, v } from "convex/values";
 import { Effect } from "effect";
@@ -56,11 +54,18 @@ const toProjectView = async (
 
 export const persistPublicGitImport = internalMutation({
   args: {
+    userId: v.string(),
+    source: v.object({
+      host: v.string(),
+      projectName: v.string(),
+      repositoryPath: v.string(),
+      normalizedUrl: v.string(),
+      url: v.string(),
+    }),
     remote: v.object({
       defaultBranch: v.optional(v.string()),
       documents: v.array(
         v.object({
-          content: v.string(),
           kind: v.union(
             v.literal("readme"),
             v.literal("agents"),
@@ -70,18 +75,11 @@ export const persistPublicGitImport = internalMutation({
             v.literal("tech")
           ),
           path: v.string(),
+          content: v.string(),
         })
       ),
-      warnings: v.array(v.object({ message: v.string(), path: v.string() })),
+      warnings: v.array(v.object({ path: v.string(), message: v.string() })),
     }),
-    source: v.object({
-      host: v.string(),
-      normalizedUrl: v.string(),
-      projectName: v.string(),
-      repositoryPath: v.string(),
-      url: v.string(),
-    }),
-    userId: v.string(),
   },
   handler: async (ctx, args): Promise<ProjectImportOutcome> => {
     const organization = await ctx.db
@@ -108,9 +106,9 @@ export const persistPublicGitImport = internalMutation({
       await ctx.db.patch(projectId, {
         defaultBranch: args.remote.defaultBranch,
         name: args.source.projectName,
-        repositoryPath: args.source.repositoryPath,
         sourceHost: args.source.host,
         sourceUrl: args.source.url,
+        repositoryPath: args.source.repositoryPath,
         updatedAt: timestamp,
       });
       const oldDocuments = await ctx.db

packages/backend/convex/publicGit.ts

@@ -1,5 +1,11 @@
-import { CONTEXT_KINDS, contextPathForKind, MAX_CONTEXT_DOCUMENT_CHARACTERS } from '@code/primitives/project';
-import type { PreparedPublicGitSource, PublicGitImportResult, RepositoryContextDocument } from '@code/primitives/project';
+import {
+  CONTEXT_KINDS,
+  contextPathForKind,
+  MAX_CONTEXT_DOCUMENT_CHARACTERS,
+  type PreparedPublicGitSource,
+  type PublicGitImportResult,
+  type RepositoryContextDocument,
+} from "@code/primitives/project";
 
 const GITHUB_HOST = "github.com";
 const GITEA_HOST = "git.openputer.com";

packages/backend/convex/schema.ts

@@ -1,77 +1,32 @@
 import { defineSchema, defineTable } from "convex/server";
 import { v } from "convex/values";
 
-/* eslint-disable sort-keys */
-
-const attemptClassification = v.union(
-  v.literal("Succeeded"),
-  v.literal("RetryableFailure"),
-  v.literal("NeedsInput"),
-  v.literal("Blocked"),
-  v.literal("VerificationFailed"),
-  v.literal("BudgetExhausted"),
-  v.literal("Cancelled"),
-  v.literal("PermanentFailure")
-);
-const workStatus = v.union(
-  v.literal("proposed"),
-  v.literal("defining"),
-  v.literal("awaiting-definition-approval"),
-  v.literal("designing"),
-  v.literal("awaiting-design-approval"),
-  v.literal("ready"),
-  v.literal("executing"),
-  v.literal("needs-input"),
-  v.literal("blocked"),
-  v.literal("completed"),
-  v.literal("failed"),
-  v.literal("cancelled")
-);
-
 export default defineSchema({
   organizations: defineTable({
-    createdAt: v.number(),
-    createdBy: v.string(),
-    kind: v.union(v.literal("personal"), v.literal("team")),
     name: v.string(),
+    kind: v.union(v.literal("personal"), v.literal("team")),
+    createdBy: v.string(),
+    createdAt: v.number(),
   }).index("by_createdBy_and_kind", ["createdBy", "kind"]),
   organizationMembers: defineTable({
-    createdAt: v.number(),
     organizationId: v.id("organizations"),
-    role: v.union(v.literal("owner"), v.literal("member")),
     userId: v.string(),
+    role: v.union(v.literal("owner"), v.literal("member")),
+    createdAt: v.number(),
   })
     .index("by_userId", ["userId"])
     .index("by_organizationId", ["organizationId"])
     .index("by_organizationId_and_userId", ["organizationId", "userId"]),
-  gitConnections: defineTable({
-    connectedAt: v.number(),
-    credentialCiphertext: v.string(),
-    credentialIv: v.string(),
-    credentialKind: v.union(v.literal("oauth"), v.literal("token")),
-    organizationId: v.id("organizations"),
-    provider: v.union(v.literal("github"), v.literal("gitea")),
-    serverUrl: v.string(),
-    updatedAt: v.number(),
-    username: v.optional(v.string()),
-  })
-    .index("by_organizationId", ["organizationId"])
-    .index("by_organizationId_and_provider_and_serverUrl", [
-      "organizationId",
-      "provider",
-      "serverUrl",
-    ]),
   projects: defineTable({
-    createdAt: v.number(),
-    defaultBranch: v.optional(v.string()),
-    description: v.optional(v.string()),
-    gitConnectionId: v.optional(v.id("gitConnections")),
-    name: v.string(),
-    normalizedSourceUrl: v.string(),
     organizationId: v.id("organizations"),
-    repositoryPath: v.string(),
-    sourceHost: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
     sourceUrl: v.string(),
+    normalizedSourceUrl: v.string(),
+    sourceHost: v.string(),
+    repositoryPath: v.string(),
+    defaultBranch: v.optional(v.string()),
+    createdAt: v.number(),
     updatedAt: v.number(),
   })
     .index("by_organizationId_and_createdAt", ["organizationId", "createdAt"])
@@ -80,8 +35,7 @@ export default defineSchema({
       "normalizedSourceUrl",
     ]),
   projectContextDocuments: defineTable({
-    content: v.string(),
-    createdAt: v.number(),
+    projectId: v.id("projects"),
     kind: v.union(
       v.literal("readme"),
       v.literal("agents"),
@@ -90,115 +44,121 @@ export default defineSchema({
       v.literal("design"),
       v.literal("tech")
     ),
-    origin: v.literal("repository"),
     path: v.string(),
-    projectId: v.id("projects"),
+    content: v.string(),
+    origin: v.literal("repository"),
     sourceUrl: v.string(),
+    createdAt: v.number(),
     updatedAt: v.number(),
   }).index("by_projectId_and_path", ["projectId", "path"]),
   conversations: defineTable({
-    createdAt: v.number(),
     organizationId: v.id("organizations"),
+    createdAt: v.number(),
   }).index("by_organizationId", ["organizationId"]),
   conversationTurns: defineTable({
-    attemptNumber: v.optional(v.number()),
-    clientRequestId: v.string(),
-    completedAt: v.optional(v.number()),
     conversationId: v.id("conversations"),
-    createdAt: v.number(),
-    error: v.optional(v.string()),
-    leaseExpiresAt: v.optional(v.number()),
-    leaseOwner: v.optional(v.string()),
+    clientRequestId: v.string(),
     status: v.union(
       v.literal("queued"),
-      v.literal("dispatching"),
-      v.literal("running"),
+      v.literal("processing"),
       v.literal("completed"),
-      v.literal("failed"),
-      v.literal("aborted")
+      v.literal("failed")
     ),
     submissionId: v.optional(v.string()),
-  })
-    .index("by_conversationId_and_clientRequestId", [
-      "conversationId",
-      "clientRequestId",
-    ])
-    .index("by_status_and_leaseExpiresAt", ["status", "leaseExpiresAt"])
-    .index("by_submissionId", ["submissionId"]),
-  conversationMessages: defineTable({
-    content: v.string(),
-    conversationId: v.id("conversations"),
+    error: v.optional(v.string()),
     createdAt: v.number(),
-    ordinal: v.number(),
-    role: v.union(v.literal("user"), v.literal("assistant")),
+    completedAt: v.optional(v.number()),
+  }).index("by_conversationId_and_clientRequestId", [
+    "conversationId",
+    "clientRequestId",
+  ]),
+  conversationMessages: defineTable({
+    conversationId: v.id("conversations"),
     turnId: v.id("conversationTurns"),
+    role: v.union(v.literal("user"), v.literal("assistant")),
+    content: v.string(),
+    ordinal: v.number(),
+    createdAt: v.number(),
   })
     .index("by_conversationId_and_ordinal", ["conversationId", "ordinal"])
     .index("by_turnId_and_role", ["turnId", "role"]),
   conversationAttachments: defineTable({
-    createdAt: v.number(),
-    filename: v.optional(v.string()),
     messageId: v.id("conversationMessages"),
-    mimeType: v.string(),
     storageId: v.id("_storage"),
+    filename: v.optional(v.string()),
+    mimeType: v.string(),
+    createdAt: v.number(),
   }).index("by_messageId", ["messageId"]),
   signals: defineTable({
-    conversationId: v.id("conversations"),
-    createdAt: v.number(),
-    desiredOutcome: v.string(),
     organizationId: v.id("organizations"),
-    processedByAgentInstanceId: v.string(),
-    processedByAgentName: v.string(),
     projectId: v.id("projects"),
+    conversationId: v.id("conversations"),
     sourceKey: v.string(),
-    summary: v.string(),
     title: v.string(),
+    summary: v.string(),
+    desiredOutcome: v.string(),
+    processedByAgentName: v.string(),
+    processedByAgentInstanceId: v.string(),
+    createdAt: v.number(),
   })
     .index("by_organization_and_createdAt", ["organizationId", "createdAt"])
     .index("by_organization_and_sourceKey", ["organizationId", "sourceKey"])
     .index("by_project_and_createdAt", ["projectId", "createdAt"]),
   signalConstraints: defineTable({
-    ordinal: v.number(),
     signalId: v.id("signals"),
+    ordinal: v.number(),
     value: v.string(),
   }).index("by_signalId_and_ordinal", ["signalId", "ordinal"]),
   signalSources: defineTable({
+    signalId: v.id("signals"),
     messageId: v.id("conversationMessages"),
     ordinal: v.number(),
     rawTextSnapshot: v.string(),
-    signalId: v.id("signals"),
     sourceCreatedAt: v.number(),
   })
     .index("by_signalId_and_ordinal", ["signalId", "ordinal"])
     .index("by_messageId", ["messageId"]),
   works: defineTable({
-    createdAt: v.number(),
-    definitionApprovalVersion: v.optional(v.number()),
-    definitionVersion: v.optional(v.number()),
-    designApprovalVersion: v.optional(v.number()),
-    designVersion: v.optional(v.number()),
-    objective: v.string(),
     organizationId: v.id("organizations"),
     projectId: v.id("projects"),
-    status: workStatus,
     title: v.string(),
+    objective: v.string(),
+    status: v.union(
+      v.literal("proposed"),
+      v.literal("defining"),
+      v.literal("awaiting-definition-approval"),
+      v.literal("designing"),
+      v.literal("awaiting-design-approval"),
+      v.literal("ready"),
+      v.literal("executing"),
+      v.literal("needs-input"),
+      v.literal("blocked"),
+      v.literal("completed"),
+      v.literal("failed"),
+      v.literal("cancelled")
+    ),
+    definitionVersion: v.optional(v.number()),
+    definitionApprovalVersion: v.optional(v.number()),
+    designVersion: v.optional(v.number()),
+    designApprovalVersion: v.optional(v.number()),
+    createdAt: v.number(),
     updatedAt: v.number(),
   })
     .index("by_project_and_createdAt", ["projectId", "createdAt"])
     .index("by_organization_and_createdAt", ["organizationId", "createdAt"]),
 
   signalWorkAttachments: defineTable({
-    createdAt: v.number(),
     signalId: v.id("signals"),
     workId: v.id("works"),
+    createdAt: v.number(),
   })
     .index("by_signal", ["signalId"])
     .index("by_work", ["workId"])
     .index("by_signal_and_work", ["signalId", "workId"]),
 
   workEvents: defineTable({
-    createdAt: v.number(),
-    idempotencyKey: v.string(),
+    workId: v.id("works"),
+    signalId: v.optional(v.id("signals")),
     kind: v.union(
       v.literal("work.proposed"),
       v.literal("signal.attached"),
@@ -207,7 +167,6 @@ export default defineSchema({
       v.literal("definition.revised"),
       v.literal("definition.approved"),
       v.literal("definition.invalidated"),
-      v.literal("question.created"),
       v.literal("question.answered"),
       v.literal("question.withdrawn"),
       v.literal("design.requested"),
@@ -215,33 +174,24 @@ export default defineSchema({
       v.literal("design.revised"),
       v.literal("design.approved"),
       v.literal("design.invalidated"),
-      v.literal("planner.failed"),
-      v.literal("slice.started"),
-      v.literal("slice.completed"),
-      v.literal("slice.ready"),
       v.literal("run.started"),
-      v.literal("run.completed"),
       v.literal("run.cancelled"),
       v.literal("attempt.claimed"),
       v.literal("attempt.event"),
       v.literal("attempt.completed"),
-      v.literal("attempt.reconciled"),
-      v.literal("resolver.decided"),
-      v.literal("artifact.recorded"),
-      v.literal("delivery.recorded"),
-      v.literal("delivery.updated")
+      v.literal("attempt.reconciled")
     ),
-    payloadJson: v.optional(v.string()),
     referenceId: v.optional(v.string()),
-    signalId: v.optional(v.id("signals")),
-    workId: v.id("works"),
+    payloadJson: v.optional(v.string()),
+    idempotencyKey: v.string(),
+    createdAt: v.number(),
   })
     .index("by_work_and_createdAt", ["workId", "createdAt"])
     .index("by_work_and_idempotencyKey", ["workId", "idempotencyKey"]),
 
   workDefinitions: defineTable({
-    createdAt: v.number(),
-    createdBy: v.string(),
+    workId: v.id("works"),
+    version: v.number(),
     payloadJson: v.string(),
     risk: v.union(v.literal("low"), v.literal("medium"), v.literal("high")),
     status: v.union(
@@ -249,55 +199,42 @@ export default defineSchema({
       v.literal("current"),
       v.literal("superseded")
     ),
-    version: v.number(),
-    workId: v.id("works"),
+    createdBy: v.string(),
+    createdAt: v.number(),
   })
     .index("by_work_and_version", ["workId", "version"])
     .index("by_work_and_status", ["workId", "status"]),
 
   workQuestions: defineTable({
-    alternativesJson: v.string(),
-    answer: v.optional(v.string()),
-    createdAt: v.number(),
+    workId: v.id("works"),
     definitionVersion: v.number(),
-    impact: v.union(v.literal("low"), v.literal("medium"), v.literal("high")),
-    prompt: v.string(),
     questionId: v.string(),
+    prompt: v.string(),
+    impact: v.union(v.literal("low"), v.literal("medium"), v.literal("high")),
     recommendation: v.optional(v.string()),
+    alternativesJson: v.string(),
     status: v.union(
       v.literal("open"),
       v.literal("answered"),
       v.literal("withdrawn")
     ),
-    workId: v.id("works"),
-  })
-    .index("by_workId_and_definitionVersion", ["workId", "definitionVersion"])
-    .index("by_workId_and_definitionVersion_and_questionId", [
-      "workId",
-      "definitionVersion",
-      "questionId",
-    ]),
+    answer: v.optional(v.string()),
+    createdAt: v.number(),
+  }).index("by_work_and_definitionVersion", ["workId", "definitionVersion"]),
 
   workApprovals: defineTable({
-    approvedAt: v.number(),
-    approvedBy: v.string(),
+    workId: v.id("works"),
+    kind: v.union(v.literal("definition"), v.literal("design")),
     definitionVersion: v.number(),
     designVersion: v.optional(v.number()),
-    kind: v.union(v.literal("definition"), v.literal("design")),
+    approvedBy: v.string(),
+    approvedAt: v.number(),
     status: v.union(v.literal("active"), v.literal("invalidated")),
-    workId: v.id("works"),
-  })
-    .index("by_workId_and_kind", ["workId", "kind"])
-    .index("by_workId_and_kind_and_definitionVersion_and_designVersion", [
-      "workId",
-      "kind",
-      "definitionVersion",
-      "designVersion",
-    ]),
+  }).index("by_work_and_kind", ["workId", "kind"]),
 
   designPackets: defineTable({
-    createdAt: v.number(),
-    createdBy: v.string(),
+    workId: v.id("works"),
+    version: v.number(),
     definitionVersion: v.number(),
     payloadJson: v.string(),
     status: v.union(
@@ -305,18 +242,19 @@ export default defineSchema({
       v.literal("current"),
       v.literal("superseded")
     ),
-    version: v.number(),
-    workId: v.id("works"),
+    createdBy: v.string(),
+    createdAt: v.number(),
   }).index("by_work_and_version", ["workId", "version"]),
 
   workSlices: defineTable({
-    createdAt: v.optional(v.number()),
+    workId: v.id("works"),
     designVersion: v.number(),
+    sliceId: v.string(),
+    ordinal: v.number(),
+    title: v.string(),
     objective: v.string(),
     observableBehavior: v.string(),
-    ordinal: v.number(),
     payloadJson: v.string(),
-    sliceId: v.string(),
     status: v.union(
       v.literal("planned"),
       v.literal("ready"),
@@ -324,27 +262,16 @@ export default defineSchema({
       v.literal("completed"),
       v.literal("blocked")
     ),
-    title: v.string(),
-    workId: v.id("works"),
-  })
-    .index("by_workId_and_designVersion", ["workId", "designVersion"])
-    .index("by_workId_and_designVersion_and_sliceId", [
-      "workId",
-      "designVersion",
-      "sliceId",
-    ]),
+  }).index("by_work_and_designVersion", ["workId", "designVersion"]),
 
   workRuns: defineTable({
-    baseRevision: v.optional(v.string()),
-    candidateRevision: v.optional(v.string()),
-    createdAt: v.number(),
-    designVersion: v.optional(v.number()),
-    endedAt: v.optional(v.number()),
-    kitId: v.string(),
-    kitVersion: v.string(),
-    environmentId: v.optional(v.string()),
-    executionKind: v.optional(
-      v.union(v.literal("simulated"), v.literal("real"))
+    workId: v.id("works"),
+    sliceId: v.optional(v.string()),
+    status: v.union(
+      v.literal("ready"),
+      v.literal("running"),
+      v.literal("terminal"),
+      v.literal("cancelled")
     ),
     scenario: v.union(
       v.literal("success"),
@@ -353,153 +280,42 @@ export default defineSchema({
       v.literal("permanent-failure"),
       v.literal("cancelled")
     ),
-    sliceId: v.optional(v.string()),
-    sliceRowId: v.optional(v.id("workSlices")),
+    kitId: v.string(),
+    kitVersion: v.string(),
+    createdAt: v.number(),
     startedAt: v.optional(v.number()),
-    status: v.union(
-      v.literal("ready"),
-      v.literal("running"),
-      v.literal("terminal"),
-      v.literal("cancelled")
-    ),
-    terminalClassification: v.optional(attemptClassification),
+    endedAt: v.optional(v.number()),
+    terminalClassification: v.optional(v.string()),
     terminalSummary: v.optional(v.string()),
-    workflowId: v.optional(v.string()),
-    workId: v.id("works"),
   }).index("by_work_and_createdAt", ["workId", "createdAt"]),
 
   workAttempts: defineTable({
-    classification: v.optional(attemptClassification),
-    failureReason: v.optional(
-      v.union(
-        v.literal("Authentication"),
-        v.literal("Cancelled"),
-        v.literal("HarnessFailed"),
-        v.literal("InvalidInput"),
-        v.literal("ProviderUnavailable"),
-        v.literal("RepositoryFailed"),
-        v.literal("Timeout")
-      )
-    ),
-    endedAt: v.optional(v.number()),
-    leaseExpiresAt: v.optional(v.number()),
-    leaseOwner: v.optional(v.string()),
-    number: v.number(),
     runId: v.id("workRuns"),
-    startedAt: v.optional(v.number()),
+    workId: v.id("works"),
+    number: v.number(),
     status: v.union(
       v.literal("queued"),
       v.literal("claimed"),
       v.literal("running"),
       v.literal("terminal")
     ),
+    leaseOwner: v.optional(v.string()),
+    leaseExpiresAt: v.optional(v.number()),
+    startedAt: v.optional(v.number()),
+    endedAt: v.optional(v.number()),
+    classification: v.optional(v.string()),
     summary: v.optional(v.string()),
-    workId: v.id("works"),
-    workspaceKey: v.optional(v.string()),
-  })
-    .index("by_runId_and_number", ["runId", "number"])
-    .index("by_status_and_leaseExpiresAt", ["status", "leaseExpiresAt"]),
+  }).index("by_run_and_number", ["runId", "number"]),
 
   workAttemptEvents: defineTable({
     attemptId: v.id("workAttempts"),
+    sequence: v.number(),
     kind: v.string(),
     message: v.string(),
     metadataJson: v.string(),
     occurredAt: v.number(),
-    sequence: v.number(),
   }).index("by_attempt_and_sequence", ["attemptId", "sequence"]),
 
-  resolverDecisions: defineTable({
-    attemptId: v.id("workAttempts"),
-    attemptNumber: v.number(),
-    classification: attemptClassification,
-    createdAt: v.number(),
-    decision: v.union(v.literal("retry"), v.literal("terminal")),
-    resultingWorkStatus: v.optional(workStatus),
-    runId: v.id("workRuns"),
-    summary: v.string(),
-    workId: v.id("works"),
-  })
-    .index("by_runId_and_attemptNumber", ["runId", "attemptNumber"])
-    .index("by_attemptId", ["attemptId"]),
-
-  workArtifacts: defineTable({
-    attemptId: v.optional(v.id("workAttempts")),
-    contentHash: v.optional(v.string()),
-    createdAt: v.number(),
-    designVersion: v.optional(v.number()),
-    environmentId: v.optional(v.string()),
-    idempotencyKey: v.string(),
-    kind: v.union(
-      v.literal("definition"),
-      v.literal("design"),
-      v.literal("diff"),
-      v.literal("test-report"),
-      v.literal("verification-report"),
-      v.literal("runtime-log"),
-      v.literal("screenshot"),
-      v.literal("video"),
-      v.literal("commit"),
-      v.literal("branch"),
-      v.literal("pull-request"),
-      v.literal("preview"),
-      v.literal("deployment"),
-      v.literal("other")
-    ),
-    metadataJson: v.string(),
-    organizationId: v.id("organizations"),
-    producer: v.string(),
-    projectId: v.id("projects"),
-    provenanceJson: v.string(),
-    runId: v.optional(v.id("workRuns")),
-    sliceId: v.optional(v.string()),
-    sourceRevision: v.optional(v.string()),
-    title: v.string(),
-    uri: v.optional(v.string()),
-    verificationStatus: v.union(
-      v.literal("unverified"),
-      v.literal("verified"),
-      v.literal("rejected")
-    ),
-    workId: v.id("works"),
-  })
-    .index("by_workId_and_createdAt", ["workId", "createdAt"])
-    .index("by_workId_and_idempotencyKey", ["workId", "idempotencyKey"])
-    .index("by_runId_and_createdAt", ["runId", "createdAt"]),
-
-  workDeliveries: defineTable({
-    artifactId: v.optional(v.id("workArtifacts")),
-    createdAt: v.number(),
-    externalId: v.string(),
-    idempotencyKey: v.string(),
-    kind: v.union(
-      v.literal("branch"),
-      v.literal("commit"),
-      v.literal("pull-request"),
-      v.literal("preview"),
-      v.literal("deployment")
-    ),
-    metadataJson: v.string(),
-    organizationId: v.id("organizations"),
-    projectId: v.id("projects"),
-    provider: v.string(),
-    sourceRevision: v.string(),
-    status: v.union(
-      v.literal("recorded"),
-      v.literal("ready"),
-      v.literal("approved"),
-      v.literal("delivered"),
-      v.literal("failed"),
-      v.literal("cancelled")
-    ),
-    target: v.string(),
-    updatedAt: v.number(),
-    url: v.optional(v.string()),
-    workId: v.id("works"),
-  })
-    .index("by_workId_and_createdAt", ["workId", "createdAt"])
-    .index("by_workId_and_idempotencyKey", ["workId", "idempotencyKey"]),
-
   // -----------------------------------------------------------------
   // Flue persistence stores (schema/format version 4).
   // -----------------------------------------------------------------
@@ -566,38 +382,38 @@ export default defineSchema({
   // Durable evidence that a submission attempt started and has not yet
   // settled. Append-once by (submissionId, attemptId).
   flueAttemptMarkers: defineTable({
+    submissionId: v.string(),
     attemptId: v.string(),
     createdAt: v.number(),
-    submissionId: v.string(),
   })
     .index("by_submissionId_and_attemptId", ["submissionId", "attemptId"])
     .index("by_submissionId", ["submissionId"]),
 
   // Conversation-stream metadata: one row per stream path.
   flueConversationStreams: defineTable({
-    closed: v.boolean(),
-    createdAt: v.number(),
+    path: v.string(),
     identityJson: v.string(),
     incarnation: v.string(),
-    nextOffset: v.number(),
-    nextProducerSequence: v.number(),
-    path: v.string(),
-    producerEpoch: v.number(),
     producerId: v.optional(v.string()),
+    producerEpoch: v.number(),
+    nextProducerSequence: v.number(),
+    nextOffset: v.number(),
+    closed: v.boolean(),
+    createdAt: v.number(),
   }).index("by_path", ["path"]),
 
   // Conversation-stream batches: one row per appended batch. Offset is
   // 0-based; `seq` is the row's position in the stream.
   flueConversationBatches: defineTable({
-    appendedAt: v.number(),
-    attemptId: v.optional(v.string()),
     path: v.string(),
-    producerEpoch: v.number(),
+    seq: v.number(),
     producerId: v.string(),
+    producerEpoch: v.number(),
     producerSequence: v.number(),
     recordsJson: v.string(),
-    seq: v.number(),
     submissionId: v.optional(v.string()),
+    attemptId: v.optional(v.string()),
+    appendedAt: v.number(),
   })
     .index("by_path_and_seq", ["path", "seq"])
     .index("by_path_producer_epoch_producerSequence", [
@@ -609,41 +425,41 @@ export default defineSchema({
 
   // Event-stream metadata: one row per stream path.
   flueEventStreams: defineTable({
+    path: v.string(),
+    nextSeq: v.number(),
     closed: v.boolean(),
     createdAt: v.number(),
-    nextSeq: v.number(),
-    path: v.string(),
   }).index("by_path", ["path"]),
 
   // Event-stream entries: one row per appended event. `onceKey` carries the
   // idempotency key for `appendEventOnce` and is null for plain appends.
   flueEventEntries: defineTable({
-    appendedAt: v.number(),
-    dataJson: v.string(),
-    onceKey: v.optional(v.string()),
     path: v.string(),
     seq: v.number(),
+    onceKey: v.optional(v.string()),
+    dataJson: v.string(),
+    appendedAt: v.number(),
   })
     .index("by_path_and_seq", ["path", "seq"])
     .index("by_path_and_onceKey", ["path", "onceKey"]),
 
   // Workflow run records.
   flueRuns: defineTable({
-    durationMs: v.optional(v.number()),
-    endedAt: v.optional(v.string()),
-    errorJson: v.optional(v.string()),
-    inputJson: v.optional(v.string()),
-    isError: v.optional(v.boolean()),
-    resultJson: v.optional(v.string()),
     runId: v.string(),
-    startedAt: v.string(),
+    workflowName: v.string(),
     status: v.union(
       v.literal("active"),
       v.literal("completed"),
       v.literal("errored")
     ),
+    startedAt: v.string(),
+    inputJson: v.optional(v.string()),
     traceCarrierJson: v.optional(v.string()),
-    workflowName: v.string(),
+    endedAt: v.optional(v.string()),
+    isError: v.optional(v.boolean()),
+    durationMs: v.optional(v.number()),
+    resultJson: v.optional(v.string()),
+    errorJson: v.optional(v.string()),
   })
     .index("by_runId", ["runId"])
     .index("by_startedAt_and_runId", ["startedAt", "runId"])
@@ -663,15 +479,15 @@ export default defineSchema({
   // Immutable attachment bytes. Identity is (streamPath, attachmentId); reads
   // are additionally scoped by conversationId.
   flueAttachments: defineTable({
-    attachmentId: v.string(),
-    bytes: v.bytes(),
+    streamPath: v.string(),
     conversationId: v.string(),
-    createdAt: v.number(),
-    digest: v.string(),
-    filename: v.optional(v.string()),
+    attachmentId: v.string(),
     mimeType: v.string(),
     size: v.number(),
-    streamPath: v.string(),
+    digest: v.string(),
+    filename: v.optional(v.string()),
+    bytes: v.bytes(),
+    createdAt: v.number(),
   })
     .index("by_streamPath", ["streamPath"])
     .index("by_streamPath_and_attachmentId", ["streamPath", "attachmentId"])

packages/backend/convex/signalRouting.test.ts

@@ -42,7 +42,7 @@ describe("signalRouting", () => {
         clientRequestId: "request-1",
         conversationId,
         createdAt: 1,
-        status: "running",
+        status: "processing",
       });
       const messageId = await ctx.db.insert("conversationMessages", {
         content: "Fix the deploy",

packages/backend/convex/signalRouting.ts

@@ -60,7 +60,7 @@ export const listEvidence = query({
         continue;
       }
       const turn = await ctx.db.get(message.turnId);
-      if (!turn || !["running", "completed"].includes(turn.status)) {
+      if (!turn || !["processing", "completed"].includes(turn.status)) {
         continue;
       }
       const consumed = await ctx.db
@@ -82,16 +82,16 @@ export const listEvidence = query({
 
 export const createSignal = mutation({
   args: {
-    messageIds: v.array(v.string()),
     organizationId: v.id("organizations"),
+    projectId: v.id("projects"),
+    messageIds: v.array(v.string()),
     problemStatement: v.object({
-      constraints: v.array(v.string()),
-      desiredOutcome: v.string(),
-      summary: v.string(),
       title: v.string(),
+      summary: v.string(),
+      desiredOutcome: v.string(),
+      constraints: v.array(v.string()),
     }),
     processedByAgentInstanceId: v.string(),
-    projectId: v.id("projects"),
     token: v.string(),
   },
   handler: async (ctx, args) => {
@@ -131,7 +131,7 @@ export const createSignal = mutation({
         throw new ConvexError(`Source message not found: ${messageId}`);
       }
       const turn = await ctx.db.get(message.turnId);
-      if (!turn || !["running", "completed"].includes(turn.status)) {
+      if (!turn || !["processing", "completed"].includes(turn.status)) {
         throw new ConvexError(`Source message is not admitted: ${messageId}`);
       }
       messages.push(message);

packages/backend/convex/workArtifacts.test.ts

@@ -1,108 +0,0 @@
-import { env } from "@code/env/convex";
-import { convexTest } from "convex-test";
-import { anyApi } from "convex/server";
-import { describe, expect, test } from "vitest";
-
-import schema from "./schema";
-
-declare global {
-  interface ImportMeta {
-    readonly glob: (pattern: string) => Record<string, () => Promise<unknown>>;
-  }
-}
-
-const modules = import.meta.glob("./**/*.ts");
-const api = anyApi;
-
-describe("Work artifacts and delivery", () => {
-  test("records exact idempotent artifact and delivery metadata", async () => {
-    const t = convexTest({ modules, schema });
-    const workId = await t.run(async (ctx) => {
-      const organizationId = await ctx.db.insert("organizations", {
-        createdAt: 1,
-        createdBy: "user",
-        kind: "personal",
-        name: "Personal",
-      });
-      const projectId = await ctx.db.insert("projects", {
-        createdAt: 1,
-        name: "Zopu",
-        normalizedSourceUrl: "https://example.com/zopu",
-        organizationId,
-        repositoryPath: "puter/zopu",
-        sourceHost: "example.com",
-        sourceUrl: "https://example.com/zopu",
-        updatedAt: 1,
-      });
-      return await ctx.db.insert("works", {
-        createdAt: 1,
-        objective: "Persist evidence",
-        organizationId,
-        projectId,
-        status: "executing",
-        title: "Artifact proof",
-        updatedAt: 1,
-      });
-    });
-
-    const draft = {
-      idempotencyKey: "attempt-1:test-report",
-      kind: "test-report" as const,
-      metadataJson: "{}",
-      producer: "fake-harness",
-      provenanceJson: "{}",
-      sourceRevision: "abc123",
-      title: "Focused tests",
-      verificationStatus: "verified" as const,
-    };
-    const first = await t.mutation(api.workArtifacts.recordArtifact, {
-      draft,
-      token: env.FLUE_DB_TOKEN,
-      workId,
-    });
-    const replay = await t.mutation(api.workArtifacts.recordArtifact, {
-      draft,
-      token: env.FLUE_DB_TOKEN,
-      workId,
-    });
-    expect(first.created).toBe(true);
-    expect(replay).toEqual({ artifactId: first.artifactId, created: false });
-
-    const delivery = await t.mutation(api.workArtifacts.recordDelivery, {
-      artifactId: first.artifactId,
-      draft: {
-        externalId: "42",
-        idempotencyKey: "pr:42",
-        kind: "pull-request",
-        metadataJson: "{}",
-        provider: "gitea",
-        sourceRevision: "abc123",
-        status: "ready",
-        target: "main",
-        url: "https://git.example/pulls/42",
-      },
-      token: env.FLUE_DB_TOKEN,
-      workId,
-    });
-    expect(delivery.created).toBe(true);
-    const updated = await t.mutation(api.workArtifacts.updateDeliveryStatus, {
-      deliveryId: delivery.deliveryId,
-      metadataJson: '{"approvedBy":"user"}',
-      status: "approved",
-      token: env.FLUE_DB_TOKEN,
-    });
-    expect(updated).toEqual({ changed: true, status: "approved" });
-    const stored = await t.run(async (ctx) => ({
-      artifacts: await ctx.db.query("workArtifacts").collect(),
-      deliveries: await ctx.db.query("workDeliveries").collect(),
-      events: await ctx.db.query("workEvents").collect(),
-    }));
-    expect(stored.artifacts).toHaveLength(1);
-    expect(stored.deliveries).toHaveLength(1);
-    expect(stored.events.map((event) => event.kind)).toEqual([
-      "artifact.recorded",
-      "delivery.recorded",
-      "delivery.updated",
-    ]);
-  });
-});

packages/backend/convex/workArtifacts.ts

@@ -1,370 +0,0 @@
-import { env } from "@code/env/convex";
-import {
-  canTransitionWorkDelivery,
-  decodeWorkArtifactDraft,
-  decodeWorkDeliveryDraft,
-} from "@code/primitives/work-artifact";
-import { ConvexError, v } from "convex/values";
-import { Effect } from "effect";
-
-import type { Id } from "./_generated/dataModel";
-import { mutation, query } from "./_generated/server";
-import type { MutationCtx } from "./_generated/server";
-import { requireProjectMember } from "./authz";
-
-const artifactKind = v.union(
-  v.literal("definition"),
-  v.literal("design"),
-  v.literal("diff"),
-  v.literal("test-report"),
-  v.literal("verification-report"),
-  v.literal("runtime-log"),
-  v.literal("screenshot"),
-  v.literal("video"),
-  v.literal("commit"),
-  v.literal("branch"),
-  v.literal("pull-request"),
-  v.literal("preview"),
-  v.literal("deployment"),
-  v.literal("other")
-);
-const verificationStatus = v.union(
-  v.literal("unverified"),
-  v.literal("verified"),
-  v.literal("rejected")
-);
-const deliveryKind = v.union(
-  v.literal("branch"),
-  v.literal("commit"),
-  v.literal("pull-request"),
-  v.literal("preview"),
-  v.literal("deployment")
-);
-const deliveryStatus = v.union(
-  v.literal("recorded"),
-  v.literal("ready"),
-  v.literal("approved"),
-  v.literal("delivered"),
-  v.literal("failed"),
-  v.literal("cancelled")
-);
-
-const requireAgent = (token: string): void => {
-  if (token !== env.FLUE_DB_TOKEN) {
-    throw new ConvexError("Invalid agent control token");
-  }
-};
-
-const appendEvent = async (
-  ctx: MutationCtx,
-  workId: Id<"works">,
-  kind: "artifact.recorded" | "delivery.recorded" | "delivery.updated",
-  idempotencyKey: string,
-  referenceId: string,
-  payloadJson: string
-): Promise<void> => {
-  const existing = await ctx.db
-    .query("workEvents")
-    .withIndex("by_work_and_idempotencyKey", (q) =>
-      q.eq("workId", workId).eq("idempotencyKey", idempotencyKey)
-    )
-    .unique();
-  if (existing) {
-    return;
-  }
-  await ctx.db.insert("workEvents", {
-    createdAt: Date.now(),
-    idempotencyKey,
-    kind,
-    payloadJson,
-    referenceId,
-    workId,
-  });
-};
-
-export const recordArtifact = mutation({
-  args: {
-    attemptId: v.optional(v.id("workAttempts")),
-    designVersion: v.optional(v.number()),
-    draft: v.object({
-      contentHash: v.optional(v.string()),
-      environmentId: v.optional(v.string()),
-      idempotencyKey: v.string(),
-      kind: artifactKind,
-      metadataJson: v.string(),
-      producer: v.string(),
-      provenanceJson: v.string(),
-      sourceRevision: v.optional(v.string()),
-      title: v.string(),
-      uri: v.optional(v.string()),
-      verificationStatus,
-    }),
-    runId: v.optional(v.id("workRuns")),
-    sliceId: v.optional(v.string()),
-    token: v.string(),
-    workId: v.id("works"),
-  },
-  handler: async (ctx, args) => {
-    requireAgent(args.token);
-    const work = await ctx.db.get(args.workId);
-    if (!work) {
-      throw new ConvexError("Work not found");
-    }
-    const draft = await Effect.runPromise(
-      decodeWorkArtifactDraft(args.draft)
-    ).catch((error: unknown) => {
-      throw new ConvexError(
-        error instanceof Error ? error.message : "Invalid Work artifact"
-      );
-    });
-    const attempt = args.attemptId ? await ctx.db.get(args.attemptId) : null;
-    if (args.attemptId && !attempt) {
-      throw new ConvexError("Attempt not found");
-    }
-    const referencedRunId = args.runId ?? attempt?.runId;
-    const run = referencedRunId ? await ctx.db.get(referencedRunId) : null;
-    if (referencedRunId && !run) {
-      throw new ConvexError("Run not found");
-    }
-    if (run && run.workId !== work._id) {
-      throw new ConvexError("Run does not belong to Work");
-    }
-    if (
-      attempt &&
-      (attempt.workId !== work._id ||
-        (run !== null && attempt.runId !== run._id))
-    ) {
-      throw new ConvexError("Attempt does not belong to Work Run");
-    }
-    if (
-      run &&
-      ((args.designVersion !== undefined &&
-        args.designVersion !== run.designVersion) ||
-        (args.sliceId !== undefined && args.sliceId !== run.sliceId))
-    ) {
-      throw new ConvexError("Artifact provenance conflicts with Work Run");
-    }
-    const designVersion = args.designVersion ?? run?.designVersion;
-    const sliceId = args.sliceId ?? run?.sliceId;
-    if (designVersion !== undefined && sliceId !== undefined) {
-      const slice = await ctx.db
-        .query("workSlices")
-        .withIndex("by_workId_and_designVersion_and_sliceId", (q) =>
-          q
-            .eq("workId", work._id)
-            .eq("designVersion", designVersion)
-            .eq("sliceId", sliceId)
-        )
-        .unique();
-      if (!slice) {
-        throw new ConvexError("Artifact slice not found");
-      }
-    } else if (designVersion !== undefined) {
-      const design = await ctx.db
-        .query("designPackets")
-        .withIndex("by_work_and_version", (q) =>
-          q.eq("workId", work._id).eq("version", designVersion)
-        )
-        .unique();
-      if (!design) {
-        throw new ConvexError("Artifact Design not found");
-      }
-    }
-    const existing = await ctx.db
-      .query("workArtifacts")
-      .withIndex("by_workId_and_idempotencyKey", (q) =>
-        q.eq("workId", work._id).eq("idempotencyKey", draft.idempotencyKey)
-      )
-      .unique();
-    if (existing) {
-      const exactReplay =
-        existing.kind === draft.kind &&
-        existing.title === draft.title &&
-        existing.uri === draft.uri &&
-        existing.contentHash === draft.contentHash &&
-        existing.sourceRevision === draft.sourceRevision &&
-        existing.environmentId === draft.environmentId &&
-        existing.producer === draft.producer &&
-        existing.provenanceJson === draft.provenanceJson &&
-        existing.metadataJson === draft.metadataJson &&
-        existing.verificationStatus === draft.verificationStatus &&
-        existing.designVersion === designVersion &&
-        existing.sliceId === sliceId &&
-        existing.runId === run?._id &&
-        existing.attemptId === attempt?._id;
-      if (!exactReplay) {
-        throw new ConvexError("Artifact idempotency key has conflicting data");
-      }
-      return { artifactId: existing._id, created: false };
-    }
-    const createdAt = Date.now();
-    const artifactId = await ctx.db.insert("workArtifacts", {
-      ...draft,
-      attemptId: attempt?._id,
-      createdAt,
-      designVersion,
-      organizationId: work.organizationId,
-      projectId: work.projectId,
-      runId: run?._id,
-      sliceId,
-      workId: work._id,
-    });
-    await appendEvent(
-      ctx,
-      work._id,
-      "artifact.recorded",
-      `artifact:${draft.idempotencyKey}`,
-      String(artifactId),
-      JSON.stringify({ kind: draft.kind, title: draft.title })
-    );
-    return { artifactId, created: true };
-  },
-});
-
-export const recordDelivery = mutation({
-  args: {
-    artifactId: v.optional(v.id("workArtifacts")),
-    draft: v.object({
-      externalId: v.string(),
-      idempotencyKey: v.string(),
-      kind: deliveryKind,
-      metadataJson: v.string(),
-      provider: v.string(),
-      sourceRevision: v.string(),
-      status: deliveryStatus,
-      target: v.string(),
-      url: v.optional(v.string()),
-    }),
-    token: v.string(),
-    workId: v.id("works"),
-  },
-  handler: async (ctx, args) => {
-    requireAgent(args.token);
-    const work = await ctx.db.get(args.workId);
-    if (!work) {
-      throw new ConvexError("Work not found");
-    }
-    const draft = await Effect.runPromise(
-      decodeWorkDeliveryDraft(args.draft)
-    ).catch((error: unknown) => {
-      throw new ConvexError(
-        error instanceof Error ? error.message : "Invalid Work delivery"
-      );
-    });
-    const artifact = args.artifactId ? await ctx.db.get(args.artifactId) : null;
-    if (args.artifactId && !artifact) {
-      throw new ConvexError("Artifact not found");
-    }
-    if (artifact && artifact.workId !== work._id) {
-      throw new ConvexError("Artifact does not belong to Work");
-    }
-    const existing = await ctx.db
-      .query("workDeliveries")
-      .withIndex("by_workId_and_idempotencyKey", (q) =>
-        q.eq("workId", work._id).eq("idempotencyKey", draft.idempotencyKey)
-      )
-      .unique();
-    if (existing) {
-      const exactReplay =
-        existing.kind === draft.kind &&
-        existing.provider === draft.provider &&
-        existing.externalId === draft.externalId &&
-        existing.url === draft.url &&
-        existing.sourceRevision === draft.sourceRevision &&
-        existing.target === draft.target &&
-        existing.status === draft.status &&
-        existing.metadataJson === draft.metadataJson &&
-        existing.artifactId === artifact?._id;
-      if (!exactReplay) {
-        throw new ConvexError("Delivery idempotency key has conflicting data");
-      }
-      return { created: false, deliveryId: existing._id };
-    }
-    const timestamp = Date.now();
-    const deliveryId = await ctx.db.insert("workDeliveries", {
-      ...draft,
-      artifactId: artifact?._id,
-      createdAt: timestamp,
-      organizationId: work.organizationId,
-      projectId: work.projectId,
-      updatedAt: timestamp,
-      workId: work._id,
-    });
-    await appendEvent(
-      ctx,
-      work._id,
-      "delivery.recorded",
-      `delivery:${draft.idempotencyKey}`,
-      String(deliveryId),
-      JSON.stringify({ kind: draft.kind, sourceRevision: draft.sourceRevision })
-    );
-    return { created: true, deliveryId };
-  },
-});
-
-export const updateDeliveryStatus = mutation({
-  args: {
-    deliveryId: v.id("workDeliveries"),
-    metadataJson: v.string(),
-    status: deliveryStatus,
-    token: v.string(),
-  },
-  handler: async (ctx, args) => {
-    requireAgent(args.token);
-    // Validate JSON before persisting, matching recordDelivery's decode path.
-    const metadata = JSON.parse(args.metadataJson) as unknown;
-    if (typeof metadata !== "object" || metadata === null) {
-      throw new ConvexError("Delivery metadata must be a JSON object");
-    }
-    const delivery = await ctx.db.get(args.deliveryId);
-    if (!delivery) {
-      throw new ConvexError("Delivery not found");
-    }
-    if (delivery.status === args.status) {
-      return { changed: false, status: delivery.status };
-    }
-    if (!canTransitionWorkDelivery(delivery.status, args.status)) {
-      throw new ConvexError(
-        `Invalid delivery transition: ${delivery.status} -> ${args.status}`
-      );
-    }
-    await ctx.db.patch(delivery._id, {
-      metadataJson: args.metadataJson,
-      status: args.status,
-      updatedAt: Date.now(),
-    });
-    await appendEvent(
-      ctx,
-      delivery.workId,
-      "delivery.updated",
-      `delivery-updated:${delivery._id}:${args.status}`,
-      String(delivery._id),
-      JSON.stringify({ from: delivery.status, to: args.status })
-    );
-    return { changed: true, status: args.status };
-  },
-});
-
-export const listForWork = query({
-  args: { workId: v.id("works") },
-  handler: async (ctx, args) => {
-    const work = await ctx.db.get(args.workId);
-    if (!work) {
-      return null;
-    }
-    await requireProjectMember(ctx, work.projectId);
-    const [artifacts, deliveries] = await Promise.all([
-      ctx.db
-        .query("workArtifacts")
-        .withIndex("by_workId_and_createdAt", (q) => q.eq("workId", work._id))
-        .order("desc")
-        .take(100),
-      ctx.db
-        .query("workDeliveries")
-        .withIndex("by_workId_and_createdAt", (q) => q.eq("workId", work._id))
-        .order("desc")
-        .take(50),
-    ]);
-    return { artifacts, deliveries };
-  },
-});

packages/backend/convex/workExecution.test.ts

@@ -1,5 +1,5 @@
 import { convexTest } from "convex-test";
-import { anyApi, makeFunctionReference } from "convex/server";
+import { anyApi } from "convex/server";
 import { describe, expect, test } from "vitest";
 
 import type { Id } from "./_generated/dataModel";
@@ -15,11 +15,6 @@ const modules = {
 };
 const identity = { tokenIdentifier: "https://convex.test|exec-user" };
 const api = anyApi;
-const claimAttemptRef = makeFunctionReference<
-  "mutation",
-  { attemptId: Id<"workAttempts">; leaseMs: number; owner: string },
-  { number: number } | null
->("workExecution:claimAttempt");
 
 const makeTest = () => convexTest({ modules, schema });
 type TestT = ReturnType<typeof makeTest>;
@@ -31,7 +26,7 @@ type Scenario =
   | "permanent-failure"
   | "cancelled";
 
-const seedReadyWork = async (options: { secondSlice?: boolean } = {}) => {
+const seedReadyWork = async () => {
   const t = convexTest({ modules, schema });
   const { workId } = await t.withIdentity(identity).run(async (ctx) => {
     const organizationId = await ctx.db.insert("organizations", {
@@ -79,7 +74,6 @@ const seedReadyWork = async (options: { secondSlice?: boolean } = {}) => {
       workId: id,
     });
     await ctx.db.insert("workSlices", {
-      createdAt: 1,
       designVersion: 1,
       objective: "execute the slice",
       observableBehavior: "terminal run",
@@ -90,20 +84,6 @@ const seedReadyWork = async (options: { secondSlice?: boolean } = {}) => {
       title: "first",
       workId: id,
     });
-    if (options.secondSlice) {
-      await ctx.db.insert("workSlices", {
-        createdAt: 1,
-        designVersion: 1,
-        objective: "execute the second slice",
-        observableBehavior: "second terminal run",
-        ordinal: 1,
-        payloadJson: "{}",
-        sliceId: "slice-2",
-        status: "planned",
-        title: "second",
-        workId: id,
-      });
-    }
     return { workId: id };
   });
   return { t, workId };
@@ -123,14 +103,12 @@ const attemptNumber = async (
   const attempt = await t.run(async (ctx) =>
     ctx.db
       .query("workAttempts")
-      .withIndex("by_runId_and_number", (q) =>
+      .withIndex("by_run_and_number", (q) =>
         q.eq("runId", runId).eq("number", number)
       )
       .unique()
   );
-  if (!attempt) {
-    throw new Error(`attempt ${number} not found`);
-  }
+  if (!attempt) throw new Error(`attempt ${number} not found`);
   return attempt._id;
 };
 
@@ -138,21 +116,15 @@ const snapshot = async (t: TestT, workId: Id<"works">, runId: Id<"workRuns">) =>
   t.run(async (ctx) => ({
     attempts: await ctx.db
       .query("workAttempts")
-      .withIndex("by_runId_and_number", (q) => q.eq("runId", runId))
+      .withIndex("by_run_and_number", (q) => q.eq("runId", runId))
       .collect(),
     run: await ctx.db.get(runId),
     slice: await ctx.db
       .query("workSlices")
-      .withIndex("by_workId_and_designVersion", (q) =>
+      .withIndex("by_work_and_designVersion", (q) =>
         q.eq("workId", workId).eq("designVersion", 1)
       )
       .first(),
-    slices: await ctx.db
-      .query("workSlices")
-      .withIndex("by_workId_and_designVersion", (q) =>
-        q.eq("workId", workId).eq("designVersion", 1)
-      )
-      .collect(),
     work: await ctx.db.get(workId),
   }));
 
@@ -172,77 +144,6 @@ describe("simulated execution resolver", () => {
     expect(state.run?.terminalClassification).toBe("Succeeded");
     expect(state.attempts).toHaveLength(1);
     expect(state.slice?.status).toBe("completed");
-    const decisions = await t.run(async (ctx) =>
-      ctx.db.query("resolverDecisions").collect()
-    );
-    expect(decisions).toHaveLength(1);
-    expect(decisions[0]).toMatchObject({
-      classification: "Succeeded",
-      decision: "terminal",
-      resultingWorkStatus: "completed",
-    });
-  });
-
-  test("completes Work only after every approved slice succeeds", async () => {
-    const { t, workId } = await seedReadyWork({ secondSlice: true });
-    const first = await t
-      .withIdentity(identity)
-      .mutation(api.workExecution.startSimulatedExecution, {
-        scenario: "success",
-        workId,
-      });
-    await runAttempt(t, first.attemptId, "success");
-    const afterFirst = await snapshot(t, workId, first.runId);
-    expect(afterFirst.work?.status).toBe("ready");
-    expect(
-      afterFirst.slices.find((slice) => slice.sliceId === "slice-1")?.status
-    ).toBe("completed");
-    expect(
-      afterFirst.slices.find((slice) => slice.sliceId === "slice-2")?.status
-    ).toBe("ready");
-    await expect(
-      t
-        .withIdentity(identity)
-        .mutation(api.workExecution.retrySimulatedExecution, {
-          runId: first.runId,
-        })
-    ).rejects.toThrow(/retryable state/u);
-
-    const second = await t
-      .withIdentity(identity)
-      .mutation(api.workExecution.startSimulatedExecution, {
-        scenario: "success",
-        sliceId: "slice-2",
-        workId,
-      });
-    await runAttempt(t, second.attemptId, "success");
-    const completed = await snapshot(t, workId, second.runId);
-    expect(completed.work?.status).toBe("completed");
-    expect(
-      completed.slices.every((slice) => slice.status === "completed")
-    ).toBe(true);
-  });
-
-  test("allows only one owner to claim a queued attempt", async () => {
-    const { t, workId } = await seedReadyWork();
-    const started = await t
-      .withIdentity(identity)
-      .mutation(api.workExecution.startSimulatedExecution, {
-        scenario: "success",
-        workId,
-      });
-    const first = await t.mutation(claimAttemptRef, {
-      attemptId: started.attemptId,
-      leaseMs: 60_000,
-      owner: "worker-a",
-    });
-    const second = await t.mutation(claimAttemptRef, {
-      attemptId: started.attemptId,
-      leaseMs: 60_000,
-      owner: "worker-b",
-    });
-    expect(first?.number).toBe(1);
-    expect(second).toBeNull();
   });
 
   test("transient failure retries within the kit budget and then succeeds", async () => {

packages/backend/convex/workExecution.ts

@@ -1,7 +1,12 @@
-import { FakeHarnessLive } from "@code/primitives/harness-runtime";
-import type { FakeScenario } from "@code/primitives/harness-runtime";
-import { defaultCodingKitV0, resolveOutcome } from "@code/primitives/resolver";
-import type { WorkEventKind } from "@code/primitives/work";
+import {
+  FakeHarnessLive,
+  type FakeScenario,
+} from "@code/primitives/harness-runtime";
+import {
+  type AttemptClassification,
+  defaultCodingKitV0,
+  resolveOutcome,
+} from "@code/primitives/resolver";
 import { makeFunctionReference } from "convex/server";
 import { ConvexError, v } from "convex/values";
 import { Effect } from "effect";
@@ -13,7 +18,6 @@ import {
   mutation,
   query,
 } from "./_generated/server";
-import type { MutationCtx } from "./_generated/server";
 import { requireProjectMember } from "./authz";
 
 const executeRef = makeFunctionReference<
@@ -49,51 +53,34 @@ const finishRef = makeFunctionReference<
   unknown
 >("workExecution:finishAttempt");
 const now = () => Date.now();
-const attemptClassification = v.union(
-  v.literal("Succeeded"),
-  v.literal("RetryableFailure"),
-  v.literal("NeedsInput"),
-  v.literal("Blocked"),
-  v.literal("VerificationFailed"),
-  v.literal("BudgetExhausted"),
-  v.literal("Cancelled"),
-  v.literal("PermanentFailure")
-);
 
-const requireWorkForMember = async (
-  ctx: MutationCtx,
-  workId: Id<"works">
-): Promise<Doc<"works">> => {
+const requireWorkForMember = async (ctx: any, workId: Id<"works">) => {
   const work = await ctx.db.get(workId);
-  if (!work) {
-    throw new ConvexError("Work not found");
-  }
+  if (!work) throw new ConvexError("Work not found");
   await requireProjectMember(ctx, work.projectId);
   return work;
 };
 
 const appendWorkEvent = async (
-  ctx: MutationCtx,
+  ctx: any,
   workId: Id<"works">,
-  kind: WorkEventKind,
+  kind: any,
   idempotencyKey: string,
   referenceId?: string,
   payloadJson?: string
 ) => {
   const existing = await ctx.db
     .query("workEvents")
-    .withIndex("by_work_and_idempotencyKey", (q) =>
+    .withIndex("by_work_and_idempotencyKey", (q: any) =>
       q.eq("workId", workId).eq("idempotencyKey", idempotencyKey)
     )
     .unique();
-  if (existing) {
-    return;
-  }
+  if (existing) return;
   await ctx.db.insert("workEvents", {
-    createdAt: now(),
-    idempotencyKey,
-    kind,
     workId,
+    kind,
+    idempotencyKey,
+    createdAt: now(),
     ...(referenceId ? { referenceId } : {}),
     ...(payloadJson ? { payloadJson } : {}),
   });
@@ -102,64 +89,54 @@ const appendWorkEvent = async (
 // Slice the Run targets for the currently approved Design. `sliceId` is
 // optional only to let the resolver default to the first ready slice.
 const resolveRunSlice = async (
-  ctx: MutationCtx,
+  ctx: any,
   work: Doc<"works">,
   sliceId?: string
-): Promise<Doc<"workSlices">> => {
+) => {
   const currentDesignVersion = work.designVersion;
-  if (currentDesignVersion === undefined) {
+  if (currentDesignVersion === undefined)
     throw new ConvexError("Work has no approved Design to execute");
-  }
   const slices = await ctx.db
     .query("workSlices")
-    .withIndex("by_workId_and_designVersion", (q) =>
+    .withIndex("by_work_and_designVersion", (q: any) =>
       q.eq("workId", work._id).eq("designVersion", currentDesignVersion)
     )
     .collect();
-  if (slices.length === 0) {
+  if (slices.length === 0)
     throw new ConvexError("No slices found for the current approved Design");
-  }
   const slice = sliceId
-    ? slices.find((row) => row.sliceId === sliceId)
-    : slices
-        .sort((a, b) => a.ordinal - b.ordinal)
-        .find((row) => row.status === "ready");
-  if (!slice) {
+    ? slices.find((row: any) => row.sliceId === sliceId)
+    : slices.sort((a: any, b: any) => a.ordinal - b.ordinal)[0];
+  if (!slice)
     throw new ConvexError(
       "Requested slice does not belong to the current approved Design"
     );
-  }
-  if (slice.status !== "ready") {
-    throw new ConvexError("Only the next ready slice can be executed");
-  }
-  return slice;
+  return slice as Doc<"workSlices">;
 };
 
-const getRunSlice = async (
-  ctx: MutationCtx,
-  run: Doc<"workRuns">
-): Promise<Doc<"workSlices"> | null> => {
-  if (run.sliceRowId) {
-    return await ctx.db.get(run.sliceRowId);
-  }
-  if (run.designVersion === undefined || run.sliceId === undefined) {
-    return null;
-  }
-  return await ctx.db
-    .query("workSlices")
-    .withIndex("by_workId_and_designVersion_and_sliceId", (q) =>
-      q
-        .eq("workId", run.workId)
-        .eq("designVersion", run.designVersion!)
-        .eq("sliceId", run.sliceId!)
-    )
-    .unique();
+const setSliceStatus = async (
+  ctx: any,
+  workId: Id<"works">,
+  sliceId: string | undefined,
+  status: any
+) => {
+  if (!sliceId) return;
+  const slice = (
+    await ctx.db
+      .query("workSlices")
+      .withIndex("by_work_and_designVersion", (q: any) =>
+        q.eq("workId", workId)
+      )
+      .collect()
+  ).find((row: any) => row.sliceId === sliceId);
+  if (slice) await ctx.db.patch(slice._id, { status });
 };
 
-const RETRYABLE_WORK_STATUSES = new Set(["failed", "needs-input", "blocked"]);
+const RETRYABLE_WORK_STATUSES = ["failed", "needs-input", "blocked", "ready"];
 
 export const startSimulatedExecution = mutation({
   args: {
+    workId: v.id("works"),
     scenario: v.union(
       v.literal("success"),
       v.literal("transient-failure-then-success"),
@@ -168,46 +145,41 @@ export const startSimulatedExecution = mutation({
       v.literal("cancelled")
     ),
     sliceId: v.optional(v.string()),
-    workId: v.id("works"),
   },
   handler: async (ctx, args) => {
     const work = await requireWorkForMember(ctx, args.workId);
-    if (work.status !== "ready") {
+    if (work.status !== "ready")
       throw new ConvexError("Work must be Ready before simulated execution");
-    }
     if (
       work.definitionApprovalVersion !== work.definitionVersion ||
       work.designApprovalVersion !== work.designVersion
-    ) {
+    )
       throw new ConvexError(
         "Execution requires exact approved Definition and Design versions"
       );
-    }
     const slice = await resolveRunSlice(ctx, work, args.sliceId);
     const createdAt = now();
     const runId = await ctx.db.insert("workRuns", {
-      createdAt,
-      designVersion: slice.designVersion,
+      workId: work._id,
+      sliceId: slice.sliceId,
+      status: "ready",
+      scenario: args.scenario,
       kitId: defaultCodingKitV0.id,
       kitVersion: defaultCodingKitV0.version,
-      scenario: args.scenario,
-      sliceId: slice.sliceId,
-      sliceRowId: slice._id,
-      status: "ready",
-      workId: work._id,
+      createdAt,
     });
     const attemptId = await ctx.db.insert("workAttempts", {
-      number: 1,
       runId,
-      status: "queued",
       workId: work._id,
+      number: 1,
+      status: "queued",
     });
     await ctx.db.patch(work._id, {
       status: "executing",
       updatedAt: createdAt,
     });
     await ctx.db.patch(slice._id, { status: "running" });
-    await ctx.db.patch(runId, { startedAt: createdAt, status: "running" });
+    await ctx.db.patch(runId, { status: "running", startedAt: createdAt });
     await appendWorkEvent(
       ctx,
       work._id,
@@ -215,18 +187,11 @@ export const startSimulatedExecution = mutation({
       `run-started:${runId}`,
       String(runId)
     );
-    await appendWorkEvent(
-      ctx,
-      work._id,
-      "slice.started",
-      `slice-started:${runId}:${slice.sliceId}`,
-      String(slice._id)
-    );
     await ctx.scheduler.runAfter(0, executeRef, {
       attemptId,
       scenario: args.scenario,
     });
-    return { attemptId, runId };
+    return { runId, attemptId };
   },
 });
 
@@ -234,56 +199,29 @@ export const cancelSimulatedExecution = mutation({
   args: { runId: v.id("workRuns") },
   handler: async (ctx, args) => {
     const run = await ctx.db.get(args.runId);
-    if (!run) {
-      throw new ConvexError("Run not found");
-    }
+    if (!run) throw new ConvexError("Run not found");
     const work = await requireWorkForMember(ctx, run.workId);
-    if (run.status === "terminal" || run.status === "cancelled") {
+    if (run.status === "terminal" || run.status === "cancelled")
       return { cancelled: false };
-    }
     await ctx.db.patch(run._id, {
-      endedAt: now(),
       status: "cancelled",
+      endedAt: now(),
       terminalClassification: "Cancelled",
       terminalSummary: "Simulation cancelled",
     });
     const attempts = await ctx.db
       .query("workAttempts")
-      .withIndex("by_runId_and_number", (q) => q.eq("runId", run._id))
+      .withIndex("by_run_and_number", (q: any) => q.eq("runId", run._id))
       .collect();
-    for (const attempt of attempts) {
-      if (attempt.status !== "terminal") {
+    for (const attempt of attempts)
+      if (attempt.status !== "terminal")
         await ctx.db.patch(attempt._id, {
-          classification: "Cancelled",
-          endedAt: now(),
           status: "terminal",
-          summary: "Simulation cancelled",
-        });
-        await ctx.db.insert("resolverDecisions", {
-          attemptId: attempt._id,
-          attemptNumber: attempt.number,
+          endedAt: now(),
           classification: "Cancelled",
-          createdAt: now(),
-          decision: "terminal",
-          resultingWorkStatus: "ready",
-          runId: run._id,
           summary: "Simulation cancelled",
-          workId: work._id,
         });
-        await appendWorkEvent(
-          ctx,
-          work._id,
-          "resolver.decided",
-          `resolver-decided:${attempt._id}`,
-          String(attempt._id),
-          JSON.stringify({ classification: "Cancelled", decision: "terminal" })
-        );
-      }
-    }
-    const slice = await getRunSlice(ctx, run);
-    if (slice) {
-      await ctx.db.patch(slice._id, { status: "ready" });
-    }
+    await setSliceStatus(ctx, work._id, run.sliceId, "ready");
     await ctx.db.patch(work._id, { status: "ready", updatedAt: now() });
     await appendWorkEvent(
       ctx,
@@ -302,40 +240,32 @@ export const retrySimulatedExecution = mutation({
   args: { runId: v.id("workRuns") },
   handler: async (ctx, args) => {
     const run = await ctx.db.get(args.runId);
-    if (!run) {
-      throw new ConvexError("Run not found");
-    }
+    if (!run) throw new ConvexError("Run not found");
     const work = await requireWorkForMember(ctx, run.workId);
-    if (run.status !== "terminal") {
+    if (run.status !== "terminal")
       throw new ConvexError("Only terminal Runs can be retried");
-    }
-    if (!RETRYABLE_WORK_STATUSES.has(work.status)) {
+    if (!RETRYABLE_WORK_STATUSES.includes(work.status))
       throw new ConvexError("Work is not in a retryable state");
-    }
     const attempts = await ctx.db
       .query("workAttempts")
-      .withIndex("by_runId_and_number", (q) => q.eq("runId", run._id))
+      .withIndex("by_run_and_number", (q: any) => q.eq("runId", run._id))
       .collect();
     const number = attempts.length + 1;
     const attemptId = await ctx.db.insert("workAttempts", {
-      number,
       runId: run._id,
-      status: "queued",
       workId: work._id,
+      number,
+      status: "queued",
     });
     await ctx.db.patch(run._id, {
-      endedAt: undefined,
-      startedAt: now(),
       status: "running",
+      startedAt: now(),
+      endedAt: undefined,
       terminalClassification: undefined,
       terminalSummary: undefined,
     });
     await ctx.db.patch(work._id, { status: "executing", updatedAt: now() });
-    const slice = await getRunSlice(ctx, run);
-    if (!slice) {
-      throw new ConvexError("Run slice not found");
-    }
-    await ctx.db.patch(slice._id, { status: "running" });
+    await setSliceStatus(ctx, work._id, run.sliceId, "running");
     await ctx.scheduler.runAfter(0, executeRef, {
       attemptId,
       scenario: run.scenario,
@@ -347,71 +277,62 @@ export const retrySimulatedExecution = mutation({
 export const claimAttempt = internalMutation({
   args: {
     attemptId: v.id("workAttempts"),
-    leaseMs: v.number(),
     owner: v.string(),
+    leaseMs: v.number(),
   },
   handler: async (ctx, args) => {
     const attempt = await ctx.db.get(args.attemptId);
-    if (!attempt || attempt.status !== "queued") {
-      return null;
-    }
-    const run = await ctx.db.get(attempt.runId);
-    if (!run || run.status !== "running") {
-      return null;
-    }
+    if (!attempt || attempt.status === "terminal") return null;
     const claimedAt = now();
     await ctx.db.patch(attempt._id, {
-      leaseExpiresAt: claimedAt + args.leaseMs,
-      leaseOwner: args.owner,
-      startedAt: attempt.startedAt ?? claimedAt,
       status: "claimed",
+      leaseOwner: args.owner,
+      leaseExpiresAt: claimedAt + args.leaseMs,
+      startedAt: attempt.startedAt ?? claimedAt,
     });
     await ctx.db.patch(attempt.runId, {
-      startedAt: claimedAt,
       status: "running",
+      startedAt: claimedAt,
     });
-    return { ...attempt, leaseOwner: args.owner, status: "claimed" as const };
+    return { ...attempt, status: "claimed" as const, leaseOwner: args.owner };
   },
 });
 
 export const checkpointAttempt = internalMutation({
   args: {
     attemptId: v.id("workAttempts"),
+    owner: v.string(),
+    sequence: v.number(),
     kind: v.string(),
     message: v.string(),
     metadataJson: v.string(),
-    owner: v.string(),
-    sequence: v.number(),
   },
   handler: async (ctx, args) => {
     const attempt = await ctx.db.get(args.attemptId);
     if (
       !attempt ||
       attempt.leaseOwner !== args.owner ||
-      attempt.status === "terminal" ||
-      (attempt.leaseExpiresAt !== undefined && attempt.leaseExpiresAt < now())
-    ) {
+      attempt.status === "terminal"
+    )
       return false;
-    }
     const existing = await ctx.db
       .query("workAttemptEvents")
       .withIndex("by_attempt_and_sequence", (q: any) =>
         q.eq("attemptId", attempt._id).eq("sequence", args.sequence)
       )
       .unique();
-    if (!existing) {
+    if (!existing)
       await ctx.db.insert("workAttemptEvents", {
         attemptId: attempt._id,
+        sequence: args.sequence,
         kind: args.kind,
         message: args.message,
         metadataJson: args.metadataJson,
         occurredAt: now(),
-        sequence: args.sequence,
       });
-    }
     await ctx.db.patch(attempt._id, {
-      leaseExpiresAt: now() + 60_000,
       status: "running",
+      leaseExpiresAt: now() + 60_000,
     });
     return true;
   },
@@ -424,8 +345,8 @@ export const checkpointAttempt = internalMutation({
 export const finishAttempt = internalMutation({
   args: {
     attemptId: v.id("workAttempts"),
-    classification: attemptClassification,
     owner: v.string(),
+    classification: v.string(),
     retryable: v.boolean(),
     summary: v.string(),
   },
@@ -434,21 +355,19 @@ export const finishAttempt = internalMutation({
     if (
       !attempt ||
       attempt.leaseOwner !== args.owner ||
-      attempt.status === "terminal" ||
-      (attempt.leaseExpiresAt !== undefined && attempt.leaseExpiresAt < now())
-    ) {
+      attempt.status === "terminal"
+    )
       return null;
-    }
     const endedAt = now();
     await ctx.db.patch(attempt._id, {
-      classification: args.classification,
-      endedAt,
-      leaseExpiresAt: undefined,
       status: "terminal",
+      endedAt,
+      classification: args.classification,
       summary: args.summary,
+      leaseExpiresAt: undefined,
     });
     const outcome = {
-      classification: args.classification,
+      classification: args.classification as AttemptClassification,
       retryable: args.retryable,
       summary: args.summary,
     };
@@ -458,9 +377,7 @@ export const finishAttempt = internalMutation({
       defaultCodingKitV0.retryPolicy
     );
     const run = await ctx.db.get(attempt.runId);
-    if (!run) {
-      return null;
-    }
+    if (!run) return null;
     await appendWorkEvent(
       ctx,
       attempt.workId,
@@ -473,34 +390,13 @@ export const finishAttempt = internalMutation({
         summary: args.summary,
       })
     );
-    await appendWorkEvent(
-      ctx,
-      attempt.workId,
-      "resolver.decided",
-      `resolver-decided:${attempt._id}`,
-      String(attempt._id),
-      JSON.stringify({
-        classification: args.classification,
-        decision: resolution.kind,
-      })
-    );
     if (resolution.kind === "retry") {
-      await ctx.db.insert("resolverDecisions", {
-        attemptId: attempt._id,
-        attemptNumber: attempt.number,
-        classification: args.classification,
-        createdAt: endedAt,
-        decision: "retry",
-        runId: run._id,
-        summary: args.summary,
-        workId: attempt.workId,
-      });
       // Keep Run running and Work executing; spin the next attempt.
       const nextAttemptId = await ctx.db.insert("workAttempts", {
-        number: attempt.number + 1,
         runId: run._id,
-        status: "queued",
         workId: attempt.workId,
+        number: attempt.number + 1,
+        status: "queued",
       });
       await ctx.scheduler.runAfter(0, executeRef, {
         attemptId: nextAttemptId,
@@ -509,78 +405,22 @@ export const finishAttempt = internalMutation({
       return { nextAttemptId, retried: true };
     }
     await ctx.db.patch(run._id, {
-      endedAt,
       status: "terminal",
+      endedAt,
       terminalClassification: args.classification,
       terminalSummary: args.summary,
     });
     const work = await ctx.db.get(run.workId);
-    const slice = await getRunSlice(ctx, run);
-    let resultingWorkStatus = resolution.workStatus;
-    if (args.classification === "Succeeded" && slice) {
-      await ctx.db.patch(slice._id, { status: "completed" });
-      await appendWorkEvent(
-        ctx,
-        attempt.workId,
-        "slice.completed",
-        `slice-completed:${run._id}:${slice.sliceId}`,
-        String(slice._id)
-      );
-      const slices = await ctx.db
-        .query("workSlices")
-        .withIndex("by_workId_and_designVersion", (q) =>
-          q
-            .eq("workId", attempt.workId)
-            .eq("designVersion", slice.designVersion)
-        )
-        .collect();
-      const nextSlice = slices
-        .sort((left, right) => left.ordinal - right.ordinal)
-        .find((candidate) => candidate.status === "planned");
-      if (nextSlice) {
-        await ctx.db.patch(nextSlice._id, { status: "ready" });
-        resultingWorkStatus = "ready";
-        await appendWorkEvent(
-          ctx,
-          attempt.workId,
-          "slice.ready",
-          `slice-ready:${run._id}:${nextSlice.sliceId}`,
-          String(nextSlice._id)
-        );
-      }
-    } else if (slice) {
-      const blocked = ["NeedsInput", "Blocked", "VerificationFailed"].includes(
-        args.classification
-      );
-      await ctx.db.patch(slice._id, { status: blocked ? "blocked" : "ready" });
-    }
-    if (work) {
+    if (work)
       await ctx.db.patch(work._id, {
-        status: resultingWorkStatus,
+        status: resolution.workStatus,
         updatedAt: endedAt,
       });
-    }
-    await ctx.db.insert("resolverDecisions", {
-      attemptId: attempt._id,
-      attemptNumber: attempt.number,
-      classification: args.classification,
-      createdAt: endedAt,
-      decision: "terminal",
-      resultingWorkStatus,
-      runId: run._id,
-      summary: args.summary,
-      workId: attempt.workId,
-    });
-    await appendWorkEvent(
+    await setSliceStatus(
       ctx,
       attempt.workId,
-      "run.completed",
-      `run-completed:${run._id}`,
-      String(run._id),
-      JSON.stringify({
-        classification: args.classification,
-        workStatus: resultingWorkStatus,
-      })
+      run.sliceId,
+      args.classification === "Succeeded" ? "completed" : "ready"
     );
     return { retried: false };
   },
@@ -601,19 +441,17 @@ export const executeFakeAttempt = internalAction({
     const owner = `fake-worker:${args.attemptId}`;
     const claimed = await ctx.runMutation(claimRef, {
       attemptId: args.attemptId,
-      leaseMs: 60_000,
       owner,
+      leaseMs: 60_000,
     });
-    if (!claimed) {
-      return null;
-    }
+    if (!claimed) return null;
     const [events, outcome] = await Effect.runPromise(
       FakeHarnessLive().run({
         attemptNumber: claimed.number,
         scenario: args.scenario,
       })
     );
-    for (const item of events) {
+    for (const item of events)
       await ctx.runMutation(checkpointRef, {
         attemptId: args.attemptId,
         kind: item.kind,
@@ -622,7 +460,6 @@ export const executeFakeAttempt = internalAction({
         owner,
         sequence: item.sequence,
       });
-    }
     await ctx.runMutation(finishRef, {
       attemptId: args.attemptId,
       classification: outcome.classification,
@@ -640,22 +477,7 @@ export const executeFakeAttempt = internalAction({
 export const reconcileExpiredAttempts = internalMutation({
   args: {},
   handler: async (ctx) => {
-    const timestamp = now();
-    const [claimed, running] = await Promise.all([
-      ctx.db
-        .query("workAttempts")
-        .withIndex("by_status_and_leaseExpiresAt", (q) =>
-          q.eq("status", "claimed").lt("leaseExpiresAt", timestamp)
-        )
-        .collect(),
-      ctx.db
-        .query("workAttempts")
-        .withIndex("by_status_and_leaseExpiresAt", (q) =>
-          q.eq("status", "running").lt("leaseExpiresAt", timestamp)
-        )
-        .collect(),
-    ]);
-    const active = [...claimed, ...running];
+    const active = await ctx.db.query("workAttempts").collect();
     let reconciled = 0;
     for (const attempt of active) {
       if (
@@ -664,12 +486,12 @@ export const reconcileExpiredAttempts = internalMutation({
         attempt.leaseExpiresAt < now()
       ) {
         await ctx.db.patch(attempt._id, {
-          classification: "Blocked",
-          endedAt: now(),
-          leaseExpiresAt: undefined,
-          leaseOwner: undefined,
           status: "terminal",
+          endedAt: now(),
+          classification: "Blocked",
           summary: "Attempt lease expired and was reconciled",
+          leaseOwner: undefined,
+          leaseExpiresAt: undefined,
         });
         const run = await ctx.db.get(attempt.runId);
         await appendWorkEvent(
@@ -681,44 +503,19 @@ export const reconcileExpiredAttempts = internalMutation({
           JSON.stringify({ attemptNumber: attempt.number })
         );
         reconciled += 1;
-        if (!run) {
-          continue;
-        }
+        if (!run) continue;
         const attempts = await ctx.db
           .query("workAttempts")
-          .withIndex("by_runId_and_number", (q) => q.eq("runId", run._id))
+          .withIndex("by_run_and_number", (q: any) => q.eq("runId", run._id))
           .collect();
         const withinBudget =
           attempts.length < defaultCodingKitV0.retryPolicy.maxAttempts;
-        const retry = run.status === "running" && withinBudget;
-        await ctx.db.insert("resolverDecisions", {
-          attemptId: attempt._id,
-          attemptNumber: attempt.number,
-          classification: "Blocked",
-          createdAt: now(),
-          decision: retry ? "retry" : "terminal",
-          resultingWorkStatus: retry ? undefined : "blocked",
-          runId: run._id,
-          summary: "Attempt lease expired and was reconciled",
-          workId: attempt.workId,
-        });
-        await appendWorkEvent(
-          ctx,
-          attempt.workId,
-          "resolver.decided",
-          `resolver-decided:${attempt._id}`,
-          String(attempt._id),
-          JSON.stringify({
-            classification: "Blocked",
-            decision: retry ? "retry" : "terminal",
-          })
-        );
-        if (retry) {
+        if (run.status === "running" && withinBudget) {
           const nextAttemptId = await ctx.db.insert("workAttempts", {
-            number: attempts.length + 1,
             runId: run._id,
-            status: "queued",
             workId: attempt.workId,
+            number: attempts.length + 1,
+            status: "queued",
           });
           await ctx.scheduler.runAfter(0, executeRef, {
             attemptId: nextAttemptId,
@@ -726,22 +523,18 @@ export const reconcileExpiredAttempts = internalMutation({
           });
         } else {
           await ctx.db.patch(run._id, {
-            endedAt: now(),
             status: "terminal",
+            endedAt: now(),
             terminalClassification: "Blocked",
             terminalSummary: "Run reconciled after expired lease",
           });
           const work = await ctx.db.get(run.workId);
-          if (work) {
+          if (work)
             await ctx.db.patch(work._id, {
               status: "blocked",
               updatedAt: now(),
             });
-          }
-          const slice = await getRunSlice(ctx, run);
-          if (slice) {
-            await ctx.db.patch(slice._id, { status: "blocked" });
-          }
+          await setSliceStatus(ctx, attempt.workId, run.sliceId, "ready");
         }
       }
     }
@@ -753,17 +546,13 @@ export const listRunEvents = query({
   args: { attemptId: v.id("workAttempts") },
   handler: async (ctx, args) => {
     const attempt = await ctx.db.get(args.attemptId);
-    if (!attempt) {
-      return [];
-    }
+    if (!attempt) return [];
     const work = await ctx.db.get(attempt.workId);
-    if (!work) {
-      return [];
-    }
+    if (!work) return [];
     await requireProjectMember(ctx, work.projectId);
     return await ctx.db
       .query("workAttemptEvents")
-      .withIndex("by_attempt_and_sequence", (q) =>
+      .withIndex("by_attempt_and_sequence", (q: any) =>
         q.eq("attemptId", args.attemptId)
       )
       .order("asc")

packages/backend/convex/workExecutionAgent.ts

@@ -1,97 +0,0 @@
-"use node";
-
-import { env } from "@code/env/convex";
-import {
-  WorkAttemptExecutionError,
-  decodeWorkAttemptExecutionFailure,
-  decodeWorkAttemptExecutionResult,
-} from "@code/primitives/execution-runtime";
-import { ConvexError, v } from "convex/values";
-import { Effect } from "effect";
-
-import { internal } from "./_generated/api";
-import { internalAction } from "./_generated/server";
-import { decryptCredential } from "./gitConnections";
-
-const backendUrl = () => env.AGENT_BACKEND_URL ?? env.FLUE_URL;
-
-export const executeAttempt = internalAction({
-  args: { attemptId: v.id("workAttempts") },
-  handler: async (ctx, args) => {
-    const running = await ctx.runMutation(
-      internal.workExecutionWorkflow.markAttemptRunning,
-      args
-    );
-    if (!running) {
-      throw new ConvexError("Attempt is no longer runnable");
-    }
-    const context = await ctx.runQuery(
-      internal.workExecutionWorkflow.executionContext,
-      args
-    );
-    const credential = await decryptCredential(
-      context.connection.credentialCiphertext,
-      context.connection.credentialIv
-    );
-    const response = await fetch(
-      `${backendUrl()}/internal/work-attempts/execute`,
-      {
-        body: JSON.stringify({
-          attemptId: String(context.attempt._id),
-          auth: {
-            credential,
-            provider: context.connection.provider,
-            serverUrl: context.connection.serverUrl,
-            username: context.connection.username,
-          },
-          baseBranch: context.project.defaultBranch ?? "main",
-          prompt: context.prompt,
-          repositoryUrl: context.project.sourceUrl,
-          runId: String(context.run._id),
-          workId: String(context.work._id),
-          workspaceKey: context.attempt.workspaceKey,
-        }),
-        headers: {
-          authorization: `Bearer ${env.FLUE_DB_TOKEN}`,
-          "content-type": "application/json",
-        },
-        method: "POST",
-      }
-    );
-    const payload = (await response.json()) as unknown;
-    if (!response.ok) {
-      // Decode the agent's classified failure envelope and re-throw as the
-      // typed runtime error so the workflow handler maps reason/retryable to
-      // a durable attempt classification. A malformed envelope falls back to
-      // an InvalidInput failure (non-retryable).
-      const failure = await Effect.runPromise(
-        decodeWorkAttemptExecutionFailure(payload)
-      );
-      throw new WorkAttemptExecutionError(failure.error);
-    }
-    return await Effect.runPromise(decodeWorkAttemptExecutionResult(payload));
-  },
-});
-
-export const cancelAttempt = internalAction({
-  args: {
-    attemptId: v.string(),
-    workspaceKey: v.string(),
-  },
-  handler: async (_ctx, args) => {
-    // The workspace key remains the URL path segment (workspace identity),
-    // while the body carries the attemptId so the runtime can target the
-    // matching Pi ACP session for cancellation.
-    await fetch(
-      `${backendUrl()}/internal/work-attempts/${encodeURIComponent(args.workspaceKey)}/cancel`,
-      {
-        body: JSON.stringify({ attemptId: args.attemptId }),
-        headers: {
-          authorization: `Bearer ${env.FLUE_DB_TOKEN}`,
-          "content-type": "application/json",
-        },
-        method: "POST",
-      }
-    );
-  },
-});

packages/backend/convex/workExecutionWorkflow.test.ts

@@ -1,381 +0,0 @@
-import { convexTest } from "convex-test";
-import { anyApi } from "convex/server";
-import { describe, expect, test } from "vitest";
-
-import schema from "./schema";
-
-const modules = import.meta.glob("./**/*.ts");
-const api = anyApi;
-
-type TestContext = ReturnType<typeof convexTest>;
-
-interface Seeded {
-  attemptId: string;
-  runId: string;
-  t: TestContext;
-  workId: string;
-}
-
-// Seed an in-flight real attempt so each mutation under test starts from a
-// realistic running state: Work "executing", Run "running", Attempt "running".
-const seedRunningAttempt = async (
-  overrides: {
-    attemptStatus?: "queued" | "claimed" | "running" | "terminal";
-    runStatus?: "ready" | "running" | "terminal" | "cancelled";
-  } = {}
-): Promise<Seeded> => {
-  const t = convexTest({ modules, schema });
-  const seeded = await t.run(async (ctx) => {
-    const organizationId = await ctx.db.insert("organizations", {
-      createdAt: 1,
-      createdBy: "user",
-      kind: "personal",
-      name: "Personal",
-    });
-    const projectId = await ctx.db.insert("projects", {
-      createdAt: 1,
-      name: "Zopu",
-      normalizedSourceUrl: "https://github.com/puter/zopu",
-      organizationId,
-      repositoryPath: "puter/zopu",
-      sourceHost: "github.com",
-      sourceUrl: "https://github.com/puter/zopu",
-      updatedAt: 1,
-    });
-    const workId = await ctx.db.insert("works", {
-      createdAt: 1,
-      objective: "Implement a real slice",
-      organizationId,
-      projectId,
-      status: "executing",
-      title: "Real execution",
-      updatedAt: 1,
-    });
-    const sliceRowId = await ctx.db.insert("workSlices", {
-      designVersion: 1,
-      objective: "Change the repo",
-      observableBehavior: "A diff exists",
-      ordinal: 0,
-      payloadJson: "{}",
-      sliceId: "slice-1",
-      status: "running",
-      title: "Implementation",
-      workId,
-    });
-    const runId = await ctx.db.insert("workRuns", {
-      createdAt: 1,
-      designVersion: 1,
-      executionKind: "real",
-      kitId: "coding-v0",
-      kitVersion: "1",
-      scenario: "success",
-      sliceId: "slice-1",
-      sliceRowId,
-      status: overrides.runStatus ?? "running",
-      workId,
-    });
-    const attemptId = await ctx.db.insert("workAttempts", {
-      number: 1,
-      runId,
-      status: overrides.attemptStatus ?? "running",
-      workId,
-      workspaceKey: "workspace-1",
-    });
-    return { attemptId, runId, workId };
-  });
-  return { ...seeded, t };
-};
-
-const successResult = {
-  baseRevision: "base123",
-  candidateRevision: "candidate456",
-  changedFiles: ["src/index.ts"],
-  diff: "+export const ready = true;",
-  environmentId: "workspace-1",
-  events: [
-    {
-      kind: "runtime.completed",
-      message: "completed",
-      metadata: {},
-      occurredAt: 2,
-      sequence: 0,
-    },
-  ],
-  summary: "Changed one file",
-};
-
-describe("real work execution persistence", () => {
-  test("records revisions, activity, diff, and terminal state atomically", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.completeAttempt, {
-      attemptId: seeded.attemptId,
-      result: successResult,
-    });
-
-    const state = await t.run(async (ctx) => ({
-      artifacts: await ctx.db.query("workArtifacts").collect(),
-      attempt: await ctx.db.get(seeded.attemptId as any),
-      run: await ctx.db.get(seeded.runId as any),
-      work: await ctx.db.get(seeded.workId as any),
-    }));
-    expect(state.attempt?.classification).toBe("Succeeded");
-    expect(state.run).toMatchObject({
-      baseRevision: "base123",
-      candidateRevision: "candidate456",
-      terminalClassification: "Succeeded",
-    });
-    expect(state.work?.status).toBe("completed");
-    expect(state.artifacts[0]).toMatchObject({
-      kind: "diff",
-      sourceRevision: "candidate456",
-    });
-  });
-});
-
-describe("classified failure mapping", () => {
-  test("maps a transient runtime reason to a retryable classification", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.failAttempt, {
-      attemptId: seeded.attemptId,
-      reason: "ProviderUnavailable",
-      retryable: true,
-      summary: "model provider timed out",
-    });
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.classification).toBe("RetryableFailure");
-    expect(attempt?.failureReason).toBe("ProviderUnavailable");
-  });
-
-  test("queues a new attempt without terminalizing a retryable run", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.failAttempt, {
-      attemptId: seeded.attemptId,
-      reason: "ProviderUnavailable",
-      retryable: true,
-      summary: "provider unavailable",
-    });
-    const state = await t.run(async (ctx) => ({
-      attempts: await ctx.db.query("workAttempts").collect(),
-      run: await ctx.db.get(seeded.runId as any),
-      work: await ctx.db.get(seeded.workId as any),
-    }));
-    expect(state.attempts).toHaveLength(2);
-    expect(state.attempts[1]).toMatchObject({
-      number: 2,
-      status: "queued",
-      workspaceKey: "workspace-1",
-    });
-    expect(state.run?.status).toBe("running");
-    expect(state.work?.status).toBe("executing");
-  });
-  test("maps an authentication reason to a permanent failure", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.failAttempt, {
-      attemptId: seeded.attemptId,
-      reason: "Authentication",
-      retryable: false,
-      summary: "token rejected",
-    });
-    const state = await t.run(async (ctx) => ({
-      attempt: await ctx.db.get(seeded.attemptId as any),
-      run: await ctx.db.get(seeded.runId as any),
-      work: await ctx.db.get(seeded.workId as any),
-    }));
-    expect(state.attempt?.classification).toBe("PermanentFailure");
-    expect(state.attempt?.failureReason).toBe("Authentication");
-    expect(state.run?.terminalClassification).toBe("PermanentFailure");
-    expect(state.work?.status).toBe("failed");
-  });
-});
-
-describe("cancellation fencing", () => {
-  test("a cancelled attempt cannot later settle success", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    // Simulate cancellation marking the attempt/run terminal as Cancelled.
-    await t.run(async (ctx) => {
-      await ctx.db.patch(seeded.attemptId as any, {
-        classification: "Cancelled",
-        endedAt: 5,
-        status: "terminal",
-        summary: "Execution cancelled",
-      });
-      await ctx.db.patch(seeded.runId as any, {
-        endedAt: 5,
-        status: "cancelled",
-        terminalClassification: "Cancelled",
-        terminalSummary: "Execution cancelled",
-      });
-    });
-    // A late-arriving completion must be ignored.
-    await t.mutation(api.workExecutionWorkflow.completeAttempt, {
-      attemptId: seeded.attemptId,
-      result: successResult,
-    });
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.classification).toBe("Cancelled");
-    expect(attempt?.status).toBe("terminal");
-  });
-
-  test("a late failure does not overwrite a cancelled run", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.run(async (ctx) => {
-      await ctx.db.patch(seeded.attemptId as any, {
-        classification: "Cancelled",
-        endedAt: 5,
-        status: "terminal",
-      });
-      await ctx.db.patch(seeded.runId as any, { status: "cancelled" });
-    });
-    await t.mutation(api.workExecutionWorkflow.failAttempt, {
-      attemptId: seeded.attemptId,
-      reason: "HarnessFailed",
-      retryable: true,
-      summary: "late failure",
-    });
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.classification).toBe("Cancelled");
-  });
-});
-
-describe("empty-change rejection", () => {
-  test("a no-op result with no changed files fails as permanent", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.completeAttempt, {
-      attemptId: seeded.attemptId,
-      result: {
-        ...successResult,
-        changedFiles: [],
-        candidateRevision: "base123",
-      },
-    });
-    const state = await t.run(async (ctx) => ({
-      attempt: await ctx.db.get(seeded.attemptId as any),
-      work: await ctx.db.get(seeded.workId as any),
-    }));
-    expect(state.attempt?.classification).toBe("PermanentFailure");
-    expect(state.attempt?.failureReason).toBe("InvalidInput");
-    expect(state.work?.status).toBe("failed");
-  });
-
-  test("identical base and candidate revisions are rejected", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    await t.mutation(api.workExecutionWorkflow.completeAttempt, {
-      attemptId: seeded.attemptId,
-      result: {
-        ...successResult,
-        baseRevision: "same",
-        candidateRevision: "same",
-      },
-    });
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.classification).toBe("PermanentFailure");
-  });
-});
-
-describe("attempt re-entry", () => {
-  test("markAttemptRunning re-claims an already-running attempt", async () => {
-    const { t, ...seeded } = await seedRunningAttempt();
-    // First claim (already "running" from seed) must still succeed so a
-    // workflow replay can re-enter the same live attempt.
-    const first = await t.mutation(
-      api.workExecutionWorkflow.markAttemptRunning,
-      { attemptId: seeded.attemptId }
-    );
-    expect(first).toBe(true);
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.status).toBe("running");
-    expect(attempt?.leaseExpiresAt).toBeGreaterThan(0);
-  });
-
-  test("a terminal attempt is not re-runnable", async () => {
-    const { t, ...seeded } = await seedRunningAttempt({
-      attemptStatus: "terminal",
-    });
-    const result = await t.mutation(
-      api.workExecutionWorkflow.markAttemptRunning,
-      { attemptId: seeded.attemptId }
-    );
-    expect(result).toBe(false);
-  });
-  test("a cancelled run cannot re-enter a queued attempt", async () => {
-    const { t, ...seeded } = await seedRunningAttempt({
-      attemptStatus: "queued",
-      runStatus: "cancelled",
-    });
-    const result = await t.mutation(
-      api.workExecutionWorkflow.markAttemptRunning,
-      { attemptId: seeded.attemptId }
-    );
-    expect(result).toBe(false);
-    const attempt = await t.run((ctx) => ctx.db.get(seeded.attemptId as any));
-    expect(attempt?.status).toBe("queued");
-  });
-});
-
-describe("forge credential validation", () => {
-  const identity = { tokenIdentifier: "https://convex.test|forge-user" };
-
-  const seedForgableProject = async (
-    provider: "github" | "gitea",
-    sourceHost: string
-  ) => {
-    const t = convexTest({ modules, schema }).withIdentity(identity);
-    const ids = await t.run(async (ctx) => {
-      const organizationId = await ctx.db.insert("organizations", {
-        createdAt: 1,
-        createdBy: identity.tokenIdentifier,
-        kind: "personal",
-        name: "Personal",
-      });
-      await ctx.db.insert("organizationMembers", {
-        createdAt: 1,
-        organizationId,
-        role: "owner",
-        userId: identity.tokenIdentifier,
-      });
-      const projectId = await ctx.db.insert("projects", {
-        createdAt: 1,
-        name: "Zopu",
-        normalizedSourceUrl: `https://${sourceHost}/puter/zopu`,
-        organizationId,
-        repositoryPath: "puter/zopu",
-        sourceHost,
-        sourceUrl: `https://${sourceHost}/puter/zopu`,
-        updatedAt: 1,
-      });
-      const connectionId = await ctx.db.insert("gitConnections", {
-        connectedAt: 1,
-        credentialCiphertext: "x",
-        credentialIv: "y",
-        credentialKind: provider === "github" ? "oauth" : "token",
-        organizationId,
-        provider,
-        serverUrl: `https://${sourceHost}`,
-        updatedAt: 1,
-        username: "zopu",
-      });
-      return { connectionId, projectId };
-    });
-    return { t, ids };
-  };
-
-  test("rejects a git connection whose provider mismatches the project forge", async () => {
-    // Gitea token attached to a GitHub-hosted project.
-    const { t, ids } = await seedForgableProject("gitea", "github.com");
-    await expect(
-      t.mutation(api.gitConnectionData.attachToProject, {
-        connectionId: ids.connectionId,
-        projectId: ids.projectId,
-      })
-    ).rejects.toThrow(/does not match this project's forge/u);
-  });
-
-  test("accepts a matching provider for the project forge", async () => {
-    const { t, ids } = await seedForgableProject("github", "github.com");
-    const result = await t.mutation(api.gitConnectionData.attachToProject, {
-      connectionId: ids.connectionId,
-      projectId: ids.projectId,
-    });
-    expect(result).toMatchObject({ attached: true });
-  });
-});

packages/backend/convex/workExecutionWorkflow.ts

@@ -1,632 +0,0 @@
-import { WorkAttemptExecutionError } from "@code/primitives/execution-runtime";
-import type { WorkAttemptExecutionErrorReason } from "@code/primitives/execution-runtime";
-import { defaultCodingKitV0, resolveOutcome } from "@code/primitives/resolver";
-import type { AttemptClassification } from "@code/primitives/resolver";
-import { WorkflowManager } from "@convex-dev/workflow";
-import type { WorkflowId } from "@convex-dev/workflow";
-import { ConvexError, v } from "convex/values";
-
-import { components, internal } from "./_generated/api";
-import type { Doc, Id } from "./_generated/dataModel";
-import { internalMutation, internalQuery, mutation } from "./_generated/server";
-import type { MutationCtx } from "./_generated/server";
-import { requireProjectMember } from "./authz";
-import { forgeForHost } from "./gitConnectionData";
-
-export const workflow = new WorkflowManager(components.workflow);
-
-// Lease window for a running real attempt. Long enough to outlast a single
-// agent turn; the workflow's own retry/lease reconciliation covers crashes.
-const LEASE_MS = 5 * 60_000;
-
-// Runtime failure reason -> durable attempt classification. The Convex
-// workflow stores classifications, not provider-specific reasons, so the
-// resolver and Work lifecycle stay forge-agnostic. `retryable` from the
-// runtime is carried alongside and consulted by the kit retry policy.
-const FAILURE_REASON_CLASSIFICATION = {
-  Authentication: "PermanentFailure",
-  Cancelled: "Cancelled",
-  HarnessFailed: "RetryableFailure",
-  InvalidInput: "PermanentFailure",
-  ProviderUnavailable: "RetryableFailure",
-  RepositoryFailed: "PermanentFailure",
-  Timeout: "RetryableFailure",
-} as const satisfies Record<
-  WorkAttemptExecutionErrorReason,
-  AttemptClassification
->;
-
-export const classifyFailure = (
-  reason: WorkAttemptExecutionErrorReason
-): AttemptClassification => FAILURE_REASON_CLASSIFICATION[reason];
-
-// Normalize an error thrown from the agent action into the durable failure
-// triple (reason/retryable/summary). WorkAttemptExecutionError is the
-// classified runtime failure; anything else is a Convex/infrastructure error
-// treated as a transient HarnessFailed so the workflow retry policy decides.
-const toExecutionFailure = (
-  error: unknown
-): {
-  message: string;
-  reason: WorkAttemptExecutionErrorReason;
-  retryable: boolean;
-} =>
-  error instanceof WorkAttemptExecutionError
-    ? {
-        message: error.message,
-        reason: error.reason,
-        retryable: error.retryable,
-      }
-    : {
-        message: error instanceof Error ? error.message : "Execution failed",
-        reason: "HarnessFailed",
-        retryable: true,
-      };
-
-const failureReasonValues = v.union(
-  v.literal("Authentication"),
-  v.literal("Cancelled"),
-  v.literal("HarnessFailed"),
-  v.literal("InvalidInput"),
-  v.literal("ProviderUnavailable"),
-  v.literal("RepositoryFailed"),
-  v.literal("Timeout")
-);
-
-const resolveReadySlice = async (
-  ctx: MutationCtx,
-  work: Doc<"works">,
-  sliceId?: string
-) => {
-  if (work.designVersion === undefined) {
-    throw new ConvexError("Work has no approved Design to execute");
-  }
-  const slices = await ctx.db
-    .query("workSlices")
-    .withIndex("by_workId_and_designVersion", (q) =>
-      q.eq("workId", work._id).eq("designVersion", work.designVersion!)
-    )
-    .collect();
-  const slice = sliceId
-    ? slices.find((candidate) => candidate.sliceId === sliceId)
-    : slices
-        .sort((left, right) => left.ordinal - right.ordinal)
-        .find((candidate) => candidate.status === "ready");
-  if (!slice || slice.status !== "ready") {
-    throw new ConvexError("Only the next ready slice can be executed");
-  }
-  return slice;
-};
-
-// Deployment prerequisite gate for real execution. Rejects before any
-// workflow/sandbox starts when the project lacks an attached, forge-matched
-// Git connection with a cloneable source URL and default branch. Returns the
-// validated connection so the caller can pass it to the agent unchanged.
-const validateProjectDeployment = async (
-  ctx: MutationCtx,
-  work: Doc<"works">
-): Promise<Doc<"gitConnections">> => {
-  const project = await ctx.db.get(work.projectId);
-  if (!project) {
-    throw new ConvexError("Project not found");
-  }
-  if (!project.gitConnectionId) {
-    throw new ConvexError("Connect Git credentials to this project first");
-  }
-  const connection = await ctx.db.get(project.gitConnectionId);
-  if (!connection) {
-    throw new ConvexError("Git connection not found");
-  }
-  const expected = forgeForHost(project.sourceHost);
-  if (expected && connection.provider !== expected) {
-    throw new ConvexError(
-      `Git credential provider (${connection.provider}) does not match this project's forge (${expected})`
-    );
-  }
-  return connection;
-};
-
-export const execute = workflow
-  .define({ args: { attemptId: v.id("workAttempts") } })
-  .handler(async (step, args): Promise<void> => {
-    try {
-      const result = await step.runAction(
-        internal.workExecutionAgent.executeAttempt,
-        args,
-        { retry: true }
-      );
-      await step.runMutation(internal.workExecutionWorkflow.completeAttempt, {
-        attemptId: args.attemptId,
-        result: {
-          ...result,
-          changedFiles: [...result.changedFiles],
-          events: result.events.map((item) => ({
-            ...item,
-            metadata: { ...item.metadata },
-          })),
-        },
-      });
-    } catch (error) {
-      const failure = toExecutionFailure(error);
-      await step.runMutation(internal.workExecutionWorkflow.failAttempt, {
-        attemptId: args.attemptId,
-        reason: failure.reason,
-        retryable: failure.retryable,
-        summary: failure.message,
-      });
-    }
-  });
-
-export const startExecution = mutation({
-  args: {
-    sliceId: v.optional(v.string()),
-    workId: v.id("works"),
-  },
-  handler: async (
-    ctx,
-    args
-  ): Promise<{
-    attemptId: Id<"workAttempts">;
-    runId: Id<"workRuns">;
-    workflowId: WorkflowId;
-  }> => {
-    const work = await ctx.db.get(args.workId);
-    if (!work) {
-      throw new ConvexError("Work not found");
-    }
-    await requireProjectMember(ctx, work.projectId);
-    if (work.status !== "ready") {
-      throw new ConvexError("Work must be Ready before execution");
-    }
-    if (
-      work.definitionApprovalVersion !== work.definitionVersion ||
-      work.designApprovalVersion !== work.designVersion
-    ) {
-      throw new ConvexError("Execution requires exact approved versions");
-    }
-    await validateProjectDeployment(ctx, work);
-    const slice = await resolveReadySlice(ctx, work, args.sliceId);
-    const createdAt = Date.now();
-    const runId = await ctx.db.insert("workRuns", {
-      createdAt,
-      designVersion: slice.designVersion,
-      executionKind: "real",
-      kitId: defaultCodingKitV0.id,
-      kitVersion: defaultCodingKitV0.version,
-      scenario: "success",
-      sliceId: slice.sliceId,
-      sliceRowId: slice._id,
-      status: "running",
-      workId: work._id,
-    });
-    const workspaceKey = `work-${work._id}-run-${runId}`;
-    const attemptId = await ctx.db.insert("workAttempts", {
-      number: 1,
-      runId,
-      status: "queued",
-      workId: work._id,
-      workspaceKey,
-    });
-    const workflowId: WorkflowId = await workflow.start(
-      ctx,
-      internal.workExecutionWorkflow.execute,
-      { attemptId }
-    );
-    await ctx.db.patch(runId, { startedAt: createdAt, workflowId });
-    await ctx.db.patch(slice._id, { status: "running" });
-    await ctx.db.patch(work._id, { status: "executing", updatedAt: createdAt });
-    await ctx.db.insert("workEvents", {
-      createdAt,
-      idempotencyKey: `real-run-started:${runId}`,
-      kind: "run.started",
-      referenceId: String(runId),
-      workId: work._id,
-    });
-    return { attemptId, runId, workflowId };
-  },
-});
-
-export const executionContext = internalQuery({
-  args: { attemptId: v.id("workAttempts") },
-  handler: async (ctx, args) => {
-    const attempt = await ctx.db.get(args.attemptId);
-    if (!attempt) {
-      throw new ConvexError("Attempt not found");
-    }
-    const run = await ctx.db.get(attempt.runId);
-    const work = await ctx.db.get(attempt.workId);
-    if (!run || !work || !run.sliceRowId) {
-      throw new ConvexError("Execution records are incomplete");
-    }
-    const [slice, project] = await Promise.all([
-      ctx.db.get(run.sliceRowId),
-      ctx.db.get(work.projectId),
-    ]);
-    if (!slice || !project?.gitConnectionId) {
-      throw new ConvexError("Project execution configuration is incomplete");
-    }
-    const connection = await ctx.db.get(project.gitConnectionId);
-    if (!connection) {
-      throw new ConvexError("Git connection not found");
-    }
-    const expectedForge = forgeForHost(project.sourceHost);
-    if (expectedForge && connection.provider !== expectedForge) {
-      throw new ConvexError(
-        `Git credential provider (${connection.provider}) does not match this project's forge (${expectedForge})`
-      );
-    }
-    return {
-      attempt,
-      connection,
-      project,
-      prompt: [
-        `Implement this approved Zopu slice: ${slice.title}`,
-        `Objective: ${slice.objective}`,
-        `Observable behavior: ${slice.observableBehavior}`,
-        "Inspect the repository instructions first. Make focused changes and run relevant checks.",
-      ].join("\n\n"),
-      run,
-      work,
-    };
-  },
-});
-
-export const markAttemptRunning = internalMutation({
-  args: { attemptId: v.id("workAttempts") },
-  handler: async (ctx, args) => {
-    const attempt = await ctx.db.get(args.attemptId);
-    if (!attempt || attempt.status === "terminal") {
-      return false;
-    }
-    const run = await ctx.db.get(attempt.runId);
-    if (!run || run.status !== "running") {
-      return false;
-    }
-    await ctx.db.patch(attempt._id, {
-      leaseExpiresAt: Date.now() + LEASE_MS,
-      startedAt: attempt.startedAt ?? Date.now(),
-      status: "running",
-    });
-    return true;
-  },
-});
-
-const settleSliceAndWork = async (
-  ctx: MutationCtx,
-  run: Doc<"workRuns">,
-  succeeded: boolean,
-  workStatus: Doc<"works">["status"]
-) => {
-  if (!run.sliceRowId) {
-    return;
-  }
-  const slice = await ctx.db.get(run.sliceRowId);
-  if (!slice) {
-    return;
-  }
-  let sliceStatus: "blocked" | "completed" | "ready" = "ready";
-  if (succeeded) {
-    sliceStatus = "completed";
-  } else if (workStatus === "blocked") {
-    sliceStatus = "blocked";
-  }
-  await ctx.db.patch(slice._id, { status: sliceStatus });
-  const work = await ctx.db.get(run.workId);
-  if (!work) {
-    return;
-  }
-  let status = workStatus;
-  if (succeeded) {
-    const slices = await ctx.db
-      .query("workSlices")
-      .withIndex("by_workId_and_designVersion", (q) =>
-        q.eq("workId", work._id).eq("designVersion", slice.designVersion)
-      )
-      .collect();
-    const next = slices
-      .sort((left, right) => left.ordinal - right.ordinal)
-      .find((candidate) => candidate.status === "planned");
-    if (next) {
-      await ctx.db.patch(next._id, { status: "ready" });
-      status = "ready";
-    }
-  }
-  await ctx.db.patch(work._id, { status, updatedAt: Date.now() });
-};
-
-export const completeAttempt = internalMutation({
-  args: {
-    attemptId: v.id("workAttempts"),
-    result: v.object({
-      baseRevision: v.string(),
-      candidateRevision: v.string(),
-      changedFiles: v.array(v.string()),
-      diff: v.string(),
-      environmentId: v.string(),
-      events: v.array(
-        v.object({
-          kind: v.string(),
-          message: v.string(),
-          metadata: v.record(v.string(), v.string()),
-          occurredAt: v.number(),
-          sequence: v.number(),
-        })
-      ),
-      summary: v.string(),
-    }),
-  },
-  handler: async (ctx, args) => {
-    const attempt = await ctx.db.get(args.attemptId);
-    // Cancellation fencing: a terminal or cancelled attempt/run must never
-    // later settle success, even if the agent action raced to completion.
-    if (!attempt || attempt.status === "terminal") {
-      return;
-    }
-    const run = await ctx.db.get(attempt.runId);
-    const work = await ctx.db.get(attempt.workId);
-    if (!run || !work) {
-      throw new ConvexError("Execution records not found");
-    }
-    if (run.status === "terminal" || run.status === "cancelled") {
-      return;
-    }
-    // Empty-change rejection: a no-op result (no changed files, or identical
-    // base/candidate revisions) is not a successful implementation. Fail it
-    // as a permanent InvalidInput so the resolver does not mark Work done.
-    const noOp =
-      args.result.changedFiles.length === 0 ||
-      args.result.baseRevision === args.result.candidateRevision;
-    if (noOp) {
-      await ctx.db.patch(attempt._id, {
-        classification: "PermanentFailure",
-        endedAt: Date.now(),
-        failureReason: "InvalidInput",
-        leaseExpiresAt: undefined,
-        status: "terminal",
-        summary: "Execution produced no repository changes",
-      });
-      await ctx.db.patch(run._id, {
-        endedAt: Date.now(),
-        status: "terminal",
-        terminalClassification: "PermanentFailure",
-        terminalSummary: "Execution produced no repository changes",
-      });
-      await settleSliceAndWork(ctx, run, false, "failed");
-      return;
-    }
-    for (const item of args.result.events) {
-      await ctx.db.insert("workAttemptEvents", {
-        attemptId: attempt._id,
-        kind: item.kind,
-        message: item.message,
-        metadataJson: JSON.stringify(item.metadata),
-        occurredAt: item.occurredAt,
-        sequence: item.sequence,
-      });
-    }
-    const endedAt = Date.now();
-    await ctx.db.patch(attempt._id, {
-      classification: "Succeeded",
-      endedAt,
-      leaseExpiresAt: undefined,
-      status: "terminal",
-      summary: args.result.summary,
-    });
-    await ctx.db.patch(run._id, {
-      baseRevision: args.result.baseRevision,
-      candidateRevision: args.result.candidateRevision,
-      endedAt,
-      environmentId: args.result.environmentId,
-      status: "terminal",
-      terminalClassification: "Succeeded",
-      terminalSummary: args.result.summary,
-    });
-    await ctx.db.insert("workArtifacts", {
-      attemptId: attempt._id,
-      createdAt: endedAt,
-      designVersion: run.designVersion,
-      environmentId: args.result.environmentId,
-      idempotencyKey: `real-diff:${attempt._id}`,
-      kind: "diff",
-      metadataJson: JSON.stringify({ changedFiles: args.result.changedFiles }),
-      organizationId: work.organizationId,
-      producer: "agentos-pi",
-      projectId: work.projectId,
-      provenanceJson: JSON.stringify({
-        baseRevision: args.result.baseRevision,
-      }),
-      runId: run._id,
-      sliceId: run.sliceId,
-      sourceRevision: args.result.candidateRevision,
-      title: "Implementation diff",
-      verificationStatus: "unverified",
-      workId: work._id,
-      ...(args.result.diff.length > 0
-        ? {
-            uri: `data:text/plain;charset=utf-8,${encodeURIComponent(args.result.diff.slice(0, 50_000))}`,
-          }
-        : {}),
-    });
-    await settleSliceAndWork(ctx, run, true, "completed");
-    await ctx.db.insert("workEvents", {
-      createdAt: endedAt,
-      idempotencyKey: `real-run-completed:${run._id}`,
-      kind: "run.completed",
-      payloadJson: JSON.stringify({ classification: "Succeeded" }),
-      referenceId: String(run._id),
-      workId: work._id,
-    });
-  },
-});
-
-export const launchAttemptWorkflow = internalMutation({
-  args: { attemptId: v.id("workAttempts") },
-  handler: async (ctx, args) => {
-    const attempt = await ctx.db.get(args.attemptId);
-    if (!attempt || attempt.status === "terminal") {
-      return;
-    }
-    const run = await ctx.db.get(attempt.runId);
-    if (!run || run.status !== "running") {
-      return;
-    }
-    const workflowId: WorkflowId = await workflow.start(
-      ctx,
-      internal.workExecutionWorkflow.execute,
-      args
-    );
-    await ctx.db.patch(run._id, { workflowId });
-  },
-});
-
-export const failAttempt = internalMutation({
-  args: {
-    attemptId: v.id("workAttempts"),
-    reason: failureReasonValues,
-    retryable: v.boolean(),
-    summary: v.string(),
-  },
-  handler: async (ctx, args) => {
-    const attempt = await ctx.db.get(args.attemptId);
-    // Cancellation fencing: once an attempt or run is terminal/cancelled, a
-    // late failure from the workflow catch block must not overwrite the
-    // settled state. This also prevents a cancelled attempt from settling
-    // as a different classification after cancelExecution ran.
-    if (!attempt || attempt.status === "terminal") {
-      return;
-    }
-    const run = await ctx.db.get(attempt.runId);
-    if (!run || run.status === "terminal" || run.status === "cancelled") {
-      return;
-    }
-    const classification = classifyFailure(args.reason);
-    const endedAt = Date.now();
-    await ctx.db.patch(attempt._id, {
-      classification,
-      endedAt,
-      failureReason: args.reason,
-      leaseExpiresAt: undefined,
-      status: "terminal",
-      summary: args.summary,
-    });
-    const outcome = resolveOutcome(
-      { classification, retryable: args.retryable, summary: args.summary },
-      attempt.number,
-      defaultCodingKitV0.retryPolicy
-    );
-    await ctx.db.insert("resolverDecisions", {
-      attemptId: attempt._id,
-      attemptNumber: attempt.number,
-      classification,
-      createdAt: endedAt,
-      decision: outcome.kind,
-      ...(outcome.kind === "terminal"
-        ? { resultingWorkStatus: outcome.workStatus }
-        : {}),
-      runId: run._id,
-      summary: args.summary,
-      workId: attempt.workId,
-    });
-    if (outcome.kind === "retry") {
-      const nextAttemptId = await ctx.db.insert("workAttempts", {
-        number: attempt.number + 1,
-        runId: run._id,
-        status: "queued",
-        workId: attempt.workId,
-        workspaceKey: attempt.workspaceKey,
-      });
-      await ctx.scheduler.runAfter(
-        0,
-        internal.workExecutionWorkflow.launchAttemptWorkflow,
-        { attemptId: nextAttemptId }
-      );
-      return;
-    }
-    await ctx.db.patch(run._id, {
-      endedAt,
-      status: "terminal",
-      terminalClassification: classification,
-      terminalSummary: args.summary,
-    });
-    await settleSliceAndWork(ctx, run, false, outcome.workStatus);
-    const work = await ctx.db.get(run.workId);
-    if (work) {
-      await ctx.db.insert("workEvents", {
-        createdAt: endedAt,
-        idempotencyKey: `real-run-failed:${run._id}`,
-        kind: "run.completed",
-        payloadJson: JSON.stringify({ classification }),
-        referenceId: String(run._id),
-        workId: work._id,
-      });
-    }
-  },
-});
-
-export const cancelExecution = mutation({
-  args: { runId: v.id("workRuns") },
-  handler: async (ctx, args) => {
-    const run = await ctx.db.get(args.runId);
-    if (!run) {
-      throw new ConvexError("Run not found");
-    }
-    await requireProjectMember(ctx, (await ctx.db.get(run.workId))!.projectId);
-    if (run.status !== "running") {
-      return { cancelled: false };
-    }
-    if (run.workflowId) {
-      await workflow.cancel(ctx, run.workflowId as WorkflowId);
-    }
-    const attempts = await ctx.db
-      .query("workAttempts")
-      .withIndex("by_runId_and_number", (q) => q.eq("runId", run._id))
-      .collect();
-    const attempt = attempts.find(
-      (candidate) => candidate.status !== "terminal"
-    );
-    if (attempt?.workspaceKey) {
-      await ctx.scheduler.runAfter(
-        0,
-        internal.workExecutionAgent.cancelAttempt,
-        {
-          attemptId: String(attempt._id),
-          workspaceKey: attempt.workspaceKey,
-        }
-      );
-      const cancelledAt = Date.now();
-      await ctx.db.patch(attempt._id, {
-        classification: "Cancelled",
-        endedAt: cancelledAt,
-        failureReason: "Cancelled",
-        leaseExpiresAt: undefined,
-        status: "terminal",
-        summary: "Execution cancelled",
-      });
-      await ctx.db.insert("resolverDecisions", {
-        attemptId: attempt._id,
-        attemptNumber: attempt.number,
-        classification: "Cancelled",
-        createdAt: cancelledAt,
-        decision: "terminal",
-        resultingWorkStatus: "ready",
-        runId: run._id,
-        summary: "Execution cancelled",
-        workId: run.workId,
-      });
-    }
-    await ctx.db.patch(run._id, {
-      endedAt: Date.now(),
-      status: "cancelled",
-      terminalClassification: "Cancelled",
-      terminalSummary: "Execution cancelled",
-    });
-    if (run.sliceRowId) {
-      await ctx.db.patch(run.sliceRowId, { status: "ready" });
-    }
-    const work = await ctx.db.get(run.workId);
-    if (work) {
-      await ctx.db.patch(work._id, { status: "ready", updatedAt: Date.now() });
-    }
-    return { cancelled: true };
-  },
-});

packages/backend/convex/workPlanning.test.ts

@@ -30,10 +30,10 @@ describe("Work planning and execution commands", () => {
         name: "Personal",
       });
       await ctx.db.insert("organizationMembers", {
-        createdAt: 1,
         organizationId,
-        role: "owner",
         userId: identity.tokenIdentifier,
+        role: "owner",
+        createdAt: 1,
       });
       const projectId = await ctx.db.insert("projects", {
         createdAt: 1,
@@ -46,12 +46,12 @@ describe("Work planning and execution commands", () => {
         updatedAt: 1,
       });
       const workId = await ctx.db.insert("works", {
-        createdAt: 1,
-        objective: "Prove the flow",
         organizationId,
         projectId,
-        status: "proposed",
         title: "Executable work",
+        objective: "Prove the flow",
+        status: "proposed",
+        createdAt: 1,
         updatedAt: 1,
       });
       return { projectId, workId };
@@ -63,67 +63,67 @@ describe("Work planning and execution commands", () => {
     const definition = await t
       .withIdentity(identity)
       .mutation(api.workPlanning.saveDefinitionProposal, {
+        workId: fixture.workId,
         payloadJson: JSON.stringify({
-          acceptanceCriteria: ["terminal"],
-          affectedUsers: ["user"],
-          assumptions: [],
-          constraints: [],
+          problem: "Need a proof",
           desiredOutcome: "A terminal simulation",
+          affectedUsers: ["user"],
           inScope: ["fake"],
           outOfScope: [],
-          problem: "Need a proof",
+          acceptanceCriteria: ["terminal"],
+          constraints: [],
+          assumptions: [],
           questions: [],
-          requiredArtifacts: ["events"],
           risk: "low",
+          requiredArtifacts: ["events"],
         }),
-        workId: fixture.workId,
       });
     await t
       .withIdentity(identity)
       .mutation(api.workPlanning.approveDefinition, {
-        version: definition.version,
         workId: fixture.workId,
+        version: definition.version,
       });
     const design = await t
       .withIdentity(identity)
       .mutation(api.workPlanning.saveDesignProposal, {
+        workId: fixture.workId,
         payloadJson: JSON.stringify({
-          architectureSummary: "fake",
-          callFlowDelta: [],
-          concerns: [],
-          evidenceRequirements: ["event"],
-          fileTreeDelta: [],
           impactMap: { files: [], modules: [], risks: [], summary: "small" },
-          invariants: ["terminal"],
+          architectureSummary: "fake",
+          fileTreeDelta: [],
+          callFlowDelta: [],
           keyInterfaces: [],
+          invariants: ["terminal"],
+          concerns: [],
           slices: [
             {
-              codeBoundaries: ["runtime"],
-              dependsOn: [],
-              evidenceRequirements: ["event"],
               id: "slice-1",
+              title: "fake",
               objective: "fake",
               observableBehavior: "event",
-              reviewRequired: false,
-              title: "fake",
+              codeBoundaries: ["runtime"],
+              evidenceRequirements: ["event"],
               verification: ["assert"],
+              reviewRequired: false,
+              dependsOn: [],
             },
           ],
+          evidenceRequirements: ["event"],
           tradeoffs: [],
         }),
-        workId: fixture.workId,
       });
     await t.withIdentity(identity).mutation(api.workPlanning.approveDesign, {
+      workId: fixture.workId,
       definitionVersion: definition.version,
       designVersion: design.version,
-      workId: fixture.workId,
     });
     const started = await t
       .withIdentity(identity)
       .mutation(api.workExecution.startSimulatedExecution, {
+        workId: fixture.workId,
         scenario: "success",
         sliceId: "slice-1",
-        workId: fixture.workId,
       });
     expect(started.runId).toBeTruthy();
     const state = await t.run(async (ctx) => ctx.db.get(fixture.workId));
@@ -137,7 +137,7 @@ describe("Work planning and execution commands", () => {
     const completed = await t.run(async (ctx) => ({
       attempt: await ctx.db
         .query("workAttempts")
-        .withIndex("by_runId_and_number", (q) => q.eq("runId", started.runId))
+        .withIndex("by_run_and_number", (q) => q.eq("runId", started.runId))
         .unique(),
       events: await ctx.db.query("workAttemptEvents").collect(),
       run: await ctx.db.get(started.runId as Id<"workRuns">),
@@ -164,154 +164,7 @@ const validDefinitionPayload = () => ({
   risk: "low",
 });
 
-const validDesignPayload = (sliceId = "slice-1") => ({
-  architectureSummary: "fake",
-  callFlowDelta: [],
-  concerns: [],
-  evidenceRequirements: ["event"],
-  fileTreeDelta: [],
-  impactMap: { files: [], modules: [], risks: [], summary: "small" },
-  invariants: ["terminal"],
-  keyInterfaces: [],
-  slices: [
-    {
-      codeBoundaries: ["runtime"],
-      dependsOn: [],
-      evidenceRequirements: ["event"],
-      id: sliceId,
-      objective: "fake",
-      observableBehavior: "event",
-      reviewRequired: false,
-      title: "fake",
-      verification: ["assert"],
-    },
-  ],
-  tradeoffs: [],
-});
-
 describe("Work planning guards", () => {
-  test("persists high-impact questions but blocks approval", async () => {
-    const t = convexTest({ modules, schema });
-    const { workId } = await t.withIdentity(identity).run(async (ctx) => {
-      const organizationId = await ctx.db.insert("organizations", {
-        createdAt: 1,
-        createdBy: identity.tokenIdentifier,
-        kind: "personal",
-        name: "Personal",
-      });
-      await ctx.db.insert("organizationMembers", {
-        createdAt: 1,
-        organizationId,
-        role: "owner",
-        userId: identity.tokenIdentifier,
-      });
-      const projectId = await ctx.db.insert("projects", {
-        createdAt: 1,
-        name: "Zopu",
-        normalizedSourceUrl: "https://example.com/zopu",
-        organizationId,
-        repositoryPath: "puter/zopu",
-        sourceHost: "example.com",
-        sourceUrl: "https://example.com/zopu",
-        updatedAt: 1,
-      });
-      const id = await ctx.db.insert("works", {
-        createdAt: 1,
-        objective: "Resolve a critical question",
-        organizationId,
-        projectId,
-        status: "defining",
-        title: "Question gate",
-        updatedAt: 1,
-      });
-      return { workId: id };
-    });
-    const saved = await t
-      .withIdentity(identity)
-      .mutation(api.workPlanning.saveDefinitionProposal, {
-        payloadJson: JSON.stringify({
-          ...validDefinitionPayload(),
-          questions: [
-            {
-              alternatives: ["public", "private"],
-              id: "visibility",
-              impact: "high",
-              prompt: "Should the endpoint be public?",
-              status: "open",
-            },
-          ],
-        }),
-        workId,
-      });
-    await expect(
-      t.withIdentity(identity).mutation(api.workPlanning.approveDefinition, {
-        version: saved.version,
-        workId,
-      })
-    ).rejects.toThrow(/High-impact open questions/u);
-    const stored = await t.run(async (ctx) =>
-      ctx.db.query("workQuestions").collect()
-    );
-    expect(stored).toHaveLength(1);
-    expect(stored[0]?.status).toBe("open");
-  });
-
-  test("keeps prior Design slices as versioned history", async () => {
-    const t = convexTest({ modules, schema });
-    const { workId } = await t.withIdentity(identity).run(async (ctx) => {
-      const organizationId = await ctx.db.insert("organizations", {
-        createdAt: 1,
-        createdBy: identity.tokenIdentifier,
-        kind: "personal",
-        name: "Personal",
-      });
-      await ctx.db.insert("organizationMembers", {
-        createdAt: 1,
-        organizationId,
-        role: "owner",
-        userId: identity.tokenIdentifier,
-      });
-      const projectId = await ctx.db.insert("projects", {
-        createdAt: 1,
-        name: "Zopu",
-        normalizedSourceUrl: "https://example.com/zopu",
-        organizationId,
-        repositoryPath: "puter/zopu",
-        sourceHost: "example.com",
-        sourceUrl: "https://example.com/zopu",
-        updatedAt: 1,
-      });
-      const id = await ctx.db.insert("works", {
-        createdAt: 1,
-        definitionApprovalVersion: 1,
-        definitionVersion: 1,
-        objective: "Preserve Design history",
-        organizationId,
-        projectId,
-        status: "designing",
-        title: "Versioned Design",
-        updatedAt: 1,
-      });
-      return { workId: id };
-    });
-    await t
-      .withIdentity(identity)
-      .mutation(api.workPlanning.saveDesignProposal, {
-        payloadJson: JSON.stringify(validDesignPayload("slice-v1")),
-        workId,
-      });
-    await t
-      .withIdentity(identity)
-      .mutation(api.workPlanning.saveDesignProposal, {
-        payloadJson: JSON.stringify(validDesignPayload("slice-v2")),
-        workId,
-      });
-    const slices = await t.run(async (ctx) =>
-      ctx.db.query("workSlices").collect()
-    );
-    expect(slices.map((slice) => slice.designVersion).sort()).toEqual([1, 2]);
-  });
-
   test("a Definition cannot be revised while a Run is executing", async () => {
     const t = convexTest({ modules, schema });
     const { workId } = await t.withIdentity(identity).run(async (ctx) => {

packages/backend/convex/workPlanning.ts

@@ -1,10 +1,8 @@
-import type { WorkEventKind } from "@code/primitives/work";
 import {
-  decodeDefinition,
+  type WorkDefinition,
   validateDefinition,
   WorkQuestion,
 } from "@code/primitives/work-definition";
-import type { WorkDefinition } from "@code/primitives/work-definition";
 import { validateDesignPacket } from "@code/primitives/work-design";
 import { makeFunctionReference } from "convex/server";
 import { ConvexError, v } from "convex/values";
@@ -14,12 +12,10 @@ import type { Doc, Id } from "./_generated/dataModel";
 import {
   env,
   internalAction,
-  internalMutation,
   internalQuery,
   mutation,
   query,
 } from "./_generated/server";
-import type { MutationCtx, QueryCtx } from "./_generated/server";
 import { requireProjectMember } from "./authz";
 
 const plannerRef = makeFunctionReference<
@@ -31,11 +27,6 @@ const plannerContextRef = makeFunctionReference<
   { workId: Id<"works"> },
   { objective: string; status: string; title: string } | null
 >("workPlanning:getPlannerContext");
-const plannerFailureRef = makeFunctionReference<
-  "mutation",
-  { workId: Id<"works">; error: string },
-  null
->("workPlanning:recordPlannerFailure");
 
 const parsePayload = (payloadJson: string): unknown => {
   try {
@@ -47,72 +38,67 @@ const parsePayload = (payloadJson: string): unknown => {
 
 const objectPayload = (payloadJson: string): Record<string, unknown> => {
   const value = parsePayload(payloadJson);
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new ConvexError("Proposal payload must be an object");
-  }
   return value as Record<string, unknown>;
 };
 
-const requireWork = async (
-  ctx: QueryCtx | MutationCtx,
-  workId: Id<"works">
-): Promise<Doc<"works">> => {
-  const work = await ctx.db.get(workId);
-  if (!work) {
-    throw new ConvexError("Work not found");
-  }
+const requireWork = async (ctx: { db: any }, workId: Id<"works">) => {
+  const work = (await ctx.db.get(workId)) as Doc<"works"> | null;
+  if (!work) throw new ConvexError("Work not found");
   return work;
 };
 
 const appendEvent = async (
-  ctx: MutationCtx,
+  ctx: { db: any },
   workId: Id<"works">,
-  kind: WorkEventKind,
+  kind: any,
   idempotencyKey: string,
   referenceId?: string,
   payloadJson?: string
 ) => {
   const existing = await ctx.db
     .query("workEvents")
-    .withIndex("by_work_and_idempotencyKey", (q) =>
+    .withIndex("by_work_and_idempotencyKey", (q: any) =>
       q.eq("workId", workId).eq("idempotencyKey", idempotencyKey)
     )
     .unique();
-  if (existing) {
-    return existing._id;
-  }
+  if (existing) return existing._id;
   return await ctx.db.insert("workEvents", {
-    createdAt: Date.now(),
-    idempotencyKey,
-    kind,
     workId,
+    kind,
+    idempotencyKey,
+    createdAt: Date.now(),
     ...(referenceId ? { referenceId } : {}),
     ...(payloadJson ? { payloadJson } : {}),
   });
 };
 
 const invalidateApprovalsAndDesign = async (
-  ctx: MutationCtx,
+  ctx: { db: any },
   workId: Id<"works">
 ) => {
   const approvals = await ctx.db
     .query("workApprovals")
-    .withIndex("by_workId_and_kind", (q) => q.eq("workId", workId))
+    .withIndex("by_work_and_kind", (q: any) => q.eq("workId", workId))
     .collect();
   for (const approval of approvals) {
-    if (approval.status === "active") {
+    if (approval.status === "active")
       await ctx.db.patch(approval._id, { status: "invalidated" });
-    }
   }
   const designs = await ctx.db
     .query("designPackets")
-    .withIndex("by_work_and_version", (q) => q.eq("workId", workId))
+    .withIndex("by_work_and_version", (q: any) => q.eq("workId", workId))
     .collect();
   for (const design of designs) {
-    if (design.status === "current") {
+    if (design.status === "current")
       await ctx.db.patch(design._id, { status: "superseded" });
-    }
   }
+  const slices = await ctx.db
+    .query("workSlices")
+    .withIndex("by_work_and_designVersion", (q: any) => q.eq("workId", workId))
+    .collect();
+  for (const slice of slices) await ctx.db.delete(slice._id);
 };
 
 export const requestDefinition = mutation({
@@ -120,16 +106,8 @@ export const requestDefinition = mutation({
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
-    if (
-      work.status !== "proposed" &&
-      work.status !== "defining" &&
-      !(
-        work.status === "blocked" &&
-        work.definitionApprovalVersion !== work.definitionVersion
-      )
-    ) {
+    if (work.status !== "proposed" && work.status !== "defining")
       throw new ConvexError("Work is not available for definition");
-    }
     const now = Date.now();
     await ctx.db.patch(work._id, { status: "defining", updatedAt: now });
     await appendEvent(
@@ -147,16 +125,15 @@ export const requestDefinition = mutation({
 });
 
 const saveDefinition = async (
-  ctx: MutationCtx,
+  ctx: { db: any },
   work: Doc<"works">,
   payloadJson: string,
   createdBy: string
 ) => {
-  if (work.status === "executing") {
+  if (work.status === "executing")
     throw new ConvexError("Cannot revise Work while a Run is executing");
-  }
   const decoded = await Effect.runPromise(
-    decodeDefinition({
+    validateDefinition({
       ...objectPayload(payloadJson),
       version: (work.definitionVersion ?? 0) + 1,
     })
@@ -165,45 +142,52 @@ const saveDefinition = async (
       error instanceof Error ? error.message : "Invalid Definition"
     );
   });
-  const { version } = decoded;
+  const version = decoded.version;
   await invalidateApprovalsAndDesign(ctx, work._id);
   const previous = await ctx.db
     .query("workDefinitions")
-    .withIndex("by_work_and_version", (q) => q.eq("workId", work._id))
+    .withIndex("by_work_and_version", (q: any) => q.eq("workId", work._id))
     .collect();
-  for (const row of previous) {
-    if (row.status === "current") {
+  for (const row of previous)
+    if (row.status === "current")
       await ctx.db.patch(row._id, { status: "superseded" });
-    }
-  }
   const definitionId = await ctx.db.insert("workDefinitions", {
-    createdAt: Date.now(),
-    createdBy,
+    workId: work._id,
+    version,
     payloadJson: JSON.stringify(decoded),
     risk: decoded.risk,
     status: "current",
-    version,
-    workId: work._id,
+    createdBy,
+    createdAt: Date.now(),
   });
+  const questions = await ctx.db
+    .query("workQuestions")
+    .withIndex("by_work_and_definitionVersion", (q: any) =>
+      q.eq("workId", work._id)
+    )
+    .collect();
+  for (const question of questions)
+    if (question.definitionVersion !== version)
+      await ctx.db.delete(question._id);
   for (const question of decoded.questions) {
     await ctx.db.insert("workQuestions", {
+      workId: work._id,
+      definitionVersion: version,
+      questionId: question.id,
+      prompt: question.prompt,
+      impact: question.impact,
+      recommendation: question.recommendation,
       alternativesJson: JSON.stringify(question.alternatives),
+      status: question.status,
       answer: question.answer,
       createdAt: Date.now(),
-      definitionVersion: version,
-      impact: question.impact,
-      prompt: question.prompt,
-      questionId: question.id,
-      recommendation: question.recommendation,
-      status: question.status,
-      workId: work._id,
     });
   }
   await ctx.db.patch(work._id, {
-    definitionApprovalVersion: undefined,
     definitionVersion: version,
-    designApprovalVersion: undefined,
+    definitionApprovalVersion: undefined,
     designVersion: undefined,
+    designApprovalVersion: undefined,
     status: "awaiting-definition-approval",
     updatedAt: Date.now(),
   });
@@ -219,7 +203,7 @@ const saveDefinition = async (
 };
 
 export const saveDefinitionProposal = mutation({
-  args: { payloadJson: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), payloadJson: v.string() },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
@@ -230,25 +214,22 @@ export const saveDefinitionProposal = mutation({
 export const reviseDefinition = saveDefinitionProposal;
 
 export const approveDefinition = mutation({
-  args: { version: v.number(), workId: v.id("works") },
+  args: { workId: v.id("works"), version: v.number() },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
     if (
       work.definitionVersion !== args.version ||
       work.status !== "awaiting-definition-approval"
-    ) {
+    )
       throw new ConvexError("Definition version is not current or approvable");
-    }
     const row = await ctx.db
       .query("workDefinitions")
-      .withIndex("by_work_and_version", (q) =>
+      .withIndex("by_work_and_version", (q: any) =>
         q.eq("workId", work._id).eq("version", args.version)
       )
       .unique();
-    if (!row) {
-      throw new ConvexError("Definition not found");
-    }
+    if (!row) throw new ConvexError("Definition not found");
     const definition = JSON.parse(row.payloadJson) as WorkDefinition;
     const valid = await Effect.runPromise(validateDefinition(definition)).catch(
       (error: unknown) => {
@@ -259,36 +240,19 @@ export const approveDefinition = mutation({
         );
       }
     );
-    const questions = await ctx.db
-      .query("workQuestions")
-      .withIndex("by_workId_and_definitionVersion", (q) =>
-        q.eq("workId", work._id).eq("definitionVersion", args.version)
-      )
-      .collect();
-    if (
-      questions.some(
-        (question) => question.status === "open" && question.impact === "high"
-      )
-    ) {
-      throw new ConvexError(
-        "High-impact open questions must be resolved before approval"
-      );
-    }
     const identity = await ctx.auth.getUserIdentity();
-    if (!identity) {
-      throw new ConvexError("Authentication required");
-    }
+    if (!identity) throw new ConvexError("Authentication required");
     await ctx.db.insert("workApprovals", {
-      approvedAt: Date.now(),
-      approvedBy: identity.tokenIdentifier,
-      definitionVersion: args.version,
-      kind: "definition",
-      status: "active",
       workId: work._id,
+      kind: "definition",
+      definitionVersion: args.version,
+      approvedBy: identity.subject,
+      approvedAt: Date.now(),
+      status: "active",
     });
     await ctx.db.patch(work._id, {
-      definitionApprovalVersion: valid.version,
       status: "designing",
+      definitionApprovalVersion: valid.version,
       updatedAt: Date.now(),
     });
     await appendEvent(
@@ -306,57 +270,36 @@ export const approveDefinition = mutation({
 });
 
 const reviseQuestion = async (
-  ctx: MutationCtx,
+  ctx: { db: any },
   work: Doc<"works">,
   questionId: string,
   update: { status: "answered" | "withdrawn"; answer?: string }
 ) => {
   const current = await ctx.db
     .query("workDefinitions")
-    .withIndex("by_work_and_version", (q) =>
+    .withIndex("by_work_and_version", (q: any) =>
       q.eq("workId", work._id).eq("version", work.definitionVersion ?? 0)
     )
     .unique();
-  if (!current) {
-    throw new ConvexError("Current Definition not found");
-  }
+  if (!current) throw new ConvexError("Current Definition not found");
   const definition = JSON.parse(current.payloadJson) as WorkDefinition;
-  const persistedQuestions = await ctx.db
-    .query("workQuestions")
-    .withIndex("by_workId_and_definitionVersion", (q) =>
-      q.eq("workId", work._id).eq("definitionVersion", current.version)
-    )
-    .collect();
-  if (
-    !persistedQuestions.some((question) => question.questionId === questionId)
-  ) {
-    throw new ConvexError("Question not found");
-  }
   const next = {
     ...definition,
-    questions: persistedQuestions.map((question) => ({
-      alternatives: JSON.parse(question.alternativesJson) as string[],
-      answer:
-        question.questionId === questionId ? update.answer : question.answer,
-      id: question.questionId,
-      impact: question.impact,
-      prompt: question.prompt,
-      recommendation: question.recommendation,
-      status:
-        question.questionId === questionId ? update.status : question.status,
-    })),
+    questions: definition.questions.map((question) =>
+      question.id === questionId ? { ...question, ...update } : question
+    ),
   };
   return await saveDefinition(ctx, work, JSON.stringify(next), "user");
 };
 
 export const answerQuestion = mutation({
-  args: { answer: v.string(), questionId: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), questionId: v.string(), answer: v.string() },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
     const result = await reviseQuestion(ctx, work, args.questionId, {
-      answer: args.answer,
       status: "answered",
+      answer: args.answer,
     });
     await appendEvent(
       ctx,
@@ -369,7 +312,7 @@ export const answerQuestion = mutation({
 });
 
 export const withdrawQuestion = mutation({
-  args: { questionId: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), questionId: v.string() },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
@@ -392,48 +335,35 @@ export const requestDesign = mutation({
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
     if (
-      (work.status !== "designing" && work.status !== "blocked") ||
+      work.status !== "designing" ||
       work.definitionApprovalVersion !== work.definitionVersion
-    ) {
+    )
       throw new ConvexError("Definition must be approved before Design");
-    }
-    if (work.status === "blocked") {
-      await ctx.db.patch(work._id, {
-        status: "designing",
-        updatedAt: Date.now(),
-      });
-    }
     await appendEvent(
       ctx,
       work._id,
       "design.requested",
       `design-requested:${work.definitionVersion}`
     );
-    await ctx.scheduler.runAfter(0, plannerRef, {
-      organizationId: work.organizationId,
-      workId: work._id,
-    });
-    return { status: "designing" as const };
+    return { status: work.status };
   },
 });
 
 const saveDesign = async (
-  ctx: MutationCtx,
+  ctx: { db: any },
   work: Doc<"works">,
   payloadJson: string,
   createdBy: string
 ) => {
-  if (work.status === "executing") {
+  if (work.status === "executing")
     throw new ConvexError("Cannot revise Work while a Run is executing");
-  }
-  if (work.definitionApprovalVersion !== work.definitionVersion) {
+  if (work.definitionApprovalVersion !== work.definitionVersion)
     throw new ConvexError("Design must bind an approved Definition version");
-  }
   const decoded = await Effect.runPromise(
     validateDesignPacket({
       ...objectPayload(payloadJson),
-      definitionVersion: work.definitionVersion,
       version: (work.designVersion ?? 0) + 1,
+      definitionVersion: work.definitionVersion,
     })
   ).catch((error: unknown) => {
     throw new ConvexError(
@@ -442,50 +372,51 @@ const saveDesign = async (
   });
   const prior = await ctx.db
     .query("designPackets")
-    .withIndex("by_work_and_version", (q) => q.eq("workId", work._id))
+    .withIndex("by_work_and_version", (q: any) => q.eq("workId", work._id))
     .collect();
-  for (const row of prior) {
-    if (row.status === "current") {
+  for (const row of prior)
+    if (row.status === "current")
       await ctx.db.patch(row._id, { status: "superseded" });
-    }
-  }
   const designApprovals = await ctx.db
     .query("workApprovals")
-    .withIndex("by_workId_and_kind", (q) =>
+    .withIndex("by_work_and_kind", (q: any) =>
       q.eq("workId", work._id).eq("kind", "design")
     )
     .collect();
-  for (const approval of designApprovals) {
-    if (approval.status === "active") {
+  for (const approval of designApprovals)
+    if (approval.status === "active")
       await ctx.db.patch(approval._id, { status: "invalidated" });
-    }
-  }
   const designId = await ctx.db.insert("designPackets", {
-    createdAt: Date.now(),
-    createdBy,
+    workId: work._id,
+    version: decoded.version,
     definitionVersion: decoded.definitionVersion,
     payloadJson: JSON.stringify(decoded),
     status: "current",
-    version: decoded.version,
-    workId: work._id,
+    createdBy,
+    createdAt: Date.now(),
   });
-  for (const [ordinal, slice] of decoded.slices.entries()) {
+  const priorSlices = await ctx.db
+    .query("workSlices")
+    .withIndex("by_work_and_designVersion", (q: any) =>
+      q.eq("workId", work._id)
+    )
+    .collect();
+  for (const slice of priorSlices) await ctx.db.delete(slice._id);
+  for (const [ordinal, slice] of decoded.slices.entries())
     await ctx.db.insert("workSlices", {
-      createdAt: Date.now(),
+      workId: work._id,
       designVersion: decoded.version,
+      sliceId: slice.id,
+      ordinal,
+      title: slice.title,
       objective: slice.objective,
       observableBehavior: slice.observableBehavior,
-      ordinal,
       payloadJson: JSON.stringify(slice),
-      sliceId: slice.id,
       status: ordinal === 0 ? "ready" : "planned",
-      title: slice.title,
-      workId: work._id,
     });
-  }
   await ctx.db.patch(work._id, {
-    designApprovalVersion: undefined,
     designVersion: decoded.version,
+    designApprovalVersion: undefined,
     status: "awaiting-design-approval",
     updatedAt: Date.now(),
   });
@@ -501,7 +432,7 @@ const saveDesign = async (
 };
 
 export const saveDesignProposal = mutation({
-  args: { payloadJson: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), payloadJson: v.string() },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
     await requireProjectMember(ctx, work.projectId);
@@ -513,9 +444,9 @@ export const reviseDesign = saveDesignProposal;
 
 export const approveDesign = mutation({
   args: {
+    workId: v.id("works"),
     definitionVersion: v.number(),
     designVersion: v.number(),
-    workId: v.id("works"),
   },
   handler: async (ctx, args) => {
     const work = await requireWork(ctx, args.workId);
@@ -524,27 +455,24 @@ export const approveDesign = mutation({
       work.definitionApprovalVersion !== args.definitionVersion ||
       work.designVersion !== args.designVersion ||
       work.status !== "awaiting-design-approval"
-    ) {
+    )
       throw new ConvexError(
         "Design approval must bind current Definition and Design versions"
       );
-    }
     const identity = await ctx.auth.getUserIdentity();
-    if (!identity) {
-      throw new ConvexError("Authentication required");
-    }
+    if (!identity) throw new ConvexError("Authentication required");
     await ctx.db.insert("workApprovals", {
-      approvedAt: Date.now(),
-      approvedBy: identity.tokenIdentifier,
+      workId: work._id,
+      kind: "design",
       definitionVersion: args.definitionVersion,
       designVersion: args.designVersion,
-      kind: "design",
+      approvedBy: identity.subject,
+      approvedAt: Date.now(),
       status: "active",
-      workId: work._id,
     });
     await ctx.db.patch(work._id, {
-      designApprovalVersion: args.designVersion,
       status: "ready",
+      designApprovalVersion: args.designVersion,
       updatedAt: Date.now(),
     });
     await appendEvent(
@@ -558,168 +486,83 @@ export const approveDesign = mutation({
 });
 
 export const submitDefinitionProposal = mutation({
-  args: { payloadJson: v.string(), token: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), payloadJson: v.string(), token: v.string() },
   handler: async (ctx, args) => {
-    if (args.token !== env.FLUE_DB_TOKEN) {
+    if (args.token !== env.FLUE_DB_TOKEN)
       throw new ConvexError("Invalid agent control token");
-    }
     const work = await requireWork(ctx, args.workId);
     return await saveDefinition(ctx, work, args.payloadJson, "work-planner");
   },
 });
 
 export const submitDesignProposal = mutation({
-  args: { payloadJson: v.string(), token: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), payloadJson: v.string(), token: v.string() },
   handler: async (ctx, args) => {
-    if (args.token !== env.FLUE_DB_TOKEN) {
+    if (args.token !== env.FLUE_DB_TOKEN)
       throw new ConvexError("Invalid agent control token");
-    }
     const work = await requireWork(ctx, args.workId);
     return await saveDesign(ctx, work, args.payloadJson, "work-planner");
   },
 });
 
 export const submitQuestion = mutation({
-  args: { questionJson: v.string(), token: v.string(), workId: v.id("works") },
+  args: { workId: v.id("works"), questionJson: v.string(), token: v.string() },
   handler: async (ctx, args) => {
-    if (args.token !== env.FLUE_DB_TOKEN) {
+    if (args.token !== env.FLUE_DB_TOKEN)
       throw new ConvexError("Invalid agent control token");
-    }
     const work = await requireWork(ctx, args.workId);
-    if (work.definitionVersion === undefined) {
+    if (work.definitionVersion === undefined)
       throw new ConvexError("Work has no Definition to attach a question to");
-    }
-    if (
-      work.status !== "defining" &&
-      work.status !== "awaiting-definition-approval"
-    ) {
-      throw new ConvexError(
-        "Questions can only be submitted while the Work is being defined"
-      );
-    }
     const question = await Effect.runPromise(
-      Schema.decodeUnknownEffect(WorkQuestion)(parsePayload(args.questionJson))
+      Schema.decodeUnknownEffect(WorkQuestion)(JSON.parse(args.questionJson))
     ).catch((error: unknown) => {
       throw new ConvexError(
         error instanceof Error ? error.message : "Invalid question"
       );
     });
-    const existing = await ctx.db
-      .query("workQuestions")
-      .withIndex("by_workId_and_definitionVersion_and_questionId", (q) =>
-        q
-          .eq("workId", work._id)
-          .eq("definitionVersion", work.definitionVersion!)
-          .eq("questionId", question.id)
-      )
-      .unique();
-    const questionRow = {
+    await ctx.db.insert("workQuestions", {
+      workId: work._id,
+      definitionVersion: work.definitionVersion,
+      questionId: question.id,
+      prompt: question.prompt,
+      impact: question.impact,
+      recommendation: question.recommendation,
       alternativesJson: JSON.stringify(question.alternatives),
+      status: question.status,
       answer: question.answer,
       createdAt: Date.now(),
-      definitionVersion: work.definitionVersion,
-      impact: question.impact,
-      prompt: question.prompt,
-      questionId: question.id,
-      recommendation: question.recommendation,
-      status: question.status,
-      workId: work._id,
-    };
-    if (existing) {
-      const same =
-        existing.prompt === questionRow.prompt &&
-        existing.impact === questionRow.impact &&
-        existing.recommendation === questionRow.recommendation &&
-        existing.alternativesJson === questionRow.alternativesJson &&
-        existing.status === questionRow.status &&
-        existing.answer === questionRow.answer;
-      if (!same) {
-        throw new ConvexError("Question ID already has different content");
-      }
-      return { accepted: false };
-    }
-    await ctx.db.insert("workQuestions", questionRow);
-    await appendEvent(
-      ctx,
-      work._id,
-      "question.created",
-      `question-created:${work.definitionVersion}:${question.id}`,
-      question.id,
-      JSON.stringify(question)
-    );
+    });
     return { accepted: true };
   },
 });
 
-export const recordPlannerFailure = internalMutation({
-  args: { error: v.string(), workId: v.id("works") },
-  handler: async (ctx, args): Promise<null> => {
-    const work = await ctx.db.get(args.workId);
-    if (!work || (work.status !== "defining" && work.status !== "designing")) {
-      return null;
-    }
-    await ctx.db.patch(work._id, { status: "blocked", updatedAt: Date.now() });
-    await appendEvent(
-      ctx,
-      work._id,
-      "planner.failed",
-      `planner-failed:${work._id}:${work.status}`,
-      undefined,
-      JSON.stringify({ error: args.error, phase: work.status })
-    );
-    return null;
-  },
-});
-
 export const runPlanner = internalAction({
   args: { organizationId: v.id("organizations"), workId: v.id("works") },
   handler: async (ctx, args) => {
     const flueUrl = (env as typeof env & { readonly FLUE_URL?: string })
       .FLUE_URL;
-    if (!flueUrl) {
-      await ctx.runMutation(plannerFailureRef, {
-        error: "FLUE_URL is not configured in Convex",
-        workId: args.workId,
-      });
-      return null;
-    }
+    if (!flueUrl) return null;
     const context = await ctx.runQuery(plannerContextRef, {
       workId: args.workId,
     });
-    if (!context) {
-      return null;
-    }
+    if (!context) return null;
     const endpoint = new URL(
       `agents/work-planner/${encodeURIComponent(String(args.organizationId))}`,
       `${flueUrl.replace(/\/+$/u, "")}/`
     );
     endpoint.searchParams.set("wait", "result");
-    try {
-      const response = await fetch(endpoint, {
-        body: JSON.stringify({
-          message: `Plan Work ${String(args.workId)} titled "${context.title}" with objective "${context.objective}". Current state is ${context.status}. If the Work is defining, submit only a Definition proposal and questions. If the Work is designing, submit only a Design Packet proposal bound to the approved Definition. Never approve or execute.`,
-        }),
-        headers: {
-          authorization: `Bearer ${env.FLUE_DB_TOKEN}`,
-          "content-type": "application/json",
-          "x-zopu-organization-id": String(args.organizationId),
-          "x-zopu-request-id": `work-planner:${args.workId}`,
-        },
-        method: "POST",
-      });
-      if (response.ok) {
-        return null;
-      }
-      await ctx.runMutation(plannerFailureRef, {
-        error: `Work Planner request failed (${response.status})`,
-        workId: args.workId,
-      });
-    } catch (error) {
-      await ctx.runMutation(plannerFailureRef, {
-        error: error instanceof Error ? error.message : String(error),
-        workId: args.workId,
-      });
-    }
+    await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${env.FLUE_DB_TOKEN}`,
+        "content-type": "application/json",
+        "x-zopu-organization-id": String(args.organizationId),
+        "x-zopu-request-id": `work-planner:${args.workId}`,
+      },
+      body: JSON.stringify({
+        message: `Plan Work ${String(args.workId)} titled "${context.title}" with objective "${context.objective}". Current state is ${context.status}. If the Work is defining, submit only a Definition proposal and questions. If the Work is designing, submit only a Design Packet proposal bound to the approved Definition. Never approve or execute.`,
+      }),
+    });
     // The private worker submits typed proposals through Convex mutations; it
     // never approves or advances Work itself.
     return null;
@@ -765,47 +608,17 @@ export const listForProject = query({
           .take(10);
         const slices = await ctx.db
           .query("workSlices")
-          .withIndex("by_workId_and_designVersion", (q) =>
-            q
-              .eq("workId", work._id)
-              .eq("designVersion", work.designVersion ?? 0)
+          .withIndex("by_work_and_designVersion", (q: any) =>
+            q.eq("workId", work._id)
           )
           .collect();
-        const runRows = await ctx.db
+        const runs = await ctx.db
           .query("workRuns")
           .withIndex("by_work_and_createdAt", (q: any) =>
             q.eq("workId", work._id)
           )
           .order("desc")
           .take(10);
-        const runs = await Promise.all(
-          runRows.map(async (run) => {
-            const attempts = await ctx.db
-              .query("workAttempts")
-              .withIndex("by_runId_and_number", (q) => q.eq("runId", run._id))
-              .collect();
-            const eventsByAttempt = await Promise.all(
-              attempts.map((attempt) =>
-                ctx.db
-                  .query("workAttemptEvents")
-                  .withIndex("by_attempt_and_sequence", (q: any) =>
-                    q.eq("attemptId", attempt._id)
-                  )
-                  .collect()
-              )
-            );
-            const attemptEvents = eventsByAttempt
-              .flat()
-              .sort((left, right) => left.occurredAt - right.occurredAt);
-            const artifacts = await ctx.db
-              .query("workArtifacts")
-              .withIndex("by_runId_and_createdAt", (q) =>
-                q.eq("runId", run._id)
-              )
-              .collect();
-            return { ...run, artifacts, attemptEvents, attempts };
-          })
-        );
         const events = await ctx.db
           .query("workEvents")
           .withIndex("by_work_and_createdAt", (q: any) =>
@@ -820,18 +633,18 @@ export const listForProject = query({
         const signals = await Promise.all(
           attachments.map(async (attachment) => {
             const signal = await ctx.db.get(attachment.signalId);
-            if (!signal) {
-              return null;
-            }
+            if (!signal) return null;
             const sources = await ctx.db
               .query("signalSources")
-              .withIndex("by_signalId_and_ordinal", (q) =>
+              .withIndex("by_signalId_and_ordinal", (q: any) =>
                 q.eq("signalId", signal._id)
               )
               .collect();
             return {
               createdAt: signal.createdAt,
               signalId: signal._id,
+              summary: signal.summary,
+              title: signal.title,
               sources: sources
                 .sort((a, b) => a.ordinal - b.ordinal)
                 .map((source) => ({
@@ -840,8 +653,6 @@ export const listForProject = query({
                   rawText: source.rawTextSnapshot,
                   submissionId: null,
                 })),
-              summary: signal.summary,
-              title: signal.title,
             };
           })
         );
@@ -853,16 +664,16 @@ export const listForProject = query({
         );
         return {
           ...work,
+          definitions,
+          designs,
+          slices: slices.sort((a, b) => a.ordinal - b.ordinal),
+          runs,
+          events,
+          signals: signals.filter((signal) => signal !== null),
           definition: currentDefinition
             ? JSON.parse(currentDefinition.payloadJson)
             : null,
-          definitions,
           design: currentDesign ? JSON.parse(currentDesign.payloadJson) : null,
-          designs,
-          events,
-          runs,
-          signals: signals.filter((signal) => signal !== null),
-          slices: slices.sort((a, b) => a.ordinal - b.ordinal),
         };
       })
     );

packages/backend/convex/works.ts

@@ -8,8 +8,7 @@ import { ConvexError, v } from "convex/values";
 import { Effect } from "effect";
 
 import type { Doc, Id } from "./_generated/dataModel";
-import { mutation, query } from "./_generated/server";
-import type { MutationCtx } from "./_generated/server";
+import { mutation, type MutationCtx, query } from "./_generated/server";
 import { requireProjectMember } from "./authz";
 
 const requireAgent = (token: string) => {
@@ -242,6 +241,7 @@ export const listForProject = query({
             return {
               createdAt: signal.createdAt,
               signalId: signal._id,
+              summary: signal.summary,
               sources: sources
                 .sort((a, b) => a.ordinal - b.ordinal)
                 .map((source) => ({
@@ -250,7 +250,6 @@ export const listForProject = query({
                   rawText: source.rawTextSnapshot,
                   submissionId: null,
                 })),
-              summary: signal.summary,
               title: signal.title,
             };
           })

packages/backend/package.json

@@ -8,15 +8,14 @@
     "dev": "convex dev --env-file ../../.env",
     "dev:setup": "convex dev --env-file ../../.env --configure --until-success",
     "check-types": "tsc --noEmit -p convex/tsconfig.json",
-    "test": "CONVEX_SITE_URL=https://convex.test FLUE_DB_TOKEN=test-token SITE_URL=https://site.test vitest run",
-    "test:watch": "CONVEX_SITE_URL=https://convex.test FLUE_DB_TOKEN=test-token SITE_URL=https://site.test vitest"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@better-auth/expo": "catalog:",
     "@code/env": "workspace:*",
     "@code/primitives": "workspace:*",
     "@convex-dev/better-auth": "catalog:",
-    "@convex-dev/workflow": "0.4.4",
     "better-auth": "catalog:",
     "convex": "catalog:",
     "effect": "catalog:",
@@ -24,7 +23,7 @@
   },
   "devDependencies": {
     "@code/config": "workspace:*",
-    "@types/node": "catalog:",
+    "@types/node": "^24.3.0",
     "convex-test": "catalog:",
     "typescript": "catalog:",
     "vitest": "catalog:"

packages/env/package.json

@@ -19,7 +19,7 @@
   },
   "devDependencies": {
     "@code/config": "workspace:*",
-    "@types/node": "catalog:",
+    "@types/node": "^22.13.14",
     "typescript": "catalog:"
   }
 }

packages/env/src/agent.ts

@@ -14,10 +14,6 @@ const agentEnvSchema = z.object({
   GITEA_TOKEN: z.string().min(1).optional(),
   GITEA_URL: z.url().default("https://git.openputer.com"),
   OPENROUTER_API_KEY: z.string().min(1).optional(),
-  RIVET_ENDPOINT: z.url(),
-  RIVET_PUBLIC_ENDPOINT: z.url().optional(),
-  RIVET_WORKSPACE_TOKEN: z.string().min(32),
-  ZOPU_SOURCE_REPOSITORY: z.string().min(1).default("/opt/zopu-source"),
 });
 
 export type AgentEnv = z.infer<typeof agentEnvSchema>;

packages/env/src/convex.ts

@@ -5,15 +5,10 @@ export const env = createEnv({
   emptyStringAsUndefined: true,
   runtimeEnv: process.env,
   server: {
-    AGENT_BACKEND_URL: z.url().optional(),
     CONVEX_SITE_URL: z.url(),
     FLUE_DB_TOKEN: z.string().min(1),
-    FLUE_URL: z.url().optional(),
     GITEA_TOKEN: z.string().min(1).optional(),
     GITEA_URL: z.url().default("https://git.openputer.com"),
-    GITHUB_CLIENT_ID: z.string().min(1).optional(),
-    GITHUB_CLIENT_SECRET: z.string().min(1).optional(),
-    GIT_CREDENTIAL_ENCRYPTION_KEY: z.string().min(43).optional(),
     NATIVE_APP_URL: z.string().min(1).default("code://"),
     SITE_URL: z.url(),
   },

packages/primitives/package.json

@@ -6,7 +6,6 @@
   "exports": {
     ".": "./src/index.ts",
     "./agent-os": "./src/agent-os.ts",
-    "./execution-runtime": "./src/execution-runtime.ts",
     "./git": "./src/git.ts",
     "./git-local-runtime": "./src/git-local-runtime.ts",
     "./git-remote-runtime": "./src/git-remote-runtime.ts",
@@ -17,7 +16,6 @@
     "./signal": "./src/signal.ts",
     "./smoke": "./src/smoke.ts",
     "./work": "./src/work.ts",
-    "./work-artifact": "./src/work-artifact.ts",
     "./work-definition": "./src/work-definition.ts",
     "./work-design": "./src/work-design.ts",
     "./work-lifecycle": "./src/work-lifecycle.ts",
@@ -30,14 +28,14 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agentos-software/pi": "0.2.7",
+    "@agentos-software/codex-cli": "0.3.4",
     "@agentos-software/git": "0.3.3",
-    "@rivet-dev/agentos": "0.2.14",
+    "@rivet-dev/agentos": "catalog:",
     "effect": "catalog:"
   },
   "devDependencies": {
     "@code/config": "workspace:*",
-    "@types/node": "catalog:",
+    "@types/node": "^22.13.14",
     "typescript": "catalog:",
     "vitest": "catalog:"
   }

packages/primitives/package.json.new

@@ -0,0 +1,13 @@
+{
+  "name": "@code/primitives",
+  "exports": {
+    ".": "./src/index.ts",
+    "./agent-os": "./src/agent-os.ts",
+    "./git": "./src/git.ts",
+    "./project": "./src/project.ts",
+    "./project-issue": "./src/project-issue.ts",
+    "./project-workspace": "./src/project-workspace.ts",
+    "./project-work": "./src/project-work.ts",
+    "./signal": "./src/signal.ts",
+    "./smoke": "./src/smoke.ts"
+  },

packages/primitives/src/agent-os.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+
+import { codexSessionEnv, makeCodexAgentOsConfig } from "./agent-os";
+
+describe("Codex agent-os config", () => {
+  it("always includes the codex + git software bundle", () => {
+    const config = makeCodexAgentOsConfig();
+    expect(config.software).toHaveLength(2);
+    expect(config.software?.[0]).toBeTypeOf("object");
+  });
+
+  it("builds model-provider session env", () => {
+    const env = codexSessionEnv(
+      {
+        apiKey: "sk-test",
+        baseUrl: "https://ai.example.com/v1",
+        model: "glm-5.2",
+      },
+      { CODEX_MODEL: "glm-5.2" }
+    );
+    expect(env.OPENAI_API_KEY).toBe("sk-test");
+    expect(env.OPENAI_BASE_URL).toBe("https://ai.example.com/v1");
+    expect(env.CODEX_MODEL).toBe("glm-5.2");
+  });
+});

packages/primitives/src/agent-os.ts

@@ -1,10 +1,10 @@
 /* eslint-disable max-classes-per-file -- the AgentOS service and its tagged error form one adapter contract. */
-import pi from "@agentos-software/pi";
+import codex from "@agentos-software/codex-cli";
 import { agentOS as createAgentOsActor } from "@rivet-dev/agentos";
 import type { AgentOSConfigInput } from "@rivet-dev/agentos";
 import { Context, Effect, Layer, Schema } from "effect";
 
-import { getExecutableGitSoftware } from "./agent-os-git-software.ts";
+import { getExecutableGitSoftware } from "./agent-os-git-software";
 
 const withGitSoftware = (
   config: AgentOSConfigInput<undefined>
@@ -73,94 +73,50 @@ export const createAgentOsActorEffect = Effect.fn("createAgentOsActorEffect")(
 );
 
 // ---------------------------------------------------------------------------
-// Pi harness configuration
+// Codex harness configuration
 //
-// Slice 5 intentionally runs one harness against the server's fixed Zopu
-// checkout. Pi speaks ACP natively and reads its model gateway from a mounted
-// HOME, avoiding a second executable adapter or credentials path.
+// The canonical execution registry runs exactly one AgentOS actor for the
+// puter/zopu-code repo, booted with the Codex CLI harness + git. The model
+// provider is injected as VM env (OpenAI-compatible base URL + key) so Codex
+// authenticates against the configured gateway without a second credentials
+// path. This is a pure config builder; the RivetKit registry/server that hosts
+// the actor lives in the agents package.
 // ---------------------------------------------------------------------------
 
-/** Software bundle for a Pi-capable VM: the Pi ACP harness plus git. */
-export const piSoftware = [pi, getExecutableGitSoftware()] as const;
+/** Software bundle for a Codex-capable VM: the Codex harness plus git. */
+export const codexSoftware = [codex, getExecutableGitSoftware()] as const;
 
-export interface PiModelConfig {
-  readonly api: "openai-completions";
-  readonly apiKeyEnvironmentVariable: string;
+/** Model-provider env that Codex reads inside the VM. Pass this to the session's
+ * `env` when opening a Codex session (`agent: "codex"`). */
+export interface CodexModelEnv {
+  readonly apiKey: string;
   readonly baseUrl: string;
-  readonly contextWindow: number;
-  readonly maxTokens: number;
   readonly model: string;
-  readonly provider: string;
 }
 
-export interface PiHomeFiles {
-  readonly models: string;
-  readonly settings: string;
-}
-
-/** Builds the two files Pi reads from ~/.pi/agent. */
-export const makePiHomeFiles = (model: PiModelConfig): PiHomeFiles => ({
-  models: JSON.stringify(
-    {
-      providers: {
-        [model.provider]: {
-          api: model.api,
-          apiKey: model.apiKeyEnvironmentVariable,
-          authHeader: true,
-          baseUrl: model.baseUrl,
-          models: [
-            {
-              contextWindow: model.contextWindow,
-              id: model.model,
-              maxTokens: model.maxTokens,
-              name: model.model,
-            },
-          ],
-        },
-      },
-    },
-    null,
-    2
-  ),
-  settings: JSON.stringify(
-    {
-      defaultModel: model.model,
-      defaultProvider: model.provider,
-      quietStartup: true,
-    },
-    null,
-    2
-  ),
-});
-
-/** Environment supplied to the Pi ACP session. */
-export const piSessionEnv = (
-  apiKey: string,
+/** Builds the VM env record Codex reads to authenticate against the model gateway. */
+export const codexSessionEnv = (
+  model: CodexModelEnv,
   extra: Readonly<Record<string, string>> = {}
 ): Record<string, string> => ({
-  AGENT_MODEL_API_KEY: apiKey,
-  HOME: "/home/zopu",
-  PATH: "/opt/zopu-tools/bin:/usr/local/bin:/usr/bin:/bin",
+  OPENAI_API_KEY: model.apiKey,
+  OPENAI_BASE_URL: model.baseUrl,
   ...extra,
 });
 
-export interface PiAgentOsConfigInput {
-  /** Extra software merged after the Pi+git bundle. */
+export interface CodexAgentOsConfigInput {
+  /** Extra software merged after the Codex+git bundle. */
   readonly software?: NonNullable<AgentOSConfigInput<undefined>["software"]>;
-  /** VM permission overrides merged over the execution policy. */
-  readonly permissions?: AgentOSConfigInput<undefined>["permissions"];
 }
 
-export const makePiAgentOsConfig = (
-  input: PiAgentOsConfigInput = {}
+/**
+ * Builds an AgentOS actor config for a Codex-backed VM. The Codex CLI and git
+ * are always present; software the caller passes is appended, never replacing
+ * the harness or git. Model-provider env is supplied per session via
+ * `codexSessionEnv`, not here — the actor config has no env field.
+ */
+export const makeCodexAgentOsConfig = (
+  input: CodexAgentOsConfigInput = {}
 ): AgentOSConfigInput<undefined> => ({
-  permissions: {
-    childProcess: "allow",
-    env: "allow",
-    fs: "allow",
-    network: "allow",
-    process: "allow",
-    ...input.permissions,
-  },
-  software: [...piSoftware, ...(input.software ?? [])],
+  software: [...codexSoftware, ...(input.software ?? [])],
 });

packages/primitives/src/execution-runtime.test.ts

@@ -1,38 +0,0 @@
-import { Effect } from "effect";
-import { describe, expect, test } from "vitest";
-
-import {
-  decodeGitConnectionInput,
-  decodeWorkAttemptExecutionResult,
-} from "./execution-runtime";
-
-describe("execution runtime contracts", () => {
-  test("accepts one authenticated Gitea connection", async () => {
-    const decoded = await Effect.runPromise(
-      decodeGitConnectionInput({
-        credential: "secret",
-        credentialKind: "token",
-        provider: "gitea",
-        serverUrl: "https://git.example.com",
-        username: "zopu",
-      })
-    );
-    expect(decoded.provider).toBe("gitea");
-  });
-
-  test("requires exact base and candidate revisions", async () => {
-    await expect(
-      Effect.runPromise(
-        decodeWorkAttemptExecutionResult({
-          baseRevision: "",
-          candidateRevision: "abc123",
-          changedFiles: [],
-          diff: "",
-          environmentId: "workspace-1",
-          events: [],
-          summary: "done",
-        })
-      )
-    ).rejects.toMatchObject({ reason: "InvalidInput" });
-  });
-});

packages/primitives/src/execution-runtime.ts

@@ -1,171 +0,0 @@
-/* eslint-disable max-classes-per-file -- execution boundary errors live with their schemas. */
-import { Effect, Schema } from "effect";
-
-const Text = Schema.String.check(
-  Schema.makeFilter((value) => value.trim().length > 0, {
-    expected: "a non-empty string",
-  })
-);
-
-const HttpUrl = Schema.String.check(
-  Schema.makeFilter(
-    (value) => {
-      try {
-        const url = new URL(value);
-        return url.protocol === "http:" || url.protocol === "https:";
-      } catch {
-        return false;
-      }
-    },
-    { expected: "an HTTP URL" }
-  )
-);
-
-export const GitProvider = Schema.Literals(["github", "gitea"]);
-export type GitProvider = typeof GitProvider.Type;
-
-export const GitCredentialKind = Schema.Literals(["oauth", "token"]);
-export type GitCredentialKind = typeof GitCredentialKind.Type;
-
-export const GitConnectionInput = Schema.Struct({
-  credential: Text,
-  credentialKind: GitCredentialKind,
-  provider: GitProvider,
-  serverUrl: HttpUrl,
-  username: Schema.optional(Text),
-});
-export type GitConnectionInput = typeof GitConnectionInput.Type;
-
-export const GitConnectionView = Schema.Struct({
-  connectedAt: Schema.Number,
-  credentialKind: GitCredentialKind,
-  id: Text,
-  provider: GitProvider,
-  serverUrl: HttpUrl,
-  username: Schema.optional(Text),
-});
-export type GitConnectionView = typeof GitConnectionView.Type;
-
-export const RepositoryExecutionAuth = Schema.Struct({
-  credential: Text,
-  provider: GitProvider,
-  serverUrl: HttpUrl,
-  username: Schema.optional(Text),
-});
-export type RepositoryExecutionAuth = typeof RepositoryExecutionAuth.Type;
-
-export const ExecutionEventKind = Schema.Literals([
-  "runtime.preparing",
-  "repository.cloning",
-  "repository.ready",
-  "harness.started",
-  "harness.progress",
-  "harness.log",
-  "repository.changed",
-  "runtime.completed",
-  "runtime.failed",
-  "runtime.cancelled",
-]);
-export type ExecutionEventKind = typeof ExecutionEventKind.Type;
-
-export const ExecutionEvent = Schema.Struct({
-  kind: ExecutionEventKind,
-  message: Text,
-  metadata: Schema.Record(Schema.String, Schema.String),
-  occurredAt: Schema.Number,
-  sequence: Schema.Int,
-});
-export type ExecutionEvent = typeof ExecutionEvent.Type;
-
-export const WorkAttemptExecutionInput = Schema.Struct({
-  attemptId: Text,
-  auth: RepositoryExecutionAuth,
-  baseBranch: Text,
-  prompt: Text,
-  repositoryUrl: HttpUrl,
-  runId: Text,
-  workId: Text,
-  workspaceKey: Text,
-});
-export type WorkAttemptExecutionInput = typeof WorkAttemptExecutionInput.Type;
-
-export const WorkAttemptExecutionResult = Schema.Struct({
-  baseRevision: Text,
-  candidateRevision: Text,
-  changedFiles: Schema.Array(Text),
-  diff: Schema.String,
-  environmentId: Text,
-  events: Schema.Array(ExecutionEvent),
-  summary: Text,
-});
-export type WorkAttemptExecutionResult = typeof WorkAttemptExecutionResult.Type;
-
-export const WorkAttemptExecutionErrorReason = Schema.Literals([
-  "Authentication",
-  "Cancelled",
-  "HarnessFailed",
-  "InvalidInput",
-  "ProviderUnavailable",
-  "RepositoryFailed",
-  "Timeout",
-]);
-export type WorkAttemptExecutionErrorReason =
-  typeof WorkAttemptExecutionErrorReason.Type;
-
-export class WorkAttemptExecutionError extends Schema.TaggedErrorClass<WorkAttemptExecutionError>()(
-  "WorkAttemptExecutionError",
-  {
-    message: Schema.String,
-    reason: WorkAttemptExecutionErrorReason,
-    retryable: Schema.Boolean,
-  }
-) {}
-
-export const WorkAttemptExecutionFailure = Schema.Struct({
-  error: Schema.Struct({
-    message: Text,
-    reason: WorkAttemptExecutionErrorReason,
-    retryable: Schema.Boolean,
-  }),
-});
-export type WorkAttemptExecutionFailure =
-  typeof WorkAttemptExecutionFailure.Type;
-
-const invalidInput = (message: string) =>
-  new WorkAttemptExecutionError({
-    message,
-    reason: "InvalidInput",
-    retryable: false,
-  });
-
-export const decodeGitConnectionInput = (input: unknown) =>
-  Schema.decodeUnknownEffect(GitConnectionInput)(input).pipe(
-    Effect.mapError((cause) => invalidInput(cause.message))
-  );
-
-export const decodeWorkAttemptExecutionInput = (input: unknown) =>
-  Schema.decodeUnknownEffect(WorkAttemptExecutionInput)(input).pipe(
-    Effect.mapError((cause) => invalidInput(cause.message))
-  );
-
-export const decodeWorkAttemptExecutionResult = (input: unknown) =>
-  Schema.decodeUnknownEffect(WorkAttemptExecutionResult)(input).pipe(
-    Effect.mapError((cause) => invalidInput(cause.message))
-  );
-
-export const decodeWorkAttemptExecutionFailure = (input: unknown) =>
-  Schema.decodeUnknownEffect(WorkAttemptExecutionFailure)(input).pipe(
-    Effect.mapError((cause) => invalidInput(cause.message))
-  );
-
-export interface SandboxRuntime {
-  readonly name: string;
-  readonly execute: (
-    input: WorkAttemptExecutionInput,
-    signal?: AbortSignal
-  ) => Effect.Effect<WorkAttemptExecutionResult, WorkAttemptExecutionError>;
-  readonly cancel: (
-    workspaceKey: string,
-    attemptId: string
-  ) => Effect.Effect<void, WorkAttemptExecutionError>;
-}

packages/primitives/src/git-local-runtime.ts

@@ -4,7 +4,7 @@ import { promisify } from "node:util";
 
 import { Context, Effect, Layer, Schema } from "effect";
 
-import { GitBranchName } from "./git.ts";
+import { GitBranchName } from "./git.js";
 
 const execFileP = promisify(execFile);