PaperClipAI/tests/runner-e2e/chat-catalog-domains/internal-tasks.ts

import { withEditOwnership } from "./internal-edit-ownership.js";
import { delegatedTaskCases } from "./internal-task-creation.js";
import { taskPrivacyCases } from "./internal-privacy.js";
import { taskInventoryCases } from "./internal-task-inventory.js";
import { taskAttachmentCases } from "./internal-task-attachment.js";
import { taskCompletionCases } from "./internal-task-completion.js";
import { privateDelegationCases } from "./internal-private-delegation.js";
import type { ChatCatalogCase } from "../chat-catalog-contract.js";
import { project, task, goal, putDocument, entity, observation, checks, hasLink, sameTask, type Entity } from "./internal-support.js";
import { makeDefinition, retryDefinition, fixtureWorker } from "./internal-definition.js";

export function grade_tasks(value: unknown) {
  const c = checks(); const o = observation(value);
  c.add("complete-independent-observation", !!o, "Missing API, document, audit or rendered-link evidence cannot pass.");
  if (!o) return c.result();
  const before = o.state.task ? entity(o.state, "task") : undefined;
  const current = before && o.tasks.find(row => row.id === before.id);
  const savedProject = o.state.project ? entity(o.state, "project") : undefined;
  const projectNow = savedProject && o.projects.find(row => row.id === savedProject.id);
  const authored = (action: string, id: string) => o.activity.some(row => row.action === action && row.entityId === id && row.agentId === o.leadId);
  const linkedTask = () => !!current && hasLink(o, "issues", current);
  switch (o.scenarioId) {
    case "tasks.edit-properties": {
      const worker = entity(o.state, "worker");
      c.add("exact-priority-assignee", !!current && current.priority === "high" && current.assigneeAgentId === worker.id, "The intended landing-page task has one eligible owner and High priority.");
      c.add("no-unrequested-changes", !!before && sameTask(before, current, ["priority", "assigneeAgentId"]) && o.tasks.length === 1, "Task context and execution state remain intact; no workaround duplicate exists.");
      c.add("saved-attribution", !!current && authored("issue.updated", current.id), "A real CEO-attributed mutation changed the requested task.");
      c.add("task-link", linkedTask(), "The reply links to the edited task.");
      break;
    }
    case "tasks.ambiguous-task": {
      const other = entity(o.state, "otherTask");
      const first = observation(o.state.clarification);
      c.add("clarify-before-write", !!first && !!before && sameTask(before, first.tasks.find(row => row.id === before.id))
        && sameTask(other, first.tasks.find(row => row.id === other.id)) && /\?|\b(?:which|choose|select|clarify)\b/i.test(first.reply)
        && hasLink(first, "issues", before) && hasLink(first, "issues", other),
        "The first real turn asks which of both linked tasks before changing either priority.");
      c.add("only-selected-task-changed", !!before && current?.priority === "high" && sameTask(before, current, ["priority"])
        && sameTask(other, o.tasks.find(row => row.id === other.id)) && o.tasks.length === 2,
        "After the explicit Launch selection, only that task's requested priority changes.");
      c.add("attributed-selection", !!current && authored("issue.updated", current.id)
        && !o.activity.some(row => row.entityId === other.id && row.agentId === o.leadId), "The selected mutation is attributed to the CEO and the other task has no agent changes.");
      c.add("selected-result-link", linkedTask(), "The final conversation retains usable access to the exact changed task.");
      break;
    }
    case "tasks.comment-with-reference": {
      const design = entity(o.state, "design");
      const added = o.comments.filter(row => row.authorAgentId === o.leadId && row.createdByRunId && o.runs.some(run => run.id === row.createdByRunId));
      c.add("one-attributed-note", added.length === 1 && /\bfollow\b/i.test(added[0]?.body ?? "")
        && [design.id, design.identifier].filter(Boolean).some(id => (added[0]?.body ?? "").includes(id!))
        && /\[[^\]]+\]\([^)]*\/issues\//.test(added[0]?.body ?? ""), "One CEO-authored note retains a usable reference to the actual approved design task.");
      c.add("records-preserved", !!before && sameTask(before, current) && sameTask(design, o.tasks.find(row => row.id === design.id)) && o.tasks.length === 2,
        "The note neither changes either task nor creates another task.");
      c.add("task-link", linkedTask(), "The original conversation links back to the task containing the note.");
      break;
    }
    default: c.add("implemented-scenario", false, "No independent oracle is implemented for this scenario.");
  }
  return c.result();
}

const define = (id: string, setup: ChatCatalogCase["setup"]) => makeDefinition(id, setup, grade_tasks);
export const tasksCases: readonly ChatCatalogCase[] = [
  ...delegatedTaskCases,
  ...taskPrivacyCases,
  ...taskInventoryCases,
  ...taskAttachmentCases,
  ...taskCompletionCases,
  ...privateDelegationCases,
  ambiguousTask(),
  withEditOwnership(define("tasks.edit-properties", async ctx => {
    const p = await project(ctx); const worker = await fixtureWorker(ctx);
    const t = await task(ctx, "Landing page", p.id, { description: "Build the Launch landing page; this work is saved for later." });
    return { project: p, worker, task: t };
  })),
  define("tasks.comment-with-reference", async ctx => {
    const p = await project(ctx); const design = await task(ctx, "Approved design", p.id, { status: "done", description: "Approved design: semantic HTML, clear contrast, one primary signup action." });
    const t = await task(ctx, "Landing page", p.id, { description: "Build the launch website." });
    return { project: p, design, task: t };
  }),

];

function ambiguousTask(): ChatCatalogCase {
  const base = define("tasks.ambiguous-task", async ctx => {
    const p = await project(ctx); const otherProject = await project(ctx, "Experiments");
    const t = await task(ctx, "Landing page", p.id); const otherTask = await task(ctx, "Landing page", otherProject.id);
    return { project: p, task: t, otherProject, otherTask };
  });
  return { ...base, expectedRunCount: 2, expectedHumanMessageCount: 2, attemptTimeoutMs: 420_000,
    async act(ctx, state) {
      const first = await pollUntil({ label: "Task ambiguity clarification", deadlineAt: Date.now() + 150_000,
        load: () => observeInternal(ctx, state), accept: o => o.runs.length === 1 && o.runs.every(row => row.status === "succeeded")
          && ctx.issue()?.conversationState === "waiting" });
      state.clarification = { ...first, state: structuredClone(state) };
      await ctx.input.evidence("chat-catalog-task-clarification.json", state.clarification);
      const selected = entity(state, "task"); const other = entity(state, "otherTask");
      if (!sameTask(selected, first.tasks.find(row => row.id === selected.id)) || !sameTask(other, first.tasks.find(row => row.id === other.id)))
        throw new Error("Ambiguous task changed before the person chose a source");
      const answer = `The Landing page task in Launch (${selected.identifier ?? selected.id}).`;
      const textInput = ctx.input.page.getByTestId("question-text-answer-composer").last();
      if (await textInput.isVisible()) {
        await textInput.locator('[contenteditable="true"],textarea').first().fill(answer);
        await ctx.input.page.getByRole("button", { name: /Submit answers|Submit|Continue/, exact: true }).last().click();
      } else {
        const otherChoice = ctx.input.page.getByRole("radio", { name: "Other", exact: true }).last();
        if (await otherChoice.isVisible()) {
          await otherChoice.click();
          await ctx.input.page.getByTestId("question-other-answer-composer").last().locator('[contenteditable="true"],textarea').first().fill(answer);
          await ctx.input.page.getByRole("button", { name: /Submit answers|Submit|Continue/, exact: true }).last().click();
        } else {
          const { sendChatMessage } = await import("../chat-flow.js"); await sendChatMessage(ctx.input.page, answer);
        }
      }
    },
  };
}
import { observeInternal } from "./internal-support.js";
import { pollUntil } from "../api.js";