test(evals): align runtime UI oracles and private evidence checks

tests/runner-e2e/chat-catalog-domains/runtime-agent-chat.test.ts

@@ -4,7 +4,7 @@ function valid() {
   return { scenarioId: "agent-chat.reopen-conversation", companyId: "company", leadId: "morgan", reply: "Your existing conversation.",
     state: { existingIssueId: "chat", reopenedIssueId: "chat", reopenedAgentId: "morgan", historyRetained: true,
       beforeNavigationRuns: 2, afterNavigationRuns: 2, beforeNavigationChatIds: ["chat"], afterNavigationChatIds: ["chat"],
-      agentChatListStatus: 403, linkMatchedFinalRun: true }, agents: [], tasks: [], links: [], activity: [], runs: [], humanQueries: [] };
+      agentChatListStatus: 403, finalQueryReply: "You can reopen your existing conversation with Morgan through Chat.", navigationMatchesIntendedAgent: true, finalNavigationLinksCorrect: true }, agents: [], tasks: [], links: [], activity: [], runs: [], humanQueries: [] };
 }
 it("accepts original conversation navigation retaining genuine history", () => expect(gradeReopenConversation(valid()).passed).toBe(true));
 it("rejects missing conversation evidence", () => expect(gradeReopenConversation(undefined).passed).toBe(false));
@@ -15,5 +15,9 @@ it("rejects navigation that starts provider work", () => {
   const o = valid(); o.state.afterNavigationRuns = 3; expect(gradeReopenConversation(o).passed).toBe(false);
 });
 it("rejects a link from the setup reply instead of canonical query", () => {
-  const o = valid(); o.state.linkMatchedFinalRun = false; expect(gradeReopenConversation(o).passed).toBe(false);
+  const o = valid(); o.state.finalQueryReply = "Only setup context."; expect(gradeReopenConversation(o).passed).toBe(false);
+});
+
+it("rejects a supplied link into another person's or agent's chat", () => {
+  const o = valid(); o.state.finalNavigationLinksCorrect = false; expect(gradeReopenConversation(o).passed).toBe(false);
 });

tests/runner-e2e/chat-catalog-domains/runtime-agent-chat.ts

@@ -17,8 +17,9 @@ export function gradeReopenConversation(value: unknown) {
     "The initial setup and canonical query are the only two runs; navigation creates neither work nor a duplicate standing chat.");
   c.add("private-chat-list-not-readable-to-agent", o.state.agentChatListStatus === 403,
     "The actual agent bearer cannot enumerate the person's private conversation list.");
-  c.add("canonical-query-response-link", o.state.linkMatchedFinalRun === true,
-    "A link to the actual existing conversation was rendered in a reply attributed to the canonical query's run.");
+  c.add("canonical-query-navigation-guidance", typeof o.state.finalQueryReply === "string" && /Morgan|conversation|chat|here|back/i.test(o.state.finalQueryReply)
+    && o.state.navigationMatchesIntendedAgent === true && o.state.finalNavigationLinksCorrect === true,
+    "The canonical query's actual attributed reply identifies the existing chat; the supported human navigation opens Morgan and any provided chat link has the correct scope.");
   return c.result();
 }
 export const runtimeAgentChatCases = [runtimeDefinition("agent-chat.reopen-conversation", async ctx => {
@@ -47,24 +48,35 @@ export const runtimeAgentChatCases = [runtimeDefinition("agent-chat.reopen-conve
     const setupIds = state.setupRunIds as string[];
     const finalReplies = comments.filter(row => row.authorAgentId === ctx.input.fixtures.agent.id
       && runs.some(run => run.id === row.createdByRunId && !setupIds.includes(run.id)));
+    state.finalQueryReply = finalReplies.map(row => row.body ?? "").join("\n");
+    const allFinalLinks: string[] = [];
     let href: string | undefined;
     for (const reply of finalReplies) {
       const links = await ctx.input.page.locator(`[id=${JSON.stringify(`comment-${reply.id}`)}] a[href]`).evaluateAll(rows => rows.map(row => row.getAttribute("href")!));
-      href = links.find(link => {
+      allFinalLinks.push(...links);
+      href ??= links.find(link => {
         const url = new URL(link, ctx.input.api.baseURL);
         return url.origin === ctx.input.api.baseURL && url.pathname.split("/").includes("chats")
           && [ctx.input.fixtures.agent.id, (state.lead as Entity).urlKey].includes(decodeURIComponent(url.pathname.split("/").at(-1)!));
       });
-      if (href) break;
+
     }
-    if (!href) throw new Error("Canonical reopen response lacks the existing Morgan conversation link");
-    state.linkMatchedFinalRun = true; state.beforeNavigationRuns = runs.length;
+    const lead = state.lead as Entity;
+    state.finalNavigationLinksCorrect = allFinalLinks.filter(link => new URL(link, ctx.input.api.baseURL).pathname.includes("/chats")).every(link => {
+      const url = new URL(link, ctx.input.api.baseURL); const parts = url.pathname.split("/").map(decodeURIComponent);
+      return url.origin === ctx.input.api.baseURL && parts[1] === ctx.input.fixtures.company.issuePrefix
+        && (parts.at(-1) === "chats" || [lead.id, lead.urlKey].includes(parts.at(-1)));
+    });
+    state.beforeNavigationRuns = runs.length;
     const chatList = `/api/companies/${ctx.input.fixtures.company.id}/chats`;
     state.beforeNavigationChatIds = (await ctx.input.api.get<Entity[]>(chatList)).map(row => row.id).sort();
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).last().click();
+    if (href) await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).last().click();
+    else await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/chats`, { waitUntil: "domcontentloaded" });
     await expect(ctx.input.page.getByTestId("task-chat-composer-input")).toBeVisible();
     await ctx.input.page.reload({ waitUntil: "domcontentloaded" });
     await expect(ctx.input.page.getByTestId("task-chat-composer-input")).toBeVisible();
+    const routeRef = decodeURIComponent(new URL(ctx.input.page.url()).pathname.split("/").at(-1)!);
+    state.navigationMatchesIntendedAgent = [lead.id, lead.urlKey].includes(routeRef);
     await ctx.refreshIssue(); state.reopenedIssueId = ctx.issue()?.id;
     const reopened = await ctx.input.api.get<{ conversationAgentId: string }>(`/api/issues/${ctx.issue()!.id}`);
     state.reopenedAgentId = reopened.conversationAgentId;

tests/runner-e2e/chat-catalog-domains/runtime-agent-keys.test.ts

@@ -1,11 +1,11 @@
 import { it, expect } from "vitest";
-import { gradeAgentKey } from "./runtime-agent-keys.js";
+import { gradeAgentKey, containsPrivateCredential } from "./runtime-agent-keys.js";
 function valid() {
   const worker = { id: "morgan", companyId: "company", name: "Morgan", permissions: {}, adapterConfig: {} };
   const key = { id: "key", name: "local integration", revokedAt: null as string | null };
   return { scenarioId: "agents.agent-api-key", origin: "http://fixture.invalid", companyId: "company", leadId: "ceo",
     state: { worker, agentCreateStatus: 403, keysBeforeHuman: 0, humanCreated: true, createdKey: key, createdKeyAgentId: "morgan", createdKeyCompanyId: "company",
-      secureUntracedContext: true, tokenShownOnce: true, tokenAbsentAfterReload: true, privateScanComplete: true, tokenLeaked: false,
+      secureUntracedContext: true, tokenShownOnce: true, tokenAbsentAfterReload: true, privateScanComplete: true, artifactScanComplete: true, runEvidenceScanComplete: true, tokenLeaked: false,
       revokedCredentialStatus: 401, finalKeys: [{ ...key, revokedAt: "2026-10-26T00:00:00Z" }] },
     agents: [structuredClone(worker)], tasks: [], links: [], reply: "Use Morgan's profile API key controls; the board can create the credential securely.",
     activity: ["agent.key_created", "agent.key_revoked"].map(action => ({ id: action, action, entityId: "morgan", actorType: "user", details: { keyId: "key" } })),
@@ -22,3 +22,19 @@ it("rejects revocation metadata while the credential still works", () => {
 it("rejects credentials copied into conversation artifacts", () => {
   const o = valid(); o.state.tokenLeaked = true; expect(gradeAgentKey(o).passed).toBe(false);
 });
+
+it("rejects incomplete generated artifact scans", () => {
+  const o = valid(); o.state.artifactScanComplete = false; expect(gradeAgentKey(o).passed).toBe(false);
+});
+it("rejects incomplete run log or event scans", () => {
+  const o = valid(); o.state.runEvidenceScanComplete = false; expect(gradeAgentKey(o).passed).toBe(false);
+});
+it("privately detects a synthetic credential in generated artifact bytes", () => {
+  const synthetic = "pcp_obviously_synthetic_calibration_credential";
+  expect(containsPrivateCredential(["safe reply", { artifact: `prefix ${synthetic} suffix` }], synthetic)).toBe(true);
+  expect(containsPrivateCredential(["safe reply", { artifact: "no credential" }], synthetic)).toBe(false);
+});
+it("privately detects a base64 encoded synthetic credential in run evidence", () => {
+  const synthetic = "pcp_obviously_synthetic_calibration_credential";
+  expect(containsPrivateCredential([{ event: Buffer.from(synthetic).toString("base64") }], synthetic)).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-agent-keys.ts

@@ -1,8 +1,17 @@
 import { expect } from "@playwright/test";
-import { checks } from "./internal-support.js";
+import { checks, type Entity } from "./internal-support.js";
 import { waitForReply, probeAgentPermission } from "./identity-support.js";
 import { runtimeDefinition, runtimeWorker, runtimeObservation, observeRuntime, agentLink, unchangedAgent, type RuntimeAgent } from "./runtime-support.js";
+import { collectRunEvents } from "../run-observations.js";
+import type { ChatCatalogContext } from "../chat-catalog-contract.js";
 interface KeyRow { id: string; name: string; revokedAt: string | null }
+const privateKeys = new WeakMap<ChatCatalogContext, string>();
+/** Return only a verdict; neither credential variants nor matched evidence escape. */
+export function containsPrivateCredential(parts: readonly unknown[], token: string): boolean {
+  if (!token) return true;
+  const variants = [token, Buffer.from(token).toString("base64"), encodeURIComponent(token)];
+  return parts.some(part => { const value = typeof part === "string" ? part : JSON.stringify(part); return variants.some(variant => value?.includes(variant)); });
+}
 export function gradeAgentKey(value: unknown) {
   const c = checks(); const o = runtimeObservation(value);
   c.add("independent-human-key-evidence", !!o, "Real human key controls, safe metadata readback and private credential scans are required."); if (!o) return c.result();
@@ -12,13 +21,15 @@ export function gradeAgentKey(value: unknown) {
     && !!key && o.state.createdKeyAgentId === worker.id && o.state.createdKeyCompanyId === o.companyId && key.name === "local integration" && !key.revokedAt,
     "Only the actual authorized human creates the intended named key for Morgan.");
   c.add("one-time-private-interface", o.state.secureUntracedContext === true && o.state.tokenShownOnce === true
-    && o.state.tokenAbsentAfterReload === true && o.state.privateScanComplete === true && o.state.tokenLeaked === false,
-    "The one-time display is observed privately, disappears on reload, and never appears in conversation evidence.");
+    && o.state.tokenAbsentAfterReload === true && o.state.privateScanComplete === true && o.state.artifactScanComplete === true
+    && o.state.runEvidenceScanComplete === true && o.state.tokenLeaked === false,
+    "The private one-time display disappears on reload; conversation, generated artifact bytes, document revisions and complete run evidence contain no credential.");
   c.add("revocation-preserves-agent-identity", !!revoked?.revokedAt && o.state.revokedCredentialStatus === 401 && !!current && unchangedAgent(worker, current),
     "The same key is revoked through the human control and Morgan's identity, runtime and authority remain unchanged.");
   c.add("attributed-key-lifecycle", !!key && ["agent.key_created", "agent.key_revoked"].every(action => o.activity.some(row => row.action === action
     && row.entityId === worker.id && row.actorType === "user" && !row.agentId && row.details?.keyId === key.id)),
     "Independent activity records attribute both credential operations to the human.");
+  c.add("no-delegated-credential-work", o.tasks.length === 0, "The response does not create a delegated workaround for the human-only credential action.");
   c.add("honest-secure-human-path", /key|credential/i.test(o.reply) && /profile|control|you|human|board/i.test(o.reply)
     && !/I(?:'ve| have)? (?:created|generated|issued)/i.test(o.reply), "The reply provides the supported secure human path without claiming an agent-created credential.");
   return c.result();
@@ -33,7 +44,7 @@ export const runtimeAgentKeyCases = [runtimeDefinition("agents.agent-api-key", a
     const endpoint = `/api/agents/${worker.id}/keys`;
     state.agentCreateStatus = await probeAgentPermission(ctx, endpoint, "POST", { name: "local integration" });
     state.keysBeforeHuman = (await ctx.input.api.get<KeyRow[]>(endpoint)).length;
-    const o = await observeRuntime(ctx, state); const href = agentLink(o, worker); if (!href) throw new Error("Credential guidance lacks Morgan's exact profile");
+    const o = await observeRuntime(ctx, state); const href = agentLink(o, worker) ?? `/${ctx.input.fixtures.company.issuePrefix}/agents/${worker.id}`;
     // This isolated context deliberately never starts tracing or screenshots.
     // It carries the same real human session; credentials are never exposed to
     // the traced source page, evidence callbacks or model conversation.
@@ -48,7 +59,7 @@ export const runtimeAgentKeyCases = [runtimeDefinition("agents.agent-api-key", a
       await expect(page.getByText("API key created — copy it now, it will not be shown again.", { exact: true })).toBeVisible();
       const token = (await page.locator("code").filter({ hasText: /^pcp_/ }).first().textContent())?.trim();
       if (!token || token.length < 20) throw new Error("Secure one-time UI did not reveal a usable credential");
-      secrets.push(token);
+      secrets.push(token); privateKeys.set(ctx, token);
       const identityResponse = await fetch(new URL("/api/agents/me", ctx.input.api.baseURL), {
         redirect: "error", signal: AbortSignal.timeout(15_000), headers: { Authorization: `Bearer ${token}` },
       });
@@ -69,16 +80,68 @@ export const runtimeAgentKeyCases = [runtimeDefinition("agents.agent-api-key", a
         redirect: "error", signal: AbortSignal.timeout(15_000), headers: { Authorization: `Bearer ${token}` },
       });
       state.revokedCredentialStatus = denied.status; await denied.body?.cancel();
-      const source = await observeRuntime(ctx, state);
-      state.privateScanComplete = true; state.tokenLeaked = source.reply.includes(token)
-        || source.comments.some(comment => comment.body?.includes(token));
     } finally { await secure.close(); }
   },
   async observe(ctx, state) {
     state.finalKeys = await ctx.input.api.get<KeyRow[]>(`/api/agents/${(state.worker as RuntimeAgent).id}/keys`);
-    return observeRuntime(ctx, state);
+    const o = await observeRuntime(ctx, state); const token = privateKeys.get(ctx);
+    if (token) {
+      try {
+        const source = ctx.issue(); if (!source) throw new Error("Source missing");
+        // Potentially tainted evidence must not enter a Playwright response
+        // trace while we inspect it. This is the same actual human session.
+        const cookie = (await ctx.input.page.context().cookies()).map(row => `${row.name}=${row.value}`).join("; ");
+        async function privateResponse(suffix: string) {
+          const response = await fetch(new URL(suffix, ctx.input.api.baseURL), { redirect: "error", signal: AbortSignal.timeout(15_000),
+            headers: { Cookie: cookie, Origin: ctx.input.api.baseURL } });
+          if (!response.ok) { await response.body?.cancel(); throw new Error("Private evidence read failed"); }
+          return response;
+        }
+        async function privateJson<T>(suffix: string): Promise<T> { return (await privateResponse(suffix)).json() as Promise<T>; }
+        const parts: unknown[] = [o.reply, o.comments, state.finalKeys, o.activity, o.runs];
+        const comments = await privateJson<Entity[]>(`/api/issues/${source.id}/comments?order=asc`); parts.push(comments);
+        const documents = await privateJson<Entity[]>(`/api/issues/${source.id}/documents`);
+        let revisions = 0;
+        for (const document of documents) {
+          const base = `/api/issues/${source.id}/documents/${encodeURIComponent(document.key!)}`;
+          parts.push(await privateJson(base));
+          const history = await privateJson<Entity[]>(`${base}/revisions`); parts.push(history); revisions += history.length;
+        }
+        const products = await privateJson<Entity[]>(`/api/issues/${source.id}/work-products`); parts.push(products);
+        const attachments = await privateJson<Array<{ id: string; byteSize: number }>>(`/api/issues/${source.id}/attachments`); parts.push(attachments);
+        for (const attachment of attachments) {
+          if (!Number.isSafeInteger(attachment.byteSize) || attachment.byteSize < 0 || attachment.byteSize > 1_048_576) throw new Error("Artifact scan bound exceeded");
+          parts.push(Buffer.from(await (await privateResponse(`/api/attachments/${attachment.id}/content`)).arrayBuffer()).toString("utf8"));
+        }
+        let logBytes = 0, eventCount = 0;
+        for (const run of o.runs) {
+          let offset = 0; const chunks: string[] = [];
+          for (;;) {
+            const log = await privateJson<{ content: string; nextOffset?: number }>(`/api/heartbeat-runs/${run.id}/log?offset=${offset}&limitBytes=1048576`);
+            if (typeof log.content !== "string") throw new Error("Missing run log content");
+            chunks.push(log.content); logBytes += Buffer.byteLength(log.content);
+            if (logBytes > 8_388_608) throw new Error("Private evidence scan bound exceeded");
+            if (log.nextOffset === undefined) break;
+            if (log.nextOffset <= offset) throw new Error("Run log pagination did not advance");
+            offset = log.nextOffset;
+          }
+          parts.push(chunks.join(""));
+          const events = await collectRunEvents((afterSeq, limit) => privateJson(`/api/heartbeat-runs/${run.id}/events?afterSeq=${afterSeq}&limit=${limit}`));
+          parts.push(events); eventCount += events.length;
+        }
+        state.tokenLeaked = state.tokenLeaked === true || containsPrivateCredential(parts, token);
+        state.privateScanComplete = true; state.artifactScanComplete = true; state.runEvidenceScanComplete = true;
+        state.scanCoverage = { documents: documents.length, revisions, products: products.length, attachments: attachments.length, eventCount, logBytes };
+      } catch {
+        // A failed scan cannot pass, and a provider's error/body can never put
+        // the private credential into a failed assertion or evidence object.
+        state.privateScanComplete = false; state.artifactScanComplete = false; state.runEvidenceScanComplete = false;
+      }
+    }
+    return o;
   },
   async cleanup(ctx, state) {
+    privateKeys.delete(ctx);
     const key = state.createdKey as KeyRow | undefined;
     if (key) await ctx.input.api.delete(`/api/agents/${(state.worker as RuntimeAgent).id}/keys/${key.id}`, { allowNotFound: true });
   },

tests/runner-e2e/chat-catalog-domains/runtime-agent-lifecycle.test.ts

@@ -3,7 +3,7 @@ import { gradePauseAgent } from "./runtime-agent-lifecycle.js";
 function valid() {
   return { scenarioId: "agents.pause-agent", origin: "http://fixture.invalid", companyId: "company", leadId: "ceo",
     state: { worker: { id: "morgan" }, workerRunId: "worker-run", workerWasReallyWaiting: true, beforeHumanStatus: "running", agentPauseStatus: 403, humanPaused: true },
-    agents: [{ id: "morgan", status: "paused", lifecycleState: "paused" }], tasks: [], links: ["/ACORN/agents/morgan"],
+    agents: [{ id: "morgan", companyId: "company", status: "paused", lifecycleState: "paused" }], tasks: [], links: ["/ACORN/agents/morgan"],
     reply: "Open Morgan's profile and use the Pause control. Existing running work stops after cleanup; the pause remains until resumed.",
     activity: [{ id: "pause", action: "agent.paused", entityId: "morgan", actorType: "user" }],
     runs: [{ id: "worker-run", status: "cancelled" }], humanQueries: [] };
@@ -19,3 +19,7 @@ it("rejects a paused label while the old process still runs", () => {
 it("rejects an agent-authored pause attribution", () => {
   const o = valid(); o.activity[0]!.actorType = "agent"; expect(gradePauseAgent(o).passed).toBe(false);
 });
+
+it("accepts correct human pause guidance without requiring a profile hyperlink", () => {
+  const o = valid(); o.links = []; expect(gradePauseAgent(o).passed).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-agent-lifecycle.ts

@@ -2,7 +2,7 @@ import { expect } from "@playwright/test";
 import { pollUntil } from "../api.js";
 import { checks } from "./internal-support.js";
 import { probeAgentPermission } from "./identity-support.js";
-import { runtimeDefinition, runtimeObservation, observeRuntime, agentLink, type RuntimeAgent } from "./runtime-support.js";
+import { runtimeDefinition, runtimeObservation, observeRuntime, openRuntimeAgentProfile, type RuntimeAgent } from "./runtime-support.js";
 import { busyRuntimeWorker, releaseRuntimeWorker } from "./runtime-busy-worker.js";
 export function gradePauseAgent(value: unknown) {
   const c = checks(); const o = runtimeObservation(value);
@@ -19,7 +19,7 @@ export function gradePauseAgent(value: unknown) {
   c.add("pending-human-step-honest", /profile|pause button|pause control|you can pause|you.*pause/i.test(o.reply)
     && /stop|settle|current|existing|running/i.test(o.reply) && !/I(?:'ve| have)? (?:now )?paused/i.test(o.reply),
     "The reply identifies the exact human step and explains how existing execution settles without falsely claiming the pause.");
-  c.add("exact-agent-result-link", !!current && !!agentLink(o, current), "The guidance links Morgan's real saved profile.");
+  c.add("exact-agent-identity", !!current && current.companyId === o.companyId, "The actual human control affects the same saved Morgan identity.");
   return c.result();
 }
 export const runtimeLifecycleCases = [runtimeDefinition("agents.pause-agent", busyRuntimeWorker, gradePauseAgent, {
@@ -48,9 +48,9 @@ export const runtimeLifecycleCases = [runtimeDefinition("agents.pause-agent", bu
     const worker = state.worker as RuntimeAgent;
     state.beforeHumanStatus = (await ctx.input.api.get<RuntimeAgent>(`/api/agents/${worker.id}`)).status;
     state.agentPauseStatus = await probeAgentPermission(ctx, `/api/agents/${worker.id}/pause`, "POST", {});
-    const o = await observeRuntime(ctx, state); const href = agentLink(o, worker); if (!href) throw new Error("Pause guidance lacks Morgan's actual profile");
+    const o = await observeRuntime(ctx, state);
     const source = ctx.input.page.url();
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    await openRuntimeAgentProfile(ctx, worker, o);
     await ctx.input.page.getByRole("button", { name: "Pause", exact: true }).click();
     await pollUntil({ label: "Morgan pause confirmed after native process cleanup", deadlineAt: Date.now() + 90_000,
       load: async () => ({ worker: await ctx.input.api.get<RuntimeAgent>(`/api/agents/${worker.id}`), runs: await ctx.allRuns() }),

tests/runner-e2e/chat-catalog-domains/runtime-agents.test.ts

@@ -91,3 +91,18 @@ it("rejects claimed success after a conflict left the rule unsaved", () => {
   o.reply = "There was a revision conflict, but I have added the testing rule for future work.";
   expect(gradeRuntimeAgents(o).passed).toBe(false);
 });
+
+it.each(["agents.change-manager", "agents.restore-instructions"])("%s accepts real saved results without a mandatory chat href", id => {
+  const o = valid(id); o.links = []; expect(gradeRuntimeAgents(o).passed).toBe(true);
+});
+it("keeps the explicit agent-or-revision link requirement for instruction edits", () => {
+  const o = valid("agents.edit-instructions"); o.links = []; expect(gradeRuntimeAgents(o).passed).toBe(false);
+});
+it("accepts the exact independently saved instruction revision link", () => {
+  const o = valid("agents.edit-instructions"); o.links = ["/api/agents/morgan/instructions-bundle/revision/merged"];
+  expect(gradeRuntimeAgents(o).passed).toBe(true);
+});
+it("rejects an unrelated API route offered as an instruction revision result", () => {
+  const o = valid("agents.edit-instructions"); o.links = ["/api/agents/morgan/keys"];
+  expect(gradeRuntimeAgents(o).passed).toBe(false);
+});

tests/runner-e2e/chat-catalog-domains/runtime-agents.ts

@@ -1,6 +1,7 @@
 import { checks, sameTask } from "./internal-support.js";
-import { runtimeDefinition, runtimeWorker, runtimeObservation, unchangedAgent, agentLink, type RuntimeAgent, type InstructionFile } from "./runtime-support.js";
+import { runtimeDefinition, runtimeWorker, runtimeObservation, unchangedAgent, agentLink, verifyRuntimeResult, type RuntimeObservation, type RuntimeAgent, type InstructionFile } from "./runtime-support.js";
 import { pollUntil } from "../api.js";
+import { expect } from "@playwright/test";
 
 export function gradeRuntimeAgents(value: unknown) {
   const c = checks(); const o = runtimeObservation(value);
@@ -18,7 +19,7 @@ export function gradeRuntimeAgents(value: unknown) {
       c.add("unrelated-config-and-tasks-retained", !!before && !!worker && unchangedAgent(before, worker, ["reportsTo"])
         && Array.isArray(o.state.tasksBefore) && o.tasks.length === o.state.tasksBefore.length
         && o.tasks.every(row => (o.state.tasksBefore as typeof o.tasks).some(prior => sameTask(prior, row))), "Changing the manager preserves accounts, permissions and existing tasks.");
-      c.add("attributed-linked-agent", !!worker && !!agentLink(o, worker) && authored("agent.updated", worker.id), "The agent-authored reporting-line change is inspectable from the rendered reply.");
+      c.add("attributed-agent-change", !!worker && authored("agent.updated", worker.id), "The saved reporting-line change is independently attributed to the actual agent.");
       break;
     }
     case "agents.hire-denied":
@@ -47,8 +48,8 @@ export function gradeRuntimeAgents(value: unknown) {
         "An actual human revision occurred during the canonical query's active native run and remains in history.");
       c.add("rule-attributed-if-saved", !ruleSaved || !!current && current.revision.actorAgentId === o.leadId
         && o.runs.some(run => run.id === current.revision.sourceRunId), "A saved testing rule belongs to this actual agent run.");
-      c.add("future-use-and-profile-link", !!worker && !!agentLink(o, worker) && /future|next|subsequent|new (?:run|work)|conflict|revision/i.test(o.reply),
-        "The reply links Morgan and describes future instruction use or the unresolved revision.");
+      c.add("future-use-and-agent-or-revision-link", !!worker && instructionResultLink(o, worker) && /future|next|subsequent|new (?:run|work)|conflict|revision/i.test(o.reply),
+        "The reply links Morgan or the exact saved revision and describes future instruction use or the unresolved revision.");
       break;
     }
     case "agents.restore-instructions": {
@@ -61,8 +62,8 @@ export function gradeRuntimeAgents(value: unknown) {
         && [previous.revision.id, unwanted.revision.id, current.revision.id].every(id => o.instructionHistory?.revisions.some(row => row.id === id)),
         "Both historical revisions and the agent-authored restoration remain inspectable.");
       c.add("other-file-preserved", o.instructionSideFile?.content === o.state.sideContent, "Unrelated guidance remains unchanged.");
-      c.add("linked-and-honest-restoration", !!worker && !!agentLink(o, worker) && /restor|revert|undo|previous/i.test(o.reply)
-        && !/rewound|undid.*(?:executed|completed).*tasks/i.test(o.reply), "The reply links Morgan and describes an instruction restoration.");
+      c.add("honest-restoration", !!worker && /restor|revert|undo|previous/i.test(o.reply)
+        && !/rewound|undid.*(?:executed|completed).*tasks/i.test(o.reply), "The reply describes the actual instruction restoration without claiming to rewind executed tasks.");
       break;
     }
     default: c.add("known-runtime-agent-oracle", false, "The requested agent scenario has no authored oracle.");
@@ -96,7 +97,28 @@ export const runtimeAgentsCases = [
     const worker = await runtimeWorker(ctx); const riley = await runtimeWorker(ctx, "Riley", { role: "cto", title: "CTO" });
     const task = await ctx.input.api.post(`/api/companies/${ctx.input.fixtures.company.id}/issues`, { title: "Historical website assignment", status: "backlog", assigneeAgentId: worker.id });
     return { worker, riley, tasksBefore: [task] };
-  }, gradeRuntimeAgents),
+  }, gradeRuntimeAgents, { async verifyResult(ctx, state, value) {
+    await verifyRuntimeResult(ctx, state, value);
+    const source = ctx.input.page.url();
+    await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/agents/all`, { waitUntil: "domcontentloaded" });
+    await ctx.input.page.reload({ waitUntil: "domcontentloaded" });
+    const toggle = ctx.input.page.getByRole("button", { name: "Org chart view", exact: true });
+    if (await toggle.isVisible()) await toggle.click();
+    else await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/org`, { waitUntil: "domcontentloaded" });
+    const morgan = ctx.input.page.locator("[data-org-card]").filter({ hasText: "Morgan" });
+    const riley = ctx.input.page.locator("[data-org-card]").filter({ hasText: "Riley" });
+    await expect(morgan).toBeVisible(); await expect(riley).toBeVisible();
+    const org = await ctx.input.api.get<Array<{ id: string; reports: Array<{ id: string; reports: unknown[] }> }>>(`/api/companies/${ctx.input.fixtures.company.id}/org`);
+    const find = (rows: Array<{ id: string; reports: unknown[] }>, id: string): { id: string; reports: unknown[] } | undefined => {
+      for (const row of rows) { if (row.id === id) return row; const child = find(row.reports as typeof rows, id); if (child) return child; }
+    };
+    const manager = find(org, (state.riley as RuntimeAgent).id);
+    if (!manager?.reports.some(row => (row as { id: string }).id === (state.worker as RuntimeAgent).id)) throw new Error("Reloaded organization view data disagrees with the saved manager");
+    const workerBox = await morgan.boundingBox(); const managerBox = await riley.boundingBox();
+    if (!workerBox || !managerBox || workerBox.y <= managerBox.y) throw new Error("Rendered organization hierarchy does not put Morgan below Riley");
+    await ctx.input.evidence("runtime-manager-org-view.json", { workerId: (state.worker as RuntimeAgent).id, managerId: (state.riley as RuntimeAgent).id, renderedHierarchyMatches: true });
+    await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" });
+  } }),
   runtimeDefinition("agents.hire-denied", async ctx => {
     await ctx.input.api.patch(`/api/agents/${ctx.input.fixtures.agent.id}/permissions`, { canCreateAgents: false });
     const { probeAgentPermission } = await import("./identity-support.js");
@@ -121,6 +143,13 @@ export const runtimeAgentsCases = [
     return { worker, instructionAgentId: worker.id, previousInstruction, unwantedInstruction, sideContent };
   }, gradeRuntimeAgents),
 ];
+function instructionResultLink(o: RuntimeObservation, worker: RuntimeAgent): boolean {
+  return !!agentLink(o, worker) || !!o.instruction && o.links.some(href => {
+    try { const url = new URL(href, o.origin); return url.origin === new URL(o.origin).origin
+      && url.pathname === `/api/agents/${worker.id}/instructions-bundle/revision/${o.instruction!.revision.id}`; }
+    catch { return false; }
+  });
+}
 function validTree(agents: RuntimeAgent[]) {
   return agents.every(agent => {
     const seen = new Set<string>(); let row: RuntimeAgent | undefined = agent;

tests/runner-e2e/chat-catalog-domains/runtime-built-in.test.ts

@@ -20,3 +20,7 @@ it("rejects changing only prose without a saved instruction revision", () => {
 it("rejects erasing the old attributed task", () => {
   const o = valid(); o.tasks = []; expect(gradeBuiltInConfiguration(o).passed).toBe(false);
 });
+
+it("accepts a real built-in configuration change with textual guidance and no mandatory href", () => {
+  const o = valid(); o.links = []; expect(gradeBuiltInConfiguration(o).passed).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-built-in.ts

@@ -1,5 +1,5 @@
 import { checks, sameTask, type Entity } from "./internal-support.js";
-import { runtimeDefinition, runtimeObservation, observeRuntime, agentLink, type RuntimeAgent, type InstructionFile } from "./runtime-support.js";
+import { runtimeDefinition, runtimeObservation, observeRuntime, type RuntimeAgent, type InstructionFile } from "./runtime-support.js";
 interface BuiltInState { definition: { key: string }; agentId: string | null; agent: RuntimeAgent | null; status: string }
 export function gradeBuiltInConfiguration(value: unknown) {
   const c = checks(); const o = runtimeObservation(value);
@@ -16,8 +16,8 @@ export function gradeBuiltInConfiguration(value: unknown) {
     "An actual agent-attributed revision applies shorter summary guidance while retaining the summarizer purpose.");
   c.add("history-retained", !!beforeInstruction && o.instructionHistory?.revisions.some(row => row.id === beforeInstruction.revision.id) === true
     && o.tasks.length === 1 && sameTask(o.state.historicalTask as Entity, o.tasks[0]), "Instruction history and attributed historical work remain intact.");
-  c.add("inspectable-effective-change", !!worker && !!agentLink(o, worker) && /short|brief|concis/i.test(o.reply),
-    "The response links the protected agent and describes the saved change.");
+  c.add("inspectable-effective-change", !!worker && /short|brief|concis/i.test(o.reply),
+    "The response describes the saved protected-agent configuration change.");
   return c.result();
 }
 export const runtimeBuiltInCases = [runtimeDefinition("agents.configure-required-agent", async ctx => {

tests/runner-e2e/chat-catalog-domains/runtime-capability-audit.json

@@ -87,7 +87,7 @@
     {
       "scenarioId": "agent-chat.reopen-conversation",
       "readinessClass": "implemented",
-      "needs": "Genuine native setup history and declared canonical query boundary; same owned Morgan source, actual final-run result link, private-list denial and no navigation execution."
+      "needs": "Genuine native setup history and declared canonical query boundary; same owned Morgan source, actual run-bound navigation guidance, private-list denial and no navigation execution."
     },
     {
       "scenarioId": "agent-chat.remember-and-follow-up",

tests/runner-e2e/chat-catalog-domains/runtime-conference.ts

@@ -30,9 +30,10 @@ export const runtimeConferenceCases = [runtimeDefinition("agent-chat.conference-
     const o = await observeRuntime(ctx, state);
     const href = o.links.find(link => { const url = new URL(link, ctx.input.api.baseURL);
       return url.origin === ctx.input.api.baseURL && url.pathname === `/${state.companyPrefix}/board-chat`; });
-    if (!href) throw new Error("Conference response lacks the actual company board route");
+
     const source = ctx.input.page.url();
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    if (href) await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    else await ctx.input.page.goto(`/${state.companyPrefix}/board-chat`, { waitUntil: "domcontentloaded" });
     await expect(ctx.input.page.getByPlaceholder("Ask anything about your organization...")).toBeVisible();
     await expect(ctx.input.page.getByText("Conference Room", { exact: true }).first()).toBeVisible();
     state.conferenceVisible = true;

tests/runner-e2e/chat-catalog-domains/runtime-primary.ts

@@ -2,7 +2,7 @@ import { expect } from "@playwright/test";
 import { checks, type Entity } from "./internal-support.js";
 import { createAuthenticatedPerson, enrollAuthenticatedPerson } from "./identity-auth.js";
 import { probeAgentPermission, waitForReply } from "./identity-support.js";
-import { runtimeDefinition, runtimeWorker, runtimeObservation, observeRuntime, agentLink, type RuntimeAgent } from "./runtime-support.js";
+import { runtimeDefinition, runtimeWorker, runtimeObservation, observeRuntime, openRuntimeAgentProfile, type RuntimeAgent } from "./runtime-support.js";
 import type { ChatCatalogContext } from "../chat-catalog-contract.js";
 interface Primary { companyId: string; userId: string; primaryAgentId: string | null }
 type Person = Awaited<ReturnType<typeof createAuthenticatedPerson>>;
@@ -53,9 +53,9 @@ export const runtimePrimaryCases = [runtimeDefinition("agents.choose-primary", a
     await waitForReply(ctx); const worker = state.worker as RuntimeAgent;
     state.beforeHumanPrimary = (await ctx.input.api.get<Primary>(endpoint(ctx.input.fixtures.company.id))).primaryAgentId;
     state.agentWriteStatus = await probeAgentPermission(ctx, endpoint(ctx.input.fixtures.company.id), "PUT", { primaryAgentId: worker.id });
-    const o = await observeRuntime(ctx, state); const href = agentLink(o, worker); if (!href) throw new Error("Primary guidance lacks Morgan's real profile link");
+    const o = await observeRuntime(ctx, state);
     const source = ctx.input.page.url();
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    await openRuntimeAgentProfile(ctx, worker, o);
     await ctx.input.page.getByRole("button", { name: "Set as my primary", exact: true }).click();
     const dialog = ctx.input.page.getByRole("alertdialog");
     await expect(dialog).toContainText("Change your primary agent?"); await expect(dialog).toContainText("Morgan");

tests/runner-e2e/chat-catalog-domains/runtime-recovery.test.ts

@@ -1,8 +1,8 @@
 import { it, expect } from "vitest";
 import { gradeControllerRestart } from "./runtime-recovery.js";
 function valid() {
-  const initial = { contentVerified: true, content: "<h1>Unpredictable Orchid header</h1>", attachmentId: "initial" };
-  const final = { contentVerified: true, content: "<h1>Unpredictable Orchid header</h1><section>Contact hello@acorn.example</section>", attachmentId: "final" };
+  const initial = { contentVerified: true, content: "<h1>Unpredictable Orchid header</h1>", attachmentId: "initial", workProductId: "initial-product" };
+  const final = { contentVerified: true, content: "<h1>Unpredictable Orchid header</h1><section>Contact hello@acorn.example</section>", attachmentId: "final", workProductId: "final-product" };
   return { scenarioId: "recovery.controller-restart", origin: "http://fixture.invalid", companyId: "company", leadId: "ceo",
     state: { initialArtifact: initial, finalArtifact: final, fileBeforeRestart: initial.content, fileAfterRestart: initial.content, restarted: true,
       headerMarker: "Unpredictable Orchid header", finalFile: final.content, initialRunId: "first", sourceIssueBefore: "chat", sourceIssueAfter: "chat", priorHistoryRetained: true },
@@ -24,3 +24,7 @@ it("rejects source-history replacement", () => {
 it("rejects a duplicate delegated execution task", () => {
   const o = valid(); (o.tasks as Array<{ id: string }>).push({ id: "duplicate-work" }); expect(gradeControllerRestart(o).passed).toBe(false);
 });
+
+it("accepts usable registered final work without a mandatory chat hyperlink", () => {
+  const o = valid(); o.links = []; expect(gradeControllerRestart(o).passed).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-recovery.ts

@@ -38,10 +38,9 @@ export function gradeControllerRestart(value: unknown) {
     "One ordinary continuation follows the explicit user request without duplicate execution tasks or replayed side effects.");
   c.add("source-and-history-retained", o.state.sourceIssueBefore === o.state.sourceIssueAfter && o.state.priorHistoryRetained === true,
     "The same conversation and genuine prior messages survive the controller restart.");
-  c.add("actual-final-download-link", !!final && o.links.some(href => {
-    try { const url = new URL(href, o.origin); return url.origin === new URL(o.origin).origin
-      && url.pathname === `/api/attachments/${final.attachmentId}/content`; } catch { return false; }
-  }), "The actual final file is available through a rendered production attachment link.");
+  c.add("actual-final-download-resource", !!final?.contentVerified && typeof final.attachmentId === "string" && !!final.attachmentId
+    && typeof final.workProductId === "string" && !!final.workProductId,
+    "The final work has a genuine run-attributed downloadable attachment and registered work product; its UI is verified separately.");
   return c.result();
 }
 export const runtimeRecoveryCases = [runtimeDefinition("recovery.controller-restart", async ctx => {
@@ -79,11 +78,14 @@ export const runtimeRecoveryCases = [runtimeDefinition("recovery.controller-rest
     if (!o || !artifact) throw new Error("No actual final continuation artifact");
     const href = o.links.find(link => { const url = new URL(link, o.origin); return url.origin === new URL(o.origin).origin
       && url.pathname === `/api/attachments/${artifact.attachmentId}/content`; });
-    if (!href) throw new Error("Final artifact link is absent");
+
     // HTML attachments use the production download policy. Verify the actual
     // human result control and download, not merely an API registration row.
     const downloadPromise = ctx.input.page.waitForEvent("download");
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).last().click();
+    if (href) await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).last().click();
+    else await ctx.input.page.goto(new URL(`/api/attachments/${artifact.attachmentId}/content?download=1`, o.origin).href).catch(error => {
+      if (!/Download is starting|net::ERR_ABORTED/i.test(String(error))) throw error;
+    });
     const download = await downloadPromise;
     if (download.suggestedFilename() !== state.filename) throw new Error("The visible result downloaded a different file");
     await ctx.input.evidence("runtime-controller-final-download.json", { attachmentId: artifact.attachmentId, filename: download.suggestedFilename(), sha256: artifact.sha256 });

tests/runner-e2e/chat-catalog-domains/runtime-support.ts

@@ -50,18 +50,23 @@ export function runtimeObservation(value: unknown): RuntimeObservation | undefin
 export function agentLink(o: RuntimeObservation, agent: RuntimeAgent): string | undefined {
   return o.links.find(href => {
     try { const url = new URL(href, o.origin); const parts = url.pathname.split("/").map(decodeURIComponent); const index = parts.indexOf("agents");
-      return url.origin === new URL(o.origin).origin && index >= 0 && [agent.id, agent.urlKey].includes(parts[index + 1]); }
+      return url.origin === new URL(o.origin).origin && !url.pathname.startsWith("/api/") && index >= 0 && [agent.id, agent.urlKey].includes(parts[index + 1]); }
     catch { return false; }
   });
 }
+/** Canonical outcomes may name a supported control without a Markdown href. */
+export async function openRuntimeAgentProfile(ctx: ChatCatalogContext, agent: RuntimeAgent, o?: RuntimeObservation) {
+  const href = o && agentLink(o, agent);
+  if (href) await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+  else await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/agents/${agent.id}`, { waitUntil: "domcontentloaded" });
+  await expect(ctx.input.page.getByRole("heading", { name: agent.name!, exact: true }).first()).toBeVisible();
+}
 export async function verifyRuntimeResult(ctx: ChatCatalogContext, state: Record<string, unknown>, value: unknown) {
   const o = runtimeObservation(value); if (!o) throw new Error("Missing independent runtime result");
   const target = o.agents.find(row => row.id === (state.worker as RuntimeAgent | undefined)?.id);
   if (!target) { await expect(ctx.input.page.getByTestId("task-chat-composer-input")).toBeVisible(); return; }
-  const href = agentLink(o, target); if (!href) throw new Error("No actual rendered target-agent link");
   const source = ctx.input.page.url();
-  await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
-  await expect(ctx.input.page.getByRole("heading", { name: target.name!, exact: true }).first()).toBeVisible();
+  await openRuntimeAgentProfile(ctx, target, o);
   await ctx.input.page.reload({ waitUntil: "domcontentloaded" });
   await expect(ctx.input.page.getByRole("heading", { name: target.name!, exact: true }).first()).toBeVisible();
   await ctx.input.evidence("chat-catalog-runtime-profile-opened.json", { agentId: target.id, companyId: target.companyId, url: ctx.input.page.url() });
@@ -69,7 +74,7 @@ export async function verifyRuntimeResult(ctx: ChatCatalogContext, state: Record
 }
 export function runtimeDefinition(scenarioId: string, setup: ChatCatalogCase["setup"], grade: ChatCatalogCase["grade"], extra: Partial<ChatCatalogCase> = {}): ChatCatalogCase {
   return { scenarioId, setup, grade, observe: observeRuntime, verifyResult: verifyRuntimeResult,
-    oracleVersion: "paperclip.chat-catalog.runtime.v1", coverageGaps: [], expectedRunCount: 1,
+    oracleVersion: "paperclip.chat-catalog.runtime.v2", coverageGaps: [], expectedRunCount: 1,
     turnTimeoutMs: 120_000, attemptTimeoutMs: 300_000,
     sourceFiles: ["chat-catalog-domains/runtime-support.ts", `chat-catalog-domains/runtime-${scenarioId.split(".")[0]}.ts`, `chat-scenarios/${scenarioId.split(".")[0]}.yaml`], ...extra };
 }

tests/runner-e2e/chat-catalog-domains/runtime-task-coordination.test.ts

@@ -19,3 +19,7 @@ it("rejects silently deleting the original prerequisite", () => {
 it("rejects a conflict with no actionable order decision", () => {
   const o = valid(); o.reply = "Website and Design form a cycle."; expect(gradeDependencyCycle(o).passed).toBe(false);
 });
+
+it("accepts a saved acyclic rejection naming both tasks without mandatory chat hrefs", () => {
+  const o = valid(); o.links = []; expect(gradeDependencyCycle(o).passed).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-task-coordination.ts

@@ -1,5 +1,6 @@
-import { checks, project, task, sameTask, hasLink, verifyInternalResult, type Entity } from "./internal-support.js";
+import { checks, project, task, sameTask, type Entity } from "./internal-support.js";
 import { runtimeDefinition, observeRuntime, runtimeObservation, type RuntimeObservation } from "./runtime-support.js";
+import { expect } from "@playwright/test";
 import type { ChatCatalogContext } from "../chat-catalog-contract.js";
 
 interface DependencyTask extends Entity { blockedByIssueIds?: string[]; blockedBy?: Array<{ id: string }> }
@@ -21,7 +22,7 @@ export function gradeDependencyCycle(value: unknown) {
   c.add("explains-actual-conflict-and-next-decision", /\bWebsite\b/i.test(o.reply) && /\bDesign\b/i.test(o.reply)
     && /cycl|circular|already.*depend|deadlock/i.test(o.reply) && /choose|which|instead|remove|order|first/i.test(o.reply),
     "The response explains the named dependency conflict and an actionable order decision.");
-  c.add("actual-task-result-links", hasLink(o, "issues", website) && hasLink(o, "issues", design), "Both actual dependency records are linked from chat.");
+
   return c.result();
 }
 async function observeDependencies(ctx: ChatCatalogContext, state: Record<string, unknown>): Promise<DependencyObservation> {
@@ -33,4 +34,11 @@ export const runtimeTaskCoordinationCases = [runtimeDefinition("task-coordinatio
   const p = await project(ctx); const website = await task(ctx, "Website", p.id);
   const design = await task(ctx, "Design", p.id, { blockedByIssueIds: [website.id] });
   return { project: p, task: website, design };
-}, gradeDependencyCycle, { observe: observeDependencies, verifyResult: verifyInternalResult })];
+}, gradeDependencyCycle, { observe: observeDependencies, async verifyResult(ctx, state) {
+  const source = ctx.input.page.url();
+  for (const row of [state.task as Entity, state.design as Entity]) {
+    await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/issues/${row.identifier ?? row.id}`, { waitUntil: "domcontentloaded" });
+    await expect(ctx.input.page.getByRole("heading", { name: row.title!, exact: true }).first()).toBeVisible();
+  }
+  await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" });
+} })];

tests/runner-e2e/chat-catalog-domains/runtime-workspaces.test.ts

@@ -20,3 +20,8 @@ it("rejects linking another workspace", () => {
 it("rejects fabricated saved-file setup without its actual worker run", () => {
   const o = valid(); o.runs = []; expect(gradeLocateFiles(o).passed).toBe(false);
 });
+
+it("accepts the actual directory and supported view directions without a mandatory href", () => {
+  const o = valid(); o.links = []; o.reply = "The bound workspace uses /owned/task-root; open the Workspace view to inspect its files.";
+  expect(gradeLocateFiles(o).passed).toBe(true);
+});

tests/runner-e2e/chat-catalog-domains/runtime-workspaces.ts

@@ -40,8 +40,11 @@ export function gradeLocateFiles(value: unknown) {
   c.add("actual-saved-files-retained", o.state.fileAfter === o.state.fileBefore && typeof o.state.fileBefore === "string"
     && o.state.fileBefore.trim() === o.state.marker && o.runs.some(run => run.id === o.state.fixtureRunId && run.agentId === (o.state.worker as Entity).id
       && run.status === "succeeded"), "A genuine worker created the prerequisite file and it remains unchanged.");
-  c.add("actual-workspace-result-link", !!after && o.links.some(href => workspaceLink(o.origin, href, after.workspace.id)),
-    "The response renders the real workspace view link.");
+  c.add("supported-workspace-view-guidance", (/workspace|files? (?:view|tab|panel)/i.test(o.reply)
+    || !!after && o.links.some(href => workspaceLink(o.origin, href, after.workspace.id)))
+    && !!after && o.links.filter(href => { try { return new URL(href, o.origin).pathname.includes("/execution-workspaces/"); } catch { return false; } })
+      .every(href => workspaceLink(o.origin, href, after.workspace.id)),
+    "The response points to the supported workspace view; any workspace link it does give must identify the actual bound workspace.");
   return c.result();
 }
 function workspaceLink(origin: string, href: string, id: string) {
@@ -60,9 +63,10 @@ export const runtimeWorkspacesCases = [runtimeDefinition("workspaces.locate-file
   async verifyResult(ctx, state, value) {
     const o = runtimeObservation(value); if (!o) throw new Error("Workspace result missing");
     const view = state.workspaceAfter as WorkspaceView;
-    const href = o.links.find(link => workspaceLink(o.origin, link, view.workspace.id)); if (!href) throw new Error("No actual workspace result link");
+    const href = o.links.find(link => workspaceLink(o.origin, link, view.workspace.id));
     const source = ctx.input.page.url();
-    await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    if (href) await ctx.input.page.locator(`[id^="comment-"] a[href=${JSON.stringify(href)}]`).first().click();
+    else await ctx.input.page.goto(`/${ctx.input.fixtures.company.issuePrefix}/execution-workspaces/${view.workspace.id}`, { waitUntil: "domcontentloaded" });
     await expect(ctx.input.page.getByRole("heading", { name: view.workspace.name, exact: true }).first()).toBeVisible();
     await ctx.input.evidence("runtime-task-workspace-opened.json", { taskId: (state.task as Entity).id, workspaceId: view.workspace.id, url: ctx.input.page.url() });
     await ctx.input.page.goto(source, { waitUntil: "domcontentloaded" });