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

import { expect } from "@playwright/test";
import type { ChatCatalogCase } from "../chat-catalog-contract.js";
import { pollUntil } from "../api.js";
import { fixtureWorker, makeDefinition } from "./internal-definition.js";
import { agentStatus, cleanupPrivacyProbes } from "./internal-privacy.js";
import { createAuthenticatedPerson, enrollPrerequisitePerson } from "./identity-auth.js";
import { startTimelineVerifier, type VerificationReceipt } from "./internal-timeline-verifier.js";
import { collectRunEvents } from "../run-observations.js";
import { readRecord, recordParams } from "./api-read-receipts.js";
import { localDay } from "./internal-routine-audit.js";
import { checks, entity, hasLink, observation, observeInternal, project, task, type Entity, type InternalObservation } from "./internal-support.js";
interface Timeline extends InternalObservation { verification: VerificationReceipt[]; hiddenStatus: number; timelineEvents: Entity[]; savedTimelineRead?: boolean }
const objectRecord = (value: unknown): Record<string, unknown> => value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
/** Native outcomes are projected by the canonical committer, not an agent PATCH. */
export function timelineStatusMilestone(row: Entity, task: Entity, run: Entity, workerId: string, status: "blocked" | "done") {
  if (typeof workerId !== "string" || !workerId || !task.id || !run.id || row.action !== "issue.updated" || row.entityId !== task.id) return false;
  // Preserve genuinely attributed legacy agent updates; system rows need the full native join.
  if (row.actorType !== "system" && row.agentId === workerId && row.details?.status === status) return true;
  const event = objectRecord(row), current = objectRecord(task), native = objectRecord(run), context = objectRecord(native.contextSnapshot), result = objectRecord(native.resultJson);
  return typeof task.companyId === "string" && !!task.companyId && row.companyId === task.companyId && native.companyId === task.companyId
    && task.status === status && task.assigneeAgentId === workerId && run.agentId === workerId && run.status === "succeeded"
    && (context.issueId === task.id || context.taskId === task.id)
    && (context.issueId === undefined || context.issueId === task.id) && (context.taskId === undefined || context.taskId === task.id)
    && row.actorType === "system" && row.actorId === "native-status-committer" && event.runId === run.id
    && row.details?.source === "native_status_decision" && row.details.toStatus === status
    && typeof current.lastStatusDecisionId === "string" && !!current.lastStatusDecisionId
    && row.details.decisionId === current.lastStatusDecisionId && result.decisionId === current.lastStatusDecisionId
    && result.issueStatusAfter === status && result.issueStatusBefore === row.details.fromStatus
    && typeof result.assessmentId === "string" && !!result.assessmentId && row.details.assessmentId === result.assessmentId;
}
/**
 * The chat run read the launch task's saved activity, comments or history
 * through a product tool before answering. A call_api read is bound to the task
 * by its saved input digest and a successful result, because the port redacts
 * API bodies before saving; an unredacted dedicated-tool output must name the
 * task. The agent's own wording is never matched.
 */
export function readSavedTaskTimeline(events: readonly Record<string, unknown>[], taskId: string, identifier?: string | null) {
  const params = recordParams("id", taskId, identifier);
  if (taskId && readRecord(events, ["GET /api/issues/{id}/activity", "GET /api/issues/{id}/comments"].map(operationId => ({ operationId, pathParams: params, paged: true, queries: [{ order: "asc" }, { order: "desc" }] })))) return true;
  return !!taskId && events.some(row => {
    const envelope = objectRecord(objectRecord(row.payload).prpEvent), payload = objectRecord(envelope.payload);
    const output = typeof payload.output === "string" ? payload.output : "";
    return row.eventType === "tool.execution.completed" && envelope.sourceKind === "runner" && payload.status === "completed"
      && output.includes(taskId)
      && (payload.name === "paperclip_get_task_history" || /GET \/api\/issues\/\{id\}\/(?:activity|comments)\b/.test(output));
  });
}
export function gradeWorkTimeline(value: unknown) {
  const c = checks(); const o = observation(value) as Timeline | undefined;
  c.add("real-timeline-and-command-receipts", !!o && Array.isArray(o.verification) && Array.isArray(o.timelineEvents) && typeof o.hiddenStatus === "number", "Real command exits, current-week state events and independent private access are required.");
  if (!o || !Array.isArray(o.verification) || !Array.isArray(o.timelineEvents)) return c.result();
  const t = entity(o.state, "task"); const first = entity(o.state, "firstRun"); const second = entity(o.state, "secondRun"); const prep = entity(o.state, "prepTask");
  const failed = o.verification.find(row => row.runId === first.id && row.exitCode === 1); const passed = o.verification.find(row => row.runId === second.id && row.exitCode === 0);
  c.add("actual-command-failure-then-repair", !!failed && !!passed && failed.taskId === t.id && passed.taskId === t.id && failed.sha256 !== passed.sha256
    && [failed, passed].every(row => row.filename === "launch.html" && row.command === "node accessible-heading-and-email-label-check" && /^[a-f0-9]{64}$/i.test(row.sha256))
    && Date.parse(failed.checkedAt) <= Date.parse(passed.checkedAt) && [first, second].every(prior => o.runs.some(row => row.id === prior.id && row.status === "succeeded" && row.agentId === prior.agentId && (row.contextSnapshot?.issueId === t.id || row.contextSnapshot?.taskId === t.id)))
    && (o.state.blockedTask as Entity | undefined)?.status === "blocked" && o.tasks.some(row => row.id === t.id && row.status === "done" && row.assigneeAgentId === second.agentId), "A real verification command fails before a saved pause, then a real handoff repairs the bytes and verifies successfully; native reporting runs themselves succeeded.");
  const events = o.timelineEvents.filter(row => [o.state.blockedEventId, o.state.handoffEventId, o.state.doneEventId].includes(row.id));
  const today = String(o.state.today); const zone = String(o.state.timezone); const monday = new Date(`${today}T12:00:00Z`); monday.setUTCDate(monday.getUTCDate() - (monday.getUTCDay() + 6) % 7);
  c.add("ordered-current-week-native-milestones", events.length === 3 && [o.state.blockedEventId, o.state.handoffEventId, o.state.doneEventId].every(id => events.some(row => row.id === id))
    && events.every(row => row.entityId === t.id && row.action === "issue.updated")
    && events.some(row => row.id === o.state.blockedEventId && timelineStatusMilestone(row, entity(o.state, "blockedTask"), first, first.agentId!, "blocked"))
    && events.some(row => row.id === o.state.handoffEventId && row.actorType === "user" && row.actorId === o.state.personId && row.details?.assigneeAgentId === second.agentId)
    && events.some(row => row.id === o.state.doneEventId && timelineStatusMilestone(row, t, second, second.agentId!, "done"))
    && events.every(row => !!row.createdAt && localDay(row.createdAt, zone) >= monday.toISOString().slice(0, 10) && localDay(row.createdAt, zone) <= today)
    && Date.parse(events.find(row => row.id === o.state.blockedEventId)!.createdAt!) <= Date.parse(events.find(row => row.id === o.state.handoffEventId)!.createdAt!)
    && Date.parse(events.find(row => row.id === o.state.handoffEventId)!.createdAt!) <= Date.parse(events.find(row => row.id === o.state.doneEventId)!.createdAt!), "The saved actual blocked → human handoff → agent completion events fall in the person's real current week and retain chronological attribution.");
  // The model's prose is nondeterministic, so it is not pattern-matched. The
  // saved milestones above are checked exactly; here the account must come
  // from reading those saved events, and the links below must point at them.
  c.add("account-grounded-in-saved-timeline", o.savedTimelineRead === true,
    "Before answering, the chat run read the launch task's saved activity, comments or history through a product tool.");
  c.add("inspectable-major-milestones", hasLink(o, "issues", t) && hasLink(o, "issues", prep), "Both actual launch work items are linked for inspection.");
  const hidden = entity(o.state, "hiddenTask");
  c.add("hidden-work-never-disclosed", [403, 404].includes(o.hiddenStatus) && ![hidden.id, hidden.title, hidden.description].filter(Boolean).some(text => o.reply.includes(text!))
    && !hasLink(o, "issues", hidden), "The acting agent's real private-task denial and answer/link absence protect hidden work.");
  c.add("read-only-timeline", !o.activity.some(row => row.agentId === o.leadId && [t.id, prep.id].includes(row.entityId ?? "") && /issue\.(?:updated|deleted)/.test(row.action ?? "")), "Summarizing progress leaves source milestones intact.");
  return c.result();
}
function timeline(): ChatCatalogCase {
  let verifier: Awaited<ReturnType<typeof startTimelineVerifier>> | undefined; let owner: Awaited<ReturnType<typeof createAuthenticatedPerson>> | undefined;
  const base = makeDefinition("activity.work-timeline", async ctx => {
    const browser = ctx.input.page.context().browser(); if (!browser || !ctx.input.privateSecrets) throw new Error("Timeline privacy context needs authenticated people");
    owner = await createAuthenticatedPerson({ api: ctx.input.api, browser, secrets: ctx.input.privateSecrets, name: "Casey" }); await enrollPrerequisitePerson(ctx, owner, "operator");
    const response = await owner.request(`/api/companies/${ctx.input.fixtures.company.id}/issues`, "POST", { title: `Hidden acquisition launch ${ctx.input.nonce}`, description: "Protected acquisition research", status: "backlog", visibility: "private" }); if (!response.ok) throw new Error("Private timeline distractor was not created"); const hiddenTask = await response.json() as Entity;
    await agentStatus(ctx, ctx.input.fixtures.agent.id, `/api/issues/${hiddenTask.id}`);
    const p = await project(ctx, "Launch", { workspace: { name: "Launch timeline workspace", sourceType: "local_path", cwd: ctx.input.workspacePath, isPrimary: true } });
    const prepTask = await task(ctx, "Launch requirements recorded", p.id, { status: "done", description: "Human recorded the launch accessibility requirements before implementation." });
    await ctx.input.api.post(`/api/issues/${prepTask.id}/comments`, { body: "Launch requires an accessible email signup and semantic page heading." });
    const worker = await fixtureWorker(ctx); const repair = await fixtureWorker(ctx); const repairWorker = await ctx.input.api.patch<Entity>(`/api/agents/${repair.id}`, { name: "Riley" });
    for (const scope of [{ scopeType: "company", scopeId: ctx.input.fixtures.company.id }, ...[worker, repair].map(row => ({ scopeType: "agent", scopeId: row.id }))]) await ctx.input.api.post(`/api/companies/${ctx.input.fixtures.company.id}/budgets/policies`, { ...scope, amount: 500, hardStopEnabled: true, isActive: true, unpricedUsagePolicy: "allow" });
    const t = await task(ctx, "Launch signup implementation", p.id);
    verifier = await startTimelineVerifier(ctx, t.id, [worker.id, repair.id]);
    await ctx.input.api.patch(`/api/issues/${t.id}`, { status: "todo", assigneeAgentId: worker.id, description: "Build the initial launch.html prototype with a semantic h1 and an email input id=\"email\", deliberately leave the label pending for the later accessibility review. Run the authorized Launch verification app verify_launch_html on the actual saved bytes. If it fails, record its actual exit code and pause this task as blocked awaiting a label repair; do not pretend the command passed, fix the pending label yet, or mark it done. Do not create other tasks." });
    const first = await pollUntil({ label: "Real launch verification failure and saved pause", deadlineAt: Date.now() + 180000, load: async () => ({ t: await ctx.input.api.get<Entity>(`/api/issues/${t.id}`), runs: await ctx.allRuns() }), accept: row => row.t.status === "blocked" && row.runs.length === 1 && row.runs[0]?.status === "succeeded" && verifier!.receipts.some(r => r.runId === row.runs[0]?.id && r.exitCode === 1) });
    const firstRun = await ctx.input.api.get<Entity>(`/api/heartbeat-runs/${first.runs[0]!.id}`);
    const blockedEvent = (await ctx.input.api.get<Entity[]>(`/api/issues/${t.id}/activity`)).find(row => timelineStatusMilestone(row, first.t, firstRun, worker.id, "blocked")); if (!blockedEvent) throw new Error("Missing actual blocked milestone");
    await ctx.input.api.patch(`/api/issues/${t.id}`, { status: "todo", assigneeAgentId: repair.id, description: "Repair the existing launch.html prototype by adding a real label for the email input. Preserve its semantic heading. Run Launch verification verify_launch_html on the saved bytes, report its actual result, and complete only if the real command succeeds. The earlier failed check and pause remain history; do not rewrite them." });
    const second = await pollUntil({ label: "Real human handoff and verified native repair", deadlineAt: Date.now() + 180000, load: async () => ({ t: await ctx.input.api.get<Entity>(`/api/issues/${t.id}`), runs: await ctx.allRuns() }), accept: row => row.t.status === "done" && row.runs.length === 2 && row.runs.every(r => r.status === "succeeded") && verifier!.receipts.some(r => r.runId !== first.runs[0]?.id && r.exitCode === 0) });
    const secondRun = await ctx.input.api.get<Entity>(`/api/heartbeat-runs/${second.runs.find(row => row.id !== firstRun.id)!.id}`);
    const events = await ctx.input.api.get<Entity[]>(`/api/issues/${t.id}/activity`); const handoff = events.find(row => row.actorType === "user" && row.details?.assigneeAgentId === repair.id); const done = events.find(row => timelineStatusMilestone(row, second.t, secondRun, repair.id, "done")); if (!handoff || !done) throw new Error("Missing actual handoff/completion milestone");
    const timezone = await ctx.input.page.evaluate(() => Intl.DateTimeFormat().resolvedOptions().timeZone); const now = new Date(); const today = localDay(now.toISOString(), timezone); const zoneLabel = new Intl.DateTimeFormat("en-US", { timeZone: timezone, timeZoneName: "short" }).formatToParts(now).find(part => part.type === "timeZoneName")!.value;
    const session = await ctx.input.api.get<{ user?: { id: string; name?: string } }>("/api/auth/get-session"); if (!session.user?.id) throw new Error("Timeline requires actual human handoff identity");
    const state = { worker, repairWorker, project: p, task: second.t, prepTask, hiddenTask, firstRun, secondRun, blockedTask: first.t, blockedEventId: blockedEvent.id, handoffEventId: handoff.id, doneEventId: done.id, timezone, today, zoneLabel, personId: session.user.id, personName: session.user.name };
    await ctx.input.evidence("chat-catalog-real-launch-timeline.json", { ...state, verification: verifier.receipts, events }); return state;
  }, gradeWorkTimeline);
  return { ...base, oracleVersion: "paperclip.chat-catalog.work-timeline.v16", authentication: "human-session", expectedRunCount: 3, minimumRunCount: 3, attemptTimeoutMs: 720000,
    sourceFiles: [...base.sourceFiles, "chat-catalog-domains/internal-work-timeline.ts", "chat-catalog-domains/api-read-receipts.ts", "chat-catalog-domains/internal-timeline-verifier.ts", "chat-catalog-domains/internal-privacy.ts", "chat-catalog-domains/identity-auth.ts", "chat-catalog-domains/internal-routine-audit.ts", "../e2e/fetch-allowed-port.ts", "../../server/src/services/native-runtime/status-decision-committer.ts", "../../server/src/services/work-timeline.ts","../../server/src/services/native-runtime/runner-api-catalog.ts"],
    async observe(ctx, state): Promise<Timeline> {
      const o = await observeInternal(ctx, state), taskId = entity(state, "task").id ?? "";
      let savedTimelineRead = false;
      for (const run of o.runs.filter(row => row.agentId === o.leadId && row.contextSnapshot?.issueId === ctx.issue()?.id)) {
        const events = await collectRunEvents<Record<string, unknown>>(afterSeq => ctx.input.api.get(`/api/heartbeat-runs/${run.id}/events?afterSeq=${afterSeq}&limit=1000`));
        savedTimelineRead = savedTimelineRead || readSavedTaskTimeline(events, taskId, entity(state, "task").identifier);
      }
      return { ...o, savedTimelineRead, verification: structuredClone(verifier?.receipts ?? []), timelineEvents: await ctx.input.api.get(`/api/issues/${taskId}/activity`), hiddenStatus: await agentStatus(ctx, ctx.input.fixtures.agent.id, `/api/issues/${entity(state, "hiddenTask").id}`) };
    },
    async verifyResult(ctx, state, value) { await base.verifyResult(ctx, state, value); const source = ctx.input.page.url(); try { await ctx.input.page.goto(new URL(`/${ctx.input.fixtures.company.issuePrefix}/issues/${entity(state, "prepTask").identifier}`, ctx.input.api.baseURL).href); await expect(ctx.input.page.getByRole("heading", { name: entity(state, "prepTask").title!, exact: true })).toBeVisible(); } finally { await ctx.input.page.goto(source); await expect(ctx.input.page.getByTestId("task-chat-composer-input")).toBeVisible(); } },
    async cleanup(ctx) { try { await verifier?.close(); } finally { verifier = undefined; await cleanupPrivacyProbes(ctx); await owner?.dispose(); owner = undefined; } },
  };
}
export const workTimelineCases: readonly ChatCatalogCase[] = [timeline()];