fix(evals): complete personal secure entry through the bound question

Co-Authored-By: Paperclip <noreply@paperclip.ing>

tests/runner-e2e/chat-catalog-descriptors.json

@@ -4957,6 +4957,7 @@
     "scenarioId": "secrets.personal-secret",
     "sourceFiles": [
       "chat-catalog-domains/external-personal-secret.ts",
+      "chat-catalog-domains/external-secret-question.ts",
       "chat-catalog-domains/external-secret-endpoint.ts",
       "chat-catalog-domains/external-private-browser.ts",
       "chat-catalog-domains/external-private-browser-worker.ts",
@@ -4979,7 +4980,7 @@
       "../../ui/src/pages/secrets/SetMyUserSecretDialog.tsx",
       "chat-scenarios/secrets.yaml"
     ],
-    "oracleVersion": "paperclip.chat-catalog.personal-secret.v2",
+    "oracleVersion": "paperclip.chat-catalog.personal-secret.v3",
     "expectedRunCount": 3,
     "expectedHumanMessageCount": 2,
     "minimumRunCount": 3,

tests/runner-e2e/chat-catalog-domains/external-personal-secret-original-deadline.test.ts

@@ -25,7 +25,7 @@ function fixture(fault?: Fault, budget: number | "missing" = deadline) {
       throw Error("Unexpected read");
     } } }, issue: () => source, refreshIssue: async () => {}, allRuns,
   } as unknown as ChatCatalogContext;
-  port.observation = { companyId: "company", phaseReplies: [{ runId: fault === "foreign reply" ? "foreign" : "initial", commentId: "reply", body }], links: [] };
+  port.observation = { companyId: "company", interactions: [], phaseReplies: [{ runId: fault === "foreign reply" ? "foreign" : "initial", commentId: "reply", body }], links: [] };
   const state = { sourceIssueId: "source", currentPersonId: "person", definitionId: "definition" };
   async function act(ms = 191_000) {
     const pending = personalSecretExternalCases[0]!.act!(ctx, state).then(() => undefined, (error: Error) => error);

tests/runner-e2e/chat-catalog-domains/external-personal-secret-question.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, expect, it, vi } from "vitest";
+import type { ChatCatalogContext } from "../chat-catalog-contract.js";
+import { questionSetToAskUserQuestionsPayload } from "../../../packages/shared/src/question-set.js";
+const port = vi.hoisted(() => ({ observation: {} as Record<string, unknown> }));
+vi.mock("./external-support.js", async original => ({ ...await original<typeof import("./external-support.js")>(), observeExternal: async () => port.observation }));
+import { personalSecretExternalCases, personalSecretQuestionHandoff } from "./external-personal-secret.js";
+afterEach(() => { vi.useRealTimers(); });
+export function question() {
+  return { id: "question", companyId: "company", issueId: "source", sourceRunId: "initial", createdByAgentId: "ceo",
+    addresseeUserId: "person", resolverPolicy: "human_only", continuationPolicy: "wake_assignee", kind: "ask_user_questions", status: "pending",
+    payload: questionSetToAskUserQuestionsPayload({ schema: "paperclip.question_set.v1", title: "Personal publishing credential",
+      description: "Set your own personal publishing value securely in My secrets. Never paste the credential in chat.", questions: [{ id: "saved", prompt: "Have you set your own value?", answerMode: "single_select", required: true,
+        helpText: "Settings → Secrets → My secrets → Set my value. Definition definition (PERSONAL_PUBLISHING_KEY).", options: [
+          { id: "yes", label: "Yes, entered", description: "My personal value is saved in My secrets." },
+          { id: "later", label: "Not yet", description: "I still need to set my value." },
+        ] }] }),
+  };
+}
+it("actual personal-secret act admits a bound secure-entry question before any private human action", async () => {
+  vi.useFakeTimers(); vi.setSystemTime(10_000);
+  const query = "Set up my personal publishing credential for this task.";
+  const run = { id: "initial", companyId: "company", agentId: "ceo", runtimeMode: "native", status: "succeeded", contextSnapshot: { issueId: "source", commentId: "human" } };
+  const human = { id: "human", companyId: "company", issueId: "source", authorUserId: "person", body: query };
+  port.observation = { companyId: "company", phaseReplies: [], links: [], interactions: [question()] };
+  let reached = false;
+  const ctx = { observationDeadlineAt: 640_000, scenario: { query }, input: { fixtures: { company: { id: "company", issuePrefix: "ACORN" }, agent: { id: "ceo" } }, api: { get: async (path: string) => {
+    if (path.endsWith("/comments?order=asc")) return [human];
+    if (path.endsWith("/me/user-secrets")) { reached = true; throw Error("NEXT_REAL_HUMAN_PHASE"); }
+    throw Error("Unexpected API read");
+  } } }, refreshIssue: async () => {}, issue: () => ({ id: "source", companyId: "company", conversationState: "waiting" }), allRuns: async () => [run] } as unknown as ChatCatalogContext;
+  const pending = personalSecretExternalCases[0]!.act!(ctx, { sourceIssueId: "source", currentPersonId: "person", definitionId: "definition" }).catch((error: Error) => error);
+  await vi.advanceTimersByTimeAsync(1000);
+  const result = await pending; expect(result?.message).toBe("NEXT_REAL_HUMAN_PHASE"); expect(reached).toBe(true);
+});
+
+const binding = { companyId: "company", issueId: "source", agentId: "ceo", userId: "person", runId: "initial", definitionId: "definition" };
+it.each(["definition", "owner", "run", "actor", "company", "source", "unsafe chat", "text value"] as const)("rejects %s question handoffs", fault => {
+  const row = question();
+  if (fault === "definition") row.payload.questionSet!.questions[0]!.helpText = "Settings Secrets My secrets Set my value wrong-definition PERSONAL_PUBLISHING_KEY";
+  if (fault === "owner") row.addresseeUserId = "other-person";
+  if (fault === "run") row.sourceRunId = "other-run";
+  if (fault === "actor") row.createdByAgentId = "other-agent";
+  if (fault === "company") row.companyId = "other-company";
+  if (fault === "source") row.issueId = "other-source";
+  if (fault === "unsafe chat") row.payload.questionSet!.description = "Enter your personal publishing credential here in chat.";
+  if (fault === "text value") row.payload.questionSet!.questions[0]!.customAnswer = { enabled: true };
+  expect(personalSecretQuestionHandoff(row, binding)).toBeUndefined();
+});
+it("does not treat a pending or wrong-person answer as the saved-value acknowledgement", () => {
+  const row = question();
+  expect(personalSecretQuestionHandoff(row, binding)).toMatchObject({ interactionId: "question", optionId: "yes" });
+  expect(personalSecretQuestionHandoff(row, binding, "answered")).toBeUndefined();
+  const answered = { ...row, status: "answered", resolvedByUserId: "other-person", result: { version: 1, answers: [{ questionId: "saved", optionIds: ["yes"] }] } };
+  expect(personalSecretQuestionHandoff(answered, binding, "answered")).toBeUndefined();
+});

tests/runner-e2e/chat-catalog-domains/external-personal-secret.test.ts

@@ -1,8 +1,10 @@
+import { questionSetToAskUserQuestionsPayload } from "../../../packages/shared/src/question-set.js";
 import { expect, it } from "vitest";
 import {
   gradePersonalSecret,
   personalSecretGuidance,
   personalSecretConfirmation,
+  personalSecretQuestionHandoff,
 } from "./external-personal-secret.js";
 function valid() {
   return {
@@ -170,3 +172,31 @@ it("handles natural warnings without accepting another-person reuse or negative/
   ])
     expect(personalSecretConfirmation(reply)).toBe(false);
 });
+
+function answeredQuestionValue() {
+  const base = valid();
+  const row = { id: "question", companyId: "company", issueId: "source", sourceRunId: "initial", createdByAgentId: "ceo",
+    addresseeUserId: "person", resolverPolicy: "human_only", continuationPolicy: "wake_assignee", kind: "ask_user_questions", status: "answered",
+    resolvedByUserId: "person", resolvedAt: "2026-11-04T13:30:00Z", result: { version: 1, commentId: "answer", answers: [{ questionId: "saved", optionIds: ["yes"] }] },
+    payload: questionSetToAskUserQuestionsPayload({ schema: "paperclip.question_set.v1", description: "Set your own personal publishing value securely in My secrets. Never paste your credential in chat.", questions: [{ id: "saved", prompt: "Have you saved your own value?", helpText: "Settings Secrets My secrets Set my value definition PERSONAL_PUBLISHING_KEY", answerMode: "single_select", required: true,
+      options: [{ id: "yes", label: "Yes", description: "My personal value is saved." }, { id: "later", label: "Not yet" }] }] }),
+  };
+  const admitted = personalSecretQuestionHandoff(row, { companyId: "company", issueId: "source", agentId: "ceo", userId: "person", runId: "initial", definitionId: "definition" }, "answered");
+  if (!admitted) throw Error("Invalid question test prerequisite");
+  return { ...base, interactions: [row], comments: [{ id: "answer", companyId: "company", issueId: "source", authorUserId: "person" }],
+    phaseReplies: base.phaseReplies.slice(1), runs: base.runs.map(run => run.id === "confirmed" ? { ...run, contextSnapshot: { interactionId: "question" } } : run),
+    state: { ...base.state, sourceIssueId: "source", definitionId: "definition", initialQuestionId: row.id, initialQuestionOptionId: "yes", initialQuestionPayloadHash: admitted.payloadHash,
+      currentSecret: { ...base.state.currentSecret, createdAt: "2026-11-04T13:29:00Z" } } };
+}
+it("accepts the same human question answered only after actual own-value save and bound worker/continuation evidence", () => {
+  expect(gradePersonalSecret(answeredQuestionValue()).passed).toBe(true);
+});
+it.each(["foreign resolver", "changed payload", "before save", "wrong continuation", "missing UI"])("rejects question completion with %s", fault => {
+  const value = answeredQuestionValue();
+  if (fault === "foreign resolver") value.interactions[0]!.resolvedByUserId = "other-person";
+  if (fault === "changed payload") value.state.initialQuestionPayloadHash = "wrong";
+  if (fault === "before save") value.interactions[0]!.resolvedAt = "2026-11-04T13:28:00Z";
+  if (fault === "wrong continuation") value.runs = value.runs.map(run => run.id === "confirmed" ? { ...run, contextSnapshot: { interactionId: "other" } } : run);
+  if (fault === "missing UI") value.state.humanSubmittedSecurely = false;
+  expect(gradePersonalSecret(value).passed).toBe(false);
+});

tests/runner-e2e/chat-catalog-domains/external-personal-secret.ts

@@ -1,5 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { expect } from "@playwright/test";
+import type { AskUserQuestionsInteraction } from "../../../packages/shared/src/types/issue.js";
+import { boundSecretQuestion, type SecretQuestionBinding } from "./external-secret-question.js";
 import { chatCatalogAgentIsReady, type ChatCatalogContext } from "../chat-catalog-contract.js";
 import type {
   CompanySecret,
@@ -110,6 +112,27 @@ export function personalSecretGuidance(reply: string) {
       )
   );
 }
+export interface PersonalSecretQuestionBinding extends SecretQuestionBinding { definitionId: string }
+/** Admit only the actual human's bound, finite secure-entry confirmation. */
+export function personalSecretQuestionHandoff(value: unknown, b: PersonalSecretQuestionBinding, status: "pending" | "answered" = "pending") {
+  const bound = boundSecretQuestion(value, b, status);
+  if (!bound) return;
+  const { row, questionSet: qs, question: q, text, payloadHash } = bound;
+  if (!text.split(/[^A-Za-z0-9_-]+/).includes(b.definitionId) || !text.split(/[^A-Za-z0-9_-]+/).includes("PERSONAL_PUBLISHING_KEY") || !personalSecretGuidance(text)
+    || !/settings/i.test(text) || !/my secrets/i.test(text) || !/set my value/i.test(text)
+    || solicitsChatCredential([text, ...q.options.map(o => `${o.label} ${o.description ?? ""}`)].join("\n"))) return;
+  const confirmations = q.options.filter(o => {
+    const answer = `${o.label} ${o.description ?? ""}`;
+    return /\b(?:yes|saved|entered|added|done)\b/i.test(answer) && /\b(?:my|own|personal)\b/i.test(answer)
+      && !/\b(?:not|never|cannot|can't|yet|need|later|will|another|their)\b/i.test(answer);
+  });
+  if (confirmations.length !== 1) return;
+  const option = confirmations[0]!;
+  if (status === "answered" && (row.result?.answers.length !== 1 || row.result.answers[0]?.questionId !== q.id
+    || row.result.answers[0]?.optionIds.join() !== option.id || row.result.answers[0]?.otherText)) return;
+  return { interactionId: row.id, questionId: q.id, optionId: option.id, optionLabel: option.label,
+    submitLabel: qs.submitLabel ?? "Submit answers", payloadHash };
+}
 export function personalSecretConfirmation(reply: string) {
   return (
     !solicitsChatCredential(reply) &&
@@ -139,6 +162,14 @@ export function gradePersonalSecret(value: unknown) {
   const initial = o.phaseReplies.find(
       (row) => row.runId === o.state.initialRunId,
     ),
+    questionRow = o.interactions.find(row => row.id === o.state.initialQuestionId),
+    question = personalSecretQuestionHandoff(questionRow, { companyId: o.companyId, issueId: String(o.state.sourceIssueId),
+      agentId: o.leadId, userId: String(o.state.currentPersonId), runId: String(o.state.initialRunId), definitionId: String(o.state.definitionId) }, "answered"),
+    answeredQuestion = questionRow as Partial<AskUserQuestionsInteraction> | undefined,
+    questionAnswered = !!question && question.payloadHash === o.state.initialQuestionPayloadHash
+      && question.optionId === o.state.initialQuestionOptionId
+      && o.comments.some(comment => comment.id === answeredQuestion?.result?.commentId && comment.companyId === o.companyId
+        && comment.issueId === o.state.sourceIssueId && comment.authorUserId === o.state.currentPersonId && !comment.authorAgentId),
     last = o.phaseReplies
       .filter((row) => row.runId !== o.state.initialRunId)
       .at(-1);
@@ -148,8 +179,7 @@ export function gradePersonalSecret(value: unknown) {
       o.state.requiredReferenceBefore === true &&
       o.state.otherConfiguredBefore === true &&
       o.state.currentPersonId !== o.state.otherPersonId &&
-      !!initial &&
-      personalSecretGuidance(initial.body) &&
+      ((!!initial && personalSecretGuidance(initial.body)) || questionAnswered) &&
       o.state.agentValueCreateStatus === 403,
     "Another person's real stored value does not satisfy the current person's required publishing definition, and chat directs secure own-value entry before claiming completion.",
   );
@@ -210,6 +240,10 @@ export function gradePersonalSecret(value: unknown) {
         (run) => run.id === last.runId && run.status === "succeeded",
       ) &&
       personalSecretConfirmation(last.body) &&
+      (!o.state.initialQuestionId || (questionAnswered
+        && o.runs.some(run => run.id === last.runId && run.contextSnapshot?.interactionId === question?.interactionId)
+        && Number.isFinite(Date.parse(String(secret?.createdAt))) && Number.isFinite(Date.parse(String(questionRow?.resolvedAt)))
+        && Date.parse(String(secret?.createdAt)) <= Date.parse(String(questionRow?.resolvedAt)))) &&
       o.state.secretScanComplete === true &&
       o.state.secretLeaked === false,
     "A later actual model response confirms availability after secure entry and observed delivery, with private scans of both owners' values across task/source output and run events.",
@@ -346,7 +380,7 @@ export const personalSecretExternalCases = [
     gradePersonalSecret,
     {
       authentication: "human-session",
-      oracleVersion: "paperclip.chat-catalog.personal-secret.v2",
+      oracleVersion: "paperclip.chat-catalog.personal-secret.v3",
       setupPolicy: { readiness: "preserve-scenario", invariantCheckIds: ["current-owner-missing-required-personal-value"] },
       expectedRunCount: 3,
       minimumRunCount: 3,
@@ -354,6 +388,7 @@ export const personalSecretExternalCases = [
       attemptTimeoutMs: 660000,
       sourceFiles: [
         "chat-catalog-domains/external-personal-secret.ts",
+        "chat-catalog-domains/external-secret-question.ts",
         "chat-catalog-domains/external-secret-endpoint.ts",
         "chat-catalog-domains/external-private-browser.ts",
         "chat-catalog-domains/external-private-browser-worker.ts",
@@ -470,14 +505,19 @@ export const personalSecretExternalCases = [
           initial = await observeExternal(ctx, state),
           reply = initial.phaseReplies.at(-1);
         remaining();
-        if (initial.companyId !== source.companyId || !reply || reply.runId !== run.id
-          || !comments.some(comment => comment.id === reply.commentId && comment.companyId === source.companyId
+        const pendingQuestions = initial.interactions.filter(row => row.status === "pending" && (row as Partial<AskUserQuestionsInteraction>).sourceRunId === run.id);
+        const question = pendingQuestions.length === 1 ? personalSecretQuestionHandoff(pendingQuestions[0], {
+          companyId: source.companyId, issueId: source.id, agentId: run.agentId, userId: String(state.currentPersonId), runId: run.id, definitionId: String(state.definitionId),
+        }) : undefined;
+        const commentHandoff = !!reply && reply.runId === run.id
+          && comments.some(comment => comment.id === reply.commentId && comment.companyId === source.companyId
             && comment.issueId === source.id && comment.authorAgentId === run.agentId && comment.createdByRunId === run.id
-            && comment.body?.trim() === reply.body.trim()) || !personalSecretGuidance(reply.body))
-          throw new Error(
-            "Personal setup must direct the current person's secure publishing value before human action",
-          );
-        state.initialRunId = reply.runId;
+            && comment.body?.trim() === reply.body.trim()) && personalSecretGuidance(reply.body);
+        if (initial.companyId !== source.companyId || (pendingQuestions.length ? !question : !commentHandoff))
+          throw new Error("Personal setup must direct the current person's secure publishing value before human action");
+        state.initialRunId = run.id;
+        if (question) Object.assign(state, { initialQuestionId: question.interactionId,
+          initialQuestionOptionId: question.optionId, initialQuestionPayloadHash: question.payloadHash });
         if (
           (
             await ctx.input.api.get<OwnEntry[]>(`${root(ctx)}/me/user-secrets`)
@@ -500,18 +540,19 @@ export const personalSecretExternalCases = [
               return false;
             }
           });
-        if (!link)
+        if (!link && !question)
           throw new Error(
             "Actual reply must direct the supported own-value settings path for this definition",
           );
-        const url = new URL(link, initial.origin);
-        url.searchParams.set("definition", String(state.definitionId));
+        const url = new URL(question ? path : link!, initial.origin);
+        if (!question) url.searchParams.set("definition", String(state.definitionId));
         const receipt = await privateBrowserEntry({
           mode: "personal-secret-create",
           companyId: ctx.input.fixtures.company.id,
           personal: {
             definitionId: String(state.definitionId),
             userId: String(state.currentPersonId),
+            viaMySecrets: !!question,
           },
           baseURL: initial.origin,
           setupURL: url.href,
@@ -584,7 +625,24 @@ export const personalSecretExternalCases = [
               : undefined,
         });
         state.workerRunId = result.runs[0]!.id;
-        await sendChatMessage(ctx.input.page, ctx.scenario.query);
+        if (question) {
+          const [current] = (await ctx.input.api.get<OwnEntry[]>(`${root(ctx)}/me/user-secrets`)).filter(row => row.definition.id === state.definitionId);
+          if (!current?.secret || current.secret.id !== state.secretId || current.secret.ownerUserId !== state.currentPersonId
+            || current.secret.userSecretDefinitionId !== state.definitionId || current.secret.status !== "active")
+            throw new Error("Secure question confirmation requires the actual saved current-owner value");
+          const rows = await ctx.input.api.get<AskUserQuestionsInteraction[]>(`/api/issues/${source.id}/interactions`);
+          const currentQuestion = personalSecretQuestionHandoff(rows.find(row => row.id === question.interactionId), {
+            companyId: source.companyId, issueId: source.id, agentId: run.agentId, userId: String(state.currentPersonId), runId: run.id, definitionId: String(state.definitionId),
+          });
+          if (!currentQuestion || currentQuestion.payloadHash !== question.payloadHash) throw new Error("Secure-entry question changed before human confirmation");
+          const form = ctx.input.page.getByTestId("task-chat-composer-takeover");
+          await form.locator(`[id=${JSON.stringify(`${question.interactionId}-${question.questionId}-${question.optionId}`)}]`).click({ timeout: remaining() });
+          const [response] = await Promise.all([
+            ctx.input.page.waitForResponse(res => new URL(res.url()).pathname === `/api/issues/${source.id}/interactions/${question.interactionId}/respond` && res.request().method() === "POST", { timeout: remaining() }),
+            form.getByRole("button", { name: question.submitLabel, exact: true }).click({ timeout: remaining() }),
+          ]);
+          if (!response.ok()) throw new Error("Secure-entry human question response failed");
+        } else await sendChatMessage(ctx.input.page, ctx.scenario.query);
       },
       async observe(ctx, state) {
         const fixture = fixtures.get(ctx)!;

tests/runner-e2e/chat-catalog-domains/external-private-browser-worker.ts

@@ -5,7 +5,7 @@ import { chromium, test, type Cookie } from "@playwright/test";
 import { validGrokRoutinePrivateInput, matchesConfiguredGrokRoutine, type GrokRoutinePrivateInput } from "./external-grok-private-contract.js";
 import { validSlackIdentityInput, validSlackWizardIdentityInput, matchingSlackIdentityPreview, type SlackIdentityPrivateInput } from "./external-slack-identity-contract.js";
 import { validSlackSetupPrivate, type SlackSetupPrivateInput } from "./external-slack-setup-private-contract.js";
-interface Request { mode: "secure-key" | "canary" | "gateway-token-rotation" | "company-secret-create" | "personal-secret-create" | "grok-routine-configure" | "slack-identity-confirm" | "slack-endpoint-configure" | "slack-wizard-confirm" | "slack-wizard-resume" | "slack-endpoint-reconnect" | "device-approve" | "device-expired"; device?: DevicePrivateInput; slackSetup?:SlackSetupPrivateInput; slackIdentity?:SlackIdentityPrivateInput; grok?:GrokRoutinePrivateInput; companyId?:string; personal?:{definitionId:string;userId:string}; gateway?: { id: string; oldTokenId: string; otherToken: string; endpointPath: string; readName: string }; baseURL: string; setupURL: string; providerURL: string; credential: string; cookies: Cookie[]; executablePath?: string; channel?: string }
+interface Request { mode: "secure-key" | "canary" | "gateway-token-rotation" | "company-secret-create" | "personal-secret-create" | "grok-routine-configure" | "slack-identity-confirm" | "slack-endpoint-configure" | "slack-wizard-confirm" | "slack-wizard-resume" | "slack-endpoint-reconnect" | "device-approve" | "device-expired"; device?: DevicePrivateInput; slackSetup?:SlackSetupPrivateInput; slackIdentity?:SlackIdentityPrivateInput; grok?:GrokRoutinePrivateInput; companyId?:string; personal?:{definitionId:string;userId:string;viaMySecrets?:boolean}; gateway?: { id: string; oldTokenId: string; otherToken: string; endpointPath: string; readName: string }; baseURL: string; setupURL: string; providerURL: string; credential: string; cookies: Cookie[]; executablePath?: string; channel?: string }
 /** Separate Node process: no Playwright Test worker, API-step listener or artifact
  * recorder exists. This module never enables tracing, video or screenshots. */
 async function main() {
@@ -203,12 +203,23 @@ async function main() {
     }
     if(input.mode === "personal-secret-create"){
       const personal=input.personal,setup=new URL(input.setupURL);
-      if(!input.companyId||!/^[a-f0-9-]{36}$/i.test(input.companyId)||!personal||!/^[a-f0-9-]{36}$/i.test(personal.definitionId)||!personal.userId||personal.userId.length>160||!setup.pathname.endsWith('/company/settings/secrets')||setup.searchParams.get('definition')!==personal.definitionId)throw new Error('Invalid finite personal secret operation');
-      await page.goto(input.setupURL,{waitUntil:'domcontentloaded'});
+      if (personal?.viaMySecrets !== undefined && typeof personal.viaMySecrets !== 'boolean') throw new Error('Invalid finite personal secret navigation');
+      if(!input.companyId||!/^[a-f0-9-]{36}$/i.test(input.companyId)||!personal||!/^[a-f0-9-]{36}$/i.test(personal.definitionId)||!personal.userId||personal.userId.length>160||!setup.pathname.endsWith('/company/settings/secrets')||(personal.viaMySecrets ? setup.search!=='' : setup.searchParams.get('definition')!==personal.definitionId))throw new Error('Invalid finite personal secret operation');
+      if (!personal.viaMySecrets) await page.goto(input.setupURL,{waitUntil:'domcontentloaded'});
       const session=await context.request.get('/api/auth/get-session');if(!session.ok()||(await session.json()).user?.id!==personal.userId)throw new Error('Personal secret human identity mismatch');
+      const companyResponse = await context.request.get(`/api/companies/${input.companyId}`);
+      const company = companyResponse.ok() ? await companyResponse.json() as { id: string; issuePrefix: string } : null;
+      if (company?.id !== input.companyId || setup.pathname !== `/${company.issuePrefix}/company/settings/secrets`) throw new Error('Personal secret company navigation mismatch');
       const own=await context.request.get(`/api/companies/${input.companyId}/me/user-secrets`);if(!own.ok())throw new Error('Personal definition not readable');
       const entries=await own.json() as Array<{definition:{id:string;key:string;name:string};secret:unknown}>;const entry=entries.find(row=>row.definition.id===personal.definitionId);if(!entry||entry.definition.key!=='PERSONAL_PUBLISHING_KEY'||entry.secret)throw new Error('Personal definition already configured or mismatched');
-      await page.getByRole('button',{name:'Set my value',exact:true}).click();const dialog=page.getByRole('dialog');await dialog.getByRole('heading',{name:/^Set your value/}).waitFor();
+      if (personal.viaMySecrets) {
+        const settings = new URL(setup); settings.pathname = settings.pathname.replace(/\/secrets$/, '');
+        await page.goto(settings.href,{waitUntil:'domcontentloaded'});
+        await page.getByRole('link',{name:'Secrets',exact:true}).filter({visible:true}).click();
+        await page.getByRole('tab',{name:'My secrets',exact:true}).click();
+        await page.getByRole('listitem').filter({hasText:entry.definition.key}).getByRole('button',{name:'Set value',exact:true}).click();
+      } else await page.getByRole('button',{name:'Set my value',exact:true}).click();
+      const dialog=page.getByRole('dialog');await dialog.getByRole('heading',{name:/^Set your value/}).waitFor();
       if(!await dialog.getByText('Personal publishing credential',{exact:true}).isVisible())throw new Error('Wrong personal credential form');
       await dialog.getByRole('textbox').fill(input.credential);
       const created=page.waitForResponse(response=>new URL(response.url()).pathname===`/api/companies/${input.companyId}/me/user-secrets`&&response.request().method()==='POST'&&response.status()===201);

tests/runner-e2e/chat-catalog-domains/external-private-browser.ts

@@ -10,7 +10,7 @@ import type { GrokRoutinePrivateInput } from "./external-grok-private-contract.j
 import type { SlackIdentityPrivateInput } from "./external-slack-identity-contract.js";
 import type { SlackSetupPrivateInput } from "./external-slack-setup-private-contract.js";
 export interface PrivateBrowserReceipt { processIsolation: true; testRunnerAttached: false; tracingEnabled: false; videoEnabled: false; apiStepRecorder: false; credentialEntered?: boolean; connectionId?: string; challengeVisible?: boolean; passwordInput?: boolean; autocompleteOff?: boolean; humanSubmittedSecurely?: boolean; visibleReady?: boolean; storageClean?: boolean; newTokenId?: string; tokenUiVisible?: boolean; newWorkedBeforeRevocation?: boolean; oldWorkedUntilRevocation?: boolean; oldRevoked?: boolean; newWorksAfter?: boolean; oldStatusAfter?: number; otherWorksAfter?: boolean; secretId?:string; secretUiVisible?:boolean; bindingId?:string; routineConfigured?:boolean; routineUiVisible?:boolean; identityConfirmed?:boolean; identityUiVisible?:boolean; principalId?:string; paperclipUserId?:string; endpointId?:string; slackCredentialUiVisible?:boolean; activationUiVisible?:boolean; endpointActive?:boolean; identityWasAlreadyLinked?:boolean; credentialUiRejected?:boolean; deviceSessionVerified?:boolean; currentCodeVisible?:boolean; companyConsentVisible?:boolean; readScopeVisible?:boolean; humanApproved?:boolean; expiredPageVisible?:boolean }
-export async function privateBrowserEntry(input: { mode: "secure-key" | "canary" | "gateway-token-rotation" | "company-secret-create" | "personal-secret-create" | "grok-routine-configure" | "slack-identity-confirm" | "slack-endpoint-configure" | "slack-wizard-confirm" | "slack-wizard-resume" | "slack-endpoint-reconnect" | "device-approve" | "device-expired"; device?: DevicePrivateInput; slackSetup?:SlackSetupPrivateInput; slackIdentity?:SlackIdentityPrivateInput; grok?:GrokRoutinePrivateInput; companyId?:string; personal?:{definitionId:string;userId:string}; gateway?: { id: string; oldTokenId: string; otherToken: string; endpointPath: string; readName: string }; baseURL: string; setupURL: string; providerURL: string; credential: string; cookies: Cookie[] }, onToken?: (token: { id: string; token: string }) => void) {
+export async function privateBrowserEntry(input: { mode: "secure-key" | "canary" | "gateway-token-rotation" | "company-secret-create" | "personal-secret-create" | "grok-routine-configure" | "slack-identity-confirm" | "slack-endpoint-configure" | "slack-wizard-confirm" | "slack-wizard-resume" | "slack-endpoint-reconnect" | "device-approve" | "device-expired"; device?: DevicePrivateInput; slackSetup?:SlackSetupPrivateInput; slackIdentity?:SlackIdentityPrivateInput; grok?:GrokRoutinePrivateInput; companyId?:string; personal?:{definitionId:string;userId:string;viaMySecrets?:boolean}; gateway?: { id: string; oldTokenId: string; otherToken: string; endpointPath: string; readName: string }; baseURL: string; setupURL: string; providerURL: string; credential: string; cookies: Cookie[] }, onToken?: (token: { id: string; token: string }) => void) {
   if (input.mode.startsWith("device-") && !validDevicePrivateInput(input.mode, input.baseURL, input.setupURL, input.companyId, input.device, input.credential)) throw new Error("Invalid finite private device UI operation");
   const directory = await mkdtemp(path.join(tmpdir(), "paperclip-private-browser-"));
   try {

ui/src/components/task-chat/QuestionForm.personal-secret-handoff.test.tsx

@@ -0,0 +1,24 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { expect, it, vi } from "vitest";
+import { QuestionForm } from "./QuestionForm";
+vi.mock("./TaskChatRichInput", () => ({ TaskChatRichInput: () => <textarea /> }));
+vi.mock("@/components/MarkdownBody", () => ({ MarkdownBody: ({ children }: { children: string }) => <div>{children}</div> }));
+it("the existing question form submits the exact saved-value choice only after a human selection and submit", async () => {
+  const host = document.createElement("div"); document.body.append(host); const root = createRoot(host), submit = vi.fn();
+  try {
+    await act(async () => root.render(<QuestionForm id="bound-question" questionSet={{ schema: "paperclip.question_set.v1", submitLabel: "Confirm value", questions: [
+      { id: "saved", prompt: "Have you saved your own value?", answerMode: "single_select", required: true, options: [
+        { id: "yes", label: "Yes", description: "My personal value is saved." }, { id: "later", label: "Not yet" },
+      ] },
+    ] }} onSubmit={submit} />));
+    expect(submit).not.toHaveBeenCalled();
+    expect(host.querySelector('[id="foreign-question-saved-yes"]')).toBeNull();
+    const option = host.querySelector<HTMLButtonElement>('[id="bound-question-saved-yes"]'); expect(option).not.toBeNull();
+    await act(async () => option!.click()); expect(submit).not.toHaveBeenCalled();
+    const button = [...host.querySelectorAll("button")].find(node => node.textContent === "Confirm value"); expect(button).toBeDefined();
+    await act(async () => button!.click());
+    expect(submit).toHaveBeenCalledExactlyOnceWith({ schema: "paperclip.question_response.v1", answers: { saved: { selectedOptionIds: ["yes"] } } });
+  } finally { await act(async () => root.unmount()); host.remove(); localStorage.clear(); }
+});

ui/src/pages/Secrets.render.test.tsx

@@ -861,6 +861,25 @@ describe("Secrets page layout", () => {
     });
   });
 
+  it("opens the current person's Set value form through My secrets without admin definitions", async () => {
+    const definition = makeUserSecretDefinition({ key: "PERSONAL_PUBLISHING_KEY", name: "Personal publishing credential" });
+    mockSecretsApi.listUserSecretDefinitions.mockRejectedValue(new ApiError("Forbidden", 403, null));
+    mockSecretsApi.listMyUserSecrets.mockResolvedValue([{ definition, secret: null }]);
+    const root = await renderSecrets(container, { path: "/company/settings/secrets" });
+    const mine = [...container.querySelectorAll('[role="tab"]')].find(node => node.textContent === "My secrets") as HTMLElement | undefined;
+    expect(mine).toBeDefined();
+    await act(async () => { mine!.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true })); mine!.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, key: "Enter" })); mine!.click(); });
+    await flushReact();
+    const row = [...container.querySelectorAll("li")].find(node => node.textContent?.includes("PERSONAL_PUBLISHING_KEY"));
+    const set = [...(row?.querySelectorAll("button") ?? [])].find(node => node.textContent === "Set value");
+    expect(set).toBeDefined();
+    await act(async () => { set!.click(); }); await flushReact();
+    expect(document.body.textContent).toContain("Set your value");
+    expect(document.body.querySelector('[role="dialog"]')?.textContent).toContain("Personal publishing credential");
+    expect(mockSecretsApi.createMyUserSecret).not.toHaveBeenCalled();
+    await act(async () => { root.unmount(); });
+  });
+
   it("keeps the new secret value textarea width-constrained for long tokens", async () => {
     const root = await renderSecrets(container);